/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "stateengine.h"

#include "utils.h"

#include "uievent.h"

#include "uieventsender.h"

#include "filelogger.h"

//#include "flogger.h"

using namespace stmUiEventEngine ;

/*!

  State definitions glue together the methods of the stateengine.cpp

  so that it will behave as defined in the state machine specification.

  First define the separate elements for each possible event and then tie them together

  to create one state entry.  The state entries then are put to array

  where the index is at the same time also the state ID.

  STATE_ELEMENT arrays define the methods called when handling a message.

  \sa STATE_ELEMENT.

  Note that the last row of STATE_ELEMENT array must NOT have a ConditionFunction entry

  and it must have a NextState entry != Eignore.  Otherwise the state machine will

  not behave correctly.

 */

/*! Add macro with token pasting to make creation of the state machine tables easier

   and removing the necessity to write the classname twice.

   Maybe there would be some better way to do this using templates and typedefs?

 */

#define CND(x) isF<CStateEngine,&CStateEngine::##x>

#define ACT(x) aF<CStateEngine,&CStateEngine::##x>

/*********************************************************************************

 * empty statedef as a dummy entry

 *  */

const STATE_ELEMENT __ErrorEvent[1] = {

        0,

        ACT(ErrorEvent),

        EInit

};

const STATE Ignore__[1] = {

        EDown,          __ErrorEvent

} ;

/*!

  :INIT state and its event specific elements

  See the spec in http://wikis.in.nokia.com/Runtimes/NewGestureLibrary

  Down is only valid event in :INIT state

  The event is consumed immediately, so that the state machine will process only these

  methods when processing the message.

  If touch timer has been set, the next state is InTouchTime.

  If no touch timer, but if hold timer has been defined, the next state is InHoldTime_U

  If no touch or hold timer have been defined, but touch area has been defined, next state is InTouchArea.

  11-May-2009: addition: add another touch area: one for touch time and one for touch area after touch time

  has elapsed.  This allows "sloppy" touch to be handled properly without extra move if touchtimearea is larger,

  but after touch has been detected a smaller movement is allowed.

 */

const STATE_ELEMENT Init__Down[12] = {

        0,                  ACT(ConsumeEvent),    Eignore,

        0,                  ACT(SetGestureStart), Eignore,

        0,                  ACT(SetCurrentPos),   Eignore,

        CND(IsTouchTimer),  ACT(InitTouchTimer),  Eignore,

        CND(IsHoldTimer),   ACT(InitHoldTimer),   Eignore,

        CND(IsTouchTimeArea),   ACT(PrepareTouchTimeArea),Eignore,

        CND(IsHoldArea),    ACT(PrepareHoldArea) ,Eignore,

        CND(IsTouchTimer),  0,                    EInTouchTime,

        0,                  ACT(ProduceTouch),    Eignore,

        CND(IsHoldTimer),   0,                    EInHoldTime_U,

        CND(IsTouchArea),   ACT(PrepareTouchArea),EInTouchArea,

        0,                  0,                    EDispatch             // If nothing else happens, goto to Dispatch state

};

/**

 * All the rest of the events are errors so produce error entry to log and

 * stay in the Init state

 */

const STATE_ELEMENT Init__ErrorEvent[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      EInit

};

/*!

 * :INIT

 * note that only valid event is DOWN, all the rest can be handled as errors

 */

const STATE Init__[7] = {

        EDown,          Init__Down,

        EDrag,          Init__ErrorEvent,

        ECapacitiveUP,  Init__ErrorEvent,

        EResistiveUP,   Init__ErrorEvent,

        ETouchTimer,    Init__ErrorEvent,

        EHoldTimer,     Init__ErrorEvent,

        ESuppressTimer, Init__ErrorEvent

};

/*!

 *  :Dispatch state end its elements

 *  Here the valid events are DRAG and the UP events.

 */

const STATE_ELEMENT Dispatch__Drag[7] = {

        0,                  ACT(StoreMovePos),    Eignore,

        0,                  ACT(ConsumeEvent),    Eignore,

        0,                  ACT(SetCurrentPos),   Eignore,

        0,                  ACT(AddDraggingPos),  Eignore,

        0,                  ACT(ProduceMove),     Eignore,

        CND(LooksLikeHold), ACT(InitHoldTimer),EInHoldTime_U,

        0,                  0,                    EDispatch

} ;

const STATE_ELEMENT Dispatch__CapacitiveUp[3] = {

        0,                  ACT(ConsumeEvent),    Eignore,

        0,                  ACT(SetCurrentPos),   Eignore,

        0,                  ACT(ProduceRelease),  EInit

} ;

const STATE_ELEMENT Dispatch__ResistiveUp[4] = {

        0,                   ACT(ConsumeEvent),       Eignore,

        0,                   ACT(SetCurrentPos),   Eignore,

        CND(IsSuppressTimer),ACT(InitMoveSuppressTimer),  ESuppress_D,

        0,                   ACT(ProduceRelease),     EInit

} ;

/*!

 * All the rest of the events are errors so produce error entry to log and

 * stay in the Dispatch state

 * (TODO: note that in the future we may further

 * define the error cases so that they may change state; )

 */

const STATE_ELEMENT DispatchErrorEvent[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      EDispatch

};

const STATE Dispatch__[7] = {

        EDown,          DispatchErrorEvent,

        EDrag,          Dispatch__Drag,

        ECapacitiveUP,  Dispatch__CapacitiveUp,

        EResistiveUP,   Dispatch__ResistiveUp,

        ETouchTimer,    DispatchErrorEvent,

        EHoldTimer,     DispatchErrorEvent,

        ESuppressTimer, DispatchErrorEvent

};

/*!

 *  :InTouchTime state end its elements

 *  Here the valid events are DRAG and the UP events and the TouchTimer

 */

const STATE_ELEMENT InTouchTime__Drag[6] = {

        0,                  ACT(StoreMovePos),    Eignore,

        CND(InsideTouchTimeArea), ACT(ConsumeEvent),      Eignore,

        CND(InsideTouchTimeArea), ACT(AddToTouch),        EInTouchTime,     // Calculate touch XY as average of the touches

        0,                    ACT(ClearTouchTimer),   Eignore,          // These lines are done only if InsideTouchArea returns false

        0,                    ACT(ClearHoldTimer),    Eignore,

        0,                    ACT(ProduceTouch),      EDispatch

} ;

/**

 * Note that ConsumeEvent is missing so after doing this the state engine will do EDispatch

 */

const STATE_ELEMENT InTouchTime__CapacitiveUp[4] = {

        0,                  ACT(SetCurrentPos),       Eignore,

        0,                  ACT(ClearTouchTimer),     Eignore,

        0,                  ACT(ClearHoldTimer),      Eignore,

        0,                  ACT(ProduceTouch),        EDispatch

} ;

/**

 * Note that ConsumeEvent is not called if IsHoldTimer returns false, so the Dispatch will be done

 * by the state machine.

 */

const STATE_ELEMENT InTouchTime__ResistiveUp[5] = {

        0,                   ACT(SetCurrentPos),   Eignore,

        0,                   ACT(ClearTouchTimer),    Eignore,

        0,                   ACT(ProduceTouch),       Eignore,

        CND(IsHoldTimer),    0, /*ACT(ConsumeEvent),*/EInHoldTime_U,    // Note that otherwise immediate UP is handled improperly

        0,                   0,                       EDispatch

} ;

const STATE_ELEMENT InTouchTime__TouchTimer[6] = {

        0,                   ACT(ConsumeEvent),       Eignore,

        0,                   ACT(ClearTouchTimer),    Eignore,

        0,                   ACT(ProduceTouch),       Eignore,

        CND(IsTouchArea),    ACT(PrepareTouchArea),Eignore,         // prepare the other touch area

        CND(IsHoldTimer),    0,                       EInHoldTime_U,

        0,                   0,                     EInTouchArea

} ;

/**

 * All the rest of the events are errors so produce error entry to log and

 * stay in the InTouchTime state

 */

const STATE_ELEMENT InTouchTimeErrorEvent[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      EInTouchTime

};

const STATE InTouchTime__[7] = {

        EDown,          InTouchTimeErrorEvent,

        EDrag,          InTouchTime__Drag,

        ECapacitiveUP,  InTouchTime__CapacitiveUp,

        EResistiveUP,   InTouchTime__ResistiveUp,

        ETouchTimer,    InTouchTime__TouchTimer,

        EHoldTimer,     InTouchTimeErrorEvent,

        ESuppressTimer, InTouchTimeErrorEvent

};

/*!

 *  :InHoldTime_U state end its elements

 *  Here only touch timer event is invalid

 */

const STATE_ELEMENT InHoldTime_U__Down[1] = {

        0,                    0,      EInHoldTime_D  // Note that ConsumeEvent is not called

} ;

const STATE_ELEMENT InHoldTime_U__Drag[3] = {

        0,                  ACT(StoreMovePos),    Eignore,

        CND(InsideHoldArea), ACT(ConsumeEvent),       EInHoldTime_U,

        0,                    ACT(ClearHoldTimer),    EDispatch     // Note that in this case ConsumeEvent is not called

} ;

/**

 * Note that ConsumeEvent is missing so after doing this the state engine will do EDispatch

 */

const STATE_ELEMENT InHoldTime_U__CapacitiveUp[1] = {

        0,                  ACT(ClearHoldTimer),      EDispatch     // Note that ConsumeEvent not called

} ;

/**

 *

 */

const STATE_ELEMENT InHoldTime_U__ResistiveUp[5] = {

        0,                   ACT(ConsumeEvent),  Eignore,

        0,                   ACT(SetCurrentPos),   Eignore,

        CND(IsSuppressTimer),ACT(InitTouchSuppressTimer),  EInHoldTime_D,   // If suppression, start timer and wait for down or timer

        0,                   ACT(ClearHoldTimer), Eignore,  // remember to do this

        0,                   ACT(ProduceRelease), EInit     // No suppression, then this is immediate release

} ;

const STATE_ELEMENT InHoldTime_U__HoldTimer[3] = {

        0,                   ACT(ConsumeEvent),       Eignore,

        0,                   ACT(ProduceHold),        Eignore,

        0,                   ACT(RestartHoldTimer),   EInHoldTime_U,

} ;

const STATE_ELEMENT InHoldTime_U__SuppressTimer[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      EInHoldTime_U

} ;

/**

 * All the rest of the events are errors so produce error entry to log and

 * stay in the InHoldTime_U state

 */

const STATE_ELEMENT InHoldTime_UErrorEvent[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      EInHoldTime_U

};

const STATE InHoldTime_U__[7] = {

        EDown,          InHoldTime_U__Down,

        EDrag,          InHoldTime_U__Drag,

        ECapacitiveUP,  InHoldTime_U__CapacitiveUp,

        EResistiveUP,   InHoldTime_U__ResistiveUp,

        ETouchTimer,    InHoldTime_UErrorEvent,

        EHoldTimer,     InHoldTime_U__HoldTimer,

        ESuppressTimer, InHoldTime_U__SuppressTimer

};

/*!

 *  :InHoldTime_D state end its elements

 *  Here drag, touch timer and suppress timer events are invalid

 */

const STATE_ELEMENT InHoldTime_D__Down[5] = {

        0,                    ACT(ClearSuppressTimer),    Eignore,

        0,                    ACT(ConsumeEvent),      Eignore,

        CND(InsideHoldArea),  0,                      EInHoldTime_U,

        0,                    ACT(ClearHoldTimer),    Eignore,

        0,                    ACT(ProduceMove),       EDispatch

} ;

/**

 * Note that ConsumeEvent is missing so after doing this the state engine will do InHoldTime_U

 */

const STATE_ELEMENT InHoldTime_D__CapacitiveUp[1] = {

        0,                  0,    EInHoldTime_U

} ;

/**

 * Note that ConsumeEvent is missing so after doing this the state engine will do InHoldTime_U

 */

const STATE_ELEMENT InHoldTime_D__ResistiveUp[1] = {

        0,                  0,    EInHoldTime_U     // InHoldTime_U initialises timers etc. if needed

} ;

/*!

 * In case of hold timer has been elapsed stop the timers, generate Release UI event.

 */

const STATE_ELEMENT InHoldTime_D__HoldTimer[4] = {

        0,                   ACT(ConsumeEvent),       Eignore,

        0,                   ACT(ClearSuppressTimer), Eignore,

        0,                   ACT(ClearHoldTimer),     Eignore,

        0,                   ACT(ProduceRelease),     EInit,

} ;

/*!

 * If suppress timer hits, stop the timers and generate Release UI event.

 */

const STATE_ELEMENT InHoldTime_D__SuppressTimer[4] = {

        0,                   ACT(ConsumeEvent),       Eignore,

        0,                   ACT(ClearSuppressTimer), Eignore,

        0,                   ACT(ClearHoldTimer),     Eignore,

        0,                   ACT(ProduceRelease),     EInit,

} ;

/**

 * All the rest of the events are errors so produce error entry to log and

 * stay in the InHoldTime_D state

 */

const STATE_ELEMENT InHoldTime_DErrorEvent[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      EInHoldTime_D

};

const STATE InHoldTime_D__[7] = {

        EDown,          InHoldTime_D__Down,

        EDrag,          InHoldTime_DErrorEvent,

        ECapacitiveUP,  InHoldTime_D__CapacitiveUp,

        EResistiveUP,   InHoldTime_D__ResistiveUp,

        ETouchTimer,    InHoldTime_DErrorEvent,

        EHoldTimer,     InHoldTime_D__HoldTimer,

        ESuppressTimer, InHoldTime_D__SuppressTimer

};

/*!

 *  :InTouchArea state end its elements

 *  Here Drag and Up events are valid.

 *  If drag is inside touch are it is ignored, otherwise

 *  the Dispatch state will handle the event.

 */

const STATE_ELEMENT InTouchArea__Drag[3] = {

        0,                  ACT(StoreMovePos),    Eignore,

        CND(InsideTouchArea), ACT(ConsumeEvent),     EInTouchArea,

        0,                    0,                     EDispatch  // Note that in this case ConsumeEvent has not been called so Dispatch state processes the message

} ;

/**

 * Note that ConsumeEvent is missing so after doing this the state engine will do Dispatch

 */

const STATE_ELEMENT InTouchArea__CapacitiveUp[1] = {

        0,                  0,    EDispatch

} ;

/**

 * Note that ConsumeEvent is missing so after doing this the state engine will do Dispatch

 */

const STATE_ELEMENT InTouchArea__ResistiveUp[1] = {

        0,                  0,    EDispatch

} ;

/**

 * All the rest of the events are errors so produce error entry to log and

 * stay in the InTouchArea state

 */

const STATE_ELEMENT InTouchAreaErrorEvent[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      EInTouchArea

};

const STATE InTouchArea__[7] = {

        EDown,          InTouchAreaErrorEvent,

        EDrag,          InTouchArea__Drag,

        ECapacitiveUP,  InTouchArea__CapacitiveUp,

        EResistiveUP,   InTouchArea__ResistiveUp,

        ETouchTimer,    InTouchAreaErrorEvent,

        EHoldTimer,     InTouchAreaErrorEvent,

        ESuppressTimer, InTouchAreaErrorEvent

};

/*!

 *  :Suppress_D state end its elements

 *  Here Down and suppress timers are OK.

 */

/*!

 * Down will be handled as a Drag event in the Dispatch state.

 */

const STATE_ELEMENT Suppress_D__Down[4] = {

        0,           ACT(ClearSuppressTimer),    Eignore,

        0,           ACT(RenameToDrag),          EDispatch

} ;

/*!

 * Suppress timer will generate Release UI event.

 */

const STATE_ELEMENT Suppress_D__SuppressTimer[3] = {

        0,                   ACT(ConsumeEvent),       Eignore,

        0,                   ACT(ClearSuppressTimer), Eignore,

        0,                   ACT(ProduceRelease),     EInit,

} ;

/**

 * All the rest of the events are errors so produce error entry to log and

 * stay in the Suppress_D state

 */

const STATE_ELEMENT Suppress_DErrorEvent[2] = {

        0,              ACT(ConsumeEvent),    Eignore,  // remember to consume event, otherwise state machine will loop...

        0,              ACT(ErrorEvent),      ESuppress_D

};

const STATE Suppress_D__[7] = {

        EDown,          Suppress_D__Down,

        EDrag,          Suppress_DErrorEvent,

        ECapacitiveUP,  Suppress_DErrorEvent,

        EResistiveUP,   Suppress_DErrorEvent,

        ETouchTimer,    Suppress_DErrorEvent,

        EHoldTimer,     Suppress_DErrorEvent,

        ESuppressTimer, Suppress_D__SuppressTimer

};

/*!

 * The allStates array contains all the possible states of the state machine.

 */

const STATE* const allStates[8] =

{

        Ignore__,

        Init__,

        Dispatch__,

        InTouchTime__,

        InHoldTime_U__,

        InHoldTime_D__,

        InTouchArea__,

        Suppress_D__

};

/*!

 * stateNames are used in the logging

 */

const char* const stateNames[8] =

{

        "Ignore",

        "Init",

        "Dispatch",

        "InTouchTime",

        "InHoldTime_U",

        "InHoldTime_D",

        "InTouchArea",

        "Suppress"

};

// event names are also used in logging

const char* const hweventNames[] = {

        "EDown",

        "EDrag",

        "ECapacitiveUP",

        "EResistiveUP",

        "ETouchTimer",

        "EHoldTimer",

        "ESuppressTimer"

} ;

/*! CStateEngine contains the methods used in the state machine implementation.

 *

 *  The methods in CStateEngine used in the state machine definition are

 *  either condition methods or action methods.

 *

 *  Constructor

 *  \param[in]: MTimerInterface atimerif.  An attempt to make this more OS agnostic the actual

 *  timers are accessed using a separate interface.

 */

CStateEngine::CStateEngine(CStateEngineConfiguration* aConfig, MTimerInterface* atimerif, int aIndex)

{

    m_config = aConfig ;

    m_timerif = atimerif ;

    m_currentState = EInit ;

    m_index = aIndex ;

    isStatemachineBlocked = false;

}

CStateEngine::~CStateEngine()

{

    // Just to be sure...

    iTouchPoints.Reset() ;

    iDragPoints.ResetAndDestroy() ;

}

/*!

 * ConsumeEvent: the method defines that the turnStateMachine will stop the processing

 * of the state methods after it has reached the next state.

 *

 */

void CStateEngine::ConsumeEvent()

{

    m_eventConsumed = true ;

}

/*!

 * Condition method

 * \return true, if the touch timer limit > 0

 */

bool CStateEngine::IsTouchTimer()

{

    bool isit =  (m_config->m_touchTimerLimit > 0) ;

    return isit ;

}

/*!

 * Condition method

 * \return true, if the hold timer limit > 0

 */

bool CStateEngine::IsHoldTimer()

{

    bool isit =  (m_config->m_holdTimerLimit > 0) ;

    return isit ;