+Show TOC
×Hide TOC

EventCallbackAdapter

Kind of class:	public class
Package:	com.bourre.events
Inherits from:	none
Implements:	Command TickListener
Version:	1.0
Author:	Francis Bourre
Classpath:	com.bourre.events.EventCallbackAdapter
File last modified:	Monday, 24 November 2008, 11:36:53

► 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.events 
{
    import com.bourre.commands.Command;
    import com.bourre.commands.Delegate;
    import com.bourre.error.IllegalArgumentException;
    import com.bourre.log.PixlibDebug;
    import com.bourre.log.PixlibStringifier;
    import com.bourre.transitions.TickListener;
    import com.bourre.utils.ClassUtils;
    
    import flash.events.Event;    
    
    /**
     * @author Francis Bourre
     * @version 1.0
     */
    public class EventCallbackAdapter 
        implements Command, TickListener
    {
        protected var _cArgumentCallbackFactoryClass : Class;
        protected var _oCallbackTarget : Object;
        protected var _a : Array;

        public function EventCallbackAdapter( argumentCallbackFactoryClass : Class = null, callbackTarget : Object = null, ... rest ) 
        {
            if ( argumentCallbackFactoryClass != null ) setArgumentCallbackFactoryClass( argumentCallbackFactoryClass );
            if ( callbackTarget != null ) setCallbackTarget( callbackTarget );
            _a = rest;
        }

        public function getArguments() : Array
        {
            return _a;
        }

        public function setArguments( ... rest ) : void
        {
            if ( rest.length > 0 ) _a = rest;
        }

        public function setArgumentsArray( a : Array ) : void
        {
            if ( a.length > 0 ) _a = a;
        }

        public function addArguments( ... rest ) : void
        {
            if ( rest.length > 0 ) _a = _a.concat( rest );
        }

        public function addArgumentsArray( a : Array ) : void
        {
            if ( a.length > 0 ) _a = _a.concat( a );
        }

        public function setArgumentCallbackFactoryClass( argumentCallbackFactoryClass : Class ) : void
        {
            if ( ClassUtils.inherit( argumentCallbackFactoryClass, ArgumentCallbackFactory ) )
            {
                _cArgumentCallbackFactoryClass = argumentCallbackFactoryClass;

            } else
            {
                var msg : String = this + ".setSource(" + argumentCallbackFactoryClass + ") fails. Argument doesn't implement " + ArgumentCallbackFactory;
                PixlibDebug.ERROR( msg );
                throw new IllegalArgumentException( msg );
            }
        }

        public function getArgumentCallbackFactoryClass() : Class
        {
            return _cArgumentCallbackFactoryClass;
        }

        public function getArgumentCallbackFactoryInstance() : ArgumentCallbackFactory
        {
            try
            {
                var argumentCallBackFactory : ArgumentCallbackFactory = new _cArgumentCallbackFactoryClass () as ArgumentCallbackFactory;
                return argumentCallBackFactory;

            } catch ( e : Error )
            {
                PixlibDebug.ERROR( e.message );
                throw e;
            }
            
            return null;
        }

        public function setCallbackTarget( callbackTarget : Object, ...typeList ): void
        {
            _oCallbackTarget = callbackTarget;
        }

        public function getCallbackTarget() : Object
        {
            return _oCallbackTarget;
        }

        public function getCallbackTargetCaller( event : Event ) : Delegate
        {
            var d : Delegate;

            if ( _oCallbackTarget is Function )
            {
                d = new Delegate( _oCallbackTarget as Function );

            } else
            {
                try
                {
                    d = new Delegate( _oCallbackTarget[ event.type ] );

                } catch ( e : Error )
                {
                    PixlibDebug.ERROR( e.message );
                    throw e;
                }
            }

            return d;
        }

        public function handleEvent( e : Event ) : void
        {
            execute( e );
        }

        public function execute( event : Event = null ) : void
        {
            try
            {
                var argumentCallbackFactory : ArgumentCallbackFactory = getArgumentCallbackFactoryInstance();
                var d : Delegate = getCallbackTargetCaller( event );
                var a : Array = [ event ];
                if ( _a != null && _a.length > 0 ) a = a.concat( _a );
                d.setArgumentsArray( argumentCallbackFactory.getArguments.apply( null, a ) );
                d.execute();

            } catch( e : Error )
            {
                var msg : String = this + ".handleEvent(" + e + ") fails.";
                PixlibDebug.ERROR( msg );
                throw new IllegalArgumentException( msg );
            }
        }

        public function onTick( e : Event = null ) : void
        {
            execute( e );
        }

        /**
         * Returns the string representation of this instance.
         * 
         * @return the string representation of this instance
         */
        public function toString() : String 
        {
            return PixlibStringifier.stringify( this );
        }
    }
}

Summary

Constructor

EventCallbackAdapter (argumentCallbackFactoryClass:Class = null, callbackTarget:Object = null, rest)

Instance methods

getArguments : Array
setArguments (rest) : void
setArgumentsArray (a:Array) : void
addArguments (rest) : void
addArgumentsArray (a:Array) : void
setArgumentCallbackFactoryClass (argumentCallbackFactoryClass:Class) : void
getArgumentCallbackFactoryClass : Class
getArgumentCallbackFactoryInstance : ArgumentCallbackFactory
setCallbackTarget (callbackTarget:Object, typeList) : void
getCallbackTarget : Object
getCallbackTargetCaller (event:Event) : Delegate
handleEvent (e:Event) : void
execute (event:Event = null) : void
toString : String
- Returns the string representation of this instance.

Event handlers

onTick (e:Event = null) : void
- Method called by the {VISDOC_CODE_BLOCK_5} for each

Constructor

EventCallbackAdapter

public function EventCallbackAdapter (

argumentCallbackFactoryClass:Class = null, callbackTarget:Object = null, rest)

Instance methods

addArguments

public function addArguments (

rest) : void

addArgumentsArray

public function addArgumentsArray (

a:Array) : void

execute

public function execute (

event:Event = null) : void

getArgumentCallbackFactoryClass

public function getArgumentCallbackFactoryClass (

) : Class

getArgumentCallbackFactoryInstance

public function getArgumentCallbackFactoryInstance (

) : ArgumentCallbackFactory

getArguments

public function getArguments (

) : Array

getCallbackTarget

public function getCallbackTarget (

) : Object

getCallbackTargetCaller

public function getCallbackTargetCaller (

event:Event) : Delegate

handleEvent

public function handleEvent (

e:Event) : void

setArgumentCallbackFactoryClass

public function setArgumentCallbackFactoryClass (

argumentCallbackFactoryClass:Class) : void

setArguments

public function setArguments (

rest) : void

setArgumentsArray

public function setArgumentsArray (

a:Array) : void

setCallbackTarget

public function setCallbackTarget (

callbackTarget:Object, typeList) : void

toString

public function toString (

) : String

Returns the string representation of this instance.

Returns:

the string representation of this instance

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