nureyev / SignalLite

A lite version of as3-signals with features like navive Event

SignalLite: A lite version of as3-signals with features like native Event

SignalLite is a lite version of Robert Penner ’s as3-signals with some features more like AS3 native Events.

Differences from as3-signals like AS3 native Event:

• The listened signal is the only argument pass to handler functions.
• Signals have a target property.
• Signals carry parameters as properties.

Signals are passed to listeners as the only argument just like native event handlers.

SomeListener:

private function addHandlers():void
{
    someDispatcher.someSignal.addOnce(someDispatcher_someSignalHandler);
}
private function someDispatcher_someSignalHandler(signal:SomeSignal):void
{
    var target:SomeDispatcher = signal.target;
    var someValue:Number = signal.someValue;
    var anotherValue:Number = signal.anotherValue;
    // ...
}

Signals has a target property like native events.

SomeSignal:

public function SignalBase(target:Object = null)
{
    _target = target;
}
private var _target:Object;
public function get target():Object
{
    return _target;
}

SomeSignal extends SignalBase:

public const someSignal:SomeSignal = new SomeSignal(this);

Signals carry parameters as properties.

SomeSignal:

private var _someValue:Number;
public function get someValue():Number
{
    return _someValue;
}
private var _anotherValue:Number;
public function get anotherValue():Number
{
    return _anotherValue;
}

Signals has own dispatch() methods according to parameters.

SomeSignal:

public function dispatch(someValue:Number, anotherValue:Number):void
{
    _someValue = someValue;
    _anotherValue = anotherValue;
    callListeners();
}

SomeDispatcher:

private function somethingHappened():void
{
    someSignal.dispatch(someValue, anotherValue);
}

MessageBus and Robotlegs

There is a MessageBus class to work with Robotlegs Framework. With MessageBus and MessageType classes both view and model classes can be free form framework (No injection).

MessageType

MessageBus relay on MessageType like Event.type.

You can dispatch a MessageType:

messageBus.dispatch(ContextMessage.STARTUP);

You can bind a Signal to a MessageType>:

messageBus.bindSignal(playModel.roundStarted, RoundMessage.ROUND_STARTED);

Or bind a Event to a MessageType:

messageBus.bindEvent(view, GameFlowEvent.START_GAME, GameMessage.GAME_STARTED);

SignalCommandMap based on MessageBus and MessageType

signalCommandMap.map(GameMessage.GAME_STARTED, StartGameCommand);

Signal or Event trigger some message will pass to handlers.

override public function onRegister():void
{
    messageBus.addListener(GameMessage.GAME_ENDED, gameEndedHandler);
}
private function gameEndedHandler(signal:PlayResultSignal):void
{
    view.renderGameResult(signal.result);
}

Signal or Event trigger some message will pass to mapped Command.

[Inject]
public var triggerEvent:PlayerActEvent;
[Inject]
public var model:PlayModel;
public function execute():void
{
    model.actPlayerRound(triggerEvent.value);
}

More…

See example