/*
* 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:   Timer implementation
*
*/

#ifndef CALLBACKTIMER_H_
#define CALLBACKTIMER_H_
// INCLUDES
#include <e32std.h>
#include <e32base.h>
#include <coemain.h>
#include <aknutils.h>
#include <e32property.h>
#include <w32std.h>

namespace stmUiEventEngine
{
/**
 * define the method to be called by the timer; this includes the pointer number
 * the timer is associated with (maybe some other solution could do this, but...)
 */
class CStateMachine ;
typedef void (CStateMachine::*CallbackFunctionL)(TInt aPointerNumber);


/**
 * CCallbackTimer to implement the timers.  This needs to be replaced
 * with something else if cross platform is needed.
 */
NONSHARABLE_CLASS( CCallbackTimer ): public CTimer
{
public:
    /** Two-phase constructor */
    static CCallbackTimer* NewL(CStateMachine& aHelper,
            CallbackFunctionL aCallbackFunctionL, 
            TInt aDelay, 
            TInt aPointerNumber, 
            TBool aIsEnabled)
    {
        CCallbackTimer* self = new (ELeave) CCallbackTimer(aHelper,
                aCallbackFunctionL, aDelay, aPointerNumber, aIsEnabled);
        CleanupStack::PushL(self);
        self->ConstructL(); // construct base class
        CActiveScheduler::Add(self);
        CleanupStack::Pop(self);
        return self;
    }

    /** Destructor */
    ~CCallbackTimer()
    {
        Cancel();
    }

    /** Set whether sending events is currently enabled */
    void SetEnabled(TBool aEnabled)
    {
        iIsEnabled = aEnabled;
        // cancel in case timer is already running
        Cancel();
    }

    /** @return whether sending events is currently enabled */
    TBool IsEnabled() const
    {
        return iIsEnabled;
    }

    /** Start the timer. Calls callback upon completion.  It is possible to give temporary delay if needed,
     * otherwise use the defined delay.
     */
    void Start(TInt aNewDelay = 0)
    {
        if (iIsEnabled)
        {
            Cancel();
            if (aNewDelay != 0)
            {
                After(aNewDelay);
            }
            else
            {
                After(iDelay);
            }
        }
    }
    void SetDelay(TInt aDelay)
    {
        iDelay = aDelay;
    }
    TInt GetDelay()
    {
        return iDelay;
    }
    /**
     * method for checking are we inside the RunL method...
     */
    TBool isTriggered()
    {
        return iIsTriggered;
    }

private:
    /** Constructor */
    CCallbackTimer(CStateMachine& aHelper, CallbackFunctionL aCallbackFunctionL,
            TInt aDelay, TInt aPointerNumber, TBool aIsEnabled)
    :
                CTimer(EPriorityRealTime - 1), // handle the timers always first before anything else
                iHelper(aHelper), iCallbackFunctionL(aCallbackFunctionL),
                iDelay(aDelay), iIsEnabled(aIsEnabled), iPointerNumber(aPointerNumber)
    {
        iIsTriggered = EFalse;
    }

    void RunL() // From CActive
    {
        iIsTriggered = ETrue ;
        (iHelper .*iCallbackFunctionL)(iPointerNumber);
        iIsTriggered = EFalse ;
    }

private:
    /// helper object that will be called back when timer is triggered
    CStateMachine& iHelper;
    /// Function in the iHelper object call
    CallbackFunctionL iCallbackFunctionL;
    /// How long a time to wait before calling back after Start()
    TInt iDelay;
    /// whether sending holding events is currently enabled
    TBool iIsEnabled;
    /**
     * while we are inside RunL iIsTriggered = ETrue
     */
    TBool iIsTriggered;
    /*
     * in multitouch now we need timers for each pointer
     * could this be handled in some other way?
     */
    TInt iPointerNumber ;
};
} // namespace

#endif /* CALLBACKTIMER_H_ */