FrontController

Adds all key/commands associations within the passed-in

Dictionnary in the current front controller.
The errors thrown by the pushCommandClass and

pushCommandInstance are also thrown in the

add method.

Handles all events received by this object.
For each received event the controller will look up
its registered events table, if a command or
a class is registered the controller proceed.

If the command object is an asynchronous command
the instance is stored in a specific map in order
to keep a reference to that command during all its
execution, and prevent it to be collected by the
garbage collector. The front controller will
automatically remove the reference when it receive
the onCommandEnd event from the command.

Returns the command located at the specified keyindex. If there's no command registered with the passed-in key
the function fail and throw an error.

The locate method will always return a Commandinstance, even if it was a class which was registered with this key.
The locate will instanciate the command and then return it.

Creates a new Front Controller instance for the passed-in
plugin. If the plugin argument is omitted, the Front Controller
is owned by the global instance of the

NullPlugin</code

class.



@param	owner	plugin object which own the controller

/
    public function FrontController( owner : Plugin = null ) 
    {
        _owner = ( owner == null ) ? NullPlugin.getInstance() : owner;
        if ( owner == null ) EventBroadcaster.getInstance().addListener( this );

        super( Command, null, PluginDebug.getInstance( getOwner() ) );

        _oASyncCommands = new Dictionary();
    }

    /**

Returns the owner plugin of this controller



@return 	the owner plugin of this controller

/
    final public function getOwner() : Plugin
    {
        return _owner;
    }

    /**

@inheritDoc

/
    override public function register( eventName : String, o : Object ) : Boolean
    {
        try
        {
            if ( o is Class )
            {
                return pushCommandClass( eventName, o as Class );

            } else
            {
                return pushCommandInstance( eventName, o as Command );
            }

        } catch( e : Error )
        {
            getLogger().fatal( e.message );
            throw e;
        }

        return false;
    }

    /**

Registers the passed-in command class to be triggered at each time

the controller will receive an event of type <code>eventName

.

The passed-in command class must at least implement the Commandinterface. If the class doesn't inherit from Command the
association failed and an exception is throw.

If there is already a command or a class associated with the passed-in event,
the association failed and an exception is throw.

Registers the passed-in command to be triggered at each time
the controller will receive an event of type eventName.

If there is already a class or a command associated with the passed-in
event, the association failed and an exception is throw.

Removes the class or the command registered with the
passed-in event name.

Returns the string representation of this instance.

Catch callback events from asynchronous commands thiggered
by this front controller. When the controller receive an event
from the command, that command is removed from the controller
storage.