mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-19 09:37:50 -05:00
Brought up to date with the private repository (feea4c7)
This commit is contained in:
1 parent
1aa738d692
commit
1b1df1ae48
7925 files changed
+2617237
-20
No files matched your search
@@ -0,0 +1,811 @@
|
||||
package com.greensock
|
||||
{
|
||||
import flash.display.BitmapData;
|
||||
import flash.display.DisplayObject;
|
||||
import flash.display.Graphics;
|
||||
import flash.display.Sprite;
|
||||
import flash.events.Event;
|
||||
import flash.events.MouseEvent;
|
||||
import flash.geom.ColorTransform;
|
||||
import flash.geom.Matrix;
|
||||
import flash.geom.Point;
|
||||
import flash.geom.Rectangle;
|
||||
import flash.geom.Transform;
|
||||
|
||||
public class BlitMask extends Sprite
|
||||
{
|
||||
|
||||
public static var version:Number = 0.62;
|
||||
|
||||
protected static var _tempContainer:Sprite = new Sprite();
|
||||
|
||||
protected static var _sliceRect:Rectangle = new Rectangle();
|
||||
|
||||
protected static var _drawRect:Rectangle = new Rectangle();
|
||||
|
||||
protected static var _destPoint:Point = new Point();
|
||||
|
||||
protected static var _tempMatrix:Matrix = new Matrix();
|
||||
|
||||
protected static var _emptyArray:Array = [];
|
||||
|
||||
protected static var _colorTransform:ColorTransform = new ColorTransform();
|
||||
|
||||
protected static var _mouseEvents:Array = ["click","doubleClick","mouseDown","mouseMove","mouseOut","mouseOver","mouseUp","mouseWheel","rollOut","rollOver","gesturePressAndTap","gesturePan","gestureRotate","gestureSwipe","gestureZoom","gestureTwoFingerTap","touchBegin","touchEnd","touchMove","touchOut","touchOver","touchRollOut","touchRollOver","touchTap"];
|
||||
|
||||
protected var _target:DisplayObject;
|
||||
|
||||
protected var _fillColor:uint;
|
||||
|
||||
protected var _smoothing:Boolean;
|
||||
|
||||
protected var _width:Number;
|
||||
|
||||
protected var _height:Number;
|
||||
|
||||
protected var _bd:BitmapData;
|
||||
|
||||
protected var _gridSize:int = 2879;
|
||||
|
||||
protected var _grid:Array;
|
||||
|
||||
protected var _bounds:Rectangle;
|
||||
|
||||
protected var _clipRect:Rectangle;
|
||||
|
||||
protected var _bitmapMode:Boolean;
|
||||
|
||||
protected var _rows:int;
|
||||
|
||||
protected var _columns:int;
|
||||
|
||||
protected var _scaleX:Number;
|
||||
|
||||
protected var _scaleY:Number;
|
||||
|
||||
protected var _prevMatrix:Matrix;
|
||||
|
||||
protected var _transform:Transform;
|
||||
|
||||
protected var _prevRotation:Number;
|
||||
|
||||
protected var _autoUpdate:Boolean;
|
||||
|
||||
protected var _wrap:Boolean;
|
||||
|
||||
protected var _wrapOffsetX:Number = 0;
|
||||
|
||||
protected var _wrapOffsetY:Number = 0;
|
||||
|
||||
public function BlitMask(param1:DisplayObject, param2:Number = 0, param3:Number = 0, param4:Number = 100, param5:Number = 100, param6:Boolean = false, param7:Boolean = false, param8:uint = 0, param9:Boolean = false)
|
||||
{
|
||||
super();
|
||||
if(param4 < 0 || param5 < 0)
|
||||
{
|
||||
throw new Error("A FlexBlitMask cannot have a negative width or height.");
|
||||
}
|
||||
_width = param4;
|
||||
_height = param5;
|
||||
_scaleX = _scaleY = 1;
|
||||
_smoothing = param6;
|
||||
_fillColor = param8;
|
||||
_autoUpdate = param7;
|
||||
_wrap = param9;
|
||||
_grid = [];
|
||||
_bounds = new Rectangle();
|
||||
if(_smoothing)
|
||||
{
|
||||
super.x = param2;
|
||||
super.y = param3;
|
||||
}
|
||||
else
|
||||
{
|
||||
super.x = param2 < 0 ? param2 - 0.5 >> 0 : param2 + 0.5 >> 0;
|
||||
super.y = param3 < 0 ? param3 - 0.5 >> 0 : param3 + 0.5 >> 0;
|
||||
}
|
||||
_clipRect = new Rectangle(0,0,_gridSize + 1,_gridSize + 1);
|
||||
_bd = new BitmapData(param4 + 1,param5 + 1,true,_fillColor);
|
||||
_bitmapMode = true;
|
||||
this.target = param1;
|
||||
}
|
||||
|
||||
protected function _captureTargetBitmap() : void
|
||||
{
|
||||
var _loc1_:Number = NaN;
|
||||
var _loc4_:BitmapData = null;
|
||||
var _loc12_:int = 0;
|
||||
var _loc7_:int = 0;
|
||||
if(_bd == null || _target == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_disposeGrid();
|
||||
var _loc11_:DisplayObject = _target.mask;
|
||||
if(_loc11_ != null)
|
||||
{
|
||||
_target.mask = null;
|
||||
}
|
||||
var _loc2_:Rectangle = _target.scrollRect;
|
||||
if(_loc2_ != null)
|
||||
{
|
||||
_target.scrollRect = null;
|
||||
}
|
||||
var _loc13_:Array = _target.filters;
|
||||
if(_loc13_.length != 0)
|
||||
{
|
||||
_target.filters = _emptyArray;
|
||||
}
|
||||
_grid = [];
|
||||
if(_target.parent == null)
|
||||
{
|
||||
_tempContainer.addChild(_target);
|
||||
}
|
||||
_bounds = _target.getBounds(_target.parent);
|
||||
var _loc10_:Number = 0;
|
||||
var _loc6_:Number = 0;
|
||||
_columns = Math.ceil(_bounds.width / _gridSize);
|
||||
_rows = Math.ceil(_bounds.height / _gridSize);
|
||||
var _loc8_:Number = 0;
|
||||
var _loc9_:Matrix = _transform.matrix;
|
||||
var _loc5_:Number = _loc9_.tx - _bounds.x;
|
||||
var _loc3_:Number = _loc9_.ty - _bounds.y;
|
||||
if(!_smoothing)
|
||||
{
|
||||
_loc5_ = _loc5_ + 0.5 >> 0;
|
||||
_loc3_ = _loc3_ + 0.5 >> 0;
|
||||
}
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < _rows)
|
||||
{
|
||||
_loc6_ = Number(_bounds.height - _loc8_ > _gridSize ? _gridSize : _bounds.height - _loc8_);
|
||||
_loc9_.ty = -_loc8_ + _loc3_;
|
||||
_loc1_ = 0;
|
||||
_grid[_loc12_] = [];
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _columns)
|
||||
{
|
||||
_loc10_ = Number(_bounds.width - _loc1_ > _gridSize ? _gridSize : _bounds.width - _loc1_);
|
||||
_grid[_loc12_][_loc7_] = _loc4_ = new BitmapData(_loc10_ + 1,_loc6_ + 1,true,_fillColor);
|
||||
_loc9_.tx = -_loc1_ + _loc5_;
|
||||
_loc4_.draw(_target,_loc9_,null,null,_clipRect,_smoothing);
|
||||
_loc1_ += _loc10_;
|
||||
_loc7_++;
|
||||
}
|
||||
_loc8_ += _loc6_;
|
||||
_loc12_++;
|
||||
}
|
||||
if(_target.parent == _tempContainer)
|
||||
{
|
||||
_tempContainer.removeChild(_target);
|
||||
}
|
||||
if(_loc11_ != null)
|
||||
{
|
||||
_target.mask = _loc11_;
|
||||
}
|
||||
if(_loc2_ != null)
|
||||
{
|
||||
_target.scrollRect = _loc2_;
|
||||
}
|
||||
if(_loc13_.length != 0)
|
||||
{
|
||||
_target.filters = _loc13_;
|
||||
}
|
||||
}
|
||||
|
||||
protected function _disposeGrid() : void
|
||||
{
|
||||
var _loc3_:int = 0;
|
||||
var _loc1_:Array = null;
|
||||
var _loc2_:int = int(_grid.length);
|
||||
while(--_loc2_ > -1)
|
||||
{
|
||||
_loc1_ = _grid[_loc2_];
|
||||
_loc3_ = int(_loc1_.length);
|
||||
while(--_loc3_ > -1)
|
||||
{
|
||||
BitmapData(_loc1_[_loc3_]).dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function update(param1:Event = null, param2:Boolean = false) : void
|
||||
{
|
||||
var _loc3_:Matrix = null;
|
||||
if(_bd == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(_target == null)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
else if(_target.parent)
|
||||
{
|
||||
_bounds = _target.getBounds(_target.parent);
|
||||
if(this.parent != _target.parent)
|
||||
{
|
||||
_target.parent.addChildAt(this,_target.parent.getChildIndex(_target));
|
||||
}
|
||||
}
|
||||
if(_bitmapMode || param2)
|
||||
{
|
||||
_loc3_ = _transform.matrix;
|
||||
if(param2 || _prevMatrix == null || _loc3_.a != _prevMatrix.a || _loc3_.b != _prevMatrix.b || _loc3_.c != _prevMatrix.c || _loc3_.d != _prevMatrix.d)
|
||||
{
|
||||
_captureTargetBitmap();
|
||||
_render();
|
||||
}
|
||||
else if(_loc3_.tx != _prevMatrix.tx || _loc3_.ty != _prevMatrix.ty)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
else if(_bitmapMode && _target != null)
|
||||
{
|
||||
this.filters = _target.filters;
|
||||
this.transform.colorTransform = _transform.colorTransform;
|
||||
}
|
||||
_prevMatrix = _loc3_;
|
||||
}
|
||||
}
|
||||
|
||||
protected function _render(param1:Number = 0, param2:Number = 0, param3:Boolean = true, param4:Boolean = false) : void
|
||||
{
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc16_:int = 0;
|
||||
var _loc5_:BitmapData = null;
|
||||
if(param3)
|
||||
{
|
||||
_sliceRect.x = _sliceRect.y = 0;
|
||||
_sliceRect.width = _width + 1;
|
||||
_sliceRect.height = _height + 1;
|
||||
_bd.fillRect(_sliceRect,_fillColor);
|
||||
if(_bitmapMode && _target != null)
|
||||
{
|
||||
this.filters = _target.filters;
|
||||
this.transform.colorTransform = _transform.colorTransform;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.filters = _emptyArray;
|
||||
this.transform.colorTransform = _colorTransform;
|
||||
}
|
||||
}
|
||||
if(_bd == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(_rows == 0)
|
||||
{
|
||||
_captureTargetBitmap();
|
||||
}
|
||||
var _loc13_:Number = super.x + param1;
|
||||
var _loc15_:Number = super.y + param2;
|
||||
var _loc10_:int = _bounds.width + _wrapOffsetX + 0.5 >> 0;
|
||||
var _loc12_:int = _bounds.height + _wrapOffsetY + 0.5 >> 0;
|
||||
var _loc8_:Graphics = this.graphics;
|
||||
if(_bounds.width == 0 || _bounds.height == 0 || _wrap && (_loc10_ == 0 || _loc12_ == 0) || !_wrap && (_loc13_ + _width < _bounds.x || _loc15_ + _height < _bounds.y || _loc13_ > _bounds.right || _loc15_ > _bounds.bottom))
|
||||
{
|
||||
_loc8_.clear();
|
||||
_loc8_.beginBitmapFill(_bd);
|
||||
_loc8_.drawRect(0,0,_width,_height);
|
||||
_loc8_.endFill();
|
||||
return;
|
||||
}
|
||||
var _loc9_:int = (_loc13_ - _bounds.x) / _gridSize;
|
||||
if(_loc9_ < 0)
|
||||
{
|
||||
_loc9_ = 0;
|
||||
}
|
||||
var _loc17_:int = (_loc15_ - _bounds.y) / _gridSize;
|
||||
if(_loc17_ < 0)
|
||||
{
|
||||
_loc17_ = 0;
|
||||
}
|
||||
var _loc18_:int = (_loc13_ + _width - _bounds.x) / _gridSize;
|
||||
if(_loc18_ >= _columns)
|
||||
{
|
||||
_loc18_ = _columns - 1;
|
||||
}
|
||||
var _loc14_:uint = uint(int((_loc15_ + _height - _bounds.y) / _gridSize));
|
||||
if(_loc14_ >= _rows)
|
||||
{
|
||||
_loc14_ = _rows - 1;
|
||||
}
|
||||
var _loc6_:Number = (_bounds.x - _loc13_) % 1;
|
||||
var _loc19_:Number = (_bounds.y - _loc15_) % 1;
|
||||
if(_loc15_ <= _bounds.y)
|
||||
{
|
||||
_destPoint.y = _bounds.y - _loc15_ >> 0;
|
||||
_sliceRect.y = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_destPoint.y = 0;
|
||||
_sliceRect.y = Math.ceil(_loc15_ - _bounds.y) - _loc17_ * _gridSize - 1;
|
||||
if(param3 && _loc19_ != 0)
|
||||
{
|
||||
_loc19_ += 1;
|
||||
}
|
||||
}
|
||||
if(_loc13_ <= _bounds.x)
|
||||
{
|
||||
_destPoint.x = _bounds.x - _loc13_ >> 0;
|
||||
_sliceRect.x = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_destPoint.x = 0;
|
||||
_sliceRect.x = Math.ceil(_loc13_ - _bounds.x) - _loc9_ * _gridSize - 1;
|
||||
if(param3 && _loc6_ != 0)
|
||||
{
|
||||
_loc6_ += 1;
|
||||
}
|
||||
}
|
||||
if(_wrap && param3)
|
||||
{
|
||||
_render(Math.ceil((_bounds.x - _loc13_) / _loc10_) * _loc10_,Math.ceil((_bounds.y - _loc15_) / _loc12_) * _loc12_,false,false);
|
||||
}
|
||||
else if(_rows != 0)
|
||||
{
|
||||
_loc11_ = _destPoint.x;
|
||||
_loc7_ = _sliceRect.x;
|
||||
_loc16_ = _loc9_;
|
||||
while(_loc17_ <= _loc14_)
|
||||
{
|
||||
_loc5_ = _grid[_loc17_][0];
|
||||
_sliceRect.height = _loc5_.height - _sliceRect.y;
|
||||
_destPoint.x = _loc11_;
|
||||
_sliceRect.x = _loc7_;
|
||||
_loc9_ = _loc16_;
|
||||
while(_loc9_ <= _loc18_)
|
||||
{
|
||||
_loc5_ = _grid[_loc17_][_loc9_];
|
||||
_sliceRect.width = _loc5_.width - _sliceRect.x;
|
||||
_bd.copyPixels(_loc5_,_sliceRect,_destPoint);
|
||||
_destPoint.x += _sliceRect.width - 1;
|
||||
_sliceRect.x = 0;
|
||||
_loc9_++;
|
||||
}
|
||||
_destPoint.y += _sliceRect.height - 1;
|
||||
_sliceRect.y = 0;
|
||||
_loc17_++;
|
||||
}
|
||||
}
|
||||
if(param3)
|
||||
{
|
||||
_tempMatrix.tx = _loc6_ - 1;
|
||||
_tempMatrix.ty = _loc19_ - 1;
|
||||
_loc8_.clear();
|
||||
_loc8_.beginBitmapFill(_bd,_tempMatrix,false,_smoothing);
|
||||
_loc8_.drawRect(0,0,_width,_height);
|
||||
_loc8_.endFill();
|
||||
}
|
||||
else if(_wrap)
|
||||
{
|
||||
if(_loc13_ + _width > _bounds.right)
|
||||
{
|
||||
_render(param1 - _loc10_,param2,false,true);
|
||||
}
|
||||
if(!param4 && _loc15_ + _height > _bounds.bottom)
|
||||
{
|
||||
_render(param1,param2 - _loc12_,false,false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function setSize(param1:Number, param2:Number) : void
|
||||
{
|
||||
if(_width == param1 && _height == param2)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(param1 < 0 || param2 < 0)
|
||||
{
|
||||
throw new Error("A BlitMask cannot have a negative width or height.");
|
||||
}
|
||||
if(_bd != null)
|
||||
{
|
||||
_bd.dispose();
|
||||
}
|
||||
_width = param1;
|
||||
_height = param2;
|
||||
_bd = new BitmapData(param1 + 1,param2 + 1,true,_fillColor);
|
||||
_render();
|
||||
}
|
||||
|
||||
protected function _mouseEventPassthrough(param1:Event) : void
|
||||
{
|
||||
if(this.mouseEnabled && (!_bitmapMode || param1 is MouseEvent && this.hitTestPoint(MouseEvent(param1).stageX,MouseEvent(param1).stageY,false)))
|
||||
{
|
||||
dispatchEvent(param1);
|
||||
}
|
||||
}
|
||||
|
||||
public function enableBitmapMode(param1:Event = null) : void
|
||||
{
|
||||
this.bitmapMode = true;
|
||||
}
|
||||
|
||||
public function disableBitmapMode(param1:Event = null) : void
|
||||
{
|
||||
this.bitmapMode = false;
|
||||
}
|
||||
|
||||
public function normalizePosition() : void
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
if(_target && _bounds)
|
||||
{
|
||||
_loc1_ = _bounds.width + _wrapOffsetX + 0.5 >> 0;
|
||||
_loc4_ = _bounds.height + _wrapOffsetY + 0.5 >> 0;
|
||||
_loc2_ = (_bounds.x - this.x) % _loc1_;
|
||||
_loc3_ = (_bounds.y - this.y) % _loc4_;
|
||||
if(_loc2_ > (_width + _wrapOffsetX) / 2)
|
||||
{
|
||||
_loc2_ -= _loc1_;
|
||||
}
|
||||
else if(_loc2_ < (_width + _wrapOffsetX) / -2)
|
||||
{
|
||||
_loc2_ += _loc1_;
|
||||
}
|
||||
if(_loc3_ > (_height + _wrapOffsetY) / 2)
|
||||
{
|
||||
_loc3_ -= _loc4_;
|
||||
}
|
||||
else if(_loc3_ < (_height + _wrapOffsetY) / -2)
|
||||
{
|
||||
_loc3_ += _loc4_;
|
||||
}
|
||||
_target.x += this.x + _loc2_ - _bounds.x;
|
||||
_target.y += this.y + _loc3_ - _bounds.y;
|
||||
}
|
||||
}
|
||||
|
||||
public function dispose() : void
|
||||
{
|
||||
if(_bd == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_disposeGrid();
|
||||
_bd.dispose();
|
||||
_bd = null;
|
||||
this.bitmapMode = false;
|
||||
this.autoUpdate = false;
|
||||
if(_target != null)
|
||||
{
|
||||
_target.mask = null;
|
||||
}
|
||||
if(this.parent != null)
|
||||
{
|
||||
this.parent.removeChild(this);
|
||||
}
|
||||
this.target = null;
|
||||
}
|
||||
|
||||
public function get bitmapMode() : Boolean
|
||||
{
|
||||
return _bitmapMode;
|
||||
}
|
||||
|
||||
public function set bitmapMode(param1:Boolean) : void
|
||||
{
|
||||
if(_bitmapMode != param1)
|
||||
{
|
||||
_bitmapMode = param1;
|
||||
if(_target != null)
|
||||
{
|
||||
_target.visible = !_bitmapMode;
|
||||
update(null);
|
||||
if(_bitmapMode)
|
||||
{
|
||||
this.filters = _target.filters;
|
||||
this.transform.colorTransform = _transform.colorTransform;
|
||||
this.blendMode = _target.blendMode;
|
||||
_target.mask = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.filters = _emptyArray;
|
||||
this.transform.colorTransform = _colorTransform;
|
||||
this.blendMode = "normal";
|
||||
this.cacheAsBitmap = false;
|
||||
_target.mask = this;
|
||||
if(_wrap)
|
||||
{
|
||||
normalizePosition();
|
||||
}
|
||||
}
|
||||
if(_bitmapMode && _autoUpdate)
|
||||
{
|
||||
this.addEventListener("enterFrame",update,false,-10,true);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.removeEventListener("enterFrame",update);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get autoUpdate() : Boolean
|
||||
{
|
||||
return _autoUpdate;
|
||||
}
|
||||
|
||||
public function set autoUpdate(param1:Boolean) : void
|
||||
{
|
||||
if(_autoUpdate != param1)
|
||||
{
|
||||
_autoUpdate = param1;
|
||||
if(_bitmapMode && _autoUpdate)
|
||||
{
|
||||
this.addEventListener("enterFrame",update,false,-10,true);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.removeEventListener("enterFrame",update);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get target() : DisplayObject
|
||||
{
|
||||
return _target;
|
||||
}
|
||||
|
||||
public function set target(param1:DisplayObject) : void
|
||||
{
|
||||
if(_target != param1)
|
||||
{
|
||||
_target = param1;
|
||||
if(_target != null)
|
||||
{
|
||||
_prevMatrix = null;
|
||||
_transform = _target.transform;
|
||||
_bitmapMode = !_bitmapMode;
|
||||
this.bitmapMode = !_bitmapMode;
|
||||
}
|
||||
else
|
||||
{
|
||||
_bounds = new Rectangle();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override public function get x() : Number
|
||||
{
|
||||
return super.x;
|
||||
}
|
||||
|
||||
override public function set x(param1:Number) : void
|
||||
{
|
||||
if(_smoothing)
|
||||
{
|
||||
super.x = param1;
|
||||
}
|
||||
else if(param1 >= 0)
|
||||
{
|
||||
super.x = param1 + 0.5 >> 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
super.x = param1 - 0.5 >> 0;
|
||||
}
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
|
||||
override public function get y() : Number
|
||||
{
|
||||
return super.y;
|
||||
}
|
||||
|
||||
override public function set y(param1:Number) : void
|
||||
{
|
||||
if(_smoothing)
|
||||
{
|
||||
super.y = param1;
|
||||
}
|
||||
else if(param1 >= 0)
|
||||
{
|
||||
super.y = param1 + 0.5 >> 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
super.y = param1 - 0.5 >> 0;
|
||||
}
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
|
||||
override public function get width() : Number
|
||||
{
|
||||
return _width;
|
||||
}
|
||||
|
||||
override public function set width(param1:Number) : void
|
||||
{
|
||||
setSize(param1,_height);
|
||||
}
|
||||
|
||||
override public function get height() : Number
|
||||
{
|
||||
return _height;
|
||||
}
|
||||
|
||||
override public function set height(param1:Number) : void
|
||||
{
|
||||
setSize(_width,param1);
|
||||
}
|
||||
|
||||
override public function get scaleX() : Number
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
override public function set scaleX(param1:Number) : void
|
||||
{
|
||||
var _loc2_:Number = _scaleX;
|
||||
_scaleX = param1;
|
||||
setSize(_width * (_scaleX / _loc2_),_height);
|
||||
}
|
||||
|
||||
override public function get scaleY() : Number
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
override public function set scaleY(param1:Number) : void
|
||||
{
|
||||
var _loc2_:Number = _scaleY;
|
||||
_scaleY = param1;
|
||||
setSize(_width,_height * (_scaleY / _loc2_));
|
||||
}
|
||||
|
||||
override public function set rotation(param1:Number) : void
|
||||
{
|
||||
if(param1 != 0)
|
||||
{
|
||||
throw new Error("Cannot set the rotation of a BlitMask to a non-zero number. BlitMasks should remain unrotated.");
|
||||
}
|
||||
}
|
||||
|
||||
public function get scrollX() : Number
|
||||
{
|
||||
return (super.x - _bounds.x) / (_bounds.width - _width);
|
||||
}
|
||||
|
||||
public function set scrollX(param1:Number) : void
|
||||
{
|
||||
var _loc2_:Number = NaN;
|
||||
if(_target != null && _target.parent)
|
||||
{
|
||||
_bounds = _target.getBounds(_target.parent);
|
||||
_loc2_ = super.x - (_bounds.width - _width) * param1 - _bounds.x;
|
||||
_target.x += _loc2_;
|
||||
_bounds.x += _loc2_;
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get scrollY() : Number
|
||||
{
|
||||
return (super.y - _bounds.y) / (_bounds.height - _height);
|
||||
}
|
||||
|
||||
public function set scrollY(param1:Number) : void
|
||||
{
|
||||
var _loc2_:Number = NaN;
|
||||
if(_target != null && _target.parent)
|
||||
{
|
||||
_bounds = _target.getBounds(_target.parent);
|
||||
_loc2_ = super.y - (_bounds.height - _height) * param1 - _bounds.y;
|
||||
_target.y += _loc2_;
|
||||
_bounds.y += _loc2_;
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get smoothing() : Boolean
|
||||
{
|
||||
return _smoothing;
|
||||
}
|
||||
|
||||
public function set smoothing(param1:Boolean) : void
|
||||
{
|
||||
if(_smoothing != param1)
|
||||
{
|
||||
_smoothing = param1;
|
||||
_captureTargetBitmap();
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get fillColor() : uint
|
||||
{
|
||||
return _fillColor;
|
||||
}
|
||||
|
||||
public function set fillColor(param1:uint) : void
|
||||
{
|
||||
if(_fillColor != param1)
|
||||
{
|
||||
_fillColor = param1;
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get wrap() : Boolean
|
||||
{
|
||||
return _wrap;
|
||||
}
|
||||
|
||||
public function set wrap(param1:Boolean) : void
|
||||
{
|
||||
if(_wrap != param1)
|
||||
{
|
||||
_wrap = param1;
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get wrapOffsetX() : Number
|
||||
{
|
||||
return _wrapOffsetX;
|
||||
}
|
||||
|
||||
public function set wrapOffsetX(param1:Number) : void
|
||||
{
|
||||
if(_wrapOffsetX != param1)
|
||||
{
|
||||
_wrapOffsetX = param1;
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get wrapOffsetY() : Number
|
||||
{
|
||||
return _wrapOffsetY;
|
||||
}
|
||||
|
||||
public function set wrapOffsetY(param1:Number) : void
|
||||
{
|
||||
if(_wrapOffsetY != param1)
|
||||
{
|
||||
_wrapOffsetY = param1;
|
||||
if(_bitmapMode)
|
||||
{
|
||||
_render();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,852 @@
|
||||
package com.greensock
|
||||
{
|
||||
import com.greensock.core.Animation;
|
||||
import com.greensock.core.SimpleTimeline;
|
||||
|
||||
public class TimelineLite extends SimpleTimeline
|
||||
{
|
||||
|
||||
public static const version:String = "12.1.5";
|
||||
|
||||
protected var _labels:Object;
|
||||
|
||||
public function TimelineLite(param1:Object = null)
|
||||
{
|
||||
var _loc2_:String = null;
|
||||
var _loc3_:Object = null;
|
||||
super(param1);
|
||||
_labels = {};
|
||||
autoRemoveChildren = this.vars.autoRemoveChildren == true;
|
||||
smoothChildTiming = this.vars.smoothChildTiming == true;
|
||||
_sortChildren = true;
|
||||
_onUpdate = this.vars.onUpdate;
|
||||
for(_loc2_ in this.vars)
|
||||
{
|
||||
_loc3_ = this.vars[_loc2_];
|
||||
if(_loc3_ is Array)
|
||||
{
|
||||
if(_loc3_.join("").indexOf("{self}") !== -1)
|
||||
{
|
||||
this.vars[_loc2_] = _swapSelfInParams(_loc3_ as Array);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(this.vars.tweens is Array)
|
||||
{
|
||||
this.add(this.vars.tweens,0,this.vars.align || "normal",this.vars.stagger || 0);
|
||||
}
|
||||
}
|
||||
|
||||
protected static function _prepVars(param1:Object) : Object
|
||||
{
|
||||
return param1._isGSVars ? param1.vars : param1;
|
||||
}
|
||||
|
||||
protected static function _copy(param1:Object) : Object
|
||||
{
|
||||
var _loc2_:String = null;
|
||||
var _loc3_:Object = {};
|
||||
for(_loc2_ in param1)
|
||||
{
|
||||
_loc3_[_loc2_] = param1[_loc2_];
|
||||
}
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
public static function exportRoot(param1:Object = null, param2:Boolean = true) : TimelineLite
|
||||
{
|
||||
var _loc6_:TimelineLite = null;
|
||||
var _loc3_:Animation = null;
|
||||
param1 ||= {};
|
||||
if(!("smoothChildTiming" in param1))
|
||||
{
|
||||
param1.smoothChildTiming = true;
|
||||
}
|
||||
_loc6_ = new TimelineLite(param1);
|
||||
var _loc5_:SimpleTimeline = _loc6_._timeline;
|
||||
_loc5_._remove(_loc6_,true);
|
||||
_loc6_._startTime = 0;
|
||||
_loc6_._rawPrevTime = _loc6_._time = _loc6_._totalTime = _loc5_._time;
|
||||
var _loc4_:Animation = _loc5_._first;
|
||||
while(_loc4_)
|
||||
{
|
||||
_loc3_ = _loc4_._next;
|
||||
if(!param2 || !(_loc4_ is TweenLite && TweenLite(_loc4_).target == _loc4_.vars.onComplete))
|
||||
{
|
||||
_loc6_.add(_loc4_,_loc4_._startTime - _loc4_._delay);
|
||||
}
|
||||
_loc4_ = _loc3_;
|
||||
}
|
||||
_loc5_.add(_loc6_,0);
|
||||
return _loc6_;
|
||||
}
|
||||
|
||||
public function to(param1:Object, param2:Number, param3:Object, param4:* = "+=0") : *
|
||||
{
|
||||
return param2 ? add(new TweenLite(param1,param2,param3),param4) : this.set(param1,param3,param4);
|
||||
}
|
||||
|
||||
public function from(param1:Object, param2:Number, param3:Object, param4:* = "+=0") : *
|
||||
{
|
||||
return add(TweenLite.from(param1,param2,param3),param4);
|
||||
}
|
||||
|
||||
public function fromTo(param1:Object, param2:Number, param3:Object, param4:Object, param5:* = "+=0") : *
|
||||
{
|
||||
return param2 ? add(TweenLite.fromTo(param1,param2,param3,param4),param5) : this.set(param1,param4,param5);
|
||||
}
|
||||
|
||||
public function staggerTo(param1:Array, param2:Number, param3:Object, param4:Number, param5:* = "+=0", param6:Function = null, param7:Array = null) : *
|
||||
{
|
||||
var _loc9_:int = 0;
|
||||
var _loc8_:TimelineLite = new TimelineLite({
|
||||
"onComplete":param6,
|
||||
"onCompleteParams":param7,
|
||||
"smoothChildTiming":this.smoothChildTiming
|
||||
});
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < param1.length)
|
||||
{
|
||||
if(param3.startAt != null)
|
||||
{
|
||||
param3.startAt = _copy(param3.startAt);
|
||||
}
|
||||
_loc8_.to(param1[_loc9_],param2,_copy(param3),_loc9_ * param4);
|
||||
_loc9_++;
|
||||
}
|
||||
return add(_loc8_,param5);
|
||||
}
|
||||
|
||||
public function staggerFrom(param1:Array, param2:Number, param3:Object, param4:Number = 0, param5:* = "+=0", param6:Function = null, param7:Array = null) : *
|
||||
{
|
||||
param3 = _prepVars(param3);
|
||||
if(!("immediateRender" in param3))
|
||||
{
|
||||
param3.immediateRender = true;
|
||||
}
|
||||
param3.runBackwards = true;
|
||||
return staggerTo(param1,param2,param3,param4,param5,param6,param7);
|
||||
}
|
||||
|
||||
public function staggerFromTo(param1:Array, param2:Number, param3:Object, param4:Object, param5:Number = 0, param6:* = "+=0", param7:Function = null, param8:Array = null) : *
|
||||
{
|
||||
param4 = _prepVars(param4);
|
||||
param3 = _prepVars(param3);
|
||||
param4.startAt = param3;
|
||||
param4.immediateRender = param4.immediateRender != false && param3.immediateRender != false;
|
||||
return staggerTo(param1,param2,param4,param5,param6,param7,param8);
|
||||
}
|
||||
|
||||
public function call(param1:Function, param2:Array = null, param3:* = "+=0") : *
|
||||
{
|
||||
return add(TweenLite.delayedCall(0,param1,param2),param3);
|
||||
}
|
||||
|
||||
public function set(param1:Object, param2:Object, param3:* = "+=0") : *
|
||||
{
|
||||
param3 = _parseTimeOrLabel(param3,0,true);
|
||||
param2 = _prepVars(param2);
|
||||
if(param2.immediateRender == null)
|
||||
{
|
||||
param2.immediateRender = param3 === _time && !_paused;
|
||||
}
|
||||
return add(new TweenLite(param1,0,param2),param3);
|
||||
}
|
||||
|
||||
public function addPause(param1:* = "+=0", param2:Function = null, param3:Array = null) : *
|
||||
{
|
||||
return call(_pauseCallback,["{self}",param2,param3],param1);
|
||||
}
|
||||
|
||||
protected function _pauseCallback(param1:TweenLite, param2:Function = null, param3:Array = null) : void
|
||||
{
|
||||
pause(param1._startTime);
|
||||
if(param2 != null)
|
||||
{
|
||||
param2.apply(null,param3);
|
||||
}
|
||||
}
|
||||
|
||||
override public function insert(param1:*, param2:* = 0) : *
|
||||
{
|
||||
return add(param1,param2 || 0);
|
||||
}
|
||||
|
||||
override public function add(param1:*, param2:* = "+=0", param3:String = "normal", param4:Number = 0) : *
|
||||
{
|
||||
var _loc10_:* = undefined;
|
||||
var _loc7_:int = 0;
|
||||
var _loc6_:SimpleTimeline = null;
|
||||
if(typeof param2 !== "number")
|
||||
{
|
||||
param2 = _parseTimeOrLabel(param2,0,true,param1);
|
||||
}
|
||||
if(!(param1 is Animation))
|
||||
{
|
||||
if(param1 is Array)
|
||||
{
|
||||
var _loc5_:Number = param2;
|
||||
var _loc9_:Number = Number(param1.length);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc9_)
|
||||
{
|
||||
_loc10_ = param1[_loc7_];
|
||||
if(_loc10_ is Array)
|
||||
{
|
||||
_loc10_ = new TimelineLite({"tweens":_loc10_});
|
||||
}
|
||||
add(_loc10_,_loc5_);
|
||||
if(!(typeof _loc10_ === "string" || typeof _loc10_ === "function"))
|
||||
{
|
||||
switch(param3)
|
||||
{
|
||||
case "sequence":
|
||||
_loc5_ = _loc10_._startTime + _loc10_.totalDuration() / _loc10_._timeScale;
|
||||
break;
|
||||
case "start":
|
||||
_loc10_._startTime -= _loc10_.delay();
|
||||
}
|
||||
}
|
||||
_loc5_ += param4;
|
||||
_loc7_++;
|
||||
}
|
||||
return _uncache(true);
|
||||
}
|
||||
if(typeof param1 === "string")
|
||||
{
|
||||
return addLabel(String(param1),param2);
|
||||
}
|
||||
if(typeof param1 !== "function")
|
||||
{
|
||||
trace("Cannot add " + param1 + " into the TimelineLite/Max: it is not a tween, timeline, function, or string.");
|
||||
return this;
|
||||
}
|
||||
param1 = TweenLite.delayedCall(0,param1);
|
||||
}
|
||||
super.add(param1,param2);
|
||||
if(_gc || _time === _duration)
|
||||
{
|
||||
if(!_paused)
|
||||
{
|
||||
if(_duration < duration())
|
||||
{
|
||||
_loc6_ = this;
|
||||
var _loc8_:Boolean = _loc6_.rawTime() > param1._startTime;
|
||||
while(_loc6_._timeline)
|
||||
{
|
||||
if(_loc8_ && _loc6_._timeline.smoothChildTiming)
|
||||
{
|
||||
_loc6_.totalTime(_loc6_._totalTime,true);
|
||||
}
|
||||
else if(_loc6_._gc)
|
||||
{
|
||||
_loc6_._enabled(true,false);
|
||||
}
|
||||
_loc6_ = _loc6_._timeline;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function remove(param1:*) : *
|
||||
{
|
||||
var _loc2_:Number = NaN;
|
||||
if(param1 is Animation)
|
||||
{
|
||||
return _remove(param1,false);
|
||||
}
|
||||
if(param1 is Array)
|
||||
{
|
||||
_loc2_ = Number(param1.length);
|
||||
while(--_loc2_ > -1)
|
||||
{
|
||||
remove(param1[_loc2_]);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
if(typeof param1 == "string")
|
||||
{
|
||||
return removeLabel(String(param1));
|
||||
}
|
||||
return kill(null,param1);
|
||||
}
|
||||
|
||||
override public function _remove(param1:Animation, param2:Boolean = false) : *
|
||||
{
|
||||
super._remove(param1,param2);
|
||||
if(_last == null)
|
||||
{
|
||||
_time = _totalTime = _duration = _totalDuration = 0;
|
||||
}
|
||||
else if(_time > _last._startTime + _last._totalDuration / _last._timeScale)
|
||||
{
|
||||
_time = duration();
|
||||
_totalTime = _totalDuration;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function append(param1:*, param2:* = 0) : *
|
||||
{
|
||||
return add(param1,_parseTimeOrLabel(null,param2,true,param1));
|
||||
}
|
||||
|
||||
public function insertMultiple(param1:Array, param2:* = 0, param3:String = "normal", param4:Number = 0) : *
|
||||
{
|
||||
return add(param1,param2 || 0,param3,param4);
|
||||
}
|
||||
|
||||
public function appendMultiple(param1:Array, param2:* = 0, param3:String = "normal", param4:Number = 0) : *
|
||||
{
|
||||
return add(param1,_parseTimeOrLabel(null,param2,true,param1),param3,param4);
|
||||
}
|
||||
|
||||
public function addLabel(param1:String, param2:* = "+=0") : *
|
||||
{
|
||||
_labels[param1] = _parseTimeOrLabel(param2);
|
||||
return this;
|
||||
}
|
||||
|
||||
public function removeLabel(param1:String) : *
|
||||
{
|
||||
delete _labels[param1];
|
||||
return this;
|
||||
}
|
||||
|
||||
public function getLabelTime(param1:String) : Number
|
||||
{
|
||||
return param1 in _labels ? Number(_labels[param1]) : -1;
|
||||
}
|
||||
|
||||
protected function _parseTimeOrLabel(param1:*, param2:* = 0, param3:Boolean = false, param4:Object = null) : Number
|
||||
{
|
||||
var _loc5_:int = 0;
|
||||
if(param4 is Animation && param4.timeline === this)
|
||||
{
|
||||
remove(param4);
|
||||
}
|
||||
else if(param4 is Array)
|
||||
{
|
||||
_loc5_ = int(param4.length);
|
||||
while(--_loc5_ > -1)
|
||||
{
|
||||
if(param4[_loc5_] is Animation && param4[_loc5_].timeline === this)
|
||||
{
|
||||
remove(param4[_loc5_]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(typeof param2 === "string")
|
||||
{
|
||||
return _parseTimeOrLabel(param2,param3 && typeof param1 === "number" && !(param2 in _labels) ? param1 - duration() : 0,param3);
|
||||
}
|
||||
param2 ||= 0;
|
||||
if(typeof param1 === "string" && (isNaN(param1) || param1 in _labels))
|
||||
{
|
||||
_loc5_ = int(param1.indexOf("="));
|
||||
if(_loc5_ === -1)
|
||||
{
|
||||
if(!(param1 in _labels))
|
||||
{
|
||||
return param3 ? (_labels[param1] = duration() + param2) : param2;
|
||||
}
|
||||
return _labels[param1] + param2;
|
||||
}
|
||||
param2 = parseInt(param1.charAt(_loc5_ - 1) + "1",10) * Number(param1.substr(_loc5_ + 1));
|
||||
param1 = _loc5_ > 1 ? _parseTimeOrLabel(param1.substr(0,_loc5_ - 1),0,param3) : duration();
|
||||
}
|
||||
else if(param1 == null)
|
||||
{
|
||||
param1 = duration();
|
||||
}
|
||||
return Number(param1) + param2;
|
||||
}
|
||||
|
||||
override public function seek(param1:*, param2:Boolean = true) : *
|
||||
{
|
||||
return totalTime(typeof param1 === "number" ? Number(param1) : _parseTimeOrLabel(param1),param2);
|
||||
}
|
||||
|
||||
public function stop() : *
|
||||
{
|
||||
return paused(true);
|
||||
}
|
||||
|
||||
public function gotoAndPlay(param1:*, param2:Boolean = true) : *
|
||||
{
|
||||
return play(param1,param2);
|
||||
}
|
||||
|
||||
public function gotoAndStop(param1:*, param2:Boolean = true) : *
|
||||
{
|
||||
return pause(param1,param2);
|
||||
}
|
||||
|
||||
override public function render(param1:Number, param2:Boolean = false, param3:Boolean = false) : Boolean
|
||||
{
|
||||
var _loc10_:Animation = null;
|
||||
var _loc13_:Boolean = false;
|
||||
var _loc5_:Animation = null;
|
||||
var _loc12_:String = null;
|
||||
var _loc9_:Boolean = false;
|
||||
if(_gc)
|
||||
{
|
||||
_enabled(true,false);
|
||||
}
|
||||
var _loc8_:Number = Number(!_dirty ? _totalDuration : totalDuration());
|
||||
var _loc7_:Number = _time;
|
||||
var _loc4_:Number = _startTime;
|
||||
var _loc11_:Number = _timeScale;
|
||||
var _loc6_:Boolean = _paused;
|
||||
if(param1 >= _loc8_)
|
||||
{
|
||||
_totalTime = _time = _loc8_;
|
||||
if(!_reversed)
|
||||
{
|
||||
if(!_hasPausedChild())
|
||||
{
|
||||
_loc13_ = true;
|
||||
_loc12_ = "onComplete";
|
||||
if(_duration === 0)
|
||||
{
|
||||
if(param1 === 0 || _rawPrevTime < 0 || _rawPrevTime === _tinyNum)
|
||||
{
|
||||
if(_rawPrevTime !== param1 && _first != null)
|
||||
{
|
||||
_loc9_ = true;
|
||||
if(_rawPrevTime > _tinyNum)
|
||||
{
|
||||
_loc12_ = "onReverseComplete";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_rawPrevTime = _duration !== 0 || !param2 || param1 !== 0 || _rawPrevTime === param1 ? param1 : _tinyNum;
|
||||
param1 = _loc8_ + 0.0001;
|
||||
}
|
||||
else if(param1 < 1e-7)
|
||||
{
|
||||
_totalTime = _time = 0;
|
||||
if(_loc7_ !== 0 || _duration === 0 && _rawPrevTime !== _tinyNum && (_rawPrevTime > 0 || param1 < 0 && _rawPrevTime >= 0))
|
||||
{
|
||||
_loc12_ = "onReverseComplete";
|
||||
_loc13_ = _reversed;
|
||||
}
|
||||
if(param1 < 0)
|
||||
{
|
||||
_active = false;
|
||||
if(_rawPrevTime >= 0 && _first != null)
|
||||
{
|
||||
_loc9_ = true;
|
||||
}
|
||||
_rawPrevTime = param1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_rawPrevTime = _duration || !param2 || param1 !== 0 || _rawPrevTime === param1 ? param1 : _tinyNum;
|
||||
param1 = 0;
|
||||
if(!_initted)
|
||||
{
|
||||
_loc9_ = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_totalTime = _time = _rawPrevTime = param1;
|
||||
}
|
||||
if((_time == _loc7_ || !_first) && !param3 && !_loc9_)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if(!_initted)
|
||||
{
|
||||
_initted = true;
|
||||
}
|
||||
if(!_active)
|
||||
{
|
||||
if(!_paused && _time !== _loc7_ && param1 > 0)
|
||||
{
|
||||
_active = true;
|
||||
}
|
||||
}
|
||||
if(_loc7_ == 0)
|
||||
{
|
||||
if(vars.onStart)
|
||||
{
|
||||
if(_time != 0)
|
||||
{
|
||||
if(!param2)
|
||||
{
|
||||
vars.onStart.apply(null,vars.onStartParams);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_time >= _loc7_)
|
||||
{
|
||||
_loc10_ = _first;
|
||||
while(_loc10_)
|
||||
{
|
||||
_loc5_ = _loc10_._next;
|
||||
if(_paused && !_loc6_)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if(_loc10_._active || _loc10_._startTime <= _time && !_loc10_._paused && !_loc10_._gc)
|
||||
{
|
||||
if(!_loc10_._reversed)
|
||||
{
|
||||
_loc10_.render((param1 - _loc10_._startTime) * _loc10_._timeScale,param2,param3);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc10_.render((!_loc10_._dirty ? _loc10_._totalDuration : _loc10_.totalDuration()) - (param1 - _loc10_._startTime) * _loc10_._timeScale,param2,param3);
|
||||
}
|
||||
}
|
||||
_loc10_ = _loc5_;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc10_ = _last;
|
||||
while(_loc10_)
|
||||
{
|
||||
_loc5_ = _loc10_._prev;
|
||||
if(_paused && !_loc6_)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if(_loc10_._active || _loc10_._startTime <= _loc7_ && !_loc10_._paused && !_loc10_._gc)
|
||||
{
|
||||
if(!_loc10_._reversed)
|
||||
{
|
||||
_loc10_.render((param1 - _loc10_._startTime) * _loc10_._timeScale,param2,param3);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc10_.render((!_loc10_._dirty ? _loc10_._totalDuration : _loc10_.totalDuration()) - (param1 - _loc10_._startTime) * _loc10_._timeScale,param2,param3);
|
||||
}
|
||||
}
|
||||
_loc10_ = _loc5_;
|
||||
}
|
||||
}
|
||||
if(_onUpdate != null)
|
||||
{
|
||||
if(!param2)
|
||||
{
|
||||
_onUpdate.apply(null,vars.onUpdateParams);
|
||||
}
|
||||
}
|
||||
if(_loc12_)
|
||||
{
|
||||
if(!_gc)
|
||||
{
|
||||
if(_loc4_ == _startTime || _loc11_ != _timeScale)
|
||||
{
|
||||
if(_time == 0 || _loc8_ >= totalDuration())
|
||||
{
|
||||
if(_loc13_)
|
||||
{
|
||||
if(_timeline.autoRemoveChildren)
|
||||
{
|
||||
_enabled(false,false);
|
||||
}
|
||||
_active = false;
|
||||
}
|
||||
if(!param2)
|
||||
{
|
||||
if(vars[_loc12_])
|
||||
{
|
||||
vars[_loc12_].apply(null,vars[_loc12_ + "Params"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public function _hasPausedChild() : Boolean
|
||||
{
|
||||
var _loc1_:Animation = _first;
|
||||
while(_loc1_)
|
||||
{
|
||||
if(_loc1_._paused || _loc1_ is TimelineLite && Boolean(TimelineLite(_loc1_)._hasPausedChild()))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
_loc1_ = _loc1_._next;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public function getChildren(param1:Boolean = true, param2:Boolean = true, param3:Boolean = true, param4:Number = -9999999999) : Array
|
||||
{
|
||||
var _loc6_:Array = [];
|
||||
var _loc5_:Animation = _first;
|
||||
var _loc7_:int = 0;
|
||||
while(_loc5_)
|
||||
{
|
||||
if(_loc5_._startTime >= param4)
|
||||
{
|
||||
if(_loc5_ is TweenLite)
|
||||
{
|
||||
if(param2)
|
||||
{
|
||||
_loc6_[_loc7_++] = _loc5_;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(param3)
|
||||
{
|
||||
_loc6_[_loc7_++] = _loc5_;
|
||||
}
|
||||
if(param1)
|
||||
{
|
||||
_loc6_ = _loc6_.concat(TimelineLite(_loc5_).getChildren(true,param2,param3));
|
||||
_loc7_ = int(_loc6_.length);
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc5_ = _loc5_._next;
|
||||
}
|
||||
return _loc6_;
|
||||
}
|
||||
|
||||
public function getTweensOf(param1:Object, param2:Boolean = true) : Array
|
||||
{
|
||||
var _loc4_:Array = null;
|
||||
var _loc6_:int = 0;
|
||||
var _loc7_:Boolean = this._gc;
|
||||
var _loc3_:Array = [];
|
||||
var _loc5_:int = 0;
|
||||
if(_loc7_)
|
||||
{
|
||||
_enabled(true,true);
|
||||
}
|
||||
_loc4_ = TweenLite.getTweensOf(param1);
|
||||
_loc6_ = int(_loc4_.length);
|
||||
while(--_loc6_ > -1)
|
||||
{
|
||||
if(_loc4_[_loc6_].timeline === this || param2 && _contains(_loc4_[_loc6_]))
|
||||
{
|
||||
_loc3_[_loc5_++] = _loc4_[_loc6_];
|
||||
}
|
||||
}
|
||||
if(_loc7_)
|
||||
{
|
||||
_enabled(false,true);
|
||||
}
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
private function _contains(param1:Animation) : Boolean
|
||||
{
|
||||
var _loc2_:SimpleTimeline = param1.timeline;
|
||||
while(_loc2_)
|
||||
{
|
||||
if(_loc2_ == this)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
_loc2_ = _loc2_.timeline;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public function shiftChildren(param1:Number, param2:Boolean = false, param3:Number = 0) : *
|
||||
{
|
||||
var _loc5_:Animation = _first;
|
||||
while(_loc5_)
|
||||
{
|
||||
if(_loc5_._startTime >= param3)
|
||||
{
|
||||
_loc5_._startTime += param1;
|
||||
}
|
||||
_loc5_ = _loc5_._next;
|
||||
}
|
||||
if(param2)
|
||||
{
|
||||
for(var _loc4_:String in _labels)
|
||||
{
|
||||
if(_labels[_loc4_] >= param3)
|
||||
{
|
||||
var _loc6_:String = _loc4_;
|
||||
var _loc7_:Number = _labels[_loc6_] + param1;
|
||||
_labels[_loc6_] = _loc7_;
|
||||
}
|
||||
}
|
||||
}
|
||||
_uncache(true);
|
||||
return this;
|
||||
}
|
||||
|
||||
override public function _kill(param1:Object = null, param2:Object = null) : Boolean
|
||||
{
|
||||
var _loc3_:Array = null;
|
||||
if(param1 == null)
|
||||
{
|
||||
if(param2 == null)
|
||||
{
|
||||
return _enabled(false,false);
|
||||
}
|
||||
}
|
||||
_loc3_ = param2 == null ? getChildren(true,true,false) : getTweensOf(param2);
|
||||
var _loc4_:int = int(_loc3_.length);
|
||||
var _loc5_:Boolean = false;
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
if(_loc3_[_loc4_]._kill(param1,param2))
|
||||
{
|
||||
_loc5_ = true;
|
||||
}
|
||||
}
|
||||
return _loc5_;
|
||||
}
|
||||
|
||||
public function clear(param1:Boolean = true) : *
|
||||
{
|
||||
var _loc2_:Array = null;
|
||||
_loc2_ = getChildren(false,true,true);
|
||||
var _loc3_:int = int(_loc2_.length);
|
||||
_time = _totalTime = 0;
|
||||
while(--_loc3_ > -1)
|
||||
{
|
||||
_loc2_[_loc3_]._enabled(false,false);
|
||||
}
|
||||
if(param1)
|
||||
{
|
||||
_labels = {};
|
||||
}
|
||||
return _uncache(true);
|
||||
}
|
||||
|
||||
override public function invalidate() : *
|
||||
{
|
||||
var _loc1_:Animation = _first;
|
||||
while(_loc1_)
|
||||
{
|
||||
_loc1_.invalidate();
|
||||
_loc1_ = _loc1_._next;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
override public function _enabled(param1:Boolean, param2:Boolean = false) : Boolean
|
||||
{
|
||||
var _loc3_:Animation = null;
|
||||
if(param1 == _gc)
|
||||
{
|
||||
_loc3_ = _first;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc3_._enabled(param1,true);
|
||||
_loc3_ = _loc3_._next;
|
||||
}
|
||||
}
|
||||
return super._enabled(param1,param2);
|
||||
}
|
||||
|
||||
override public function duration(param1:Number = NaN) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
if(_dirty)
|
||||
{
|
||||
totalDuration();
|
||||
}
|
||||
return _duration;
|
||||
}
|
||||
if(duration() !== 0)
|
||||
{
|
||||
if(param1 !== 0)
|
||||
{
|
||||
timeScale(_duration / param1);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
override public function totalDuration(param1:Number = NaN) : *
|
||||
{
|
||||
var _loc6_:Animation = null;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
if(!arguments.length)
|
||||
{
|
||||
if(_dirty)
|
||||
{
|
||||
_loc5_ = 0;
|
||||
var _loc4_:Animation = _last;
|
||||
var _loc3_:Number = Infinity;
|
||||
while(_loc4_)
|
||||
{
|
||||
_loc6_ = _loc4_._prev;
|
||||
if(_loc4_._dirty)
|
||||
{
|
||||
_loc4_.totalDuration();
|
||||
}
|
||||
if(_loc4_._startTime > _loc3_ && _sortChildren && !_loc4_._paused)
|
||||
{
|
||||
add(_loc4_,_loc4_._startTime - _loc4_._delay);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc3_ = _loc4_._startTime;
|
||||
}
|
||||
if(_loc4_._startTime < 0 && !_loc4_._paused)
|
||||
{
|
||||
_loc5_ -= _loc4_._startTime;
|
||||
if(_timeline.smoothChildTiming)
|
||||
{
|
||||
_startTime += _loc4_._startTime / _timeScale;
|
||||
}
|
||||
shiftChildren(-_loc4_._startTime,false,-9999999999);
|
||||
_loc3_ = 0;
|
||||
}
|
||||
_loc7_ = _loc4_._startTime + _loc4_._totalDuration / _loc4_._timeScale;
|
||||
if(_loc7_ > _loc5_)
|
||||
{
|
||||
_loc5_ = _loc7_;
|
||||
}
|
||||
_loc4_ = _loc6_;
|
||||
}
|
||||
_duration = _totalDuration = _loc5_;
|
||||
_dirty = false;
|
||||
}
|
||||
return _totalDuration;
|
||||
}
|
||||
if(totalDuration() != 0)
|
||||
{
|
||||
if(param1 != 0)
|
||||
{
|
||||
timeScale(_totalDuration / param1);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function usesFrames() : Boolean
|
||||
{
|
||||
var _loc1_:SimpleTimeline = _timeline;
|
||||
while(_loc1_._timeline)
|
||||
{
|
||||
_loc1_ = _loc1_._timeline;
|
||||
}
|
||||
return _loc1_ == _rootFramesTimeline;
|
||||
}
|
||||
|
||||
override public function rawTime() : Number
|
||||
{
|
||||
return _paused ? _totalTime : (_timeline.rawTime() - _startTime) * _timeScale;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,937 @@
|
||||
package com.greensock
|
||||
{
|
||||
import com.greensock.core.Animation;
|
||||
import com.greensock.core.PropTween;
|
||||
import com.greensock.core.SimpleTimeline;
|
||||
import com.greensock.events.TweenEvent;
|
||||
import com.greensock.plugins.AutoAlphaPlugin;
|
||||
import com.greensock.plugins.BevelFilterPlugin;
|
||||
import com.greensock.plugins.BezierPlugin;
|
||||
import com.greensock.plugins.BezierThroughPlugin;
|
||||
import com.greensock.plugins.BlurFilterPlugin;
|
||||
import com.greensock.plugins.ColorMatrixFilterPlugin;
|
||||
import com.greensock.plugins.ColorTransformPlugin;
|
||||
import com.greensock.plugins.DropShadowFilterPlugin;
|
||||
import com.greensock.plugins.EndArrayPlugin;
|
||||
import com.greensock.plugins.FrameLabelPlugin;
|
||||
import com.greensock.plugins.FramePlugin;
|
||||
import com.greensock.plugins.GlowFilterPlugin;
|
||||
import com.greensock.plugins.HexColorsPlugin;
|
||||
import com.greensock.plugins.RemoveTintPlugin;
|
||||
import com.greensock.plugins.RoundPropsPlugin;
|
||||
import com.greensock.plugins.ShortRotationPlugin;
|
||||
import com.greensock.plugins.TintPlugin;
|
||||
import com.greensock.plugins.TweenPlugin;
|
||||
import com.greensock.plugins.VisiblePlugin;
|
||||
import com.greensock.plugins.VolumePlugin;
|
||||
import flash.display.DisplayObject;
|
||||
import flash.display.DisplayObjectContainer;
|
||||
import flash.display.Shape;
|
||||
import flash.events.Event;
|
||||
import flash.events.EventDispatcher;
|
||||
import flash.events.IEventDispatcher;
|
||||
import flash.utils.getTimer;
|
||||
|
||||
public class TweenMax extends TweenLite implements IEventDispatcher
|
||||
{
|
||||
|
||||
public static const version:String = "12.1.5";
|
||||
|
||||
protected static var _listenerLookup:Object = {
|
||||
"onCompleteListener":"complete",
|
||||
"onUpdateListener":"change",
|
||||
"onStartListener":"start",
|
||||
"onRepeatListener":"repeat",
|
||||
"onReverseCompleteListener":"reverseComplete"
|
||||
};
|
||||
|
||||
public static var ticker:Shape = Animation.ticker;
|
||||
|
||||
public static var allTo:Function = staggerTo;
|
||||
|
||||
public static var allFrom:Function = staggerFrom;
|
||||
|
||||
public static var allFromTo:Function = staggerFromTo;
|
||||
|
||||
TweenPlugin.activate([AutoAlphaPlugin,EndArrayPlugin,FramePlugin,RemoveTintPlugin,TintPlugin,VisiblePlugin,VolumePlugin,BevelFilterPlugin,BezierPlugin,BezierThroughPlugin,BlurFilterPlugin,ColorMatrixFilterPlugin,ColorTransformPlugin,DropShadowFilterPlugin,FrameLabelPlugin,GlowFilterPlugin,HexColorsPlugin,RoundPropsPlugin,ShortRotationPlugin]);
|
||||
|
||||
protected var _dispatcher:EventDispatcher;
|
||||
|
||||
protected var _hasUpdateListener:Boolean;
|
||||
|
||||
protected var _repeat:int = 0;
|
||||
|
||||
protected var _repeatDelay:Number = 0;
|
||||
|
||||
protected var _cycle:int = 0;
|
||||
|
||||
public var _yoyo:Boolean;
|
||||
|
||||
public function TweenMax(param1:Object, param2:Number, param3:Object)
|
||||
{
|
||||
super(param1,param2,param3);
|
||||
_yoyo = this.vars.yoyo == true;
|
||||
_repeat = int(this.vars.repeat);
|
||||
_repeatDelay = this.vars.repeatDelay || 0;
|
||||
_dirty = true;
|
||||
if(this.vars.onCompleteListener || this.vars.onUpdateListener || this.vars.onStartListener || this.vars.onRepeatListener || this.vars.onReverseCompleteListener)
|
||||
{
|
||||
_initDispatcher();
|
||||
if(_duration == 0)
|
||||
{
|
||||
if(_delay == 0)
|
||||
{
|
||||
if(this.vars.immediateRender)
|
||||
{
|
||||
_dispatcher.dispatchEvent(new TweenEvent("change"));
|
||||
_dispatcher.dispatchEvent(new TweenEvent("complete"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static function killTweensOf(param1:*, param2:* = false, param3:Object = null) : void
|
||||
{
|
||||
TweenLite.killTweensOf(param1,param2,param3);
|
||||
}
|
||||
|
||||
public static function killDelayedCallsTo(param1:Function) : void
|
||||
{
|
||||
TweenLite.killTweensOf(param1);
|
||||
}
|
||||
|
||||
public static function getTweensOf(param1:*, param2:Boolean = false) : Array
|
||||
{
|
||||
return TweenLite.getTweensOf(param1,param2);
|
||||
}
|
||||
|
||||
public static function to(param1:Object, param2:Number, param3:Object) : TweenMax
|
||||
{
|
||||
return new TweenMax(param1,param2,param3);
|
||||
}
|
||||
|
||||
public static function from(param1:Object, param2:Number, param3:Object) : TweenMax
|
||||
{
|
||||
param3 = _prepVars(param3,true);
|
||||
param3.runBackwards = true;
|
||||
return new TweenMax(param1,param2,param3);
|
||||
}
|
||||
|
||||
public static function fromTo(param1:Object, param2:Number, param3:Object, param4:Object) : TweenMax
|
||||
{
|
||||
param4 = _prepVars(param4,false);
|
||||
param3 = _prepVars(param3,false);
|
||||
param4.startAt = param3;
|
||||
param4.immediateRender = param4.immediateRender != false && param3.immediateRender != false;
|
||||
return new TweenMax(param1,param2,param4);
|
||||
}
|
||||
|
||||
public static function staggerTo(param1:Array, param2:Number, param3:Object, param4:Number = 0, param5:Function = null, param6:Array = null) : Array
|
||||
{
|
||||
var copy:Object;
|
||||
var p:String;
|
||||
var targets:Array = param1;
|
||||
var duration:Number = param2;
|
||||
var vars:Object = param3;
|
||||
var stagger:Number = param4;
|
||||
var onCompleteAll:Function = param5;
|
||||
var onCompleteAllParams:Array = param6;
|
||||
vars = _prepVars(vars,false);
|
||||
var a:Array = [];
|
||||
var l:int = int(targets.length);
|
||||
var delay:Number = Number(vars.delay || 0);
|
||||
var i:int = 0;
|
||||
while(i < l)
|
||||
{
|
||||
copy = {};
|
||||
for(p in vars)
|
||||
{
|
||||
copy[p] = vars[p];
|
||||
}
|
||||
copy.delay = delay;
|
||||
if(i == l - 1)
|
||||
{
|
||||
if(onCompleteAll != null)
|
||||
{
|
||||
copy.onComplete = function():void
|
||||
{
|
||||
if(vars.onComplete)
|
||||
{
|
||||
vars.onComplete.apply(null,arguments);
|
||||
}
|
||||
onCompleteAll.apply(null,onCompleteAllParams);
|
||||
};
|
||||
}
|
||||
}
|
||||
a[i] = new TweenMax(targets[i],duration,copy);
|
||||
delay += stagger;
|
||||
i = i + 1;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
public static function staggerFrom(param1:Array, param2:Number, param3:Object, param4:Number = 0, param5:Function = null, param6:Array = null) : Array
|
||||
{
|
||||
param3 = _prepVars(param3,true);
|
||||
param3.runBackwards = true;
|
||||
if(param3.immediateRender != false)
|
||||
{
|
||||
param3.immediateRender = true;
|
||||
}
|
||||
return staggerTo(param1,param2,param3,param4,param5,param6);
|
||||
}
|
||||
|
||||
public static function staggerFromTo(param1:Array, param2:Number, param3:Object, param4:Object, param5:Number = 0, param6:Function = null, param7:Array = null) : Array
|
||||
{
|
||||
param4 = _prepVars(param4,false);
|
||||
param3 = _prepVars(param3,false);
|
||||
param4.startAt = param3;
|
||||
param4.immediateRender = param4.immediateRender != false && param3.immediateRender != false;
|
||||
return staggerTo(param1,param2,param4,param5,param6,param7);
|
||||
}
|
||||
|
||||
public static function delayedCall(param1:Number, param2:Function, param3:Array = null, param4:Boolean = false) : TweenMax
|
||||
{
|
||||
return new TweenMax(param2,0,{
|
||||
"delay":param1,
|
||||
"onComplete":param2,
|
||||
"onCompleteParams":param3,
|
||||
"onReverseComplete":param2,
|
||||
"onReverseCompleteParams":param3,
|
||||
"immediateRender":false,
|
||||
"useFrames":param4,
|
||||
"overwrite":0
|
||||
});
|
||||
}
|
||||
|
||||
public static function set(param1:Object, param2:Object) : TweenMax
|
||||
{
|
||||
return new TweenMax(param1,0,param2);
|
||||
}
|
||||
|
||||
public static function isTweening(param1:Object) : Boolean
|
||||
{
|
||||
return TweenLite.getTweensOf(param1,true).length > 0;
|
||||
}
|
||||
|
||||
public static function getAllTweens(param1:Boolean = false) : Array
|
||||
{
|
||||
var _loc2_:Array = _getChildrenOf(_rootTimeline,param1);
|
||||
return _loc2_.concat(_getChildrenOf(_rootFramesTimeline,param1));
|
||||
}
|
||||
|
||||
protected static function _getChildrenOf(param1:SimpleTimeline, param2:Boolean) : Array
|
||||
{
|
||||
if(param1 == null)
|
||||
{
|
||||
return [];
|
||||
}
|
||||
var _loc4_:Array = [];
|
||||
var _loc5_:int = 0;
|
||||
var _loc3_:Animation = param1._first;
|
||||
while(_loc3_)
|
||||
{
|
||||
if(_loc3_ is TweenLite)
|
||||
{
|
||||
_loc4_[_loc5_++] = _loc3_;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(param2)
|
||||
{
|
||||
_loc4_[_loc5_++] = _loc3_;
|
||||
}
|
||||
_loc4_ = _loc4_.concat(_getChildrenOf(SimpleTimeline(_loc3_),param2));
|
||||
_loc5_ = int(_loc4_.length);
|
||||
}
|
||||
_loc3_ = _loc3_._next;
|
||||
}
|
||||
return _loc4_;
|
||||
}
|
||||
|
||||
public static function killAll(param1:Boolean = false, param2:Boolean = true, param3:Boolean = true, param4:Boolean = true) : void
|
||||
{
|
||||
var _loc7_:Boolean = false;
|
||||
var _loc6_:Animation = null;
|
||||
var _loc8_:int = 0;
|
||||
var _loc5_:Array = null;
|
||||
_loc5_ = getAllTweens(param4);
|
||||
var _loc9_:int = int(_loc5_.length);
|
||||
var _loc10_:Boolean = param2 && param3 && param4;
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < _loc9_)
|
||||
{
|
||||
_loc6_ = _loc5_[_loc8_];
|
||||
if(_loc10_ || _loc6_ is SimpleTimeline || _loc7_ == (TweenLite(_loc6_).target == TweenLite(_loc6_).vars.onComplete) && param3 || param2 && !_loc7_)
|
||||
{
|
||||
if(param1)
|
||||
{
|
||||
_loc6_.totalTime(_loc6_._reversed ? 0 : _loc6_.totalDuration());
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_._enabled(false,false);
|
||||
}
|
||||
}
|
||||
_loc8_++;
|
||||
}
|
||||
}
|
||||
|
||||
public static function killChildTweensOf(param1:DisplayObjectContainer, param2:Boolean = false) : void
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
var _loc3_:Array = null;
|
||||
_loc3_ = getAllTweens(false);
|
||||
var _loc5_:int = int(_loc3_.length);
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < _loc5_)
|
||||
{
|
||||
if(_containsChildOf(param1,_loc3_[_loc4_].target))
|
||||
{
|
||||
if(param2)
|
||||
{
|
||||
_loc3_[_loc4_].totalTime(_loc3_[_loc4_].totalDuration());
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc3_[_loc4_]._enabled(false,false);
|
||||
}
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
}
|
||||
|
||||
private static function _containsChildOf(param1:DisplayObjectContainer, param2:Object) : Boolean
|
||||
{
|
||||
var _loc4_:DisplayObjectContainer = null;
|
||||
var _loc3_:int = 0;
|
||||
if(param2 is Array)
|
||||
{
|
||||
_loc3_ = int(param2.length);
|
||||
while(--_loc3_ > -1)
|
||||
{
|
||||
if(_containsChildOf(param1,param2[_loc3_]))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(param2 is DisplayObject)
|
||||
{
|
||||
_loc4_ = param2.parent;
|
||||
while(_loc4_)
|
||||
{
|
||||
if(_loc4_ == param1)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
_loc4_ = _loc4_.parent;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static function pauseAll(param1:Boolean = true, param2:Boolean = true, param3:Boolean = true) : void
|
||||
{
|
||||
_changePause(true,param1,param2,param3);
|
||||
}
|
||||
|
||||
public static function resumeAll(param1:Boolean = true, param2:Boolean = true, param3:Boolean = true) : void
|
||||
{
|
||||
_changePause(false,param1,param2,param3);
|
||||
}
|
||||
|
||||
private static function _changePause(param1:Boolean, param2:Boolean = true, param3:Boolean = false, param4:Boolean = true) : void
|
||||
{
|
||||
var _loc7_:Boolean = false;
|
||||
var _loc5_:Animation = null;
|
||||
var _loc6_:Array = null;
|
||||
_loc6_ = getAllTweens(param4);
|
||||
var _loc9_:Boolean = param2 && param3 && param4;
|
||||
var _loc8_:int = int(_loc6_.length);
|
||||
while(--_loc8_ > -1)
|
||||
{
|
||||
_loc5_ = _loc6_[_loc8_];
|
||||
_loc7_ = _loc5_ is TweenLite && TweenLite(_loc5_).target == _loc5_.vars.onComplete;
|
||||
if(_loc9_ || _loc5_ is SimpleTimeline || _loc7_ && param3 || param2 && !_loc7_)
|
||||
{
|
||||
_loc5_.paused(param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static function globalTimeScale(param1:Number = NaN) : Number
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _rootTimeline == null ? 1 : _rootTimeline._timeScale;
|
||||
}
|
||||
param1 ||= 0.0001;
|
||||
if(_rootTimeline == null)
|
||||
{
|
||||
TweenLite.to({},0,{});
|
||||
}
|
||||
var _loc4_:SimpleTimeline = _rootTimeline;
|
||||
var _loc3_:Number = getTimer() / 1000;
|
||||
_loc4_._startTime = _loc3_ - (_loc3_ - _loc4_._startTime) * _loc4_._timeScale / param1;
|
||||
_loc4_ = _rootFramesTimeline;
|
||||
_loc3_ = _rootFrame;
|
||||
_loc4_._startTime = _loc3_ - (_loc3_ - _loc4_._startTime) * _loc4_._timeScale / param1;
|
||||
_rootFramesTimeline._timeScale = _rootTimeline._timeScale = param1;
|
||||
return param1;
|
||||
}
|
||||
|
||||
override public function invalidate() : *
|
||||
{
|
||||
_yoyo = this.vars.yoyo == true;
|
||||
_repeat = this.vars.repeat || 0;
|
||||
_repeatDelay = this.vars.repeatDelay || 0;
|
||||
_hasUpdateListener = false;
|
||||
_initDispatcher();
|
||||
_uncache(true);
|
||||
return super.invalidate();
|
||||
}
|
||||
|
||||
public function updateTo(param1:Object, param2:Boolean = false) : *
|
||||
{
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc8_:Number = ratio;
|
||||
if(param2)
|
||||
{
|
||||
if(_startTime < _timeline._time)
|
||||
{
|
||||
_startTime = _timeline._time;
|
||||
_uncache(false);
|
||||
if(_gc)
|
||||
{
|
||||
_enabled(true,false);
|
||||
}
|
||||
else
|
||||
{
|
||||
_timeline.insert(this,_startTime - _delay);
|
||||
}
|
||||
}
|
||||
}
|
||||
for(var _loc3_:String in param1)
|
||||
{
|
||||
this.vars[_loc3_] = param1[_loc3_];
|
||||
}
|
||||
if(_initted)
|
||||
{
|
||||
if(param2)
|
||||
{
|
||||
_initted = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(_gc)
|
||||
{
|
||||
_enabled(true,false);
|
||||
}
|
||||
if(_notifyPluginsOfEnabled)
|
||||
{
|
||||
if(_firstPT != null)
|
||||
{
|
||||
_onPluginEvent("_onDisable",this);
|
||||
}
|
||||
}
|
||||
if(_time / _duration > 0.998)
|
||||
{
|
||||
_loc7_ = _time;
|
||||
render(0,true,false);
|
||||
_initted = false;
|
||||
render(_loc7_,true,false);
|
||||
}
|
||||
else if(_time > 0)
|
||||
{
|
||||
_initted = false;
|
||||
_init();
|
||||
_loc4_ = 1 / (1 - _loc8_);
|
||||
var _loc5_:PropTween = _firstPT;
|
||||
while(_loc5_)
|
||||
{
|
||||
_loc6_ = _loc5_.s + _loc5_.c;
|
||||
_loc5_.c *= _loc4_;
|
||||
_loc5_.s = _loc6_ - _loc5_.c;
|
||||
_loc5_ = _loc5_._next;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
override public function render(param1:Number, param2:Boolean = false, param3:Boolean = false) : Boolean
|
||||
{
|
||||
var _loc15_:Boolean = false;
|
||||
var _loc13_:String = null;
|
||||
var _loc5_:PropTween = null;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
if(!_initted)
|
||||
{
|
||||
if(_duration === 0 && vars.repeat)
|
||||
{
|
||||
invalidate();
|
||||
}
|
||||
}
|
||||
var _loc7_:Number = Number(!_dirty ? _totalDuration : totalDuration());
|
||||
var _loc6_:Number = _time;
|
||||
var _loc9_:Number = _totalTime;
|
||||
var _loc4_:Number = _cycle;
|
||||
if(param1 >= _loc7_)
|
||||
{
|
||||
_totalTime = _loc7_;
|
||||
_cycle = _repeat;
|
||||
if(_yoyo && (_cycle & 1) != 0)
|
||||
{
|
||||
_time = 0;
|
||||
ratio = _ease._calcEnd ? _ease.getRatio(0) : 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_time = _duration;
|
||||
ratio = _ease._calcEnd ? _ease.getRatio(1) : 1;
|
||||
}
|
||||
if(!_reversed)
|
||||
{
|
||||
_loc15_ = true;
|
||||
_loc13_ = "onComplete";
|
||||
}
|
||||
if(_duration == 0)
|
||||
{
|
||||
_loc12_ = _rawPrevTime;
|
||||
if(_startTime === _timeline._duration)
|
||||
{
|
||||
param1 = 0;
|
||||
}
|
||||
if(param1 === 0 || _loc12_ < 0 || _loc12_ === _tinyNum)
|
||||
{
|
||||
if(_loc12_ !== param1)
|
||||
{
|
||||
param3 = true;
|
||||
if(_loc12_ > _tinyNum)
|
||||
{
|
||||
_loc13_ = "onReverseComplete";
|
||||
}
|
||||
}
|
||||
}
|
||||
_rawPrevTime = _loc12_ = !param2 || param1 !== 0 || _rawPrevTime === param1 ? param1 : _tinyNum;
|
||||
}
|
||||
}
|
||||
else if(param1 < 1e-7)
|
||||
{
|
||||
_totalTime = _time = _cycle = 0;
|
||||
ratio = _ease._calcEnd ? _ease.getRatio(0) : 0;
|
||||
if(_loc9_ !== 0 || _duration === 0 && _rawPrevTime > 0 && _rawPrevTime !== _tinyNum)
|
||||
{
|
||||
_loc13_ = "onReverseComplete";
|
||||
_loc15_ = _reversed;
|
||||
}
|
||||
if(param1 < 0)
|
||||
{
|
||||
_active = false;
|
||||
if(_duration == 0)
|
||||
{
|
||||
if(_rawPrevTime >= 0)
|
||||
{
|
||||
param3 = true;
|
||||
}
|
||||
_rawPrevTime = _loc12_ = !param2 || param1 !== 0 || _rawPrevTime === param1 ? param1 : _tinyNum;
|
||||
}
|
||||
}
|
||||
else if(!_initted)
|
||||
{
|
||||
param3 = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_totalTime = _time = param1;
|
||||
if(_repeat != 0)
|
||||
{
|
||||
_loc11_ = _duration + _repeatDelay;
|
||||
_cycle = _totalTime / _loc11_ >> 0;
|
||||
if(_cycle !== 0)
|
||||
{
|
||||
if(_cycle === _totalTime / _loc11_)
|
||||
{
|
||||
_cycle = _cycle - 1;
|
||||
}
|
||||
}
|
||||
_time = _totalTime - _cycle * _loc11_;
|
||||
if(_yoyo)
|
||||
{
|
||||
if((_cycle & 1) != 0)
|
||||
{
|
||||
_time = _duration - _time;
|
||||
}
|
||||
}
|
||||
if(_time > _duration)
|
||||
{
|
||||
_time = _duration;
|
||||
}
|
||||
else if(_time < 0)
|
||||
{
|
||||
_time = 0;
|
||||
}
|
||||
}
|
||||
if(_easeType)
|
||||
{
|
||||
_loc10_ = _time / _duration;
|
||||
var _loc8_:int = _easeType;
|
||||
var _loc14_:int = _easePower;
|
||||
if(_loc8_ == 1 || _loc8_ == 3 && _loc10_ >= 0.5)
|
||||
{
|
||||
_loc10_ = 1 - _loc10_;
|
||||
}
|
||||
if(_loc8_ == 3)
|
||||
{
|
||||
_loc10_ *= 2;
|
||||
}
|
||||
if(_loc14_ == 1)
|
||||
{
|
||||
_loc10_ *= _loc10_;
|
||||
}
|
||||
else if(_loc14_ == 2)
|
||||
{
|
||||
_loc10_ *= _loc10_ * _loc10_;
|
||||
}
|
||||
else if(_loc14_ == 3)
|
||||
{
|
||||
_loc10_ *= _loc10_ * _loc10_ * _loc10_;
|
||||
}
|
||||
else if(_loc14_ == 4)
|
||||
{
|
||||
_loc10_ *= _loc10_ * _loc10_ * _loc10_ * _loc10_;
|
||||
}
|
||||
if(_loc8_ == 1)
|
||||
{
|
||||
ratio = 1 - _loc10_;
|
||||
}
|
||||
else if(_loc8_ == 2)
|
||||
{
|
||||
ratio = _loc10_;
|
||||
}
|
||||
else if(_time / _duration < 0.5)
|
||||
{
|
||||
ratio = _loc10_ / 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
ratio = 1 - _loc10_ / 2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ratio = _ease.getRatio(_time / _duration);
|
||||
}
|
||||
}
|
||||
if(_loc6_ == _time && !param3 && _cycle === _loc4_)
|
||||
{
|
||||
if(_loc9_ !== _totalTime)
|
||||
{
|
||||
if(_onUpdate != null)
|
||||
{
|
||||
if(!param2)
|
||||
{
|
||||
_onUpdate.apply(vars.onUpdateScope || this,vars.onUpdateParams);
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if(!_initted)
|
||||
{
|
||||
_init();
|
||||
if(!_initted || _gc)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if(_time && !_loc15_)
|
||||
{
|
||||
ratio = _ease.getRatio(_time / _duration);
|
||||
}
|
||||
else if(_loc15_ && _ease._calcEnd)
|
||||
{
|
||||
ratio = _ease.getRatio(_time === 0 ? 0 : 1);
|
||||
}
|
||||
}
|
||||
if(!_active)
|
||||
{
|
||||
if(!_paused && _time !== _loc6_ && param1 >= 0)
|
||||
{
|
||||
_active = true;
|
||||
}
|
||||
}
|
||||
if(_loc9_ == 0)
|
||||
{
|
||||
if(_startAt != null)
|
||||
{
|
||||
if(param1 >= 0)
|
||||
{
|
||||
_startAt.render(param1,param2,param3);
|
||||
}
|
||||
else if(!_loc13_)
|
||||
{
|
||||
_loc13_ = "_dummyGS";
|
||||
}
|
||||
}
|
||||
if(_totalTime != 0 || _duration == 0)
|
||||
{
|
||||
if(!param2)
|
||||
{
|
||||
if(vars.onStart)
|
||||
{
|
||||
vars.onStart.apply(null,vars.onStartParams);
|
||||
}
|
||||
if(_dispatcher)
|
||||
{
|
||||
_dispatcher.dispatchEvent(new TweenEvent("start"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc5_ = _firstPT;
|
||||
while(_loc5_)
|
||||
{
|
||||
if(_loc5_.f)
|
||||
{
|
||||
_loc5_.t[_loc5_.p](_loc5_.c * ratio + _loc5_.s);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_.t[_loc5_.p] = _loc5_.c * ratio + _loc5_.s;
|
||||
}
|
||||
_loc5_ = _loc5_._next;
|
||||
}
|
||||
if(_onUpdate != null)
|
||||
{
|
||||
if(param1 < 0 && _startAt != null && _startTime != 0)
|
||||
{
|
||||
_startAt.render(param1,param2,param3);
|
||||
}
|
||||
if(!param2)
|
||||
{
|
||||
if(_totalTime !== _loc9_ || _loc15_)
|
||||
{
|
||||
_onUpdate.apply(null,vars.onUpdateParams);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_hasUpdateListener)
|
||||
{
|
||||
if(param1 < 0 && _startAt != null && _onUpdate == null && _startTime != 0)
|
||||
{
|
||||
_startAt.render(param1,param2,param3);
|
||||
}
|
||||
if(!param2)
|
||||
{
|
||||
_dispatcher.dispatchEvent(new TweenEvent("change"));
|
||||
}
|
||||
}
|
||||
if(_cycle != _loc4_)
|
||||
{
|
||||
if(!param2)
|
||||
{
|
||||
if(!_gc)
|
||||
{
|
||||
if(vars.onRepeat)
|
||||
{
|
||||
vars.onRepeat.apply(null,vars.onRepeatParams);
|
||||
}
|
||||
if(_dispatcher)
|
||||
{
|
||||
_dispatcher.dispatchEvent(new TweenEvent("repeat"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_loc13_)
|
||||
{
|
||||
if(!_gc)
|
||||
{
|
||||
if(param1 < 0 && _startAt != null && _onUpdate == null && !_hasUpdateListener && _startTime != 0)
|
||||
{
|
||||
_startAt.render(param1,param2,true);
|
||||
}
|
||||
if(_loc15_)
|
||||
{
|
||||
if(_timeline.autoRemoveChildren)
|
||||
{
|
||||
_enabled(false,false);
|
||||
}
|
||||
_active = false;
|
||||
}
|
||||
if(!param2)
|
||||
{
|
||||
if(vars[_loc13_])
|
||||
{
|
||||
vars[_loc13_].apply(null,vars[_loc13_ + "Params"]);
|
||||
}
|
||||
if(_dispatcher)
|
||||
{
|
||||
_dispatcher.dispatchEvent(new TweenEvent(_loc13_ == "onComplete" ? "complete" : "reverseComplete"));
|
||||
}
|
||||
}
|
||||
if(_duration === 0 && _rawPrevTime === _tinyNum && _loc12_ !== _tinyNum)
|
||||
{
|
||||
_rawPrevTime = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
protected function _initDispatcher() : Boolean
|
||||
{
|
||||
var _loc1_:String = null;
|
||||
var _loc2_:Boolean = false;
|
||||
for(_loc1_ in _listenerLookup)
|
||||
{
|
||||
if(_loc1_ in vars)
|
||||
{
|
||||
if(vars[_loc1_] is Function)
|
||||
{
|
||||
if(_dispatcher == null)
|
||||
{
|
||||
_dispatcher = new EventDispatcher(this);
|
||||
}
|
||||
_dispatcher.addEventListener(_listenerLookup[_loc1_],vars[_loc1_],false,0,true);
|
||||
_loc2_ = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
|
||||
{
|
||||
if(_dispatcher == null)
|
||||
{
|
||||
_dispatcher = new EventDispatcher(this);
|
||||
}
|
||||
if(param1 == "change")
|
||||
{
|
||||
_hasUpdateListener = true;
|
||||
}
|
||||
_dispatcher.addEventListener(param1,param2,param3,param4,param5);
|
||||
}
|
||||
|
||||
public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
|
||||
{
|
||||
if(_dispatcher)
|
||||
{
|
||||
_dispatcher.removeEventListener(param1,param2,param3);
|
||||
}
|
||||
}
|
||||
|
||||
public function hasEventListener(param1:String) : Boolean
|
||||
{
|
||||
return _dispatcher == null ? false : _dispatcher.hasEventListener(param1);
|
||||
}
|
||||
|
||||
public function willTrigger(param1:String) : Boolean
|
||||
{
|
||||
return _dispatcher == null ? false : _dispatcher.willTrigger(param1);
|
||||
}
|
||||
|
||||
public function dispatchEvent(param1:Event) : Boolean
|
||||
{
|
||||
return _dispatcher == null ? false : _dispatcher.dispatchEvent(param1);
|
||||
}
|
||||
|
||||
override public function progress(param1:Number = NaN, param2:Boolean = false) : *
|
||||
{
|
||||
return !arguments.length ? _time / duration() : totalTime(duration() * (_yoyo && (_cycle & 1) !== 0 ? 1 - param1 : param1) + _cycle * (_duration + _repeatDelay),param2);
|
||||
}
|
||||
|
||||
override public function totalProgress(param1:Number = NaN, param2:Boolean = false) : *
|
||||
{
|
||||
return !arguments.length ? _totalTime / totalDuration() : totalTime(totalDuration() * param1,param2);
|
||||
}
|
||||
|
||||
override public function time(param1:Number = NaN, param2:Boolean = false) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _time;
|
||||
}
|
||||
if(_dirty)
|
||||
{
|
||||
totalDuration();
|
||||
}
|
||||
if(param1 > _duration)
|
||||
{
|
||||
param1 = _duration;
|
||||
}
|
||||
if(_yoyo && (_cycle & 1) !== 0)
|
||||
{
|
||||
param1 = _duration - param1 + _cycle * (_duration + _repeatDelay);
|
||||
}
|
||||
else if(_repeat != 0)
|
||||
{
|
||||
param1 += _cycle * (_duration + _repeatDelay);
|
||||
}
|
||||
return totalTime(param1,param2);
|
||||
}
|
||||
|
||||
override public function duration(param1:Number = NaN) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return this._duration;
|
||||
}
|
||||
return super.duration(param1);
|
||||
}
|
||||
|
||||
override public function totalDuration(param1:Number = NaN) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
if(_dirty)
|
||||
{
|
||||
_totalDuration = _repeat == -1 ? 999999999999 : _duration * (_repeat + 1) + _repeatDelay * _repeat;
|
||||
_dirty = false;
|
||||
}
|
||||
return _totalDuration;
|
||||
}
|
||||
return _repeat == -1 ? this : duration((param1 - _repeat * _repeatDelay) / (_repeat + 1));
|
||||
}
|
||||
|
||||
public function repeat(param1:int = 0) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _repeat;
|
||||
}
|
||||
_repeat = param1;
|
||||
return _uncache(true);
|
||||
}
|
||||
|
||||
public function repeatDelay(param1:Number = NaN) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _repeatDelay;
|
||||
}
|
||||
_repeatDelay = param1;
|
||||
return _uncache(true);
|
||||
}
|
||||
|
||||
public function yoyo(param1:Boolean = false) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _yoyo;
|
||||
}
|
||||
_yoyo = param1;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,480 @@
|
||||
package com.greensock.core
|
||||
{
|
||||
import flash.display.Shape;
|
||||
import flash.events.Event;
|
||||
import flash.utils.getTimer;
|
||||
|
||||
public class Animation
|
||||
{
|
||||
|
||||
public static const version:String = "12.1.1";
|
||||
|
||||
public static var _rootTimeline:SimpleTimeline;
|
||||
|
||||
public static var _rootFramesTimeline:SimpleTimeline;
|
||||
|
||||
protected static var _rootFrame:Number = -1;
|
||||
|
||||
protected static var _tinyNum:Number = 1e-10;
|
||||
|
||||
public static var ticker:Shape = new Shape();
|
||||
|
||||
protected static var _tickEvent:Event = new Event("tick");
|
||||
|
||||
protected var _onUpdate:Function;
|
||||
|
||||
public var _delay:Number;
|
||||
|
||||
public var _rawPrevTime:Number;
|
||||
|
||||
public var _active:Boolean;
|
||||
|
||||
public var _gc:Boolean;
|
||||
|
||||
public var _initted:Boolean;
|
||||
|
||||
public var _startTime:Number;
|
||||
|
||||
public var _time:Number;
|
||||
|
||||
public var _totalTime:Number;
|
||||
|
||||
public var _duration:Number;
|
||||
|
||||
public var _totalDuration:Number;
|
||||
|
||||
public var _pauseTime:Number;
|
||||
|
||||
public var _timeScale:Number;
|
||||
|
||||
public var _reversed:Boolean;
|
||||
|
||||
public var _timeline:SimpleTimeline;
|
||||
|
||||
public var _dirty:Boolean;
|
||||
|
||||
public var _paused:Boolean;
|
||||
|
||||
public var _next:Animation;
|
||||
|
||||
public var _prev:Animation;
|
||||
|
||||
public var vars:Object;
|
||||
|
||||
public var timeline:SimpleTimeline;
|
||||
|
||||
public var data:*;
|
||||
|
||||
public function Animation(param1:Number = 0, param2:Object = null)
|
||||
{
|
||||
super();
|
||||
this.vars = param2 || {};
|
||||
if(this.vars._isGSVars)
|
||||
{
|
||||
this.vars = this.vars.vars;
|
||||
}
|
||||
_duration = _totalDuration = param1 || 0;
|
||||
_delay = Number(this.vars.delay) || 0;
|
||||
_timeScale = 1;
|
||||
_totalTime = _time = 0;
|
||||
data = this.vars.data;
|
||||
_rawPrevTime = -1;
|
||||
if(_rootTimeline == null)
|
||||
{
|
||||
if(_rootFrame != -1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_rootFrame = 0;
|
||||
_rootFramesTimeline = new SimpleTimeline();
|
||||
_rootTimeline = new SimpleTimeline();
|
||||
_rootTimeline._startTime = getTimer() / 1000;
|
||||
_rootFramesTimeline._startTime = 0;
|
||||
_rootTimeline._active = _rootFramesTimeline._active = true;
|
||||
ticker.addEventListener("enterFrame",_updateRoot,false,0,true);
|
||||
}
|
||||
var _loc3_:SimpleTimeline = this.vars.useFrames ? _rootFramesTimeline : _rootTimeline;
|
||||
_loc3_.add(this,_loc3_._time);
|
||||
_reversed = this.vars.reversed == true;
|
||||
if(this.vars.paused)
|
||||
{
|
||||
paused(true);
|
||||
}
|
||||
}
|
||||
|
||||
public static function _updateRoot(param1:Event = null) : void
|
||||
{
|
||||
_rootFrame = _rootFrame + 1;
|
||||
if(_rootTimeline.renderCreateTime(_rootTimeline._startTime,_rootTimeline._timeScale,false,false) && _rootFramesTimeline.render((_rootFrame - _rootFramesTimeline._startTime) * _rootFramesTimeline._timeScale,false,false))
|
||||
{
|
||||
ticker.dispatchEvent(_tickEvent);
|
||||
}
|
||||
}
|
||||
|
||||
public function play(param1:* = null, param2:Boolean = true) : *
|
||||
{
|
||||
if(param1 != null)
|
||||
{
|
||||
seek(param1,param2);
|
||||
}
|
||||
reversed(false);
|
||||
return paused(false);
|
||||
}
|
||||
|
||||
public function pause(param1:* = null, param2:Boolean = true) : *
|
||||
{
|
||||
if(param1 != null)
|
||||
{
|
||||
seek(param1,param2);
|
||||
}
|
||||
return paused(true);
|
||||
}
|
||||
|
||||
public function resume(param1:* = null, param2:Boolean = true) : *
|
||||
{
|
||||
if(param1 != null)
|
||||
{
|
||||
seek(param1,param2);
|
||||
}
|
||||
return paused(false);
|
||||
}
|
||||
|
||||
public function seek(param1:*, param2:Boolean = true) : *
|
||||
{
|
||||
return totalTime(Number(param1),param2);
|
||||
}
|
||||
|
||||
public function restart(param1:Boolean = false, param2:Boolean = true) : *
|
||||
{
|
||||
reversed(false);
|
||||
paused(false);
|
||||
return totalTime(param1 ? -_delay : 0,param2,true);
|
||||
}
|
||||
|
||||
public function reverse(param1:* = null, param2:Boolean = true) : *
|
||||
{
|
||||
if(param1 != null)
|
||||
{
|
||||
seek(param1 || totalDuration(),param2);
|
||||
}
|
||||
reversed(true);
|
||||
return paused(false);
|
||||
}
|
||||
|
||||
public function render(param1:Number, param2:Boolean = false, param3:Boolean = false) : Boolean
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public function renderCreateTime(param1:Number, param2:Number, param3:Boolean = false, param4:Boolean = false) : Boolean
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public function invalidate() : *
|
||||
{
|
||||
return this;
|
||||
}
|
||||
|
||||
public function isActive() : Boolean
|
||||
{
|
||||
var _loc1_:Number = NaN;
|
||||
var _loc2_:SimpleTimeline = _timeline;
|
||||
return _loc2_ == null || !_gc && !_paused && _loc2_.isActive() && (_loc1_ = _loc2_.rawTime()) >= _startTime && _loc1_ < _startTime + totalDuration() / _timeScale;
|
||||
}
|
||||
|
||||
public function _enabled(param1:Boolean, param2:Boolean = false) : Boolean
|
||||
{
|
||||
_gc = !param1;
|
||||
_active = param1 && !_paused && _totalTime > 0 && _totalTime < _totalDuration;
|
||||
if(!param2)
|
||||
{
|
||||
if(param1 && timeline == null)
|
||||
{
|
||||
_timeline.add(this,_startTime - _delay);
|
||||
}
|
||||
else if(!param1 && timeline != null)
|
||||
{
|
||||
_timeline._remove(this,true);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public function _kill(param1:Object = null, param2:Object = null) : Boolean
|
||||
{
|
||||
return _enabled(false,false);
|
||||
}
|
||||
|
||||
public function kill(param1:Object = null, param2:Object = null) : *
|
||||
{
|
||||
_kill(param1,param2);
|
||||
return this;
|
||||
}
|
||||
|
||||
protected function _uncache(param1:Boolean) : *
|
||||
{
|
||||
var _loc2_:Animation = param1 ? this : timeline;
|
||||
while(_loc2_)
|
||||
{
|
||||
_loc2_._dirty = true;
|
||||
_loc2_ = _loc2_.timeline;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
protected function _swapSelfInParams(param1:Array) : Array
|
||||
{
|
||||
var _loc2_:int = int(param1.length);
|
||||
var _loc3_:Array = param1.concat();
|
||||
while(--_loc2_ > -1)
|
||||
{
|
||||
if(param1[_loc2_] === "{self}")
|
||||
{
|
||||
_loc3_[_loc2_] = this;
|
||||
}
|
||||
}
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
public function eventCallback(param1:String, param2:Function = null, param3:Array = null) : *
|
||||
{
|
||||
if(param1 == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if(param1.substr(0,2) == "on")
|
||||
{
|
||||
if(arguments.length == 1)
|
||||
{
|
||||
return vars[param1];
|
||||
}
|
||||
if(param2 == null)
|
||||
{
|
||||
delete vars[param1];
|
||||
}
|
||||
else
|
||||
{
|
||||
vars[param1] = param2;
|
||||
vars[param1 + "Params"] = param3 is Array && param3.join("").indexOf("{self}") !== -1 ? _swapSelfInParams(param3) : param3;
|
||||
}
|
||||
if(param1 == "onUpdate")
|
||||
{
|
||||
_onUpdate = param2;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function delay(param1:Number = NaN) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _delay;
|
||||
}
|
||||
if(_timeline.smoothChildTiming)
|
||||
{
|
||||
startTime(_startTime + param1 - _delay);
|
||||
}
|
||||
_delay = param1;
|
||||
return this;
|
||||
}
|
||||
|
||||
public function duration(param1:Number = NaN) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
_dirty = false;
|
||||
return _duration;
|
||||
}
|
||||
_duration = _totalDuration = param1;
|
||||
_uncache(true);
|
||||
if(_timeline.smoothChildTiming)
|
||||
{
|
||||
if(_time > 0)
|
||||
{
|
||||
if(_time < _duration)
|
||||
{
|
||||
if(param1 != 0)
|
||||
{
|
||||
totalTime(_totalTime * (param1 / _duration),true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function totalDuration(param1:Number = NaN) : *
|
||||
{
|
||||
_dirty = false;
|
||||
return !arguments.length ? _totalDuration : duration(param1);
|
||||
}
|
||||
|
||||
public function time(param1:Number = NaN, param2:Boolean = false) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _time;
|
||||
}
|
||||
if(_dirty)
|
||||
{
|
||||
totalDuration();
|
||||
}
|
||||
if(param1 > _duration)
|
||||
{
|
||||
param1 = _duration;
|
||||
}
|
||||
return totalTime(param1,param2);
|
||||
}
|
||||
|
||||
public function totalTime(param1:Number = NaN, param2:Boolean = false, param3:Boolean = false) : *
|
||||
{
|
||||
var _loc5_:SimpleTimeline = null;
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _totalTime;
|
||||
}
|
||||
if(_timeline)
|
||||
{
|
||||
if(param1 < 0 && !param3)
|
||||
{
|
||||
param1 += totalDuration();
|
||||
}
|
||||
if(_timeline.smoothChildTiming)
|
||||
{
|
||||
if(_dirty)
|
||||
{
|
||||
totalDuration();
|
||||
}
|
||||
if(param1 > _totalDuration && !param3)
|
||||
{
|
||||
param1 = _totalDuration;
|
||||
}
|
||||
_loc5_ = _timeline;
|
||||
_startTime = (_paused ? _pauseTime : _loc5_._time) - (!_reversed ? param1 : _totalDuration - param1) / _timeScale;
|
||||
if(!_timeline._dirty)
|
||||
{
|
||||
_uncache(false);
|
||||
}
|
||||
if(_loc5_._timeline != null)
|
||||
{
|
||||
while(_loc5_._timeline)
|
||||
{
|
||||
if(_loc5_._timeline._time !== (_loc5_._startTime + _loc5_._totalTime) / _loc5_._timeScale)
|
||||
{
|
||||
_loc5_.totalTime(_loc5_._totalTime,true);
|
||||
}
|
||||
_loc5_ = _loc5_._timeline;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_gc)
|
||||
{
|
||||
_enabled(true,false);
|
||||
}
|
||||
if(_totalTime != param1 || _duration === 0)
|
||||
{
|
||||
render(param1,param2,false);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function progress(param1:Number = NaN, param2:Boolean = false) : *
|
||||
{
|
||||
return !arguments.length ? _time / duration() : totalTime(duration() * param1,param2);
|
||||
}
|
||||
|
||||
public function totalProgress(param1:Number = NaN, param2:Boolean = false) : *
|
||||
{
|
||||
return !arguments.length ? _time / duration() : totalTime(duration() * param1,param2);
|
||||
}
|
||||
|
||||
public function startTime(param1:Number = NaN) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _startTime;
|
||||
}
|
||||
if(param1 != _startTime)
|
||||
{
|
||||
_startTime = param1;
|
||||
if(timeline)
|
||||
{
|
||||
if(timeline._sortChildren)
|
||||
{
|
||||
timeline.add(this,param1 - _delay);
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function timeScale(param1:Number = NaN) : *
|
||||
{
|
||||
var _loc3_:Number = NaN;
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _timeScale;
|
||||
}
|
||||
param1 ||= 0.000001;
|
||||
if(_timeline && _timeline.smoothChildTiming)
|
||||
{
|
||||
_loc3_ = _pauseTime || _pauseTime == 0 ? _pauseTime : _timeline._totalTime;
|
||||
_startTime = _loc3_ - (_loc3_ - _startTime) * _timeScale / param1;
|
||||
}
|
||||
_timeScale = param1;
|
||||
return _uncache(false);
|
||||
}
|
||||
|
||||
public function reversed(param1:Boolean = false) : *
|
||||
{
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _reversed;
|
||||
}
|
||||
if(param1 != _reversed)
|
||||
{
|
||||
_reversed = param1;
|
||||
totalTime(_timeline && !_timeline.smoothChildTiming ? totalDuration() - _totalTime : _totalTime,true);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function paused(param1:Boolean = false) : *
|
||||
{
|
||||
var _loc4_:Number = NaN;
|
||||
if(!arguments.length)
|
||||
{
|
||||
return _paused;
|
||||
}
|
||||
if(param1 != _paused)
|
||||
{
|
||||
if(_timeline)
|
||||
{
|
||||
_loc4_ = _timeline.rawTime();
|
||||
var _loc3_:Number = _loc4_ - _pauseTime;
|
||||
if(!param1 && _timeline.smoothChildTiming)
|
||||
{
|
||||
_startTime += _loc3_;
|
||||
_uncache(false);
|
||||
}
|
||||
_pauseTime = param1 ? _loc4_ : NaN;
|
||||
_paused = param1;
|
||||
_active = !param1 && _totalTime > 0 && _totalTime < _totalDuration;
|
||||
if(!param1 && _loc3_ != 0 && _initted && duration() !== 0)
|
||||
{
|
||||
render(_timeline.smoothChildTiming ? _totalTime : (_loc4_ - _startTime) / _timeScale,true,true);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_gc && !param1)
|
||||
{
|
||||
_enabled(true,false);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
package com.greensock.core
|
||||
{
|
||||
public final class PropTween
|
||||
{
|
||||
|
||||
public var t:Object;
|
||||
|
||||
public var p:String;
|
||||
|
||||
public var s:Number;
|
||||
|
||||
public var c:Number;
|
||||
|
||||
public var f:Boolean;
|
||||
|
||||
public var pr:int;
|
||||
|
||||
public var pg:Boolean;
|
||||
|
||||
public var n:String;
|
||||
|
||||
public var r:Boolean;
|
||||
|
||||
public var _next:PropTween;
|
||||
|
||||
public var _prev:PropTween;
|
||||
|
||||
public function PropTween(param1:Object, param2:String, param3:Number, param4:Number, param5:String, param6:Boolean, param7:PropTween = null, param8:int = 0)
|
||||
{
|
||||
super();
|
||||
this.t = param1;
|
||||
this.p = param2;
|
||||
this.s = param3;
|
||||
this.c = param4;
|
||||
this.n = param5;
|
||||
this.f = param1[param2] is Function;
|
||||
this.pg = param6;
|
||||
if(param7)
|
||||
{
|
||||
param7._prev = this;
|
||||
this._next = param7;
|
||||
}
|
||||
this.pr = param8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,180 @@
|
||||
package com.greensock.core
|
||||
{
|
||||
import flash.utils.getTimer;
|
||||
|
||||
public class SimpleTimeline extends Animation
|
||||
{
|
||||
|
||||
public var autoRemoveChildren:Boolean;
|
||||
|
||||
public var smoothChildTiming:Boolean;
|
||||
|
||||
public var _sortChildren:Boolean;
|
||||
|
||||
public var _first:Animation;
|
||||
|
||||
public var _last:Animation;
|
||||
|
||||
public function SimpleTimeline(param1:Object = null)
|
||||
{
|
||||
super(0,param1);
|
||||
this.autoRemoveChildren = this.smoothChildTiming = true;
|
||||
}
|
||||
|
||||
public function insert(param1:*, param2:* = 0) : *
|
||||
{
|
||||
return add(param1,param2 || 0);
|
||||
}
|
||||
|
||||
public function add(param1:*, param2:* = "+=0", param3:String = "normal", param4:Number = 0) : *
|
||||
{
|
||||
var _loc5_:Number = NaN;
|
||||
param1._startTime = (Number(param2 || 0)) + param1._delay;
|
||||
if(param1._paused)
|
||||
{
|
||||
if(this != param1._timeline)
|
||||
{
|
||||
param1._pauseTime = param1._startTime + (rawTime() - param1._startTime) / param1._timeScale;
|
||||
}
|
||||
}
|
||||
if(param1.timeline)
|
||||
{
|
||||
param1.timeline._remove(param1,true);
|
||||
}
|
||||
param1.timeline = param1._timeline = this;
|
||||
if(param1._gc)
|
||||
{
|
||||
param1._enabled(true,true);
|
||||
}
|
||||
var _loc6_:Animation = _last;
|
||||
if(_sortChildren)
|
||||
{
|
||||
_loc5_ = Number(param1._startTime);
|
||||
while(_loc6_ && _loc6_._startTime > _loc5_)
|
||||
{
|
||||
_loc6_ = _loc6_._prev;
|
||||
}
|
||||
}
|
||||
if(_loc6_)
|
||||
{
|
||||
param1._next = _loc6_._next;
|
||||
_loc6_._next = Animation(param1);
|
||||
}
|
||||
else
|
||||
{
|
||||
param1._next = _first;
|
||||
_first = Animation(param1);
|
||||
}
|
||||
if(param1._next)
|
||||
{
|
||||
param1._next._prev = param1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_last = Animation(param1);
|
||||
}
|
||||
param1._prev = _loc6_;
|
||||
if(_timeline)
|
||||
{
|
||||
_uncache(true);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public function _remove(param1:Animation, param2:Boolean = false) : *
|
||||
{
|
||||
if(param1.timeline == this)
|
||||
{
|
||||
if(!param2)
|
||||
{
|
||||
param1._enabled(false,true);
|
||||
}
|
||||
if(param1._prev)
|
||||
{
|
||||
param1._prev._next = param1._next;
|
||||
}
|
||||
else if(_first === param1)
|
||||
{
|
||||
_first = param1._next;
|
||||
}
|
||||
if(param1._next)
|
||||
{
|
||||
param1._next._prev = param1._prev;
|
||||
}
|
||||
else if(_last === param1)
|
||||
{
|
||||
_last = param1._prev;
|
||||
}
|
||||
param1._next = param1._prev = param1.timeline = null;
|
||||
if(_timeline)
|
||||
{
|
||||
_uncache(true);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
override public function render(param1:Number, param2:Boolean = false, param3:Boolean = false) : Boolean
|
||||
{
|
||||
var _loc4_:Animation = null;
|
||||
var _loc5_:Animation = _first;
|
||||
if(_loc5_)
|
||||
{
|
||||
_totalTime = _time = _rawPrevTime = param1;
|
||||
while(_loc5_)
|
||||
{
|
||||
_loc4_ = _loc5_._next;
|
||||
if(_loc5_._active || param1 >= _loc5_._startTime && !_loc5_._paused)
|
||||
{
|
||||
if(!_loc5_._reversed)
|
||||
{
|
||||
_loc5_.render((param1 - _loc5_._startTime) * _loc5_._timeScale,param2,param3);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_.render((!_loc5_._dirty ? _loc5_._totalDuration : _loc5_.totalDuration()) - (param1 - _loc5_._startTime) * _loc5_._timeScale,param2,param3);
|
||||
}
|
||||
}
|
||||
_loc5_ = _loc4_;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
override public function renderCreateTime(param1:Number, param2:Number, param3:Boolean = false, param4:Boolean = false) : Boolean
|
||||
{
|
||||
var _loc5_:Animation = null;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc6_:Animation = _first;
|
||||
if(_loc6_)
|
||||
{
|
||||
_totalTime = _time = _rawPrevTime = _loc7_ = (getTimer() / 1000 - param1) * param2;
|
||||
while(_loc6_)
|
||||
{
|
||||
_loc5_ = _loc6_._next;
|
||||
if(_loc6_._active || _loc7_ >= _loc6_._startTime && !_loc6_._paused)
|
||||
{
|
||||
if(!_loc6_._reversed)
|
||||
{
|
||||
_loc6_.render((_loc7_ - _loc6_._startTime) * _loc6_._timeScale,param3,param4);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_.render((!_loc6_._dirty ? _loc6_._totalDuration : _loc6_.totalDuration()) - (_loc7_ - _loc6_._startTime) * _loc6_._timeScale,param3,param4);
|
||||
}
|
||||
}
|
||||
_loc6_ = _loc5_;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public function rawTime() : Number
|
||||
{
|
||||
return _totalTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class Back
|
||||
{
|
||||
|
||||
public static var easeOut:BackOut = new BackOut();
|
||||
|
||||
public static var easeIn:BackIn = new BackIn();
|
||||
|
||||
public static var easeInOut:BackInOut = new BackInOut();
|
||||
|
||||
public function Back()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class BackIn extends Ease
|
||||
{
|
||||
|
||||
public static var ease:BackIn = new BackIn();
|
||||
|
||||
public function BackIn(param1:Number = 1.70158)
|
||||
{
|
||||
super();
|
||||
_p1 = param1;
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
return param1 * param1 * ((_p1 + 1) * param1 - _p1);
|
||||
}
|
||||
|
||||
public function config(param1:Number = 1.70158) : BackIn
|
||||
{
|
||||
return new BackIn(param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class BackInOut extends Ease
|
||||
{
|
||||
|
||||
public static var ease:BackInOut = new BackInOut();
|
||||
|
||||
public function BackInOut(param1:Number = 1.70158)
|
||||
{
|
||||
super();
|
||||
_p1 = param1;
|
||||
_p2 = _p1 * 1.525;
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
param1 *= 2;
|
||||
return param1 < 1 ? 0.5 * param1 * param1 * ((_p2 + 1) * param1 - _p2) : 0.5 * ((param1 -= 2) * param1 * ((_p2 + 1) * param1 + _p2) + 2);
|
||||
}
|
||||
|
||||
public function config(param1:Number = 1.70158) : BackInOut
|
||||
{
|
||||
return new BackInOut(param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class BackOut extends Ease
|
||||
{
|
||||
|
||||
public static var ease:BackOut = new BackOut();
|
||||
|
||||
public function BackOut(param1:Number = 1.70158)
|
||||
{
|
||||
super();
|
||||
_p1 = param1;
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
param1 -= 1;
|
||||
return param1 * param1 * ((_p1 + 1) * param1 + _p1) + 1;
|
||||
}
|
||||
|
||||
public function config(param1:Number = 1.70158) : BackOut
|
||||
{
|
||||
return new BackOut(param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class Circ
|
||||
{
|
||||
|
||||
public static var easeOut:CircOut = new CircOut();
|
||||
|
||||
public static var easeIn:CircIn = new CircIn();
|
||||
|
||||
public static var easeInOut:CircInOut = new CircInOut();
|
||||
|
||||
public function Circ()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class CircIn extends Ease
|
||||
{
|
||||
|
||||
public static var ease:CircIn = new CircIn();
|
||||
|
||||
public function CircIn()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
return -(Math.sqrt(1 - param1 * param1) - 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class CircInOut extends Ease
|
||||
{
|
||||
|
||||
public static var ease:CircInOut = new CircInOut();
|
||||
|
||||
public function CircInOut()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
param1 *= 2;
|
||||
return param1 < 1 ? -0.5 * (Math.sqrt(1 - param1 * param1) - 1) : 0.5 * (Math.sqrt(1 - (param1 -= 2) * param1) + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class CircOut extends Ease
|
||||
{
|
||||
|
||||
public static var ease:CircOut = new CircOut();
|
||||
|
||||
public function CircOut()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
return Math.sqrt(1 - (param1 -= 1) * param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public class Ease
|
||||
{
|
||||
|
||||
protected static var _baseParams:Array = [0,0,1,1];
|
||||
|
||||
protected var _func:Function;
|
||||
|
||||
protected var _params:Array;
|
||||
|
||||
protected var _p1:Number;
|
||||
|
||||
protected var _p2:Number;
|
||||
|
||||
protected var _p3:Number;
|
||||
|
||||
public var _type:int;
|
||||
|
||||
public var _power:int;
|
||||
|
||||
public var _calcEnd:Boolean;
|
||||
|
||||
public function Ease(param1:Function = null, param2:Array = null, param3:Number = 0, param4:Number = 0)
|
||||
{
|
||||
super();
|
||||
_func = param1;
|
||||
_params = param2 ? _baseParams.concat(param2) : _baseParams;
|
||||
_type = param3;
|
||||
_power = param4;
|
||||
}
|
||||
|
||||
public function getRatio(param1:Number) : Number
|
||||
{
|
||||
var _loc2_:Number = NaN;
|
||||
if(_func != null)
|
||||
{
|
||||
_params[0] = param1;
|
||||
return _func.apply(null,_params);
|
||||
}
|
||||
_loc2_ = _type == 1 ? 1 - param1 : (_type == 2 ? param1 : (param1 < 0.5 ? param1 * 2 : (1 - param1) * 2));
|
||||
if(_power == 1)
|
||||
{
|
||||
_loc2_ *= _loc2_;
|
||||
}
|
||||
else if(_power == 2)
|
||||
{
|
||||
_loc2_ *= _loc2_ * _loc2_;
|
||||
}
|
||||
else if(_power == 3)
|
||||
{
|
||||
_loc2_ *= _loc2_ * _loc2_ * _loc2_;
|
||||
}
|
||||
else if(_power == 4)
|
||||
{
|
||||
_loc2_ *= _loc2_ * _loc2_ * _loc2_ * _loc2_;
|
||||
}
|
||||
return _type == 1 ? 1 - _loc2_ : (_type == 2 ? _loc2_ : (param1 < 0.5 ? _loc2_ / 2 : 1 - _loc2_ / 2));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class Expo
|
||||
{
|
||||
|
||||
public static var easeOut:ExpoOut = new ExpoOut();
|
||||
|
||||
public static var easeIn:ExpoIn = new ExpoIn();
|
||||
|
||||
public static var easeInOut:ExpoInOut = new ExpoInOut();
|
||||
|
||||
public function Expo()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class ExpoIn extends Ease
|
||||
{
|
||||
|
||||
public static var ease:ExpoIn = new ExpoIn();
|
||||
|
||||
public function ExpoIn()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
return Math.pow(2,10 * (param1 - 1)) - 0.001;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class ExpoInOut extends Ease
|
||||
{
|
||||
|
||||
public static var ease:ExpoInOut = new ExpoInOut();
|
||||
|
||||
public function ExpoInOut()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
param1 *= 2;
|
||||
return param1 < 1 ? 0.5 * Math.pow(2,10 * (param1 - 1)) : 0.5 * (2 - Math.pow(2,-10 * (param1 - 1)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class ExpoOut extends Ease
|
||||
{
|
||||
|
||||
public static var ease:ExpoOut = new ExpoOut();
|
||||
|
||||
public function ExpoOut()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
return 1 - Math.pow(2,-10 * param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public final class Quad
|
||||
{
|
||||
|
||||
public static var easeOut:Ease = new Ease(null,null,1,1);
|
||||
|
||||
public static var easeIn:Ease = new Ease(null,null,2,1);
|
||||
|
||||
public static var easeInOut:Ease = new Ease(null,null,3,1);
|
||||
|
||||
public function Quad()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
package com.greensock.easing
|
||||
{
|
||||
public class SlowMo extends Ease
|
||||
{
|
||||
|
||||
public static var ease:SlowMo = new SlowMo();
|
||||
|
||||
private var _p:Number;
|
||||
|
||||
public function SlowMo(param1:Number = 0.7, param2:Number = 0.7, param3:Boolean = false)
|
||||
{
|
||||
super();
|
||||
if(param1 > 1)
|
||||
{
|
||||
param1 = 1;
|
||||
}
|
||||
_p = param1 != 1 ? param2 : 0;
|
||||
_p1 = (1 - param1) / 2;
|
||||
_p2 = param1;
|
||||
_p3 = _p1 + _p2;
|
||||
_calcEnd = param3;
|
||||
}
|
||||
|
||||
override public function getRatio(param1:Number) : Number
|
||||
{
|
||||
var _loc2_:Number = param1 + (0.5 - param1) * _p;
|
||||
if(param1 < _p1)
|
||||
{
|
||||
return _calcEnd ? 1 - (param1 = 1 - param1 / _p1) * param1 : _loc2_ - (param1 = 1 - param1 / _p1) * param1 * param1 * param1 * _loc2_;
|
||||
}
|
||||
if(param1 > _p3)
|
||||
{
|
||||
return _calcEnd ? 1 - (param1 = (param1 - _p3) / _p1) * param1 : _loc2_ + (param1 - _loc2_) * (param1 = (param1 - _p3) / _p1) * param1 * param1 * param1;
|
||||
}
|
||||
return _calcEnd ? 1 : _loc2_;
|
||||
}
|
||||
|
||||
public function config(param1:Number = 0.7, param2:Number = 0.7, param3:Boolean = false) : SlowMo
|
||||
{
|
||||
return new SlowMo(param1,param2,param3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
package com.greensock.events
|
||||
{
|
||||
import flash.events.Event;
|
||||
|
||||
public class TweenEvent extends Event
|
||||
{
|
||||
|
||||
public static const VERSION:Number = 12;
|
||||
|
||||
public static const START:String = "start";
|
||||
|
||||
public static const UPDATE:String = "change";
|
||||
|
||||
public static const COMPLETE:String = "complete";
|
||||
|
||||
public static const REVERSE_COMPLETE:String = "reverseComplete";
|
||||
|
||||
public static const REPEAT:String = "repeat";
|
||||
|
||||
public function TweenEvent(param1:String, param2:Boolean = false, param3:Boolean = false)
|
||||
{
|
||||
super(param1,param2,param3);
|
||||
}
|
||||
|
||||
override public function clone() : Event
|
||||
{
|
||||
return new TweenEvent(this.type,this.bubbles,this.cancelable);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
|
||||
public class AutoAlphaPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _target:Object;
|
||||
|
||||
protected var _ignoreVisible:Boolean;
|
||||
|
||||
public function AutoAlphaPlugin()
|
||||
{
|
||||
super("autoAlpha,alpha,visible");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
_target = param1;
|
||||
_addTween(param1,"alpha",param1.alpha,param2,"alpha");
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function _kill(param1:Object) : Boolean
|
||||
{
|
||||
_ignoreVisible = "visible" in param1;
|
||||
return super._kill(param1);
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
super.setRatio(param1);
|
||||
if(!_ignoreVisible)
|
||||
{
|
||||
_target.visible = _target.alpha != 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.filters.BevelFilter;
|
||||
|
||||
public class BevelFilterPlugin extends FilterPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
private static var _propNames:Array = ["distance","angle","highlightColor","highlightAlpha","shadowColor","shadowAlpha","blurX","blurY","strength","quality"];
|
||||
|
||||
public function BevelFilterPlugin()
|
||||
{
|
||||
super("bevelFilter");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
return _initFilter(param1,param2,param3,BevelFilter,new BevelFilter(0,0,16777215,0.5,0,0.5,2,2,0,param2.quality || 2),_propNames);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,790 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.geom.Point;
|
||||
|
||||
public class BezierPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected static const _RAD2DEG:Number = 57.29577951308232;
|
||||
|
||||
protected static var _r1:Array = [];
|
||||
|
||||
protected static var _r2:Array = [];
|
||||
|
||||
protected static var _r3:Array = [];
|
||||
|
||||
protected static var _corProps:Object = {};
|
||||
|
||||
protected var _target:Object;
|
||||
|
||||
protected var _autoRotate:Array;
|
||||
|
||||
protected var _round:Object;
|
||||
|
||||
protected var _lengths:Array;
|
||||
|
||||
protected var _segments:Array;
|
||||
|
||||
protected var _length:Number;
|
||||
|
||||
protected var _func:Object;
|
||||
|
||||
protected var _props:Array;
|
||||
|
||||
protected var _l1:Number;
|
||||
|
||||
protected var _l2:Number;
|
||||
|
||||
protected var _li:Number;
|
||||
|
||||
protected var _curSeg:Array;
|
||||
|
||||
protected var _s1:Number;
|
||||
|
||||
protected var _s2:Number;
|
||||
|
||||
protected var _si:Number;
|
||||
|
||||
protected var _beziers:Object;
|
||||
|
||||
protected var _segCount:int;
|
||||
|
||||
protected var _prec:Number;
|
||||
|
||||
protected var _timeRes:int;
|
||||
|
||||
protected var _initialRotations:Array;
|
||||
|
||||
protected var _startRatio:int;
|
||||
|
||||
public function BezierPlugin()
|
||||
{
|
||||
super("bezier");
|
||||
this._overwriteProps.pop();
|
||||
this._func = {};
|
||||
this._round = {};
|
||||
}
|
||||
|
||||
public static function bezierThrough(param1:Array, param2:Number = 1, param3:Boolean = false, param4:Boolean = false, param5:String = "x,y,z", param6:Object = null) : Object
|
||||
{
|
||||
var _loc13_:Array = null;
|
||||
var _loc10_:int = 0;
|
||||
var _loc14_:String = null;
|
||||
var _loc11_:int = 0;
|
||||
var _loc7_:Array = null;
|
||||
var _loc12_:int = 0;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc8_:Boolean = false;
|
||||
var _loc9_:Object = null;
|
||||
var _loc16_:Object = {};
|
||||
var _loc17_:Object = param6 || param1[0];
|
||||
param5 = "," + param5 + ",";
|
||||
if(_loc17_ is Point)
|
||||
{
|
||||
_loc13_ = ["x","y"];
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_ = [];
|
||||
for(_loc14_ in _loc17_)
|
||||
{
|
||||
_loc13_.push(_loc14_);
|
||||
}
|
||||
}
|
||||
if(param1.length > 1)
|
||||
{
|
||||
_loc9_ = param1[param1.length - 1];
|
||||
_loc8_ = true;
|
||||
_loc10_ = int(_loc13_.length);
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
_loc14_ = _loc13_[_loc10_];
|
||||
if(Math.abs(_loc17_[_loc14_] - _loc9_[_loc14_]) > 0.05)
|
||||
{
|
||||
_loc8_ = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(_loc8_)
|
||||
{
|
||||
param1 = param1.concat();
|
||||
if(param6)
|
||||
{
|
||||
param1.unshift(param6);
|
||||
}
|
||||
param1.push(param1[1]);
|
||||
param6 = param1[param1.length - 3];
|
||||
}
|
||||
}
|
||||
_r1.length = _r2.length = _r3.length = 0;
|
||||
_loc10_ = int(_loc13_.length);
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
_loc14_ = _loc13_[_loc10_];
|
||||
_corProps[_loc14_] = param5.indexOf("," + _loc14_ + ",") !== -1;
|
||||
_loc16_[_loc14_] = _parseAnchors(param1,_loc14_,_corProps[_loc14_],param6);
|
||||
}
|
||||
_loc10_ = int(_r1.length);
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
_r1[_loc10_] = Math.sqrt(_r1[_loc10_]);
|
||||
_r2[_loc10_] = Math.sqrt(_r2[_loc10_]);
|
||||
}
|
||||
if(!param4)
|
||||
{
|
||||
_loc10_ = int(_loc13_.length);
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
if(_corProps[_loc14_])
|
||||
{
|
||||
_loc7_ = _loc16_[_loc13_[_loc10_]];
|
||||
_loc12_ = _loc7_.length - 1;
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < _loc12_)
|
||||
{
|
||||
_loc15_ = _loc7_[_loc11_ + 1].da / _r2[_loc11_] + _loc7_[_loc11_].da / _r1[_loc11_];
|
||||
_r3[_loc11_] = (_r3[_loc11_] || 0) + _loc15_ * _loc15_;
|
||||
_loc11_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc10_ = int(_r3.length);
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
_r3[_loc10_] = Math.sqrt(_r3[_loc10_]);
|
||||
}
|
||||
}
|
||||
_loc10_ = int(_loc13_.length);
|
||||
_loc11_ = param3 ? 4 : 1;
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
_loc14_ = _loc13_[_loc10_];
|
||||
_loc7_ = _loc16_[_loc14_];
|
||||
_calculateControlPoints(_loc7_,param2,param3,param4,_corProps[_loc14_]);
|
||||
if(_loc8_)
|
||||
{
|
||||
_loc7_.splice(0,_loc11_);
|
||||
_loc7_.splice(_loc7_.length - _loc11_,_loc11_);
|
||||
}
|
||||
}
|
||||
return _loc16_;
|
||||
}
|
||||
|
||||
public static function _parseBezierData(param1:Array, param2:String, param3:Object = null) : Object
|
||||
{
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc5_:Array = null;
|
||||
var _loc13_:Array = null;
|
||||
var _loc10_:int = 0;
|
||||
var _loc11_:int = 0;
|
||||
var _loc12_:int = 0;
|
||||
var _loc14_:String = null;
|
||||
var _loc9_:int = 0;
|
||||
var _loc15_:Object = null;
|
||||
param2 ||= "soft";
|
||||
var _loc16_:Object = {};
|
||||
var _loc17_:int = param2 === "cubic" ? 3 : 2;
|
||||
var _loc18_:Boolean = param2 === "soft";
|
||||
if(_loc18_ && param3)
|
||||
{
|
||||
param1 = [param3].concat(param1);
|
||||
}
|
||||
if(param1 == null || param1.length < _loc17_ + 1)
|
||||
{
|
||||
throw new Error("invalid Bezier data");
|
||||
}
|
||||
if(param1[1] is Point)
|
||||
{
|
||||
_loc13_ = ["x","y"];
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_ = [];
|
||||
for(_loc14_ in param1[0])
|
||||
{
|
||||
_loc13_.push(_loc14_);
|
||||
}
|
||||
}
|
||||
_loc10_ = int(_loc13_.length);
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
_loc14_ = _loc13_[_loc10_];
|
||||
_loc16_[_loc14_] = _loc5_ = [];
|
||||
_loc9_ = 0;
|
||||
_loc12_ = int(param1.length);
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < _loc12_)
|
||||
{
|
||||
_loc15_ = param1[_loc11_][_loc14_];
|
||||
_loc4_ = Number(param3 == null ? param1[_loc11_][_loc14_] : (typeof _loc15_ === "string" && _loc15_.charAt(1) === "=" ? param3[_loc14_] + (_loc15_.charAt(0) + _loc15_.substr(2)) : Number(_loc15_)));
|
||||
if(_loc18_)
|
||||
{
|
||||
if(_loc11_ > 1)
|
||||
{
|
||||
if(_loc11_ < _loc12_ - 1)
|
||||
{
|
||||
_loc5_[_loc9_++] = (_loc4_ + _loc5_[_loc9_ - 2]) / 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc5_[_loc9_++] = _loc4_;
|
||||
_loc11_++;
|
||||
}
|
||||
_loc12_ = _loc9_ - _loc17_ + 1;
|
||||
_loc9_ = 0;
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < _loc12_)
|
||||
{
|
||||
_loc4_ = Number(_loc5_[_loc11_]);
|
||||
_loc6_ = Number(_loc5_[_loc11_ + 1]);
|
||||
_loc7_ = Number(_loc5_[_loc11_ + 2]);
|
||||
_loc8_ = Number(_loc17_ === 2 ? 0 : _loc5_[_loc11_ + 3]);
|
||||
_loc5_[_loc9_++] = _loc17_ === 3 ? new Segment(_loc4_,_loc6_,_loc7_,_loc8_) : new Segment(_loc4_,(2 * _loc6_ + _loc4_) / 3,(2 * _loc6_ + _loc7_) / 3,_loc7_);
|
||||
_loc11_ += _loc17_;
|
||||
}
|
||||
_loc5_.length = _loc9_;
|
||||
}
|
||||
return _loc16_;
|
||||
}
|
||||
|
||||
protected static function _parseAnchors(param1:Array, param2:String, param3:Boolean, param4:Object) : Array
|
||||
{
|
||||
var _loc11_:int = 0;
|
||||
var _loc10_:int = 0;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc9_:Object = null;
|
||||
var _loc6_:Array = [];
|
||||
if(param4)
|
||||
{
|
||||
param1 = [param4].concat(param1);
|
||||
_loc10_ = int(param1.length);
|
||||
while(--_loc10_ > -1)
|
||||
{
|
||||
_loc9_ = param1[_loc10_][param2];
|
||||
if(typeof _loc9_ === "string")
|
||||
{
|
||||
if(_loc9_.charAt(1) === "=")
|
||||
{
|
||||
param1[_loc10_][param2] = param4[param2] + (_loc9_.charAt(0) + _loc9_.substr(2));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc11_ = param1.length - 2;
|
||||
if(_loc11_ < 0)
|
||||
{
|
||||
_loc6_[0] = new Segment(param1[0][param2],0,0,param1[_loc11_ < -1 ? 0 : 1][param2]);
|
||||
return _loc6_;
|
||||
}
|
||||
_loc10_ = 0;
|
||||
while(_loc10_ < _loc11_)
|
||||
{
|
||||
_loc5_ = Number(param1[_loc10_][param2]);
|
||||
_loc7_ = Number(param1[_loc10_ + 1][param2]);
|
||||
_loc6_[_loc10_] = new Segment(_loc5_,0,0,_loc7_);
|
||||
if(param3)
|
||||
{
|
||||
_loc8_ = Number(param1[_loc10_ + 2][param2]);
|
||||
_r1[_loc10_] = (_r1[_loc10_] || 0) + (_loc7_ - _loc5_) * (_loc7_ - _loc5_);
|
||||
_r2[_loc10_] = (_r2[_loc10_] || 0) + (_loc8_ - _loc7_) * (_loc8_ - _loc7_);
|
||||
}
|
||||
_loc10_++;
|
||||
}
|
||||
_loc6_[_loc10_] = new Segment(param1[_loc10_][param2],0,0,param1[_loc10_ + 1][param2]);
|
||||
return _loc6_;
|
||||
}
|
||||
|
||||
protected static function _calculateControlPoints(param1:Array, param2:Number = 1, param3:Boolean = false, param4:Boolean = false, param5:Boolean = false) : void
|
||||
{
|
||||
var _loc16_:int = 0;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc19_:Segment = null;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc18_:Array = null;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc17_:int = param1.length - 1;
|
||||
var _loc6_:int = 0;
|
||||
var _loc14_:Number = Number(param1[0].a);
|
||||
_loc16_ = 0;
|
||||
while(_loc16_ < _loc17_)
|
||||
{
|
||||
_loc19_ = param1[_loc6_];
|
||||
_loc9_ = _loc19_.a;
|
||||
_loc10_ = _loc19_.d;
|
||||
_loc11_ = Number(param1[_loc6_ + 1].d);
|
||||
if(param5)
|
||||
{
|
||||
_loc21_ = Number(_r1[_loc16_]);
|
||||
_loc8_ = Number(_r2[_loc16_]);
|
||||
_loc20_ = (_loc8_ + _loc21_) * param2 * 0.25 / (param4 ? 0.5 : _r3[_loc16_] || 0.5);
|
||||
_loc12_ = _loc10_ - (_loc10_ - _loc9_) * (param4 ? param2 * 0.5 : (_loc21_ !== 0 ? _loc20_ / _loc21_ : 0));
|
||||
_loc15_ = _loc10_ + (_loc11_ - _loc10_) * (param4 ? param2 * 0.5 : (_loc8_ !== 0 ? _loc20_ / _loc8_ : 0));
|
||||
_loc7_ = _loc10_ - (_loc12_ + ((_loc15_ - _loc12_) * (_loc21_ * 3 / (_loc21_ + _loc8_) + 0.5) / 4 || 0));
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc12_ = _loc10_ - (_loc10_ - _loc9_) * param2 * 0.5;
|
||||
_loc15_ = _loc10_ + (_loc11_ - _loc10_) * param2 * 0.5;
|
||||
_loc7_ = _loc10_ - (_loc12_ + _loc15_) / 2;
|
||||
}
|
||||
_loc12_ += _loc7_;
|
||||
_loc15_ += _loc7_;
|
||||
_loc19_.c = _loc13_ = _loc12_;
|
||||
if(_loc16_ != 0)
|
||||
{
|
||||
_loc19_.b = _loc14_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc19_.b = _loc14_ = _loc19_.a + (_loc19_.c - _loc19_.a) * 0.6;
|
||||
}
|
||||
_loc19_.da = _loc10_ - _loc9_;
|
||||
_loc19_.ca = _loc13_ - _loc9_;
|
||||
_loc19_.ba = _loc14_ - _loc9_;
|
||||
if(param3)
|
||||
{
|
||||
_loc18_ = cubicToQuadratic(_loc9_,_loc14_,_loc13_,_loc10_);
|
||||
param1.splice(_loc6_,1,_loc18_[0],_loc18_[1],_loc18_[2],_loc18_[3]);
|
||||
_loc6_ += 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_++;
|
||||
}
|
||||
_loc14_ = _loc15_;
|
||||
_loc16_++;
|
||||
}
|
||||
_loc19_ = param1[_loc6_];
|
||||
_loc19_.b = _loc14_;
|
||||
_loc19_.c = _loc14_ + (_loc19_.d - _loc14_) * 0.4;
|
||||
_loc19_.da = _loc19_.d - _loc19_.a;
|
||||
_loc19_.ca = _loc19_.c - _loc19_.a;
|
||||
_loc19_.ba = _loc14_ - _loc19_.a;
|
||||
if(param3)
|
||||
{
|
||||
_loc18_ = cubicToQuadratic(_loc19_.a,_loc14_,_loc19_.c,_loc19_.d);
|
||||
param1.splice(_loc6_,1,_loc18_[0],_loc18_[1],_loc18_[2],_loc18_[3]);
|
||||
}
|
||||
}
|
||||
|
||||
public static function cubicToQuadratic(param1:Number, param2:Number, param3:Number, param4:Number) : Array
|
||||
{
|
||||
var _loc5_:Object = {"a":param1};
|
||||
var _loc6_:Object = {};
|
||||
var _loc7_:Object = {};
|
||||
var _loc8_:Object = {"c":param4};
|
||||
var _loc12_:Number = (param1 + param2) / 2;
|
||||
var _loc13_:Number = (param2 + param3) / 2;
|
||||
var _loc14_:Number = (param3 + param4) / 2;
|
||||
var _loc10_:Number = (_loc12_ + _loc13_) / 2;
|
||||
var _loc9_:Number = (_loc13_ + _loc14_) / 2;
|
||||
var _loc11_:Number = (_loc9_ - _loc10_) / 8;
|
||||
_loc5_.b = _loc12_ + (param1 - _loc12_) / 4;
|
||||
_loc6_.b = _loc10_ + _loc11_;
|
||||
_loc5_.c = _loc6_.a = (_loc5_.b + _loc6_.b) / 2;
|
||||
_loc6_.c = _loc7_.a = (_loc10_ + _loc9_) / 2;
|
||||
_loc7_.b = _loc9_ - _loc11_;
|
||||
_loc8_.b = _loc14_ + (param4 - _loc14_) / 4;
|
||||
_loc7_.c = _loc8_.a = (_loc7_.b + _loc8_.b) / 2;
|
||||
return [_loc5_,_loc6_,_loc7_,_loc8_];
|
||||
}
|
||||
|
||||
public static function quadraticToCubic(param1:Number, param2:Number, param3:Number) : Object
|
||||
{
|
||||
return new Segment(param1,(2 * param2 + param1) / 3,(2 * param2 + param3) / 3,param3);
|
||||
}
|
||||
|
||||
protected static function _parseLengthData(param1:Object, param2:uint = 6) : Object
|
||||
{
|
||||
var _loc11_:String = null;
|
||||
var _loc5_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc3_:Array = [];
|
||||
var _loc13_:Array = [];
|
||||
var _loc4_:Number = 0;
|
||||
var _loc12_:Number = 0;
|
||||
var _loc7_:int = param2 - 1;
|
||||
var _loc10_:Array = [];
|
||||
var _loc9_:Array = [];
|
||||
for(_loc11_ in param1)
|
||||
{
|
||||
_addCubicLengths(param1[_loc11_],_loc3_,param2);
|
||||
}
|
||||
_loc8_ = int(_loc3_.length);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < _loc8_)
|
||||
{
|
||||
_loc4_ += Math.sqrt(_loc3_[_loc5_]);
|
||||
_loc6_ = _loc5_ % param2;
|
||||
_loc9_[_loc6_] = _loc4_;
|
||||
if(_loc6_ == _loc7_)
|
||||
{
|
||||
_loc12_ += _loc4_;
|
||||
_loc6_ = _loc5_ / param2 >> 0;
|
||||
_loc10_[_loc6_] = _loc9_;
|
||||
_loc13_[_loc6_] = _loc12_;
|
||||
_loc4_ = 0;
|
||||
_loc9_ = [];
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
return {
|
||||
"length":_loc12_,
|
||||
"lengths":_loc13_,
|
||||
"segments":_loc10_
|
||||
};
|
||||
}
|
||||
|
||||
private static function _addCubicLengths(param1:Array, param2:Array, param3:uint = 6) : void
|
||||
{
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc5_:int = 0;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc12_:Segment = null;
|
||||
var _loc6_:int = 0;
|
||||
var _loc16_:Number = 1 / param3;
|
||||
var _loc7_:int = int(param1.length);
|
||||
while(--_loc7_ > -1)
|
||||
{
|
||||
_loc12_ = param1[_loc7_];
|
||||
_loc11_ = _loc12_.a;
|
||||
_loc13_ = _loc12_.d - _loc11_;
|
||||
_loc14_ = _loc12_.c - _loc11_;
|
||||
_loc15_ = _loc12_.b - _loc11_;
|
||||
_loc4_ = _loc8_ = 0;
|
||||
_loc5_ = 1;
|
||||
while(_loc5_ <= param3)
|
||||
{
|
||||
_loc9_ = _loc16_ * _loc5_;
|
||||
_loc10_ = 1 - _loc9_;
|
||||
_loc4_ = _loc8_ - (_loc8_ = (_loc9_ * _loc9_ * _loc13_ + 3 * _loc10_ * (_loc9_ * _loc14_ + _loc10_ * _loc15_)) * _loc9_);
|
||||
_loc6_ = _loc7_ * param3 + _loc5_ - 1;
|
||||
param2[_loc6_] = (param2[_loc6_] || 0) + _loc4_ * _loc4_;
|
||||
_loc5_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
var _loc10_:String = null;
|
||||
var _loc8_:Boolean = false;
|
||||
var _loc6_:int = 0;
|
||||
var _loc7_:int = 0;
|
||||
var _loc11_:Array = null;
|
||||
var _loc5_:Object = null;
|
||||
var _loc4_:Array = null;
|
||||
var _loc12_:Object = null;
|
||||
this._target = param1;
|
||||
var _loc13_:Object = param2 is Array ? {"values":param2} : param2;
|
||||
this._props = [];
|
||||
this._timeRes = _loc13_.timeResolution == null ? 6 : int(_loc13_.timeResolution);
|
||||
_loc4_ = _loc13_.values || [];
|
||||
var _loc15_:Object = {};
|
||||
var _loc9_:Object = _loc4_[0];
|
||||
var _loc14_:Object = _loc13_.autoRotate || param3.vars.orientToBezier;
|
||||
this._autoRotate = _loc14_ ? (_loc14_ is Array ? _loc14_ as Array : [["x","y","rotation",_loc14_ === true ? 0 : Number(_loc14_)]]) : null;
|
||||
if(_loc9_ is Point)
|
||||
{
|
||||
this._props = ["x","y"];
|
||||
}
|
||||
else
|
||||
{
|
||||
for(_loc10_ in _loc9_)
|
||||
{
|
||||
this._props.push(_loc10_);
|
||||
}
|
||||
}
|
||||
_loc6_ = int(this._props.length);
|
||||
while(--_loc6_ > -1)
|
||||
{
|
||||
_loc10_ = this._props[_loc6_];
|
||||
this._overwriteProps.push(_loc10_);
|
||||
_loc8_ = Boolean(this._func[_loc10_] = param1[_loc10_] is Function);
|
||||
var _temp_4:*;
|
||||
_loc15_[_loc10_] = !_loc8_ ? param1[_loc10_] : (_temp_4 = param1,param1[_loc10_.indexOf("set") || !("get" + _loc10_.substr(3) in param1) ? _loc10_ : "get" + _loc10_.substr(3)]());
|
||||
if(!_loc5_)
|
||||
{
|
||||
if(_loc15_[_loc10_] !== _loc4_[0][_loc10_])
|
||||
{
|
||||
_loc5_ = _loc15_;
|
||||
}
|
||||
}
|
||||
}
|
||||
this._beziers = _loc13_.type !== "cubic" && _loc13_.type !== "quadratic" && _loc13_.type !== "soft" ? bezierThrough(_loc4_,isNaN(_loc13_.curviness) ? 1 : _loc13_.curviness,false,_loc13_.type === "thruBasic",_loc13_.correlate || "x,y,z",_loc5_) : _parseBezierData(_loc4_,_loc13_.type,_loc15_);
|
||||
this._segCount = this._beziers[_loc10_].length;
|
||||
if(this._timeRes)
|
||||
{
|
||||
_loc12_ = _parseLengthData(this._beziers,this._timeRes);
|
||||
this._length = _loc12_.length;
|
||||
this._lengths = _loc12_.lengths;
|
||||
this._segments = _loc12_.segments;
|
||||
this._l1 = this._li = this._s1 = this._si = 0;
|
||||
this._l2 = this._lengths[0];
|
||||
this._curSeg = this._segments[0];
|
||||
this._s2 = this._curSeg[0];
|
||||
this._prec = 1 / this._curSeg.length;
|
||||
}
|
||||
if(_loc11_ == this._autoRotate)
|
||||
{
|
||||
this._initialRotations = [];
|
||||
if(!(_loc11_[0] is Array))
|
||||
{
|
||||
this._autoRotate = _loc11_ = [_loc11_];
|
||||
}
|
||||
_loc6_ = int(_loc11_.length);
|
||||
while(--_loc6_ > -1)
|
||||
{
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < 3)
|
||||
{
|
||||
_loc10_ = _loc11_[_loc6_][_loc7_];
|
||||
this._func[_loc10_] = param1[_loc10_] is Function ? param1[_loc10_.indexOf("set") || !("get" + _loc10_.substr(3) in param1) ? _loc10_ : "get" + _loc10_.substr(3)] : false;
|
||||
_loc7_++;
|
||||
}
|
||||
_loc10_ = _loc11_[_loc6_][2];
|
||||
this._initialRotations[_loc6_] = this._func[_loc10_] ? this._func[_loc10_]() : this._target[_loc10_];
|
||||
}
|
||||
}
|
||||
_startRatio = param3.vars.runBackwards ? 1 : 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function _kill(param1:Object) : Boolean
|
||||
{
|
||||
var _loc2_:String = null;
|
||||
var _loc4_:int = 0;
|
||||
var _loc3_:Array = this._props;
|
||||
for(_loc2_ in _beziers)
|
||||
{
|
||||
if(_loc2_ in param1)
|
||||
{
|
||||
delete _beziers[_loc2_];
|
||||
delete _func[_loc2_];
|
||||
_loc4_ = int(_loc3_.length);
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
if(_loc3_[_loc4_] === _loc2_)
|
||||
{
|
||||
_loc3_.splice(_loc4_,1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return super._kill(param1);
|
||||
}
|
||||
|
||||
override public function _roundProps(param1:Object, param2:Boolean = true) : void
|
||||
{
|
||||
var _loc3_:Array = null;
|
||||
_loc3_ = this._overwriteProps;
|
||||
var _loc4_:int = int(_loc3_.length);
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
if(_loc3_[_loc4_] in param1 || "bezier" in param1 || "bezierThrough" in param1)
|
||||
{
|
||||
this._round[_loc3_[_loc4_]] = param2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
var _loc23_:* = 0;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc7_:int = 0;
|
||||
var _loc12_:String = null;
|
||||
var _loc6_:Segment = null;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc8_:int = 0;
|
||||
var _loc17_:Array = null;
|
||||
var _loc3_:Array = null;
|
||||
var _loc13_:Segment = null;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc14_:Array = null;
|
||||
var _loc10_:int = this._segCount;
|
||||
var _loc15_:Object = this._func;
|
||||
var _loc9_:Object = this._target;
|
||||
var _loc5_:Boolean = param1 !== this._startRatio;
|
||||
if(this._timeRes == 0)
|
||||
{
|
||||
_loc23_ = int(param1 < 0 ? 0 : (param1 >= 1 ? _loc10_ - 1 : _loc10_ * param1 >> 0));
|
||||
_loc16_ = (param1 - _loc23_ * (1 / _loc10_)) * _loc10_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc17_ = this._lengths;
|
||||
_loc3_ = this._curSeg;
|
||||
param1 *= this._length;
|
||||
_loc7_ = this._li;
|
||||
if(param1 > this._l2 && _loc7_ < _loc10_ - 1)
|
||||
{
|
||||
_loc8_ = _loc10_ - 1;
|
||||
while(_loc7_ < _loc8_ && (this._l2 = _loc17_[++_loc7_]) <= param1)
|
||||
{
|
||||
}
|
||||
this._l1 = _loc17_[_loc7_ - 1];
|
||||
this._li = _loc7_;
|
||||
this._curSeg = _loc3_ = this._segments[_loc7_];
|
||||
this._s2 = _loc3_[this._s1 = this._si = 0];
|
||||
}
|
||||
else if(param1 < this._l1 && _loc7_ > 0)
|
||||
{
|
||||
while(_loc7_ > 0 && (this._l1 = _loc17_[--_loc7_]) >= param1)
|
||||
{
|
||||
}
|
||||
if(_loc7_ === 0 && param1 < this._l1)
|
||||
{
|
||||
this._l1 = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc7_++;
|
||||
}
|
||||
this._l2 = _loc17_[_loc7_];
|
||||
this._li = _loc7_;
|
||||
this._curSeg = _loc3_ = this._segments[_loc7_];
|
||||
this._s1 = _loc3_[(this._si = _loc3_.length - 1) - 1] || 0;
|
||||
this._s2 = _loc3_[this._si];
|
||||
}
|
||||
_loc23_ = _loc7_;
|
||||
param1 -= this._l1;
|
||||
_loc7_ = this._si;
|
||||
if(param1 > this._s2 && _loc7_ < _loc3_.length - 1)
|
||||
{
|
||||
_loc8_ = _loc3_.length - 1;
|
||||
while(_loc7_ < _loc8_ && (this._s2 = _loc3_[++_loc7_]) <= param1)
|
||||
{
|
||||
}
|
||||
this._s1 = _loc3_[_loc7_ - 1];
|
||||
this._si = _loc7_;
|
||||
}
|
||||
else if(param1 < this._s1 && _loc7_ > 0)
|
||||
{
|
||||
while(_loc7_ > 0 && (this._s1 = _loc3_[--_loc7_]) >= param1)
|
||||
{
|
||||
}
|
||||
if(_loc7_ === 0 && param1 < this._s1)
|
||||
{
|
||||
this._s1 = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc7_++;
|
||||
}
|
||||
this._s2 = _loc3_[_loc7_];
|
||||
this._si = _loc7_;
|
||||
}
|
||||
_loc16_ = (_loc7_ + (param1 - this._s1) / (this._s2 - this._s1)) * this._prec;
|
||||
}
|
||||
_loc11_ = 1 - _loc16_;
|
||||
_loc7_ = int(this._props.length);
|
||||
while(--_loc7_ > -1)
|
||||
{
|
||||
_loc12_ = this._props[_loc7_];
|
||||
_loc6_ = this._beziers[_loc12_][_loc23_];
|
||||
_loc2_ = (_loc16_ * _loc16_ * _loc6_.da + 3 * _loc11_ * (_loc16_ * _loc6_.ca + _loc11_ * _loc6_.ba)) * _loc16_ + _loc6_.a;
|
||||
if(this._round[_loc12_])
|
||||
{
|
||||
_loc2_ = _loc2_ + (_loc2_ > 0 ? 0.5 : -0.5) >> 0;
|
||||
}
|
||||
if(_loc15_[_loc12_])
|
||||
{
|
||||
_loc9_[_loc12_](_loc2_);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc9_[_loc12_] = _loc2_;
|
||||
}
|
||||
}
|
||||
if(this._autoRotate != null)
|
||||
{
|
||||
_loc14_ = this._autoRotate;
|
||||
_loc7_ = int(_loc14_.length);
|
||||
while(--_loc7_ > -1)
|
||||
{
|
||||
_loc12_ = _loc14_[_loc7_][2];
|
||||
_loc4_ = Number(_loc14_[_loc7_][3] || 0);
|
||||
_loc22_ = _loc14_[_loc7_][4] == true ? 1 : 57.29577951308232;
|
||||
_loc6_ = this._beziers[_loc14_[_loc7_][0]][_loc23_];
|
||||
_loc13_ = this._beziers[_loc14_[_loc7_][1]][_loc23_];
|
||||
_loc19_ = _loc6_.a + (_loc6_.b - _loc6_.a) * _loc16_;
|
||||
_loc21_ = _loc6_.b + (_loc6_.c - _loc6_.b) * _loc16_;
|
||||
_loc19_ += (_loc21_ - _loc19_) * _loc16_;
|
||||
_loc21_ += (_loc6_.c + (_loc6_.d - _loc6_.c) * _loc16_ - _loc21_) * _loc16_;
|
||||
_loc18_ = _loc13_.a + (_loc13_.b - _loc13_.a) * _loc16_;
|
||||
_loc20_ = _loc13_.b + (_loc13_.c - _loc13_.b) * _loc16_;
|
||||
_loc18_ += (_loc20_ - _loc18_) * _loc16_;
|
||||
_loc20_ += (_loc13_.c + (_loc13_.d - _loc13_.c) * _loc16_ - _loc20_) * _loc16_;
|
||||
_loc2_ = Number(_loc5_ ? Math.atan2(_loc20_ - _loc18_,_loc21_ - _loc19_) * _loc22_ + _loc4_ : this._initialRotations[_loc7_]);
|
||||
if(_loc15_[_loc12_])
|
||||
{
|
||||
_loc9_[_loc12_](_loc2_);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc9_[_loc12_] = _loc2_;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Segment
|
||||
{
|
||||
|
||||
public var a:Number;
|
||||
|
||||
public var b:Number;
|
||||
|
||||
public var c:Number;
|
||||
|
||||
public var d:Number;
|
||||
|
||||
public var da:Number;
|
||||
|
||||
public var ca:Number;
|
||||
|
||||
public var ba:Number;
|
||||
|
||||
public function Segment(param1:Number, param2:Number, param3:Number, param4:Number)
|
||||
{
|
||||
super();
|
||||
this.a = param1;
|
||||
this.b = param2;
|
||||
this.c = param3;
|
||||
this.d = param4;
|
||||
this.da = param4 - param1;
|
||||
this.ca = param3 - param1;
|
||||
this.ba = param2 - param1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
|
||||
public class BezierThroughPlugin extends BezierPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
public function BezierThroughPlugin()
|
||||
{
|
||||
super();
|
||||
_propName = "bezierThrough";
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
if(param2 is Array)
|
||||
{
|
||||
param2 = {"values":param2};
|
||||
}
|
||||
param2.type = "thru";
|
||||
return super._onInitTween(param1,param2,param3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.filters.BlurFilter;
|
||||
|
||||
public class BlurFilterPlugin extends FilterPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
private static var _propNames:Array = ["blurX","blurY","quality"];
|
||||
|
||||
public function BlurFilterPlugin()
|
||||
{
|
||||
super("blurFilter");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
return _initFilter(param1,param2,param3,BlurFilter,new BlurFilter(0,0,param2.quality || 2),_propNames);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,188 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.filters.ColorMatrixFilter;
|
||||
|
||||
public class ColorMatrixFilterPlugin extends FilterPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected static var _lumR:Number = 0.212671;
|
||||
|
||||
protected static var _lumG:Number = 0.71516;
|
||||
|
||||
protected static var _lumB:Number = 0.072169;
|
||||
|
||||
private static var _propNames:Array = [];
|
||||
|
||||
protected static var _idMatrix:Array = [1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];
|
||||
|
||||
protected var _matrix:Array;
|
||||
|
||||
protected var _matrixTween:EndArrayPlugin;
|
||||
|
||||
public function ColorMatrixFilterPlugin()
|
||||
{
|
||||
super("colorMatrixFilter");
|
||||
}
|
||||
|
||||
public static function colorize(param1:Array, param2:Number, param3:Number = 1) : Array
|
||||
{
|
||||
var _loc6_:Number = NaN;
|
||||
if(isNaN(param2))
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
if(isNaN(param3))
|
||||
{
|
||||
param3 = 1;
|
||||
}
|
||||
_loc6_ = (param2 >> 16 & 0xFF) / 255;
|
||||
var _loc8_:Number = (param2 >> 8 & 0xFF) / 255;
|
||||
var _loc5_:Number = (param2 & 0xFF) / 255;
|
||||
var _loc4_:Number = 1 - param3;
|
||||
var _loc7_:Array = [_loc4_ + param3 * _loc6_ * _lumR,param3 * _loc6_ * _lumG,param3 * _loc6_ * _lumB,0,0,param3 * _loc8_ * _lumR,_loc4_ + param3 * _loc8_ * _lumG,param3 * _loc8_ * _lumB,0,0,param3 * _loc5_ * _lumR,param3 * _loc5_ * _lumG,_loc4_ + param3 * _loc5_ * _lumB,0,0,0,0,0,1,0];
|
||||
return applyMatrix(_loc7_,param1);
|
||||
}
|
||||
|
||||
public static function setThreshold(param1:Array, param2:Number) : Array
|
||||
{
|
||||
if(isNaN(param2))
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
var _loc3_:Array = [_lumR * 256,_lumG * 256,_lumB * 256,0,-256 * param2,_lumR * 256,_lumG * 256,_lumB * 256,0,-256 * param2,_lumR * 256,_lumG * 256,_lumB * 256,0,-256 * param2,0,0,0,1,0];
|
||||
return applyMatrix(_loc3_,param1);
|
||||
}
|
||||
|
||||
public static function setHue(param1:Array, param2:Number) : Array
|
||||
{
|
||||
var _loc5_:Number = NaN;
|
||||
if(isNaN(param2))
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
param2 *= 3.141592653589793 / 180;
|
||||
_loc5_ = Math.cos(param2);
|
||||
var _loc4_:Number = Math.sin(param2);
|
||||
var _loc3_:Array = [_lumR + _loc5_ * (1 - _lumR) + _loc4_ * -_lumR,_lumG + _loc5_ * -_lumG + _loc4_ * -_lumG,_lumB + _loc5_ * -_lumB + _loc4_ * (1 - _lumB),0,0,_lumR + _loc5_ * -_lumR + _loc4_ * 0.143,_lumG + _loc5_ * (1 - _lumG) + _loc4_ * 0.14,_lumB + _loc5_ * -_lumB + _loc4_ * -0.283,0,0,_lumR + _loc5_ * -_lumR + _loc4_ * -(1 - _lumR),_lumG + _loc5_ * -_lumG + _loc4_ * _lumG,_lumB + _loc5_ * (1 - _lumB) + _loc4_ * _lumB,0,0,0,0,0,1,0,0,0,0,0,1];
|
||||
return applyMatrix(_loc3_,param1);
|
||||
}
|
||||
|
||||
public static function setBrightness(param1:Array, param2:Number) : Array
|
||||
{
|
||||
if(isNaN(param2))
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
param2 = param2 * 100 - 100;
|
||||
return applyMatrix([1,0,0,0,param2,0,1,0,0,param2,0,0,1,0,param2,0,0,0,1,0,0,0,0,0,1],param1);
|
||||
}
|
||||
|
||||
public static function setSaturation(param1:Array, param2:Number) : Array
|
||||
{
|
||||
var _loc3_:Number = NaN;
|
||||
if(isNaN(param2))
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
_loc3_ = 1 - param2;
|
||||
var _loc4_:Number = _loc3_ * _lumR;
|
||||
var _loc7_:Number = _loc3_ * _lumG;
|
||||
var _loc5_:Number = _loc3_ * _lumB;
|
||||
var _loc6_:Array = [_loc4_ + param2,_loc7_,_loc5_,0,0,_loc4_,_loc7_ + param2,_loc5_,0,0,_loc4_,_loc7_,_loc5_ + param2,0,0,0,0,0,1,0];
|
||||
return applyMatrix(_loc6_,param1);
|
||||
}
|
||||
|
||||
public static function setContrast(param1:Array, param2:Number) : Array
|
||||
{
|
||||
if(isNaN(param2))
|
||||
{
|
||||
return param1;
|
||||
}
|
||||
param2 += 0.01;
|
||||
var _loc3_:Array = [param2,0,0,0,128 * (1 - param2),0,param2,0,0,128 * (1 - param2),0,0,param2,0,128 * (1 - param2),0,0,0,1,0];
|
||||
return applyMatrix(_loc3_,param1);
|
||||
}
|
||||
|
||||
public static function applyMatrix(param1:Array, param2:Array) : Array
|
||||
{
|
||||
var _loc6_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
if(!(param1 is Array) || !(param2 is Array))
|
||||
{
|
||||
return param2;
|
||||
}
|
||||
var _loc3_:Array = [];
|
||||
var _loc5_:int = 0;
|
||||
var _loc7_:int = 0;
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < 4)
|
||||
{
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 5)
|
||||
{
|
||||
_loc7_ = int(_loc4_ == 4 ? param1[_loc5_ + 4] : 0);
|
||||
_loc3_[_loc5_ + _loc4_] = param1[_loc5_] * param2[_loc4_] + param1[_loc5_ + 1] * param2[_loc4_ + 5] + param1[_loc5_ + 2] * param2[_loc4_ + 10] + param1[_loc5_ + 3] * param2[_loc4_ + 15] + _loc7_;
|
||||
_loc4_ += 1;
|
||||
}
|
||||
_loc5_ += 5;
|
||||
_loc6_ += 1;
|
||||
}
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
var _loc4_:Object = param2;
|
||||
_initFilter(param1,{
|
||||
"remove":param2.remove,
|
||||
"index":param2.index,
|
||||
"addFilter":param2.addFilter
|
||||
},param3,ColorMatrixFilter,new ColorMatrixFilter(_idMatrix.slice()),_propNames);
|
||||
if(_filter == null)
|
||||
{
|
||||
trace("FILTER NULL! ");
|
||||
return true;
|
||||
}
|
||||
_matrix = ColorMatrixFilter(_filter).matrix;
|
||||
var _loc5_:Array = [];
|
||||
if(_loc4_.matrix != null && _loc4_.matrix is Array)
|
||||
{
|
||||
_loc5_ = _loc4_.matrix;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(_loc4_.relative == true)
|
||||
{
|
||||
_loc5_ = _matrix.slice();
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_ = _idMatrix.slice();
|
||||
}
|
||||
_loc5_ = setBrightness(_loc5_,_loc4_.brightness);
|
||||
_loc5_ = setContrast(_loc5_,_loc4_.contrast);
|
||||
_loc5_ = setHue(_loc5_,_loc4_.hue);
|
||||
_loc5_ = setSaturation(_loc5_,_loc4_.saturation);
|
||||
_loc5_ = setThreshold(_loc5_,_loc4_.threshold);
|
||||
if(!isNaN(_loc4_.colorize))
|
||||
{
|
||||
_loc5_ = colorize(_loc5_,_loc4_.colorize,_loc4_.amount);
|
||||
}
|
||||
}
|
||||
_matrixTween = new EndArrayPlugin();
|
||||
_matrixTween._init(_matrix,_loc5_);
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
_matrixTween.setRatio(param1);
|
||||
ColorMatrixFilter(_filter).matrix = _matrix;
|
||||
super.setRatio(param1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.display.DisplayObject;
|
||||
import flash.geom.ColorTransform;
|
||||
|
||||
public class ColorTransformPlugin extends TintPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
public function ColorTransformPlugin()
|
||||
{
|
||||
super();
|
||||
_propName = "colorTransform";
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
var _loc5_:ColorTransform = null;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc6_:ColorTransform = new ColorTransform();
|
||||
if(param1 is DisplayObject)
|
||||
{
|
||||
_transform = DisplayObject(param1).transform;
|
||||
_loc5_ = _transform.colorTransform;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!(param1 is ColorTransform))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc5_ = param1 as ColorTransform;
|
||||
}
|
||||
if(param2 is ColorTransform)
|
||||
{
|
||||
_loc6_.concat(param2);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_.concat(_loc5_);
|
||||
}
|
||||
for(var _loc4_:String in param2)
|
||||
{
|
||||
if(_loc4_ == "tint" || _loc4_ == "color")
|
||||
{
|
||||
if(param2[_loc4_] != null)
|
||||
{
|
||||
_loc6_.color = int(param2[_loc4_]);
|
||||
}
|
||||
}
|
||||
else if(!(_loc4_ == "tintAmount" || _loc4_ == "exposure" || _loc4_ == "brightness"))
|
||||
{
|
||||
_loc6_[_loc4_] = param2[_loc4_];
|
||||
}
|
||||
}
|
||||
if(!(param2 is ColorTransform))
|
||||
{
|
||||
if(!isNaN(param2.tintAmount))
|
||||
{
|
||||
_loc7_ = param2.tintAmount / (1 - (_loc6_.redMultiplier + _loc6_.greenMultiplier + _loc6_.blueMultiplier) / 3);
|
||||
_loc6_.redOffset *= _loc7_;
|
||||
_loc6_.greenOffset *= _loc7_;
|
||||
_loc6_.blueOffset *= _loc7_;
|
||||
_loc6_.redMultiplier = _loc6_.greenMultiplier = _loc6_.blueMultiplier = 1 - param2.tintAmount;
|
||||
}
|
||||
else if(!isNaN(param2.exposure))
|
||||
{
|
||||
_loc6_.redOffset = _loc6_.greenOffset = _loc6_.blueOffset = 255 * (param2.exposure - 1);
|
||||
_loc6_.redMultiplier = _loc6_.greenMultiplier = _loc6_.blueMultiplier = 1;
|
||||
}
|
||||
else if(!isNaN(param2.brightness))
|
||||
{
|
||||
_loc6_.redOffset = _loc6_.greenOffset = _loc6_.blueOffset = Math.max(0,(param2.brightness - 1) * 255);
|
||||
_loc6_.redMultiplier = _loc6_.greenMultiplier = _loc6_.blueMultiplier = 1 - Math.abs(param2.brightness - 1);
|
||||
}
|
||||
}
|
||||
_init(_loc5_,_loc6_);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.filters.DropShadowFilter;
|
||||
|
||||
public class DropShadowFilterPlugin extends FilterPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
private static var _propNames:Array = ["distance","angle","color","alpha","blurX","blurY","strength","quality","inner","knockout","hideObject"];
|
||||
|
||||
public function DropShadowFilterPlugin()
|
||||
{
|
||||
super("dropShadowFilter");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
return _initFilter(param1,param2,param3,DropShadowFilter,new DropShadowFilter(0,45,0,0,0,0,1,param2.quality || 2,param2.inner,param2.knockout,param2.hideObject),_propNames);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
|
||||
public class EndArrayPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _a:Array;
|
||||
|
||||
protected var _round:Boolean;
|
||||
|
||||
protected var _info:Array = [];
|
||||
|
||||
public function EndArrayPlugin()
|
||||
{
|
||||
super("endArray");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
if(!(param1 is Array) || !(param2 is Array))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_init(param1 as Array,param2);
|
||||
return true;
|
||||
}
|
||||
|
||||
public function _init(param1:Array, param2:Array) : void
|
||||
{
|
||||
_a = param1;
|
||||
var _loc4_:int = int(param2.length);
|
||||
var _loc3_:int = 0;
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
if(param1[_loc4_] != param2[_loc4_] && param1[_loc4_] != null)
|
||||
{
|
||||
_info[_loc3_++] = new ArrayTweenInfo(_loc4_,_a[_loc4_],param2[_loc4_] - _a[_loc4_]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override public function _roundProps(param1:Object, param2:Boolean = true) : void
|
||||
{
|
||||
if("endArray" in param1)
|
||||
{
|
||||
_round = param2;
|
||||
}
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
var _loc3_:ArrayTweenInfo = null;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc4_:int = int(_info.length);
|
||||
if(_round)
|
||||
{
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
_loc3_ = _info[_loc4_];
|
||||
_a[_loc3_.i] = (_loc2_ = _loc3_.c * param1 + _loc3_.s) > 0 ? _loc2_ + 0.5 >> 0 : _loc2_ - 0.5 >> 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
_loc3_ = _info[_loc4_];
|
||||
_a[_loc3_.i] = _loc3_.c * param1 + _loc3_.s;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class ArrayTweenInfo
|
||||
{
|
||||
|
||||
public var i:uint;
|
||||
|
||||
public var s:Number;
|
||||
|
||||
public var c:Number;
|
||||
|
||||
public function ArrayTweenInfo(param1:uint, param2:Number, param3:Number)
|
||||
{
|
||||
super();
|
||||
this.i = param1;
|
||||
this.s = param2;
|
||||
this.c = param3;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.filters.BitmapFilter;
|
||||
import flash.filters.BlurFilter;
|
||||
|
||||
public class FilterPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _target:Object;
|
||||
|
||||
protected var _type:Class;
|
||||
|
||||
protected var _filter:BitmapFilter;
|
||||
|
||||
protected var _index:int;
|
||||
|
||||
protected var _remove:Boolean;
|
||||
|
||||
private var _tween:TweenLite;
|
||||
|
||||
public function FilterPlugin(param1:String = "", param2:Number = 0)
|
||||
{
|
||||
super(param1,param2);
|
||||
}
|
||||
|
||||
protected function _initFilter(param1:*, param2:Object, param3:TweenLite, param4:Class, param5:BitmapFilter, param6:Array) : Boolean
|
||||
{
|
||||
var _loc7_:String = null;
|
||||
var _loc8_:int = 0;
|
||||
var _loc11_:HexColorsPlugin = null;
|
||||
_target = param1;
|
||||
_tween = param3;
|
||||
_type = param4;
|
||||
var _loc10_:Array = _target.filters;
|
||||
var _loc9_:Object = param2 is BitmapFilter ? {} : param2;
|
||||
if(_loc9_.index != null)
|
||||
{
|
||||
_index = _loc9_.index;
|
||||
}
|
||||
else
|
||||
{
|
||||
_index = _loc10_.length;
|
||||
if(_loc9_.addFilter != true)
|
||||
{
|
||||
while(--_index > -1 && !(_loc10_[_index] is _type))
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_index < 0 || !(_loc10_[_index] is _type))
|
||||
{
|
||||
if(_index < 0)
|
||||
{
|
||||
_index = _loc10_.length;
|
||||
}
|
||||
if(_index > _loc10_.length)
|
||||
{
|
||||
_loc8_ = _loc10_.length - 1;
|
||||
while(++_loc8_ < _index)
|
||||
{
|
||||
_loc10_[_loc8_] = new BlurFilter(0,0,1);
|
||||
}
|
||||
}
|
||||
_loc10_[_index] = param5;
|
||||
_target.filters = _loc10_;
|
||||
}
|
||||
_filter = _loc10_[_index];
|
||||
_remove = _loc9_.remove == true;
|
||||
_loc8_ = int(param6.length);
|
||||
while(--_loc8_ > -1)
|
||||
{
|
||||
_loc7_ = param6[_loc8_];
|
||||
if(_loc7_ in param2 && _filter[_loc7_] != param2[_loc7_])
|
||||
{
|
||||
if(_loc7_ == "color" || _loc7_ == "highlightColor" || _loc7_ == "shadowColor")
|
||||
{
|
||||
_loc11_ = new HexColorsPlugin();
|
||||
_loc11_._initColor(_filter,_loc7_,param2[_loc7_]);
|
||||
_addTween(_loc11_,"setRatio",0,1,_propName);
|
||||
}
|
||||
else if(_loc7_ == "quality" || _loc7_ == "inner" || _loc7_ == "knockout" || _loc7_ == "hideObject")
|
||||
{
|
||||
_filter[_loc7_] = param2[_loc7_];
|
||||
}
|
||||
else
|
||||
{
|
||||
_addTween(_filter,_loc7_,_filter[_loc7_],param2[_loc7_],_propName);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
super.setRatio(param1);
|
||||
var _loc2_:Array = _target.filters;
|
||||
if(!(_loc2_[_index] is _type))
|
||||
{
|
||||
_index = _loc2_.length;
|
||||
while(--_index > -1 && !(_loc2_[_index] is _type))
|
||||
{
|
||||
}
|
||||
if(_index == -1)
|
||||
{
|
||||
_index = _loc2_.length;
|
||||
}
|
||||
}
|
||||
if(param1 == 1 && _remove && _tween._time == _tween._duration && _tween.data != "isFromStart")
|
||||
{
|
||||
if(_index < _loc2_.length)
|
||||
{
|
||||
_loc2_.splice(_index,1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc2_[_index] = _filter;
|
||||
}
|
||||
_target.filters = _loc2_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.display.MovieClip;
|
||||
|
||||
public class FrameLabelPlugin extends FramePlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
public function FrameLabelPlugin()
|
||||
{
|
||||
super();
|
||||
_propName = "frameLabel";
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
if(!param3.target is MovieClip)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_target = param1 as MovieClip;
|
||||
this.frame = _target.currentFrame;
|
||||
var _loc7_:Array = _target.currentLabels;
|
||||
var _loc6_:String = param2;
|
||||
var _loc5_:int = _target.currentFrame;
|
||||
var _loc4_:int = int(_loc7_.length);
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
if(_loc7_[_loc4_].name == _loc6_)
|
||||
{
|
||||
_loc5_ = int(_loc7_[_loc4_].frame);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(this.frame != _loc5_)
|
||||
{
|
||||
_addTween(this,"frame",this.frame,_loc5_,"frame",true);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.display.MovieClip;
|
||||
|
||||
public class FramePlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
public var frame:int;
|
||||
|
||||
protected var _target:MovieClip;
|
||||
|
||||
public function FramePlugin()
|
||||
{
|
||||
super("frame,frameLabel,frameForward,frameBackward");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
if(!(param1 is MovieClip) || isNaN(param2))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_target = param1 as MovieClip;
|
||||
this.frame = _target.currentFrame;
|
||||
_addTween(this,"frame",this.frame,param2,"frame",true);
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
super.setRatio(param1);
|
||||
if(this.frame != _target.currentFrame)
|
||||
{
|
||||
_target.gotoAndStop(this.frame);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.filters.GlowFilter;
|
||||
|
||||
public class GlowFilterPlugin extends FilterPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
private static var _propNames:Array = ["color","alpha","blurX","blurY","strength","quality","inner","knockout"];
|
||||
|
||||
public function GlowFilterPlugin()
|
||||
{
|
||||
super("glowFilter");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
return _initFilter(param1,param2,param3,GlowFilter,new GlowFilter(16777215,0,0,0,param2.strength || 1,param2.quality || 2,param2.inner,param2.knockout),_propNames);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,115 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
|
||||
public class HexColorsPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _colors:Array;
|
||||
|
||||
public function HexColorsPlugin()
|
||||
{
|
||||
super("hexColors");
|
||||
_overwriteProps = [];
|
||||
_colors = [];
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
for(var _loc4_:String in param2)
|
||||
{
|
||||
_initColor(param1,_loc4_,uint(param2[_loc4_]));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public function _initColor(param1:Object, param2:String, param3:uint) : void
|
||||
{
|
||||
var _loc8_:Boolean = false;
|
||||
var _loc5_:* = 0;
|
||||
_loc8_ = typeof param1[param2] == "function";
|
||||
var _temp_2:*;
|
||||
var _loc7_:uint = uint(!_loc8_ ? param1[param2] : (_temp_2 = param1,param1[param2.indexOf("set") || !("get" + param2.substr(3) in param1) ? param2 : "get" + param2.substr(3)]()));
|
||||
var _temp_2:*;
|
||||
if(_loc7_ != param3)
|
||||
{
|
||||
_loc5_ = uint(_loc7_ >> 16);
|
||||
var _loc6_:uint = uint(_loc7_ >> 8 & 0xFF);
|
||||
var _loc4_:uint = uint(_loc7_ & 0xFF);
|
||||
_colors[_colors.length] = new ColorProp(param1,param2,_loc8_,_loc5_,(param3 >> 16) - _loc5_,_loc6_,(param3 >> 8 & 0xFF) - _loc6_,_loc4_,(param3 & 0xFF) - _loc4_);
|
||||
_overwriteProps[_overwriteProps.length] = param2;
|
||||
}
|
||||
}
|
||||
|
||||
override public function _kill(param1:Object) : Boolean
|
||||
{
|
||||
var _loc2_:int = int(_colors.length);
|
||||
while(_loc2_--)
|
||||
{
|
||||
if(param1[_colors[_loc2_].p] != null)
|
||||
{
|
||||
_colors.splice(_loc2_,1);
|
||||
}
|
||||
}
|
||||
return super._kill(param1);
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
var _loc3_:ColorProp = null;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc4_:int = int(_colors.length);
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
_loc3_ = _colors[_loc4_];
|
||||
_loc2_ = _loc3_.rs + param1 * _loc3_.rc << 16 | _loc3_.gs + param1 * _loc3_.gc << 8 | _loc3_.bs + param1 * _loc3_.bc;
|
||||
if(_loc3_.f)
|
||||
{
|
||||
_loc3_.t[_loc3_.p](_loc2_);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc3_.t[_loc3_.p] = _loc2_;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class ColorProp
|
||||
{
|
||||
|
||||
public var t:Object;
|
||||
|
||||
public var p:String;
|
||||
|
||||
public var f:Boolean;
|
||||
|
||||
public var rs:int;
|
||||
|
||||
public var rc:int;
|
||||
|
||||
public var gs:int;
|
||||
|
||||
public var gc:int;
|
||||
|
||||
public var bs:int;
|
||||
|
||||
public var bc:int;
|
||||
|
||||
public function ColorProp(param1:Object, param2:String, param3:Boolean, param4:int, param5:int, param6:int, param7:int, param8:int, param9:int)
|
||||
{
|
||||
super();
|
||||
this.t = param1;
|
||||
this.p = param2;
|
||||
this.f = param3;
|
||||
this.rs = param4;
|
||||
this.rc = param5;
|
||||
this.gs = param6;
|
||||
this.gc = param7;
|
||||
this.bs = param8;
|
||||
this.bc = param9;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
public class RemoveTintPlugin extends TintPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
public function RemoveTintPlugin()
|
||||
{
|
||||
super();
|
||||
_propName = "removeTint";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import com.greensock.core.PropTween;
|
||||
|
||||
public class RoundPropsPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _tween:TweenLite;
|
||||
|
||||
public function RoundPropsPlugin()
|
||||
{
|
||||
super("roundProps",-1);
|
||||
_overwriteProps.length = 0;
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
_tween = param3;
|
||||
return true;
|
||||
}
|
||||
|
||||
public function _onInitAllProps() : Boolean
|
||||
{
|
||||
var _loc5_:String = null;
|
||||
var _loc3_:PropTween = null;
|
||||
var _loc1_:PropTween = null;
|
||||
var _loc7_:Array = null;
|
||||
_loc7_ = _tween.vars.roundProps is Array ? _tween.vars.roundProps : _tween.vars.roundProps.split(",");
|
||||
var _loc6_:int = int(_loc7_.length);
|
||||
var _loc2_:Object = {};
|
||||
var _loc4_:PropTween = _tween._propLookup.roundProps;
|
||||
while(--_loc6_ > -1)
|
||||
{
|
||||
_loc2_[_loc7_[_loc6_]] = 1;
|
||||
}
|
||||
_loc6_ = int(_loc7_.length);
|
||||
while(--_loc6_ > -1)
|
||||
{
|
||||
_loc5_ = _loc7_[_loc6_];
|
||||
_loc3_ = _tween._firstPT;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc1_ = _loc3_._next;
|
||||
if(_loc3_.pg)
|
||||
{
|
||||
_loc3_.t._roundProps(_loc2_,true);
|
||||
}
|
||||
else if(_loc3_.n == _loc5_)
|
||||
{
|
||||
_add(_loc3_.t,_loc5_,_loc3_.s,_loc3_.c);
|
||||
if(_loc1_)
|
||||
{
|
||||
_loc1_._prev = _loc3_._prev;
|
||||
}
|
||||
if(_loc3_._prev)
|
||||
{
|
||||
_loc3_._prev._next = _loc1_;
|
||||
}
|
||||
else if(_tween._firstPT == _loc3_)
|
||||
{
|
||||
_tween._firstPT = _loc1_;
|
||||
}
|
||||
_loc3_._next = _loc3_._prev = null;
|
||||
_tween._propLookup[_loc5_] = _loc4_;
|
||||
}
|
||||
_loc3_ = _loc1_;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public function _add(param1:Object, param2:String, param3:Number, param4:Number) : void
|
||||
{
|
||||
_addTween(param1,param2,param3,param3 + param4,param2,true);
|
||||
_overwriteProps[_overwriteProps.length] = param2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
|
||||
public class ShortRotationPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
public function ShortRotationPlugin()
|
||||
{
|
||||
super("shortRotation");
|
||||
_overwriteProps.pop();
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
var _loc6_:Number = NaN;
|
||||
if(typeof param2 == "number")
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc5_:Boolean = param2.useRadians == true;
|
||||
for(var _loc4_:String in param2)
|
||||
{
|
||||
if(_loc4_ != "useRadians")
|
||||
{
|
||||
var _temp_2:*;
|
||||
_loc6_ = Number(param1[_loc4_] is Function ? (_temp_2 = param1,param1[_loc4_.indexOf("set") || !("get" + _loc4_.substr(3) in param1) ? _loc4_ : "get" + _loc4_.substr(3)]()) : param1[_loc4_]);
|
||||
_initRotation(param1,_loc4_,_loc6_,typeof param2[_loc4_] == "number" ? Number(param2[_loc4_]) : _loc6_ + Number(param2[_loc4_].split("=").join("")),_loc5_);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public function _initRotation(param1:Object, param2:String, param3:Number, param4:Number, param5:Boolean = false) : void
|
||||
{
|
||||
var _loc7_:Number = NaN;
|
||||
_loc7_ = param5 ? 3.141592653589793 * 2 : 360;
|
||||
var _loc6_:Number = (param4 - param3) % _loc7_;
|
||||
if(_loc6_ != _loc6_ % (_loc7_ / 2))
|
||||
{
|
||||
_loc6_ = _loc6_ < 0 ? _loc6_ + _loc7_ : _loc6_ - _loc7_;
|
||||
}
|
||||
_addTween(param1,param2,param3,param3 + _loc6_,param2);
|
||||
_overwriteProps[_overwriteProps.length] = param2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import flash.display.Stage;
|
||||
|
||||
public class StageQualityPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _stage:Stage;
|
||||
|
||||
protected var _during:String;
|
||||
|
||||
protected var _after:String;
|
||||
|
||||
protected var _tween:TweenLite;
|
||||
|
||||
public function StageQualityPlugin()
|
||||
{
|
||||
super("stageQuality");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
if(!(param2.stage is Stage))
|
||||
{
|
||||
trace("You must define a \'stage\' property for the stageQuality object in your tween.");
|
||||
return false;
|
||||
}
|
||||
_stage = param2.stage as Stage;
|
||||
_tween = param3;
|
||||
_during = "during" in param2 ? param2.during : "medium";
|
||||
_after = "after" in param2 ? param2.after : _stage.quality;
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
if(param1 == 1 && _tween._duration == _tween._time && _tween.data != "isFromStart" || param1 == 0 && _tween._time == 0)
|
||||
{
|
||||
_stage.quality = _after;
|
||||
}
|
||||
else if(_stage.quality != _during)
|
||||
{
|
||||
_stage.quality = _during;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.*;
|
||||
import com.greensock.core.*;
|
||||
import flash.display.*;
|
||||
import flash.geom.ColorTransform;
|
||||
import flash.geom.Transform;
|
||||
|
||||
public class TintPlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected static var _props:Array = ["redMultiplier","greenMultiplier","blueMultiplier","alphaMultiplier","redOffset","greenOffset","blueOffset","alphaOffset"];
|
||||
|
||||
protected var _transform:Transform;
|
||||
|
||||
public function TintPlugin()
|
||||
{
|
||||
super("tint,colorTransform,removeTint");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
if(!(param1 is DisplayObject))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc5_:ColorTransform = new ColorTransform();
|
||||
if(param2 != null && param3.vars.removeTint != true)
|
||||
{
|
||||
_loc5_.color = param2;
|
||||
}
|
||||
_transform = DisplayObject(param1).transform;
|
||||
var _loc4_:ColorTransform = _transform.colorTransform;
|
||||
_loc5_.alphaMultiplier = _loc4_.alphaMultiplier;
|
||||
_loc5_.alphaOffset = _loc4_.alphaOffset;
|
||||
_init(_loc4_,_loc5_);
|
||||
return true;
|
||||
}
|
||||
|
||||
public function _init(param1:ColorTransform, param2:ColorTransform) : void
|
||||
{
|
||||
var _loc3_:String = null;
|
||||
var _loc4_:int = int(_props.length);
|
||||
while(--_loc4_ > -1)
|
||||
{
|
||||
_loc3_ = _props[_loc4_];
|
||||
if(param1[_loc3_] != param2[_loc3_])
|
||||
{
|
||||
_addTween(param1,_loc3_,param1[_loc3_],param2[_loc3_],"tint");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
var _loc2_:ColorTransform = _transform.colorTransform;
|
||||
var _loc3_:PropTween = _firstPT;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc2_[_loc3_.p] = _loc3_.c * param1 + _loc3_.s;
|
||||
_loc3_ = _loc3_._next;
|
||||
}
|
||||
_transform.colorTransform = _loc2_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,194 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
import com.greensock.core.PropTween;
|
||||
|
||||
public class TweenPlugin
|
||||
{
|
||||
|
||||
public static const version:String = "12.1.5";
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
public var _propName:String;
|
||||
|
||||
public var _overwriteProps:Array;
|
||||
|
||||
public var _priority:int = 0;
|
||||
|
||||
protected var _firstPT:PropTween;
|
||||
|
||||
public function TweenPlugin(param1:String = "", param2:int = 0)
|
||||
{
|
||||
super();
|
||||
_overwriteProps = param1.split(",");
|
||||
_propName = _overwriteProps[0];
|
||||
_priority = param2 || 0;
|
||||
}
|
||||
|
||||
private static function _onTweenEvent(param1:String, param2:TweenLite) : Boolean
|
||||
{
|
||||
var _loc7_:Boolean = false;
|
||||
var _loc6_:PropTween = null;
|
||||
var _loc5_:PropTween = null;
|
||||
var _loc3_:PropTween = null;
|
||||
var _loc8_:PropTween = null;
|
||||
var _loc4_:PropTween = param2._firstPT;
|
||||
if(param1 == "_onInitAllProps")
|
||||
{
|
||||
while(_loc4_)
|
||||
{
|
||||
_loc3_ = _loc4_._next;
|
||||
_loc8_ = _loc6_;
|
||||
while(_loc8_ && _loc8_.pr > _loc4_.pr)
|
||||
{
|
||||
_loc8_ = _loc8_._next;
|
||||
}
|
||||
if(_loc4_._prev == _loc8_ ? _loc8_._prev : _loc5_)
|
||||
{
|
||||
_loc4_._prev._next = _loc4_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_ = _loc4_;
|
||||
}
|
||||
if(_loc4_._next == _loc8_)
|
||||
{
|
||||
_loc8_._prev = _loc4_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_ = _loc4_;
|
||||
}
|
||||
_loc4_ = _loc3_;
|
||||
}
|
||||
_loc4_ = param2._firstPT = _loc6_;
|
||||
}
|
||||
while(_loc4_)
|
||||
{
|
||||
if(_loc4_.pg)
|
||||
{
|
||||
if(param1 in _loc4_.t)
|
||||
{
|
||||
if(_loc4_.t[param1]())
|
||||
{
|
||||
_loc7_ = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc4_ = _loc4_._next;
|
||||
}
|
||||
return _loc7_;
|
||||
}
|
||||
|
||||
public static function activate(param1:Array) : Boolean
|
||||
{
|
||||
TweenLite._onPluginEvent = TweenPlugin._onTweenEvent;
|
||||
var _loc2_:int = int(param1.length);
|
||||
while(--_loc2_ > -1)
|
||||
{
|
||||
if(param1[_loc2_].API == 2)
|
||||
{
|
||||
TweenLite._plugins[new (param1[_loc2_] as Class)()._propName] = param1[_loc2_];
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
protected function _addTween(param1:Object, param2:String, param3:Number, param4:*, param5:String = null, param6:Boolean = false) : PropTween
|
||||
{
|
||||
var _loc7_:Number = param4 == null ? 0 : (typeof param4 === "number" || param4.charAt(1) !== "=" ? Number(param4) - param3 : (int(param4.charAt(0) + "1")) * Number(param4.substr(2)));
|
||||
if(_loc7_ !== 0)
|
||||
{
|
||||
_firstPT = new PropTween(param1,param2,param3,_loc7_,param5 || param2,false,_firstPT);
|
||||
_firstPT.r = param6;
|
||||
return _firstPT;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public function setRatio(param1:Number) : void
|
||||
{
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc3_:PropTween = _firstPT;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc2_ = _loc3_.c * param1 + _loc3_.s;
|
||||
if(_loc3_.r)
|
||||
{
|
||||
_loc2_ = _loc2_ + (_loc2_ > 0 ? 0.5 : -0.5) | 0;
|
||||
}
|
||||
if(_loc3_.f)
|
||||
{
|
||||
_loc3_.t[_loc3_.p](_loc2_);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc3_.t[_loc3_.p] = _loc2_;
|
||||
}
|
||||
_loc3_ = _loc3_._next;
|
||||
}
|
||||
}
|
||||
|
||||
public function _roundProps(param1:Object, param2:Boolean = true) : void
|
||||
{
|
||||
var _loc3_:PropTween = _firstPT;
|
||||
while(_loc3_)
|
||||
{
|
||||
if(_propName in param1 || _loc3_.n != null && _loc3_.n.split(_propName + "_").join("") in param1)
|
||||
{
|
||||
_loc3_.r = param2;
|
||||
}
|
||||
_loc3_ = _loc3_._next;
|
||||
}
|
||||
}
|
||||
|
||||
public function _kill(param1:Object) : Boolean
|
||||
{
|
||||
var _loc3_:int = 0;
|
||||
if(_propName in param1)
|
||||
{
|
||||
_overwriteProps = [];
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc3_ = int(_overwriteProps.length);
|
||||
while(--_loc3_ > -1)
|
||||
{
|
||||
if(_overwriteProps[_loc3_] in param1)
|
||||
{
|
||||
_overwriteProps.splice(_loc3_,1);
|
||||
}
|
||||
}
|
||||
}
|
||||
var _loc2_:PropTween = _firstPT;
|
||||
while(_loc2_)
|
||||
{
|
||||
if(_loc2_.n in param1)
|
||||
{
|
||||
if(_loc2_._next)
|
||||
{
|
||||
_loc2_._next._prev = _loc2_._prev;
|
||||
}
|
||||
if(_loc2_._prev)
|
||||
{
|
||||
_loc2_._prev._next = _loc2_._next;
|
||||
_loc2_._prev = null;
|
||||
}
|
||||
else if(_firstPT == _loc2_)
|
||||
{
|
||||
_firstPT = _loc2_._next;
|
||||
}
|
||||
}
|
||||
_loc2_ = _loc2_._next;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.TweenLite;
|
||||
|
||||
public class VisiblePlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _target:Object;
|
||||
|
||||
protected var _tween:TweenLite;
|
||||
|
||||
protected var _visible:Boolean;
|
||||
|
||||
protected var _initVal:Boolean;
|
||||
|
||||
protected var _progress:int;
|
||||
|
||||
public function VisiblePlugin()
|
||||
{
|
||||
super("visible");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
_target = param1;
|
||||
_tween = param3;
|
||||
_progress = _tween.vars.runBackwards ? 0 : 1;
|
||||
_initVal = _target.visible;
|
||||
_visible = param2;
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
_target.visible = param1 == 1 && (_tween._time / _tween._duration == _progress || _tween._duration == 0) ? _visible : _initVal;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.greensock.plugins
|
||||
{
|
||||
import com.greensock.*;
|
||||
import flash.media.SoundTransform;
|
||||
|
||||
public class VolumePlugin extends TweenPlugin
|
||||
{
|
||||
|
||||
public static const API:Number = 2;
|
||||
|
||||
protected var _target:Object;
|
||||
|
||||
protected var _st:SoundTransform;
|
||||
|
||||
public function VolumePlugin()
|
||||
{
|
||||
super("volume");
|
||||
}
|
||||
|
||||
override public function _onInitTween(param1:Object, param2:*, param3:TweenLite) : Boolean
|
||||
{
|
||||
if(isNaN(param2) || param1.hasOwnProperty("volume") || !param1.hasOwnProperty("soundTransform"))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_target = param1;
|
||||
_st = _target.soundTransform;
|
||||
_addTween(_st,"volume",_st.volume,param2,"volume");
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function setRatio(param1:Number) : void
|
||||
{
|
||||
super.setRatio(param1);
|
||||
_target.soundTransform = _st;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user