/**
* -----------------------------------------------------------------------------------------
* INTERSEL - 4 cité d'Hauteville - 75010 PARIS
* RCS PARIS 488 379 660 - NAF 721Z
*
* File : iFSM.js
* iFSM : a finite state machine with jQuery
*
* -----------------------------------------------------------------------------------------
* Modifications :
* - 2013/10/23 - E.Podvin - V1.0 - Creation
* - 2013/11/03 - E.Podvin - V1.1 - add
* - 2013/11/04 - E.Podvin - V1.2 - add process_event_if condition
* - 2013/11/05 - E.Podvin - V1.3 - add sub machine to manage hierarchical state machines (HSM)
* - 2013/11/12 - E.Podvin - V1.4 - debug on submachine management
* - 2013/11/22 - E.Podvin - V1.5 - add 'next_state_on_target' to change a state according to the submachine states
* - 2014/03/19 - E.Podvin - V1.6.1 - add options.initState in the jquery call to be able to define the initial state
* - 2014/06/06 - E.Podvin - 1.6.8 - add synonymous events
* - 2014/06/16 - E.Podvin - 1.6.9 - patch to correctly process process_on_UItarget option
* - 2014/06/16 - E.Podvin - 1.6.10 - copy state definition in order to be able to have it dynamic
* - 2014/07/01 - E.Podvin - 1.6.11 - patch on the reinitialisation of the event iterations when changing state
* - 2014/07/08 - E.Podvin - 1.6.13 - propagate_event may be an array of events to propagate
* - 2014/07/14 - E.Podvin - 1.6.14 - improve performance
* - 2014/09/04 - E.Podvin - 1.6.15 - fix on the 'exitMachine' message when it was sent
* - 2014/09/11 - E.Podvin - 1.6.16 - fix on synonymous event that was not set when still defined in a previous state
* - 2016/04/26 - E.Podvin - 1.6.17 - fix on delayed events
* - 2016/04/26 - E.Podvin - 1.6.18 - fix on delayed events on "DefaultState"
* - 2017/03/08 - E.Podvin - 1.7.0 - myFSM.eventCalled available for script + 'propagate_event_on_localmachine' directive + catchEvent
* - 2017/03/13 - E.Podvin - 1.7.1 - add myFSM.lastState
* - 2017/03/20 - E.Podvin - 1.7.2 - fixes to be compliant with jquery 3.2.0
* - 2017/10/14 - E.Podvin - 1.7.3 - small fix in case event is triggered with multiple parameters
* - 2017/10/17 - E.POdvin - 1.7.4 - change log level - by default, displays the state&event processing step in the console
* - 2018/03/08 - E.POdvin - 1.7.5 - transfer data transmitted by trigger to enterEvent and exitEvent
* - 2018/03/13 - E.Podvin - 1.7.6 - add some controls when starting the state machines: can't start if no id on the object or if still exists
* - 2019/11/22 - E.Podvin - 1.7.7 - prevent preventCancel event to stack if delayed again (see preventCancelSet)
* add console.warn (instead of log) for errors message
* - 2020/06/18 - E.Podvin - 1.7.8 - Add alert when next_state does not exist (not defined)
* - 2021/04/19 - E.Podvin - 1.7.9 - fix delayProcess when data is not set
* -----------------------------------------------------------------------------------------
*
* @copyright Intersel 2013-2021
* @fileoverview : iFSM : a finite state machine with jQuery
* @see {@link https://github.com/intersel/iFSM}
* @author : Emmanuel Podvin - emmanuel.podvin@intersel.fr
* @version : 1.7.9
* -----------------------------------------------------------------------------------------
*/
/**
* How to use it :
* ===============
*
*
*
*
*
* //Example of use :
*
*
*
*/
(function($){
/**
* @param integer nb_FSM - number of active FSM
*/
var nb_FSM = 0;
/**
*
* fsm_manager - class constructor
* @param {object} aStateDefinition - states definition
* {
* :
* {
* delegate_machines :
* {
* :
* {
* submachine : ,
* no_reinitialisation :
* },
* :
* {
* submachine :
* },
* ...
* },
*
* :
* {
* how_process_event: ,preventcancel:}>,
* init_function: ,
* properties_init_function: ,
* next_state: ,
* pushpop_state: <'PushState'||'PopState'>,
* next_state_when: ,
* next_state_on_target :
* {
* condition : <'||'||'&&'>
* submachines :
* {
* :
* {
* condition : <''(default)||'not'>
* target_list : [,...,],
* }
* ...
* : ...
* }
* }
* next_state_if_error: ,
* pushpop_state_if_error: <'PushState'||'PopState'>,
* propagate_event:
* process_event_if : ,
* propagate_event_on_refused :
* out_function: ,
* properties_out_function: ,
* prevent_bubble:
* process_on_UItarget:
* UI_event_bubble:
* },
* : ,
* :
* {
* ....
* },
* enterState : ...
* exitState : ...
* },
* : ,
* :
* {
* ....
* },
* DefaultState :
* {
* start: //a default start event received at the FSM start
* {
* },
* :
* {
* }
* }
* }
*
* - :
* is the name of a state.
* - delegate_machines : sub machines list to delegate the events on the state
* - submachine : the variable name of a state definition or a state definition description
* - :
* '' is the name of an event. It may be any event name supported by javascript or JQuery.
* It defines an event we want to be alerted when it occurs on the object
* Specific events :
* - 'start' : this event is automatically sent when the FSM starts. should be defined in the initial state (or 'DefaultState')
* - 'enterState' : this event is automatically sent and immediatly executed when the FSM enter the state
* - 'exitState' : this event is automatically sent and immediatly executed when the FSM exit the state
* - 'exitMachine' : this event is automatically sent when the (sub)machine will exit/close
* - 'attrchange' : received if any attribute of the jquery object (myUIObject) changed
* - data sent : event - event object
* * event.attributeName - Name of the attribute modified
* * event.oldValue - Previous value of the modified attribute
* * event.newValue - New value of the modified attribute
* - 'attrchange_' (ex: 'attrchange_class') : received if the attribute of the jquery object changed
* - data sent :
* * newValue - New value of the modified attribute
* * oldValue - Previous value of the modified attribute
* - 'attrchange_style_' (ex:'attrchange_style_width') : received if the css attribute of the jquery object changed
* - data sent :
* * newValue - New value of the modified attribute
* * oldValue - Previous value of the modified attribute
*
* its description is using an object with the following properties:
* - how_process_event [default:{push}] : {immediate}||{push}||{delay:delay_value,preventcancel:}
* if delay is defined, the processing of the event is delayed and activated at 'delay'
* by default, any event delayed will be cancelled if the state changes
* if preventcancel is defined, the delayed event won't be cancelled
* - process_event_if :
* Definition of condition test that will be evaluated, and if result is true then event will be processed
* if not, see if a propagate_event_on_refused in order to trigger it... and exit...
* - propagate_event_on_refused : an event name to trigger if process_event_if is false
* - init_function : function name or a function statement
* - properties_init_function : parameters to send to init_function
* - next_state : next state once init_function done. If not defined, there is no state change.
* - pushpop_state :
* If 'PushState', then current state is pushed in the StateStack then next_state takes place.
* If 'PopState', then the next state will be the one on top of the StateStack which is poped. next_state is so overwritten... If the stack is void, there is no state change.
* - next_state_when :
* Definition of condition test that will be evaluated, and if result is true then state will change
* Following variables may be used for the test
* this : the FSM object
* this.EventIteration : variable that gives the iteration of the number of calls of the current event.
* EventIteration is reset when the state changes
* - next_state_on_target :
* Definition of condition test based on the current states of the defined submachines
* the test consist to :
* - get the current states of each defined sub-machines,
* - match the current state to the given array, resulting to true if found
* - apply the defined operator between the results
* - next_state_if_error (default: does not change state) : state set if init_function returns false. .
* - pushpop_state_if_error :
* If 'PushState', then current state is pushed in the StateStack then next_state_if_error takes place.
* If 'PopState', then the next state will be the one on top of the StateStack which is poped. If the stack is void, there is no state change. next_state_if_error is so overwritten...
* - out_function : function name to do once next_state changed
* - properties_out_function : parameters to send to out_function
* - propagate_event : if == 'true', the current event is propagated to the next state
* if it's the name of an event, triggers the event...
* if an array of events, events are triggered in sequence
* - prevent_bubble : if defined and true, the current event will not bubble to its parent machine
* - UI_event_bubble : if defined and true, the current event will bubble. By default, no UI event bubbling...
* - process_on_UItarget : if defined and true, the current event will be processed only if the event was directly targeting
* the UI jQuery object linked to the machine
* An event may be synonymous with another event. In this case, we simply give the name of the synonymous event.
*
* @remarks
* - any FSM is automatically initialised with a 'start' event
* - state function should return a boolean : true: ok works fine; false: error
* - state function should have the following input :
* - parameters : the properties__function
* - event : the event
* - data : the data sent with the event
* - a default statename 'DefaultState' can be defined to define the default behaviour of some events...
* - an event is first search in the current state, then if not found in the 'DefaultState'
* - if an event is not found, nothing is done...
* - a 'start' event is triggered when the FSM is started with InitManager
* - when there are sub machines defined for a state :
* - the events are sent to each defined submachines in the order
* - once the event is processed by the submachines, it is bubbled to the upper machines
* - it is possible to prevent the bubbling of events with the directive 'prevent_bubble' to true
* - a submachine works as the main one :
* - if no_reinitialisation == false (default) it is initialised
* - then starts once entering in the state
* - a start event is triggered to it
*
* - to trigger an event to the machine itself, use can use the 'trigger' function
* ex: myFSM.trigger('myevent');
* - it is possible to trigger any event to a machine with the jquery trigger function :
* ex: $('#myButton1').trigger('start',{targetFSM:myFsm});
* - within a state function, it is possible to trigger event to any machine using its linked jQuery object : myFSM.myUIObject
* ex : this.myUIObject.trigger('aEventName')
* - if multiple machines are assigned to the same jQuery Object, it also possible to specify the FSM in the parameter :
* ex : this.myUIObject.trigger('aEventName',{targetFSM:this})
* - beware that if the submachine is no more accessible, it won't perhaps receive the message you triggered from it.
* a workaround is to directly "push" an event in order that it will be processed within the flow of the current event processing.
* the function to use is myFSM.pushEvent(anEventName, data) (or this.pushEvent in a FSM function)
* ex: init_function : function(){this.pushEvent('setText','I push an event');},
* - if a delayed event is sent again before a previous one was processed, the previous event is cancelled and the new one re-started
* - a sub machine can manage its first state by handling the 'start' event in the DefaultState
* - as the structure definition of the states of a machine is a javascript object,
* it is then possible to define generic states or generic events as this example :
*
* var myGenericEvent = {
* next_state : aState,
* propagate_event : anEvent,
* ....
* }
* var myMachine = {
* aState1 :
* firstEvent : $.extend(true, {}, myGenericEvent), //copy of the myGenericEvent object
* secondEvent : {...eventdefinition...},
* thirdEvent : myGenericEvent,
* ....
* }
*
* - if you stay coherent, it is possible to define and to change dynamically the states definition through myFSM._stateDefinition
* - enterState and exitState can't be delayed
* - all events in a submachine should have the prevent_bubble to true, except for those you'd like to be processed in other parts of the machine
* - delegate machines should not be created on the DefaultState state
* - if UI_event_bubble for an UI event is set to false by any part of the machine or submachine it will stay to false
*
*
* The public available variables :
* - myFSM.currentState : current processed state name
* - myFSM.currentEvent : current processed event
* - myFSM.myUIObject : the jQuery object associated to the FSM
* - myFSM._stateDefinition : the definition of the states and events
* - myFSM._stateDefinition...EventIteration - the number of times an event has been called
* - myFSM.opts - the defined options. Generally used to store local data
* - myFSM.rootMachine : the root machine
* - myFSM.parentMachine : the parent machine if it's in a sub machine (null if none)
*
* Within the call of FSM function, you can refer to the FSM by 'this', examples :
* - this.currentState
* - this.currentEvent
* - this.currentEvent.type (name of the current processed event)
* - this.myUIObject
* - ...
* plus about event:
* - this.EventIteration : the current event iteration
* - this.actualTarget : the jQuery object that is currently targetted by an event
*
* @param anObject - a jquery object on which the FSM applies.
* ATTENTION : the property 'id' needs to be defined to have the machine working properly
* @param options - an object defining the options:
* - boolean debug
* - integer LogLevel -
* - 1 only errors displayed
* - 2 - errors and warnings
* - 3 - all
* - boolean AlertError - send an alert box when error
* - boolean startEvent - name of the starting event
* - integer maxPushEvent - size of the push events array
* - string logFSM - list of FSM names to follow on debug (ex: "FSM_1 FSM_4"). If void, then displays all machine messages
*/
var fsm_manager = window.fsm_manager = function (anObject, aStateDefinition, options)
{
var $defaults = {
debug : true,
LogLevel : 1,
AlertError : false,
maxPushEvent : 100,
startEvent : 'start',
prefixFsmName : 'FSM_',
logFSM : ""
};
nb_FSM = nb_FSM+1;
// on charge les options passées en paramètre
if (options == undefined) options=null;
this.opts = jQuery.extend( {}, $defaults, options || {});
/**
* @param string FSMName - name of the FSM
*/
this.FSMName = this.opts.prefixFsmName+nb_FSM;
/**
* @param Object _stateDefinition - the definition of the states of the FSM
*/
this._stateDefinition = jQuery.extend(true, {}, aStateDefinition);
this._originalstateDefinition = aStateDefinition;//keep the original definition here
/**
* currentState - current state of the fsm
*
*/
this.currentState = '';
/**
* lastState - previous state of the current state
*/
this.lastState=this.currentState;
/**
* @param currentEvent - current event processed by the fsm
*
*/
this.currentEvent = '';
/**
* @param pushStateList array - a state list pushed that can be poped
*
*/
this.pushStateList = new Array();
/**
* @param processEventStatus - status of the process event execution
* - idle : not working
* - processing : is processing an event
*
*/
this.processEventStatus = 'idle';
/**
* @param pushEventList array - an event list waiting to be processed
*
*/
this.pushEventList = new Array();
/**
* @param myUIObject - Target object of the FSM
*/
this.myUIObject = anObject;
/**
* @param listEvents - array of the events subscribed
*/
this.listEvents ={};
/**
* @param currentDataEvent - the data of the event currently processed
*/
this.currentDataEvent ={};
/**
* @param returnGeneralEventStatus - status to send back to the event triggering (if false, generally will prevent event propagation)
*/
this.returnGeneralEventStatus = true;
/**
* @param rootMachine - root FSM machine of this current FSM
*/
if (this.opts.rootMachine == undefined) this.opts.rootMachine = this;
this.rootMachine = this.opts.rootMachine;
/**
* @param parentMachine - parent machine of this current one
*/
if (this.opts.nextParent == undefined) this.parentMachine = null;
else this.parentMachine = this.opts.nextParent;
this.opts.nextParent = this; //
/**
* @param childrenMachine - list of children of the current machine
*/
this.childrenMachine = new Array();
if (this.parentMachine) this.parentMachine.childrenMachine.push(this);//update the children of the parent if any
/**
* preventCancelId to manage the preventcancel by creating a unique id for doTimeout
* @type {Number}
*/
this.preventCancelId=0;
var aState;
var aEvent;
var theEvents ='';
var space ='';
var theTarget=$(document);
var attrChangeRequested = false;
var attrStyleChangeRequested = false;
var attrChangeEvents = new Array();
var setStart = false;
// look for all the defined and unique events
// as we're on it, copy the synonym states and events
for(aState in this._stateDefinition)
{
if (typeof this._stateDefinition[aState] == 'string') //the state is synomym to another... so copy it
this._stateDefinition[aState]=this._stateDefinition[this._stateDefinition[aState]];
for(aEvent in this._stateDefinition[aState])
{
//to process synonymous events
if (typeof this._stateDefinition[aState][aEvent] == 'string')
this._stateDefinition[aState][aEvent] = this._stateDefinition[aState][this._stateDefinition[aState][aEvent]];
// filter to the events list not subscribed by the root machine
// start is always sent to the current machine
if (!this.rootMachine.listEvents[aEvent] && aEvent != 'delegate_machines'
&& aEvent != this.opts.startEvent)
{
this.listEvents[aEvent]=aEvent;
if (this != this.rootMachine)
this.rootMachine.listEvents[aEvent]=aEvent;
}
else if (aEvent == this.opts.startEvent) setStart= true;
}
}
//list all defined events in the FSM in a $.on format
var splitevent='';
for(aEvent in this.listEvents)
{
splitevent = aEvent.split('_');
if ( splitevent[0] == 'attrchange' )
{
attrChangeRequested=true;
attrChangeEvents.push(aEvent);
if ( (splitevent[1] == 'style') && (splitevent.length > 2) )
attrStyleChangeRequested=true;
}
theEvents=theEvents+space+aEvent;
space=' ';
}
//define a selector object if none defined
if ( (!anObject.selector)
&& (anObject.attr('id')
&& (anObject.attr('id') != 'iFSMDocumentRoot'))
)
anObject.selector='#'+anObject.attr('id');// set to the #id
else anObject.selector='';
//define the triggers for attrchange
if ( attrChangeRequested && (anObject.selector) )
{
var aStyleListNew;
var aStyleCssListNew={};
var aStyleListOld;
var aStyleCssListOld={};
var splitres;
var i;
var aCssStyle;
$(anObject.selector).attrchange({
trackValues: true, // Default to false, if set to true the event object is updated with old and new value.
callback: function (event) {
//event - event object
//event.attributeName - Name of the attribute modified
//event.oldValue - Previous value of the modified attribute
//event.newValue - New value of the modified attribute
//Triggered when the selected elements attribute is added/updated/removed
//send trigger event if an attribute change...
if (jQuery.inArray('attrchange', attrChangeEvents)>=0)
$(this).trigger('attrchange',event);
//send trigger event on attribute changes
if (jQuery.inArray('attrchange'+'_'+event.attributeName, attrChangeEvents)>=0)
$(this).trigger('attrchange'+'_'+event.attributeName,{newValue:event.newValue,oldValue:event.oldValue});
//send trigger for the style changes
if ( (event.attributeName == 'style') && attrStyleChangeRequested)
{
if (event.newValue) aStyleListNew=event.newValue.split(';');
else aStyleListNew = [];
if (event.oldValue) aStyleListOld=event.oldValue.split(';');
else aStyleListOld = [];
for(i= 0; i < aStyleListNew.length; i++)
{
splitres=aStyleListNew[i].split(':');
if (splitres.length==2)
aStyleCssListNew[splitres[0]]=splitres[1].replace(/^\s+/g,'').replace(/\s+$/g,'');
}
for(i= 0; i < aStyleListOld.length; i++)
{
splitres=aStyleListOld[i].split(':');
if (splitres.length==2)
aStyleCssListOld[splitres[0]]=splitres[1].replace(/^\s+/g,'').replace(/\s+$/g,'');
}
for(aCssStyle in aStyleCssListNew)
{
if (aStyleCssListOld[aCssStyle] == undefined
|| (aStyleCssListOld[aCssStyle] && aStyleCssListOld[aCssStyle] != aStyleCssListNew[aCssStyle])
)
$(this).trigger('attrchange_style_'+fsm_manager_getcss3prop(aCssStyle),{newValue:aStyleCssListNew[aCssStyle],oldValue:aStyleCssListOld[aCssStyle]});
}
}//end if
}//end callback
}); //end attrchange selector
}//end if
//if target object not a document one
if ($.isWindow(anObject[0])) theTarget = $(window);
//activate the listening of events on object/FSM
var myFSM=this.rootMachine;
if (theEvents!='')
theTarget.on(theEvents, anObject.selector, function( event, dataevent )
{
myFSM.returnGeneralEventStatus=true;
myFSM.processEvent(event.type,arguments);
return myFSM.returnGeneralEventStatus;
});
//activate the start event if defined
if (setStart)
{
var myLocalFSM = this;
theTarget.on(this.opts.startEvent, anObject.selector, function( event, dataevent )
{
myLocalFSM.processEvent(event.type,arguments);
});
}
this._log('new fsm_manager:'+this.FSMName+'-'+anObject.selector,2);
};//fsm_manager
/*available functions*/
/**
* InitManager - init the One Page Fonction State machine
* - a 'start' event is triggered.
* public method
* @aInitState - the init state at start
*/
fsm_manager.prototype.InitManager = function(aInitState)
{
this._log('InitManager');
if (aInitState==undefined)
this.currentState = 'DefaultState';
else
this.currentState = aInitState;
if (this._stateDefinition['DefaultState']==undefined)
this._stateDefinition.DefaultState={};
//send 'start' event
if (!this.parentMachine)
this.trigger(this.opts.startEvent);
else //directly talk to the sub machine to process the start
{
var anEv = new Array();
anEv[0] = fsm_manager_create_event(this.myUIObject,this.opts.startEvent,null);
this.processEvent(this.opts.startEvent,anEv,true);
}
};//
/**
* procesEvent - process an event according to the current state
* public Method
* @param string anEvent : an event name
* @param Array data : arguments sent by the triggering event [event, dataevent]
* @param boolean forceProcess: force event to be processed
* @return false to stop propagation
* @comment
* it is possible to pass the FSM Object to test the target through 'data' : data[data.length-1].targetFSM
* ex : the function this.trigger always send the FSM through this way;
*/
fsm_manager.prototype.processEvent= function(anEvent,data,forceProcess) {
var thisFSM = this;
var currentState = this.currentState;
var currentEvent = this.currentUIEvent = data[0];
this.receivedEvent = anEvent;
this.currentDataEvent = data;
this.currentEvent = currentEvent;
var currentStateEvent = this.currentState;
var doForceProcess = (forceProcess==undefined?false:true);
var anEv = new Array();//dummy event to be used in 'processEvent' function (see processing of enterEvent and exitEvent)
anEv[0] = fsm_manager_create_event(this.myUIObject,'',null); // to use it, just change anEv[0].type='an_event_name';
anEv[1] = data[1]; anEv[2]= data[2];
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> START Processing Event',3,1);
//targetFSM is sent through the this.trigger function
//we consider the sub FSMs of a machine as the same machine...
//except if the event was triggered as addressing only the "localmachine"
if (data.length > 1
&& data[(data.length - 1)] != null
&& data[data.length-1].targetFSM
&& (data[data.length-1].targetFSM != this)
&& (
(data[data.length-1].localMachine)
|| (data[data.length-1].targetFSM.rootMachine != this.rootMachine)
)
)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> not for the current machine ---> exit',3);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return; //not for this machine...
}
if (data.length > 1 && data[(data.length - 1)] != null && data[data.length-1].localMachine)
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> process event locally',3);
// submachine needs to be active only if in the correct parent state where it was defined
if (this.subMachineName)
{
if (
(!this.parentMachine._stateDefinition[this.parentMachine.currentState].delegate_machines)
|| (
(this.parentMachine._stateDefinition[this.parentMachine.currentState].delegate_machines)
&& (!this.parentMachine._stateDefinition[this.parentMachine.currentState].delegate_machines[this.subMachineName])
)
)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> submachine can\'t run if the parent state is not active for the submachine ---> exit',3);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return; //not in the correct parent state
}
}
if (this._stateDefinition[currentState]==undefined)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> currentState does not exist!',3);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
if ( ( anEvent == 'enterState' ) || ( anEvent == 'exitState' ) ) doForceProcess = true;
//element is not a right target...?
if (
!this.myUIObject.is(currentEvent.currentTarget)
&& !this.myUIObject.is(currentEvent.target)
&& (this.myUIObject[0] != document)
&& !$.isWindow(currentEvent.currentTarget)
&& !$.isWindow(currentEvent.target)
)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> object not a good target ---> '+$(currentEvent.currentTarget).attr('id')+'---> exit',3);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
else
{
if (this.myUIObject[0] == document) this.actualTarget=$(document);
else this.actualTarget = $(currentEvent.currentTarget);
}
var currentEventConfiguration = null;
currentEventConfiguration = this._stateDefinition[currentState][anEvent];
//if we are still processing we push the event, except if explicitly asked otherwise
//see if we should push the event
if ( doForceProcess == false
&& this.processEventStatus != 'idle'
&& (
currentEventConfiguration == undefined
|| ( currentEventConfiguration
&& currentEventConfiguration.how_process_event == undefined
)
|| ( currentEventConfiguration
&& currentEventConfiguration.how_process_event
&& currentEventConfiguration.how_process_event.immediate == undefined
&& currentEventConfiguration.how_process_event.delay == undefined
)
)
)
{
this.pushEvent(anEvent,data);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Event pushed (lastevent)---> '+this.lastevent+' --> exit',3);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
this.lastevent=currentState+'-'+anEvent;//unused...mainly for debug...
/*
* Processing of the sub machines
*/
if ( ( this._stateDefinition[currentState].delegate_machines )
)
{
var aSubMachineDefinition;
for(aSubMachine in this._stateDefinition[currentState].delegate_machines)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> delegate to submachine---> '+aSubMachine,3);
aSubMachineDefinition = this._stateDefinition[currentState].delegate_machines[aSubMachine];
//initialize the sub machines if needed
if (aSubMachineDefinition.myFSM == undefined)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> process submachine ---> create FSM for the submachine '+aSubMachine,3);
this._stateDefinition[currentState].delegate_machines[aSubMachine].myFSM = new fsm_manager(this.myUIObject,aSubMachineDefinition.submachine,this.opts); //create the machine
this._stateDefinition[currentState].delegate_machines[aSubMachine].myFSM.opts.FSMParent=this;
this._stateDefinition[currentState].delegate_machines[aSubMachine].myFSM.subMachineName=aSubMachine;
}
if ( anEvent == 'enterState' )
{
if ( (aSubMachineDefinition.myFSM.currentState =='')//never initialised if ==''
|| (aSubMachineDefinition.no_reinitialisation == undefined)
|| (aSubMachineDefinition.no_reinitialisation == false)
)
{
aSubMachineDefinition.myFSM.InitManager();//reinit the sub machine
}
}
else if ( anEvent == 'exitState' )
{
anEv[0].type='exitMachine';
aSubMachineDefinition.myFSM.processEvent('exitMachine',anEv,true);//stop the sub machine
//we cancel any waiting events on the state
aSubMachineDefinition.myFSM.cancelDelayedProcess();
}
// process event except on the enterState and exitState events that are not to be delegated... or if we dont propagate the event amongst the different machines
else
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> process submachine (event)---> '+aSubMachine+'('+anEvent+') Start',3);
aSubMachineDefinition.myFSM.processEvent(anEvent,data);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> process submachine (event)---> '+aSubMachine+'('+anEvent+') Processed',3);
//current state changed during the process of the submachine...?
//not sure it is a normal behaviour... if it occurs, we exit...
if (currentState != this.currentState)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> process submachine changed the current environment (event)',3);
this.cleanExitProcess();
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
if (
( aSubMachineDefinition.myFSM._stateDefinition[aSubMachineDefinition.myFSM.currentState][anEvent]
&& aSubMachineDefinition.myFSM._stateDefinition[aSubMachineDefinition.myFSM.currentState][anEvent].prevent_bubble
)
||
( aSubMachineDefinition.myFSM._stateDefinition.DefaultState[anEvent]
&& aSubMachineDefinition.myFSM._stateDefinition.DefaultState[anEvent].prevent_bubble
)
|| (anEvent == this.opts.startEvent)
)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> submachine processed and exit due to prevent_bubble directive',3);
this.cleanExitProcess();
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> submachine exit',3);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
}
}
}
/*
* Processing of the current event on the current state
*/
//is the event to be processed?
if ( (currentState=='DefaultState') || (currentEventConfiguration == undefined) )
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> take Event '+anEvent+' configuration from DefaultState (not present in current state)',3);
currentEventConfiguration = this._stateDefinition.DefaultState[anEvent];
if (currentEventConfiguration == undefined) {
if ( ['start','enterState','exitState','exitMachine'].indexOf(anEvent) < 0)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> take Event '+anEvent+' configuration from catchEvent',3);
currentEventConfiguration = this._stateDefinition.DefaultState["catchEvent"];
//we create the dummy event in the default state if it does not exist for the catchall
if (!this._stateDefinition['DefaultState'][anEvent])
this._stateDefinition['DefaultState'][anEvent]=jQuery.extend( true,{}, currentEventConfiguration);
}
}
if (currentEventConfiguration == undefined) {
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Event '+anEvent+' does not exist and no catchEvent--> will exit',3);
this.cleanExitProcess();
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
currentStateEvent = 'DefaultState';
}
//is this a potential Pop State?
if (currentEventConfiguration.pushpop_state
&& (currentEventConfiguration.pushpop_state =='PopState')
&& (this.pushStateList.length > 0)
)
currentEventConfiguration.next_state = this.pushStateList[this.pushStateList.length-1];
if (currentEventConfiguration.pushpop_state_if_error
&& (currentEventConfiguration.pushpop_state_if_error =='PopState')
&& (this.pushStateList.length > 0)
)
currentEventConfiguration.next_state_if_error = this.pushStateList[this.pushStateList.length-1];
//look if event is processed when coming from any target
if ( !this.myUIObject.is(currentEvent.target)
&& (this.myUIObject[0] != document)
&& !$.isWindow(currentEvent.currentTarget)
&& !$.isWindow(currentEvent.target)
&& currentEventConfiguration.process_on_UItarget
&& currentEventConfiguration.process_on_UItarget == true
)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Event '+anEvent+' does not address the correct UI target (see process_on_UItarget) will exit',3);
this.cleanExitProcess();
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
//look if we let the bubbling of UI event on this event
// no bubbling by default
if ( /*(this.myUIObject[0] != document)
&&*/
(!currentEventConfiguration.UI_event_bubble
|| currentEventConfiguration.UI_event_bubble==false
)
)
{
currentEvent.stopPropagation();
this.returnGeneralEventStatus=false;
this.rootMachine.returnGeneralEventStatus=false;//the UI events always call the root machine
}
//is it a delayed event?
if ( doForceProcess == false
&& currentEventConfiguration
&& currentEventConfiguration.how_process_event
&& currentEventConfiguration.how_process_event.delay
)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Event '+anEvent+' delayed will exit',3);
this.delayProcess(anEvent, currentEventConfiguration.how_process_event.delay, data);
this.cleanExitProcess();
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
//compute EventIteration
if (this._stateDefinition[currentStateEvent][anEvent].EventIteration == undefined)
this._stateDefinition[currentStateEvent][anEvent].EventIteration =0;
this._stateDefinition[currentStateEvent][anEvent].EventIteration++;
this.EventIteration = this._stateDefinition[currentStateEvent][anEvent].EventIteration;
//verify if the event can be processed according to 'enter' condition
if ( (currentEventConfiguration.process_event_if)
&& (eval(currentEventConfiguration.process_event_if) == false)
)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Event '+anEvent+' event not allowed to process (process_event_if rule is not OK) will exit',3);
if (currentEventConfiguration.propagate_event_on_refused)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Event '+currentEventConfiguration.propagate_event_on_refused+' triggered on exit because of propagate_event_on_refused',3);
this.trigger(currentEventConfiguration.propagate_event_on_refused,null,currentEventConfiguration.propagate_event_on_localmachine);
}
//exit as not accepted...
this.cleanExitProcess();
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
return;
}
//*********************************************
//ok we will really process this event...
//*********************************************
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> currently processing',2);
var lastprocessEventStatus = this.processEventStatus;
this.processEventStatus = 'processing';
var funcReturn = true;
var localdata;
//clear any preventCancel tag
if (data && data[1] && data[1].preventCancelSet) delete(data[1].preventCancelSet);
//call to the action (init_function) before transition state
if (currentEventConfiguration.init_function)
{
localdata = [].slice.call(data);
localdata.unshift(currentEventConfiguration.properties_init_function);
funcReturn= currentEventConfiguration.init_function.apply(this,localdata);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> init_function done',3);
}
/*
* Process the transition of state
*
*/
// do we change state?
//is this a Push/Pop State?
if (funcReturn != false)//it's ok for next_state
{
if (currentEventConfiguration.pushpop_state)
{
switch(currentEventConfiguration.pushpop_state)
{
case 'PushState':
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Push state to state '+this.currentState,3);
this.pushStateList.push(this.currentState); //do not use currentStateEvent!
break;
case 'PopState':
if (this.pushStateList.length > 0)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Pop state to state '+currentEventConfiguration.next_state,3);
this.pushStateList.pop();
}
break;
}
}
}
//do we change of state?
if ( (funcReturn != false)
&& (currentEventConfiguration.next_state)
&& (currentState != currentEventConfiguration.next_state)
&& (
(
(currentEventConfiguration.next_state_when == undefined)
&& (currentEventConfiguration.next_state_on_target == undefined)
)
|| (
(currentEventConfiguration.next_state_when)
&& (eval(currentEventConfiguration.next_state_when) == true)
)
|| (
(currentEventConfiguration.next_state_on_target)
&& (this.subMachinesRespectTargets(anEvent) == true)
)
)
)
{
//we reinit the iteration on the events
$.each(this._stateDefinition[this.currentState],
function(aKey,aValue)
{
if (!thisFSM._stateDefinition[thisFSM.currentState][aKey])
{
thisFSM._log(aKey+" does not exist in state "+thisFSM.currentState,1);
}
else if (aKey!='delegate_machines')
thisFSM._stateDefinition[thisFSM.currentState][aKey].EventIteration =0;
});
//we cancel any waiting events on the state
this.cancelDelayedProcess();
anEv[0].type='exitState';
//we alert that we're exiting the state (except if we're starting the machine...
if (anEvent !=this.opts.startEvent)
{
this.processEvent('exitState',anEv,true);
}
/*
*********************************************
* we change the current state Here!
*********************************************
*/
if (this._stateDefinition[currentEventConfiguration.next_state])
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Go to (see next_state) '+currentEventConfiguration.next_state,3);
this.lastState=this.currentState;
this.currentState = currentEventConfiguration.next_state;
}
else
{
this._log('processEvent: '+this.FSMName+':'+currentEventConfiguration.next_state+'-> DOES NOT EXIST!',1);
this.lastState=this.currentState;
}
//*********************************************
//and now we're entering the new state
//*********************************************
anEv[0].type='enterState';
this.processEvent('enterState',anEv,true);
//propagate event if asked
//propagate event(s)
if (currentEventConfiguration.propagate_event != undefined)
{
if (!(currentEventConfiguration.propagate_event instanceof Array))
currentEventConfiguration.propagate_event=[currentEventConfiguration.propagate_event];
$.each(currentEventConfiguration.propagate_event,
function(aKey,aPropagateEvent)
{
thisFSM._log('processEvent: '+thisFSM.FSMName+':'+currentState+':'+anEvent+'-> trigger event (see propagate_event) ---> '+aPropagateEvent,3);
if (aPropagateEvent === true)
thisFSM.trigger( anEvent, data[1],currentEventConfiguration.propagate_event_on_localmachine);
else
thisFSM.trigger( aPropagateEvent, data[1],currentEventConfiguration.propagate_event_on_localmachine);
});
}
}
/*
* we stay in the same state?
* so process the event propagation
*/
else if ( (funcReturn != false)
&& (currentEventConfiguration.propagate_event != undefined)
)
{
if (!(currentEventConfiguration.propagate_event instanceof Array))
currentEventConfiguration.propagate_event=[currentEventConfiguration.propagate_event];
//propagate event(s)
$.each(currentEventConfiguration.propagate_event,
function(aKey,aPropagateEvent)
{
thisFSM._log('processEvent: '+thisFSM.FSMName+':'+currentState+':'+anEvent+'-> trigger event (see propagate_event) ---> '+aPropagateEvent,3);
if (aPropagateEvent === true)
thisFSM.trigger( anEvent, data[1], currentEventConfiguration.propagate_event_on_localmachine);
else
thisFSM.trigger( aPropagateEvent, data[1], currentEventConfiguration.propagate_event_on_localmachine);
});
}
/*
* oups there was an error during the processing of the action
*/
else if ( (funcReturn == false) && (currentEventConfiguration.next_state_if_error) )
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> error in init_function',3);
//is this a Push/Pop State?
if (currentEventConfiguration.pushpop_state_if_error)
{
switch(currentEventConfiguration.pushpop_state_if_error)
{
case 'PushState':
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Push state to state '+this.currentState,3);
this.pushStateList.push(this.currentState); //do not use currentStateEvent!
break;
case 'PopState':
if (this.pushStateList.length > 0)
{
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Pop state to state '+currentEventConfiguration.next_state_if_error,3);
this.pushStateList.pop();
}
break;
}
}
/*
*********************************************
* we change the current state Here!
*********************************************
*/
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> Go to (see next_state_if_error) '+currentEventConfiguration.next_state_if_error,3);
this.lastState=this.currentState;
this.currentState = currentEventConfiguration.next_state_if_error;
//and now that we're entering the new state
anEv[0].type='enterState';
this.processEvent('enterState',anEv,true);
}
else
{
//nothing to do?
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> nothing to do',3);
}
// do the exit action
if (currentEventConfiguration.out_function)
{
localdata = [].slice.call(data);
localdata.unshift(currentEventConfiguration.properties_out_function);
funcReturn= currentEventConfiguration.out_function.apply(this,localdata);
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> out_function done',3);
}
this.processEventStatus = lastprocessEventStatus; //we globally finished the job...
this.cleanExitProcess();
this._log('processEvent: '+this.FSMName+':'+currentState+':'+anEvent+'-> EXIT PROCESS',3,-1);
};//end of processEvent
/*
* cleanExitProcess - clean for exit the processing of an event
*/
fsm_manager.prototype.cleanExitProcess = function(anEvent,data) {
// processing lasting events
//we don't process the events if we were currently on an immediate event...
if (
(this.pushEventList.length)
&& (this.processEventStatus == 'idle' || this.pushEventList.length>this.opts.maxPushEvent)
)
{
this.popEvent();
}
};
/**
* pushEvent - push an event in the flow of the processing of an event
* public Method
* @param anEvent : an event name
* @param data : {event, data}
* if data is not an array, we consider that it is an external pushed event...then create one from anEvent and data.
*/
fsm_manager.prototype.pushEvent = function(anEvent,data) {
this._log('pushEvent: ---> '+anEvent);
if (this.pushEventList.length>this.opts.maxPushEvent)
{
this._log('pushEvent: too much events... ---> '+this.pushEventList.length,2);
return;
}
if ( (data == undefined) || (data.length == 0) || data[0].type == undefined )
{
var datatmp = new Array();
datatmp[0] = fsm_manager_create_event(this.myUIObject,anEvent);
datatmp[1] = data;
data = datatmp;
}
var anEventToPush = {anEvent:anEvent, data:data};
this.pushEventList.push( anEventToPush );
this._log('pushEvent: push nb event ---> '+this.pushEventList.length);
};
/*
* popEvent - pop an event and process it
* private Method
* we process event in a FIFO order
*/
fsm_manager.prototype.popEvent = function() {
this._log('popEvent');
if (this.pushEventList.length > 0)
{
anEventToProcess = this.pushEventList.shift();
this._log('popEvent:'+anEventToProcess.anEvent,3);
if (anEventToProcess == undefined || anEventToProcess.anEvent == undefined) return false;
this.processEvent(anEventToProcess.anEvent,anEventToProcess.data);
return true;
}
else this._log('popEvent void list');
return false;
};//
/**
* delayProcess - push an event after a delay
* private Method
* @param anEvent : an event name
* @param aDelay : a delay to do the processing
* @param data : {event, data}
*/
fsm_manager.prototype.delayProcess = function(anEvent, aDelay, data) {
this._log('delayProcess: ---> '+anEvent);
this.preventCancelId++;
//let aHashData = this.hashCode(JSON.stringify(data[1]));
let currentState = this.currentState;
let aDelayedProcessName=this.myUIObject.attr('id')+currentState+anEvent+this.preventCancelId;
if (!data[1]) data[1]={};//no data defined.... so define one
if (!this._stateDefinition[this.currentState][anEvent]) currentState = "DefaultState";
if (!this._stateDefinition[currentState][anEvent].how_process_event.DelayedProcessNames)
{
this._stateDefinition[currentState][anEvent].how_process_event.DelayedProcessNames=[];
}
if (this._stateDefinition[currentState][anEvent].how_process_event.preventcancel)
{
if (data[1].preventCancelSet) aDelayedProcessName=data[1].preventCancelSet; // same request that needs to be delayed again
else data[1]['preventCancelSet']=aDelayedProcessName;
}
this._stateDefinition[currentState][anEvent].how_process_event.DelayedProcessNames[aDelayedProcessName]=aDelayedProcessName;
//setTimeout(this.launchProcess,aDelay,this,anEvent,data);
jQuery.doTimeout(aDelayedProcessName,aDelay,fsm_manager_launchProcess,this,anEvent,data);
};
/**
* hash function
* from https://stackoverflow.com/questions/6122571/simple-non-secure-hash-function-for-javascript
* @todo needed?
**/
fsm_manager.prototype.hashCode = function(source) {
let hash = 0;
if (source.length == 0) {
return hash;
}
for (var i = 0; i < source.length; i++) {
var char = source.charCodeAt(i);
hash = ((hash<<5)-hash)+char;
hash = hash & hash; // Convert to 32bit integer
}
return hash;
}
/**
* cancelDelayedProcess - delete all delayed events of the current state except those declared as prevented
* public Method
*/
fsm_manager.prototype.cancelDelayedProcess = function() {
this._log('cancelDelayedProcess');
var currentState = null;
var currentEventConfiguration;
for(aEvent in this._stateDefinition[this.currentState])
{
currentState = this.currentState;
if (!this._stateDefinition[currentState][aEvent]) currentState = "DefaultState";
if (!this._stateDefinition[currentState][aEvent])
{
this._log('cancelDelayedProcess: '+aEvent+" has no definition for "+this.currentState,1);
return;
}
currentEventConfiguration = this._stateDefinition[currentState][aEvent];
if ( currentEventConfiguration.how_process_event
&& ( currentEventConfiguration.how_process_event.preventcancel == undefined
|| currentEventConfiguration.how_process_event.preventcancel != true
)
)
{
if (currentEventConfiguration.how_process_event.DelayedProcessNames)
{
for(aDelayedProcessName in currentEventConfiguration.how_process_event.DelayedProcessNames)
{
jQuery.doTimeout(aDelayedProcessName);//cancel event
}
currentEventConfiguration.how_process_event.DelayedProcessNames=[];
}
}
}
};
/**
* this.trigger - trigger an event to the machine
* public function
* @param aEventName - name of an event
* @param [object](option) data parameters linked to the event
* @param sendToLocalMachine [true|false(default)](option) - if true, send event to the local machine, if not to the root machine
*/
fsm_manager.prototype.trigger = function (aEventName,data,sendToLocalMachine) {
if (!sendToLocalMachine) sendToLocalMachine=false;
var anEv = new Array();
anEv[0] = fsm_manager_create_event(this.myUIObject,aEventName,null);
anEv[1] = data;
anEv[2] = {targetFSM:this,localMachine:sendToLocalMachine};
if (!sendToLocalMachine)
this.rootMachine.processEvent(aEventName,anEv);
else
this.processEvent(aEventName,anEv);
};//end of
/**
* subMachinesRespectTargets - verify if the set of submachines respects the target of the current event
* @param String anEvent
* @return boolean - true if target is respected
*/
fsm_manager.prototype.subMachinesRespectTargets = function (anEvent) {
this._log('subMachinesRespectTargets:');
var aStateDefinition = this._stateDefinition[this.currentState];
var targetConfiguration = aStateDefinition[anEvent].next_state_on_target;
var condition = targetConfiguration.condition;
var aResult = (condition == '||') ? false:true;
var aSMList = targetConfiguration.submachines;
var localRes;
for(aSubMachine in aSMList)
{
localRes = targetConfiguration.submachines[aSubMachine].target_list.indexOf(aStateDefinition.delegate_machines[aSubMachine].myFSM.currentState) > -1 ;
if (
(targetConfiguration.submachines[aSubMachine].condition != undefined)
&& (targetConfiguration.submachines[aSubMachine].condition == 'not')
)
localRes = !localRes;
if (condition == '||')
{
aResult = aResult || localRes;
if (aResult == true) return aResult;//we can stop as it a && operator
}
else if (condition == '&&')
{
aResult = aResult && localRes;
if (aResult == false) return aResult;//we can stop as it a && operator
}
else
{
this._log('operator unknown'+condition);
return aResult;
}
}
return aResult;
};
/**
* this._log - log function
* private function
* @param message - message to log
* @param error_level (default : 3)
* - 1 : it's an error
* - 2 : it's a warning
* - 3 : it's a notice
* @param add_offset (default:0) :
* 1 : add blank offset on the left of the message
* -1 : remove left blank offset on the left of the message
* @remarks
* - this.opts.debug needs to be set to have errors raised
* - if this.opts.AlertError is set, then error message will raise an alert box
* - if this.opts.logFSM is set, and contains a FSM name list, then only FSM in this list will raise errors
*/
fsm_manager.prototype.log_offsetstring='';
fsm_manager.prototype._log = function (message) {
/*global console:true */
let error = (arguments[1])? arguments[1] : 3;
//show only errors if debug is not set
if ( (error >= 2) && (!this.opts.debug) ) return;
if ( error > this.opts.LogLevel) return; //we continue if error_level <= LogLevel
// if logFSM is defined, only log the FSM listed in it
if ( this.opts.logFSM && this.opts.logFSM.indexOf(this.FSMName)<0) return;
if ( (arguments.length > 2) && (arguments[2] == -1))
this.log_offsetstring = this.log_offsetstring.replace(' ','');
if (window.console && console.log)
{
if (error == 1)
{
console.error('[fsm] ' + this.log_offsetstring + message);
}
else if (error == 2)
{
console.warn('[fsm] ' + this.log_offsetstring + message);
}
else
{
console.log('[fsm] ' + this.log_offsetstring + message);
}
if ( (error == 1) && this.opts.AlertError) alert(message);
if ( ( arguments.length > 2 ) && (arguments[2] == 1) )
this.log_offsetstring = this.log_offsetstring+" ";
}
};//end of _log
/*
* functions that can be used for the events of a state machine
*/
/**
* triggerMe - trigger an event on an object
* to be used within a state function
* example :
* init_function : fsm_manager_triggerMe,
* properties_init_function : {objectToTrigger:'#myButton',eventNameToTrigger:'click'} ,
* @param objectParameters
* - {objectToTrigger: a jquery selector ,eventNameToTrigger: a event name to trigger}
* @param event - the FSM event that called the function
* @param data - the FSM event data
*
* @param this - the FSM object (well... if called in a state function)
* @deprecated
*/
fsm_manager_triggerMe = function(objectParameters, event, data)
{
this._log('[fsm_manager_triggerMe]'+$(objectParameters.objectToTrigger).attr('id')+'-'+objectParameters.eventNameToTrigger);
$(objectParameters.objectToTrigger).trigger( objectParameters.eventNameToTrigger );
};
/**
* fsm_manager_getcss3prop -
* pass in an unaltered CSS property, and the function will return the vendor specific JavaScript equivalent property
* supported by the browser
* @param string cssprop - a css property
*
*
* getcss3prop('border-radius'); // returns 'borderRadius' or one of the variants, such as 'MozBorderRadius', 'WebkitBorderRadius' etc
*
*/
function fsm_manager_getcss3prop(cssprop){
var css3vendors = ['', '-moz-','-webkit-','-o-','-ms-','-khtml-'];
var root = document.documentElement;
function camelCase(str){
return str.replace(/\-([a-z])/gi, function (match, p1){ // p1 references submatch in parentheses
return p1.toUpperCase(); // convert first letter after "-" to uppercase
});
}
for (var i=0; i '+anEvent);
aFsm.processEvent(anEvent,data,true);
};
/**
* @param iFSMList - array of the created FSM linked with their Objects
* iFSMList[aStateDefinition]
*/
var iFSMList = {};
//jQuery definition
/**
* $.iFSM - iterate over a jQuery object to assign for each matched element a FSM machine
* @param aStateDefinition - a state definition
* @param options - options of the FSM machine
* Remarks :
* - any DOM object involved with a FSM needs to have its 'id' attribute defined
* - the init state may be defined with options.initState
*/
$.fn.iFSM = function(aStateDefinition, options)
{
return this.each(
function()
{
if ( ($(this)[0] == document) && !$(this).attr('id') )
{
// set an id to document... a iFSM needs one...
$(this).attr('id','iFSMDocumentRoot');
}
if ($(this).attr('id') != undefined)
{
if (iFSMList[$(this).attr('id')]==undefined)
{
iFSMList[$(this).attr('id')]=[];
}
var iFSM = new fsm_manager($(this), aStateDefinition, options);
if ($(this).getFSM(aStateDefinition))
{
console.warn('[warn][fsm] state machine was already set for this state definition on '+$(this).attr('id'));
}
iFSMList[$(this).attr('id')].push(iFSM) ;
if (options && options.initState != undefined) iFSM.InitManager(options.initState); //start it
else iFSM.InitManager(); //start it
}
else
{
if (options && options.debug) alert('Can\'t initialized state machine because the DOM object has no "id" property');
console.warn('[error][fsm] Can\'t initialized state machine because the DOM object has no "id" property');
}
});
};
/**
* $.getFSM - returns the array of FSM linked to the object
* @param aStateDefinition (optional) - if defined
* @return an array of the FSMs linked to the object
*/
$.fn.getFSM = function(aStateDefinition) {
if ( (this.length != 1) || (this.attr('id') == undefined) )
return [];
if (aStateDefinition == undefined)
return iFSMList[$(this).attr('id')];
else
{
var aFSM = null;
for (var i = 0, aFSMItem = null; i < iFSMList[$(this).attr('id')].length ; i++)
{
aFSMItem = iFSMList[$(this).attr('id')][i];
if (aFSMItem._originalstateDefinition == aStateDefinition)
{
aFSM = aFSMItem;
break;
}
}
return aFSM;
}
};
})(jQuery);