+Show TOC
×Hide TOC

TweenFLV

Kind of class:	class
Inherits from:	BasicTweenFLV < AbstractTween
Implements:	ITween
Version:	1.0
Author:	Francis Bourre
Classpath:	com.bourre.transitions.TweenFLV
File last modified:	Wednesday, 31 October 2007, 07:35:30

► 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.
 */
 
 /**
 * {@code TweenFLV} extends {@link BasicTweenFLV} class implementing
 * Pixlib Event API.
 * 
 * <p>Can use these methods to control Tween event :
 * <ul>
 *   <li>{@link #addListener}</li>
 *   <li>{@link #removeListener}</li>
 *   <li>{@link #addEventListener}</li>
 *   <li>{@link #removeEventListener}</li>
 * </ul>
 * 
 * <p>Example
 * <code>
 *   var _video : VideoDisplay = VideoDisplay.buildVideoDisplay( video );
 *   var t : TweenFLV = new TweenFLV(_video, 0, mc, '_alpha', 0, 2000, 100);
 *   t.start();
 *      _video.load( "video.flv" );
 * </code>
 * 
 * @author Francis Bourre
 * @version 1.0
 */
 
import com.bourre.events.EventBroadcaster;
import com.bourre.events.IEvent;
import com.bourre.log.PixlibStringifier;
import com.bourre.medias.video.VideoDisplay;
import com.bourre.transitions.BasicTweenFLV;
import com.bourre.transitions.ITween;
import com.bourre.transitions.ITweenListener;
import com.bourre.transitions.TweenEvent;
import com.bourre.transitions.TweenEventType;

class com.bourre.transitions.TweenFLV 
    extends BasicTweenFLV
    implements ITween
{
    //-------------------------------------------------------------------------
    // Events definition
    //-------------------------------------------------------------------------
    
    /**
     * Broadcasted to listeners when tween starts.<br>
     */
    [Event("onStart")]
    public static var onStartEVENT:TweenEventType = TweenEventType.onStartEVENT;
    
    /**
     * Broadcasted to listeners when tween stops.<br>
     */
    [Event("onStop")]
    public static var onStopEVENT:TweenEventType = TweenEventType.onStopEVENT;
    
    /**
     * Broadcasted to listeners when tween is finished.<br>
     */
    [Event("onMotionFinished")]
    public static var onMotionFinishedEVENT:TweenEventType = TweenEventType.onMotionFinishedEVENT;
    
    /**
     * Broadcasted to listeners when property value is updated.<br>
     */
    [Event("onMotionChanged")]
    public static var onMotionChangedEVENT:TweenEventType = TweenEventType.onMotionChangedEVENT;
    
    private var _oEB:EventBroadcaster;

    private var _eOnMotionChangedEvent : TweenEvent;
    private var _eOnMotionFinishedEvent : TweenEvent;
    private var _eOnMotionStartEvent : TweenEvent;
    private var _eOnMotionStopEvent : TweenEvent;
    
    
    //-------------------------------------------------------------------------
    // Public API
    //-------------------------------------------------------------------------
    
    /**
     * Constructs a new {@code TweenFLV} instance.
     * 
     * <p>Example
     * <code>
     *   var _video : VideoDisplay = VideoDisplay.buildVideoDisplay( video );
     *   var t : TweenFLV = new TweenFLV(_video, 0, mc, '_alpha', 0, 2000, 100);
     *   t.start();
     *      _video.load( "video.flv" );
     * </code>
     * 
     * @param vd     VideoDisplay listened.
     * @param offset shift with starting.
     * @param oT     Object which the Tween targets.
     * @param sP     Setter (method or property).
     * @param nE     Ending value of property.
     * @param nRate Length of time of the motion in milliseconds.
     * @param nS     Starting value of property (optional).
     * @param fE     Easing function (optional).
    */
    public function TweenFLV( vd : VideoDisplay, offset : Number, oT, sP, nEnd:Number, nMs:Number, nStart:Number, fE:Function)
    {
        super(vd, offset, oT, sP, nEnd, nMs, nStart, fE);
        _oEB = new EventBroadcaster( this );
        
        _eOnMotionStartEvent = new TweenEvent(onStartEVENT, this);
        _eOnMotionStopEvent = new TweenEvent(onStopEVENT, this);
        _eOnMotionChangedEvent = new TweenEvent(onMotionChangedEVENT, this);
        _eOnMotionFinishedEvent = new TweenEvent(onMotionFinishedEVENT, this);
    }
    
    /**
     * Adds listener for receiving all events.
     * 
     * <p>Example
     * <code>
     *   t.addListener(myListener);
     * </code>
     * 
     * @param oL Listener object which implements {@link ITweenListener} interface.
     */
    public function addListener(oL:ITweenListener) : Void
    {
        _oEB.addListener(oL);
    }
    
    /**
     * Removes listener for receiving all events.
     * 
     * <p>Example
     * <code>
     *   t.removeListener(myListener);
     * </code>
     * 
     * @param oL Listener object which implements {@link ITweenListener} interface.
     */
    public function removeListener(oL:ITweenListener) : Void
    {
        _oEB.removeListener(oL);
    }
    
    /**
     * Adds listener for specifical event.
     * 
     * <p>Example
     * <code>
     *   t.addEventListener( TweenFLV.onMotionFinishedEVENT, myListener );
     * </code>
     * 
     * @param t Name of the Event.
     * @param oL Listener object.
     */
    public function addEventListener(e:TweenEventType, oL) : Void
    {
        _oEB.addEventListener.apply(_oEB, arguments);
    }
    
    /**
     * Removes listener for specifical event.
     * 
     * <p>Example
     * <code>
     *   t.removeEventListener( TweenFLV.onMotionFinishedEVENT, myListener );
     * </code>
     * 
     * @param t Name of the Event.
     * @param oL Listener object.
     */
    public function removeEventListener(e:TweenEventType, oL) : Void
    {
        _oEB.removeEventListener(e, oL);
    }
    
    /**
     * Starts tweening.
     * 
     * <p>{@link AbstractTween#start} overridding
     */
    public function start() : Void
    {
        execute();
    }
    
    /**
     * Stops tweening.
     * 
     * <p>{@link AbstractTween#stop} overridding
     */
    public function stop() : Void
    {
        super.stop();
        _oEB.broadcastEvent( _eOnMotionStopEvent );
    }
    
    /**
     * Starts tweening
     * 
     * <p>{@link com.bourre.commands.Command} polymorphism.
     * 
     * @see com.bourre.commands.Command
     */
    public function execute( e : IEvent ) : Void
    {
        super.execute();
        _oEB.broadcastEvent( _eOnMotionStartEvent );
    }
    
    /**
     *    Implemented to add tween as listener to another tween.
     */
    public function onMotionFinished() : Void
    {
        execute();
    }
    
    /**
     * Returns the string representation of this instance.
     * @return the string representation of this instance
     */
    public function toString() : String 
    {
        return PixlibStringifier.stringify( this );
    }
    
    
    //-------------------------------------------------------------------------
    // Private implementation
    //-------------------------------------------------------------------------
    
    private function _onMotionEnd() : Void
    {
        super._onMotionEnd();
        _oEB.broadcastEvent( _eOnMotionChangedEvent );
        _oEB.broadcastEvent( _eOnMotionFinishedEvent );
    }
    
    private function _onUpdate() : Void
    {
        super._onUpdate();
        _oEB.broadcastEvent( _eOnMotionChangedEvent );
    }
}

TweenFLV extends BasicTweenFLV class implementing
Pixlib Event API.

Can use these methods to control Tween event :

Example

var _video : VideoDisplay = VideoDisplay.buildVideoDisplay( video );
var t : TweenFLV = new TweenFLV(_video, 0, mc, '_alpha', 0, 2000, 100);
t.start();
   _video.load( "video.flv" );

Summary

Constructor

TweenFLV

Class properties

onStartEVENT
onStopEVENT
onMotionFinishedEVENT
onMotionChangedEVENT

Instance properties

Instance properties inherited from BasicTweenFLV

_nT _nVO _vd

Instance properties inherited from AbstractTween

_bP _fE _isMotionFinished _nE _nRate _nRE _nRS _nS _oBeacon _onUpdate _oSetter

Class methods

Class methods inherited from AbstractTween

noEasing

Instance methods

addListener
removeListener
addEventListener
removeEventListener
start
stop
execute
toString

Instance methods inherited from BasicTweenFLV

_isMotionFinished _onUpdate execute getFLVBeacon setFLVBeacon setStartVideoOffset setVideoDisplay toString

Instance methods inherited from AbstractTween

_buildAccessor _onMotionEnd execute getDuration getEasing getProperty getTarget isPlaying resume setDuration setEasing setEndValue setProperty setStartValue setTarget start stop toString yoyo

Event handlers

onMotionFinished

Event handlers inherited from BasicTweenFLV

onChangeVideoDisplay

Event handlers inherited from AbstractTween

onEnterFrame

Constructor

TweenFLV

function TweenFLV (

vd:VideoDisplay, offset:Number, nEnd:Number, nMs:Number, nStart:Number, fE:Function)

Constructs a new TweenFLV instance.

Example

var _video : VideoDisplay = VideoDisplay.buildVideoDisplay( video );
var t : TweenFLV = new TweenFLV(_video, 0, mc, '_alpha', 0, 2000, 100);
t.start();
   _video.load( "video.flv" );

Parameters:

vd :

VideoDisplay listened.

offset:

shift with starting.

oT :

Object which the Tween targets.

sP :

Setter (method or property).

nE :

Ending value of property.

nRate :

Length of time of the motion in milliseconds.

nS :

Starting value of property (optional).

fE :

Easing function (optional).

Class properties

onMotionChangedEVENT

static onMotionChangedEVENT:TweenEventType = TweenEventType.onMotionChangedEVENT

(read,write)

Broadcasted to listeners when property value is updated.

Component metadata:

Event	onMotionChanged

onMotionFinishedEVENT

static onMotionFinishedEVENT:TweenEventType = TweenEventType.onMotionFinishedEVENT

(read,write)

Broadcasted to listeners when tween is finished.

Component metadata:

Event	onMotionFinished

onStartEVENT

static onStartEVENT:TweenEventType = TweenEventType.onStartEVENT

(read,write)

Broadcasted to listeners when tween starts.

Component metadata:

Event	onStart

onStopEVENT

static onStopEVENT:TweenEventType = TweenEventType.onStopEVENT

(read,write)

Broadcasted to listeners when tween stops.

Component metadata:

Event	onStop

Instance methods

addEventListener

function addEventListener (

e:TweenEventType) : Void

Adds listener for specifical event.

Example

t.addEventListener( TweenFLV.onMotionFinishedEVENT, myListener );

Parameters:

t :

Name of the Event.

oL:

Listener object.

Specified by:

ITween.addEventListener

addListener

function addListener (

oL:ITweenListener) : Void

Adds listener for receiving all events.

Example

t.addListener(myListener);

Parameters:

oL:

Listener object which implements ITweenListener interface.

Specified by:

ITween.addListener

execute

function execute (

e:IEvent) : Void

Starts tweening

com.bourre.commands.Command polymorphism.

removeEventListener

function removeEventListener (

e:TweenEventType) : Void

Removes listener for specifical event.

Example

t.removeEventListener( TweenFLV.onMotionFinishedEVENT, myListener );

Parameters:

t :

Name of the Event.

oL:

Listener object.

Specified by:

ITween.removeEventListener

removeListener

function removeListener (

oL:ITweenListener) : Void

Removes listener for receiving all events.

Example

t.removeListener(myListener);

Parameters:

oL:

Listener object which implements ITweenListener interface.

Specified by:

ITween.removeListener

start

function start (

) : Void

Starts tweening.

AbstractTween.start overridding

Overrides:

AbstractTween.start

Specified by:

IBasicTween.start

stop

function stop (

) : Void

Stops tweening.

AbstractTween.stop overridding

Overrides:

AbstractTween.stop

Specified by:

IBasicTween.stop

toString

function toString (

) : String

Returns the string representation of this instance.

Returns:

the string representation of this instance

Overrides:

BasicTweenFLV.toString

Event handlers

onMotionFinished

function onMotionFinished (

) : Void

Implemented to add tween as listener to another tween.