+Show TOC
×Hide TOC

AbstractMultiTween

Kind of class:	public class
Package:	com.bourre.transitions
Inherits from:	AbstractSyncCommand < AbstractCommand
Implements:	AdvancedTween TickListener
Known subclasses:	MultiTweenFPS MultiTweenMS
Author:	Cédric Néhémie
Classpath:	com.bourre.transitions.AbstractMultiTween
File last modified:	Monday, 24 November 2008, 11:36:57

► View source

▼ Hide source

/*
 * Copyright the original author or authors.
 * 
 * Licensed under the MOZILLA PUBLIC LICENSE, Version 1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.mozilla.org/MPL/MPL-1.1.html
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.bourre.transitions 
{
    import com.bourre.commands.AbstractSyncCommand;
    import com.bourre.core.AccessorComposer;
    import com.bourre.core.AccessorFactory;
    import com.bourre.error.IndexOutOfBoundsException;
    import com.bourre.error.UnimplementedVirtualMethodException;
    import com.bourre.log.PixlibDebug;
    import com.bourre.utils.ClassUtils;
    
    import flash.events.Event;    

    /**
     * @author    C√©dric N√©h√©mie
     */
    public class AbstractMultiTween 
        extends AbstractSyncCommand    
        implements AdvancedTween, TickListener
    {    
        static public function noEasing( t : Number,  b : Number,  c : Number, d : Number ) : Number 
        {
            return c * t / d + b;
        }
        
        //-------------------------------------------------------------------------
        // Private properties
        //-------------------------------------------------------------------------
        
        protected var _aStart             : Array; 
        protected var _aEnd                 : Array;
        protected var _aStartValues         : Array;
        protected var _aEndValues         : Array;
        protected var _nDuration         : Number;
        protected var _fEasing             : Function;    
        protected var _nPlayHead         : Number;
        protected var _bReversedMotion      : Boolean;    
        protected var _oSetter              : AccessorComposer;
        protected var _oBeacon              : TickBeacon;        
        protected var _eOnStart          : TweenEvent;
        protected var _eOnStop              : TweenEvent;
        protected var _eOnMotionChanged  : TweenEvent;
        protected var _eOnMotionFinished : TweenEvent;
        
        //-------------------------------------------------------------------------
        // Private implementation
        //-------------------------------------------------------------------------
        
        public function AbstractMultiTween( targets : Object, 
                                               setters : Array, 
                                               endValues : Array, 
                                               duration : Number, 
                                               startValues : Array = null, 
                                               easing : Function = null,
                                               getters : Array = null )
        {
            if( !ClassUtils.isImplementedAll( this, "com.bourre.transitions:AbstractMultiTween", "isMotionFinished", "isReversedMotionFinished" ) )
            {
                PixlibDebug.ERROR ( this + " have to implements virtual methods : isMotionFinished & isReversedMotionFinished" );
                throw new UnimplementedVirtualMethodException ( this + " have to implements virtual methods : isMotionFinished & isReversedMotionFinished" );
            }
            _buildAccessor( targets, setters, getters, startValues );
            
            _bIsRunning = false;
            _aEndValues = endValues;
            _nDuration = duration;
            
            setEasing( easing );
            reset();
            
            _eOnStart = new TweenEvent ( TweenEvent.onStartEVENT, this );
            _eOnStop = new TweenEvent ( TweenEvent.onStopEVENT, this );
            _eOnMotionChanged = new TweenEvent ( TweenEvent.onMotionChangedEVENT, this );
            _eOnMotionFinished = new TweenEvent ( TweenEvent.onMotionFinishedEVENT, this );
        }
        
        /*-----------------------------------------------
         *    TickListener IMPLEMENTATION
         *-----------------------------------------------*/
        
        public function onTick( e : Event = null ) : void
        {
            if ( _bReversedMotion ? isReversedMotionFinished() :  isMotionFinished() )
            {
                _onMotionEnd();
            } 
            else
            {
                _update();
            }
        }
        
        /*-----------------------------------------------
         *    Suspendable IMPLEMENTATION
         *-----------------------------------------------*/
        
        public function reset() : void
        {
            _nPlayHead = 0;
            _bReversedMotion = false;
            _aStart = _aStartValues;
            _oSetter.setValue( _aStart );
            _aEnd = _aEndValues;
        }
        
        public function start() : void
        {
            if ( !_aStartValues ) 
            {
                PixlibDebug.FATAL( this + " has no start value." );
                
            } 
            else
            {
                _bIsRunning = true;
                _oBeacon.addTickListener(this);
                _oEB.broadcastEvent( _eOnStart );
            }
        }
                
        public function stop() : void
        {
            _oBeacon.removeTickListener(this);
            _bIsRunning = false;
            _oEB.broadcastEvent( _eOnStop );
        }
        
        /*-----------------------------------------------
         *    Tween IMPLEMENTATION
         *-----------------------------------------------*/
        
        public function setEasing( f : Function ) : void
        {
            _fEasing = ( f != null ) ?  f : AbstractTween.noEasing;
        }
        
        
        /*-----------------------------------------------
         *    VIRTUAL MEMBERS
         *-----------------------------------------------*/
        
        public function isMotionFinished () : Boolean
        {    
            return false;
        }
        
        public function isReversedMotionFinished () : Boolean
        {    
            return false;
        }
        
        /*-----------------------------------------------
         *    ELSE
         *-----------------------------------------------*/
        
        public function onUpdate ( sV : Number, eV : Number ) : Number
        {
            return _fEasing( _nPlayHead, sV, eV - sV, _nDuration );
        }
        
        public function _update() : void
        {
            var a : Array = new Array();
            var l : Number = _aEnd.length;
            for ( var i : Number= 0; i < l; i++ ) a.push( onUpdate( _aStart[i], _aEnd[i] ) );
            _oSetter.setValue( a );
            _oEB.broadcastEvent( _eOnMotionChanged );    
        }
        
        public function isReversed() : Boolean
        {
            return _bReversedMotion;
        }
        
        public function setReversed( b : Boolean ) : void
        {
            _bReversedMotion = b;
        }
        
        public function setPlayHeadPosition ( n : Number ) : void
        {
            if ( n < 0 || n > 1 )
                throw new IndexOutOfBoundsException( "The new playhead position must be in the range 0 < n < 1" );
                
            _nPlayHead = Math.floor( n * _nDuration );
        }

        public function getPlayHeadPosition () : Number
        {
            return _nPlayHead / _nDuration;
        }
        
        public function getEasing() : Function
        {
            return _fEasing;
        }
        
        public function getDuration() : Number
        {
            return _nDuration;
        }
                
        public override function execute( e : Event = null ) : void
        {
            reset();
            start();
        }

        public function getTarget () : Object
        {
            return _oSetter.getTarget();
        }
        
        public function setStartValue( a : Array ) : void
        {
            _aStartValues = a;
        }
        
        public function getStartValue () : Array
        {
            return _aStartValues;
        }
        
        public function setEndValue( a : Array ) : void
        {
            _aEndValues = a;
        }
        
        public function getEndValue () : Array
        {
            return _aEndValues;
        }
        
        public function setDuration( n : Number ) : void
        {
            _nDuration = n;
        }
        
        public function addListener( listener : TweenListener ) : Boolean
        {
            return _oEB.addListener( listener );
        }

        public function removeListener( listener : TweenListener ) : Boolean
        {
            return _oEB.removeListener( listener );
        }
        
        public function addEventListener( type : String, listener : Object, ... rest ) : Boolean
        {
            return _oEB.addEventListener.apply( _oEB, rest.length > 0 ? [ type, listener ].concat( rest ) : [ type, listener ] );
        }
        
        public function removeEventListener( type : String, listener : Object ) : Boolean
        {
            return _oEB.removeEventListener( type, listener );
        }
        
        
        //-------------------------------------------------------------------------
        // Private implementation
        //-------------------------------------------------------------------------
        
        protected function _buildAccessor( o : Object, sP  : Array, gP : Array = null, nS : Array = null ) : void
        {
            _oSetter = AccessorFactory.getMultiAccessor( o, sP, gP );
            if (nS) _aStartValues = nS;
            else _aStartValues = _oSetter.getValue();
        }
        
        protected function _onMotionEnd() : void
        {
            _bIsRunning = false;
            _oBeacon.removeTickListener( this );
            
            _nPlayHead = _bReversedMotion ? 0 : _nDuration;
            _update();
            
            fireCommandEndEvent();
            _oEB.broadcastEvent( _eOnMotionFinished );
        }
    }
}

Summary

Constructor

AbstractMultiTween (targets:Object, setters:Array, endValues:Array, duration:Number, startValues:Array = null, easing:Function = null, getters:Array = null)

Class methods

noEasing (t:Number, b:Number, c:Number, d:Number) : Number

Instance methods

reset : void
start : void
stop : void
setEasing (f:Function) : void
- Defines the easing function used by this {VISDOC_CODE_BLOCK_2} object.
isMotionFinished : Boolean
isReversedMotionFinished : Boolean
_update : void
isReversed : Boolean
setReversed (b:Boolean) : void
setPlayHeadPosition (n:Number) : void
getPlayHeadPosition : Number
getEasing : Function
getDuration : Number
execute (e:Event = null) : void
getTarget : Object
setStartValue (a:Array) : void
getStartValue : Array
setEndValue (a:Array) : void
getEndValue : Array
setDuration (n:Number) : void
addListener (listener:TweenListener) : Boolean
- Adds the passed-in listener object as listener for
removeListener (listener:TweenListener) : Boolean
- Removes the passed-in listener from listening all events
addEventListener (type:String, listener:Object, rest) : Boolean
- Adds the passed-in listener as listener for the passed-in event type.
removeEventListener (type:String, listener:Object) : Boolean
- Removes the passed-in listener for listening the passed-in event type.

Event handlers

onTick (e:Event = null) : void
- Method called by the {VISDOC_CODE_BLOCK_5} for each
onUpdate (sV:Number, eV:Number) : Number

Constructor

AbstractMultiTween

public function AbstractMultiTween (

targets:Object, setters:Array, endValues:Array, duration:Number, startValues:Array = null, easing:Function = null, getters:Array = null)

Class methods

noEasing

public static function noEasing (

t:Number, b:Number, c:Number, d:Number) : Number

Instance methods

_update

public function _update (

) : void

addEventListener

public function addEventListener (

type:String, listener:Object, rest) : Boolean

Adds the passed-in listener as listener for the passed-in event type.

Parameters:

type :

name of the event type.

listener:

object to be added as listener.

Returns:

{VISDOC_CODE_BLOCK_8} if the object have been succesfully added as
listener for the passed-in event type
#

Specified by:

AdvancedTween.addEventListener

addListener

public function addListener (

listener:TweenListener) : Boolean

Adds the passed-in listener object as listener for
all events dispatched by the tween. The object must
implements the {VISDOC_CODE_BLOCK_5} interface.

Parameters:

listener:

object to be added as listener.

Returns:

{VISDOC_CODE_BLOCK_6} if the object have been succesfully
added as listener for this object
#

Specified by:

AdvancedTween.addListener

execute

override public function execute (

e:Event = null) : void

Overrides:

AbstractSyncCommand.execute

getDuration

public function getDuration (

) : Number

getEasing

public function getEasing (

) : Function

getEndValue

public function getEndValue (

) : Array

getPlayHeadPosition

public function getPlayHeadPosition (

) : Number

getStartValue

public function getStartValue (

) : Array

getTarget

public function getTarget (

) : Object

isMotionFinished

public function isMotionFinished (

) : Boolean

isReversed

public function isReversed (

) : Boolean

isReversedMotionFinished

public function isReversedMotionFinished (

) : Boolean

removeEventListener

public function removeEventListener (

type:String, listener:Object) : Boolean

Removes the passed-in listener for listening the passed-in event type.

Parameters:

type :

name of the event type.

listener:

object to be removed as listener.

Returns:

{VISDOC_CODE_BLOCK_9} if the object have been succesfully remove as
listener for the passed-in event type
#

Specified by:

AdvancedTween.removeEventListener

removeListener

public function removeListener (

listener:TweenListener) : Boolean

Removes the passed-in listener from listening all events
dispatched by this tween.

Parameters:

listener:

object to be removed as listener.

Returns:

{VISDOC_CODE_BLOCK_7} if the object have been succesfully removed
as listener for this object
#

Specified by:

AdvancedTween.removeListener

reset

public function reset (

) : void

setDuration

public function setDuration (

n:Number) : void

setEasing

public function setEasing (

f:Function) : void

Defines the easing function used by this {VISDOC_CODE_BLOCK_2} object.

Easing function can't be null, concret implementation must provide
a default function if no function is defined, or if the passed-in
function is {VISDOC_CODE_BLOCK_3}.

Parameters:

easing function for this tween, the function must implements
the following signature :
function easingFunc( t : Number, b : Number, c : Number, d : Number ) : Number
Where :

{VISDOC_CODE_BLOCK_4} is the elapsed time since start in milliseconds
{VISDOC_CODE_BLOCK_5} is the the start value
{VISDOC_CODE_BLOCK_6} is the size of the value range such{VISDOC_CODE_BLOCK_7}
{VISDOC_CODE_BLOCK_8} is the duration of the tween in milliseconds
the returned value is the the interpolated value

Specified by:

Tween.setEasing

setEndValue

public function setEndValue (

a:Array) : void

setPlayHeadPosition

public function setPlayHeadPosition (

n:Number) : void

setReversed

public function setReversed (

b:Boolean) : void

setStartValue

public function setStartValue (

a:Array) : void

start

public function start (

) : void

stop

public function stop (

) : void

Event handlers

onTick

public function onTick (

e:Event = null) : void

Method called by the {VISDOC_CODE_BLOCK_5} for each
step of time according to its time slicing approach.

The {VISDOC_CODE_BLOCK_6} method is very similar to the
old {VISDOC_CODE_BLOCK_7} method, but doesn't specifically
occurs when entering in a new frame of a frame-based animation.
The tick could be the result of a {VISDOC_CODE_BLOCK_8} call,
or a change in the timecode of a video.

Parameters:

event dispatched by the beacon object

Specified by:

TickListener.onTick

onUpdate

public function onUpdate (

sV:Number, eV:Number) : Number