diff -r 6297cdf66332 -r d39add9822e2 webengine/webkitutils/stmgesturefw/inc/callbacktimer.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/webkitutils/stmgesturefw/inc/callbacktimer.h	Tue Feb 02 00:56:45 2010 +0200
@@ -0,0 +1,155 @@
+/*
+* 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_ */