/*

* 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:  Gesture helper implementation

*

*/

// Gesture UI Engine

#include "statemachine.h"

// Gesture Library: Framework

#include "gestureframework.h"

#include "rt_gestureengineif.h"

// Gesture Library: Recognizers

#include "tapgesturerecogniser.h"

#include "pangesturerecogniser.h"

#include "edgescrollgesturerecogniser.h"

#include "longpressgesturerecogniser.h"

#include "pinchgesturerecogniser.h"

#include "touchgesturerecogniser.h"

#include "releasegesturerecogniser.h"

#include "flickgesturerecogniser.h"

#include "zoomgesturerecogniser.h"

#include "stmgestureinterface.h"

#include "gesturehelpereventsender.h"

#ifndef ICS_DCHECK

#define ICS_DCHECK(test)

#endif

#define LOG(args...)

EXPORT_C CStmGestureParameters::CStmGestureParameters()

    {

    }

EXPORT_C CStmGestureParameters::CStmGestureParameters(

    const CStmGestureParameters& aParams )

    {

    Mem::Copy(&iParam[0], &aParams.iParam[0], sizeof(iParam));

    Mem::Copy(&iAreaSettings[0], &aParams.iAreaSettings[0], sizeof(iAreaSettings));

    Mem::Copy(&iEnabled[0], &aParams.iEnabled[0], sizeof(iEnabled));

    }

EXPORT_C CStmGestureEngine* CStmGestureEngine::NewL()

    {

    CStmGestureEngine* eng = new(ELeave) CStmGestureEngine();

    CleanupStack::PushL(eng);

    eng->ConstructL();

    CleanupStack::Pop(eng);

    return eng;

    }

CStmGestureEngine::CStmGestureEngine()

    {

    }

void CStmGestureEngine::ConstructL()

    {

    iGf = stmGesture::CGestureFramework::NewL();

    }

CStmGestureEngine::~CStmGestureEngine()

    {

    // Prevent reactivation of contexts as they remove themselves

    iDtorPhase = ETrue;

    iContexts.ResetAndDestroy();

    iCtxtStack.Reset();

    delete iGf;

    }

EXPORT_C CStmGestureContext* CStmGestureEngine::CreateContextL(

    TInt /*aId*/ )

    {

    CStmGestureContext* ctxt = new(ELeave) CStmGestureContext(*this);

    CleanupStack::PushL(ctxt);

    ctxt->ConstructL();

    CleanupStack::Pop(ctxt);

    return ctxt;

    }

EXPORT_C CStmGestureContext* CStmGestureEngine::Context(

    TInt /*aId*/ )

    {

    return NULL;

    }

void CStmGestureEngine::EnableContextL(

    CStmGestureContext& aContext )

    {

    // NB: enabling context puts it on top of the Context Stack

    TInt idx = iCtxtStack.Find(&aContext);

    if(idx >= 0)

        {

        iCtxtStack.Remove(idx);

        }

    SetupRecognizersL(aContext, ETrue);

    iCtxtStack.AppendL(&aContext);

    }

void CStmGestureEngine::DisableContextL(

    CStmGestureContext& aContext )

    {

    TInt idx = iCtxtStack.Find(&aContext);

    ICS_DCHECK(idx >= 0);

    if(idx == KErrNotFound)

        {

        return;

        }

    iCtxtStack.Remove(idx);

    stmGesture::MGestureEngineIf* ge = iGf->getGestureEngine();

    for(TInt i = 0; i < stmGesture::EStmGestureUid_Count; ++i)

        {

        MStmGestureRecogniser* rec = aContext.iRecognizers[i];

        if(rec)

            {

            ge->removeGesture(rec);

            }

        }

    // re-activate previous (new top-most) context

    // NB: if deleted context is not top-most (active) one, no updates done

    TInt count = iCtxtStack.Count();

    if(idx == count && count > 0 && !iDtorPhase)

        {

        CStmGestureContext* previous = iCtxtStack[count - 1];

        SetupRecognizersL(*previous, EFalse);

        }

    }

template<class T>

void CStmGestureEngine::InitRecognizerL(

    T*& aGesture,

    CStmGestureContext& aContext,

    TBool aNewContext )

    {

    stmGesture::MGestureRecogniserIf*& recognizer = aContext.iRecognizers[T::KUid];

    aGesture = static_cast<T*>(recognizer);

    if(!aGesture && aNewContext)

        {

        recognizer = aGesture = T::NewL(&aContext);

        recognizer->enableLogging((aContext.iLogging & (1<<T::KUid)) != 0);

        }

    else

        {

        ICS_DCHECK(gesture && !aNewContext); // should exist in restored top context

        }

    // TODO: Add in right place according to gesture class

    TBool added = iGf->getGestureEngine()->addGesture(aGesture);

    if(!added)

        {

        User::Leave(KErrNoMemory);

        }

    }

void CStmGestureEngine::SetupRecognizersL(

    CStmGestureContext& aContext,

    TBool aNewContext )

    {

    LOG("Setup recognizers");

    // Order of recognizers in the Gesture Engine (upper ones receive input before lower ones)

    //

    // PINCH

    // CORNER_ZOOM

    // EDGE_SCROLL

    // LONGPRESS

    // TOUCH

    // UP_DOWN

    // LEFT_RIGHT

    // HOVER

    // PAN

    // TAP / DOUBLE_TAP

    // FLICK

    // RELEASE

    // UNKNOWN

    stmUiEventEngine::CStateMachine* stateMachine = iGf->getUiStateMachine();

    stmGesture::MGestureEngineIf* gestureEngine = iGf->getGestureEngine();

    MStmGestureParameters& conf = aContext.Config();

    TBool filter = conf.Param(stmGesture::EEnableFiltering) != 0;

    // TOUCH AREA

    TStmGestureArea& touchArea = *conf.Area(stmGesture::ETouchArea);

    TInt touchAreaSizeInMm = touchArea.iSize.iWidth;

    stateMachine->setTouchAreaShape ( stmUiEventEngine::TAreaShape(touchArea.iShape) );

    stateMachine->setTouchArea      ( !filter ? 0 : touchAreaSizeInMm );

    stateMachine->setTouchTimeout   ( !filter ? 0 : touchArea.iTimeout * 1000);

    CCoeControl* gestureContext = aContext.getOwner();

    TRect ctxtRect = gestureContext->Rect();

    // ===================================================== PINCH

    using stmGesture::CPinchGestureRecogniser;

    if (conf.Enabled(CPinchGestureRecogniser::KUid))

        {

        CPinchGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            TReal32 pspeed = conf.Param(stmGesture::EPinchSpeed) / 1000.f;

            gesture->setPinchingSpeed(pspeed);

            }

        }

    // ===================================================== LONG PRESS

    using stmGesture::CLongPressGestureRecogniser;

    if (conf.Enabled(CLongPressGestureRecogniser::KUid))

        {

        CLongPressGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            gesture->setArea(ctxtRect);

            }

        }

    // ===================================================== TOUCH

    using stmGesture::CTouchGestureRecogniser;

    if (conf.Enabled(CTouchGestureRecogniser::KUid))

        {

        CTouchGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            // define empty area so that touch is reported only inside

            // our window (touch recogniser handles either an area or the target window)

            gesture->setArea(TRect());

            }

        }

    // ===================================================== PAN

    using stmGesture::CPanGestureRecogniser;

    if (conf.Enabled(CPanGestureRecogniser::KUid))

        {

        CPanGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            gesture->setPanningSpeedLow ( conf.Param(stmGesture::EPanSpeedLow)  / 1000.f );

            gesture->setPanningSpeedHigh( conf.Param(stmGesture::EPanSpeedHigh) / 1000.f );

            }

        }

    // ===================================================== TAP / DOUBLE TAP

    /// Add recognizer before any existing Flick, Release, Unknown

    // Add the gesture to the gesture engine

    // TODO: Tap recognizer is special - it can combine multiple listeners,

    //       so no need to create new one if it already exists, just add new listeners to it

    using stmGesture::CTapGestureRecogniser;

    if (conf.Enabled(CTapGestureRecogniser::KUid))

        {

        CTapGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            gesture->setDoubleTapTimeout(conf.Param(stmGesture::EDoubleTapTimeout) * 1000);

            gesture->setDoubleTapRange( touchAreaSizeInMm );

            gesture->ignoreFirstTap(EFalse);

            aContext.iLogging |= 1<<CTapGestureRecogniser::KUid;

            }

        }

    // ===================================================== FLICK

    using stmGesture::CFlickGestureRecogniser;

    if (conf.Enabled(CFlickGestureRecogniser::KUid))

        {

        CFlickGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            TReal32 flickSpeed = conf.Param(stmGesture::EFlickSpeed) / 1000.f;

            gesture->setFlickingSpeed(flickSpeed);

            }

        }

    // ===================================================== RELEASE

    using stmGesture::CReleaseGestureRecogniser;

    if (conf.Enabled(CReleaseGestureRecogniser::KUid))

        {

        CReleaseGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            gesture->setArea(TRect());

            }

        }

#if 0 // use in future depending upon browser requirement

    // ===================================================== CORNER ZOOM

    using stmGesture::CZoomGestureRecogniser;

    if (conf.Enabled(CZoomGestureRecogniser::KUid))

        {

        CZoomGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            gesture->setArea(ctxtRect);

            gesture->setRange(conf.Param(stmGesture::EZoomCornerSize));

            }

        }

    // ===================================================== EDGE SCROLL

    using stmGesture::CEdgeScrollGestureRecogniser;

    if (conf.Enabled(CEdgeScrollGestureRecogniser::KUid))

        {

        CEdgeScrollGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            gesture->setArea(ctxtRect);

            gesture->setScrollRange(conf.Param(stmGesture::EEdgeScrollRange)); // range is 20 pixels from the edge TODO: add this to settings...

            }

        }

    // ===================================================== LEFT-RIGHT

    using stmGesture::CLeftrightGestureRecogniser;

    if (conf.Enabled(CLeftrightGestureRecogniser::KUid))

        {

        CLeftrightGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        }

    // ===================================================== UP-DOWN

    using stmGesture::CUpdownGestureRecogniser;

    if (conf.Enabled(CUpdownGestureRecogniser::KUid))

        {

        CUpdownGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        }

    // ===================================================== HOVER

    using stmGesture::CHoveringGestureRecogniser;

    if (conf.Enabled(CHoveringGestureRecogniser::KUid))

        {

        CHoveringGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        if(gesture)

            {

            gesture->setHoveringSpeed(conf.Param(stmGesture::EHoverSpeed) / 1000.f);

            }

        }

    // ===================================================== UNKNOWN

    using stmGesture::CUnknownGestureRecogniser;

    if (conf.Enabled(CUnknownGestureRecogniser::KUid))

        {

        CUnknownGestureRecogniser* gesture = NULL;

        InitRecognizerL(gesture, aContext, aNewContext);

        }

#endif

    // ===========================================================

    if(aNewContext)

        {

        for(TInt i = 0; i < stmGesture::EStmGestureUid_Count; ++i)

            {

            MStmGestureRecogniser* rec = aContext.iRecognizers[i];

            if(rec)

                {

                rec->enableLogging(aContext.iLogging & (1<<i)) ;

                }

            }

        }

    // HOLD AREA

    TStmGestureArea& holdArea = *conf.Area(stmGesture::EHoldArea);

    TInt holdAreaSizeInMm = holdArea.iSize.iWidth;

    stateMachine->setHoldAreaShape  ( stmUiEventEngine::TAreaShape(holdArea.iShape) );

    stateMachine->setHoldArea       ( !filter ? 0 : holdAreaSizeInMm );

    stateMachine->setHoldTimeout    ( !filter ? 0 : holdArea.iTimeout * 1000);

    // TOUCH-TIME AREA

    TStmGestureArea& tTimeArea = *conf.Area(stmGesture::ETouchTimeArea);

    TInt tTimeAreaSizeInMm = tTimeArea.iSize.iWidth;

    // NB: shape <-- TouchAreaShape

    stateMachine->setTouchTimeArea      ( !filter ? 0 : tTimeAreaSizeInMm );

    // Timeouts, Adjustments, etc.

    stateMachine->setTouchSuppressTimeout(!filter ? 0 :

                                            conf.Param(stmGesture::ESuppressTimeout)*1000) ;

    stateMachine->setMoveSuppressTimeout(!filter ? 0 :

                                            conf.Param(stmGesture::EMoveSuppressTimeout)*1000) ;

    stateMachine->enableCapacitiveUp    (!filter ? 0 :

                                            conf.Param(stmGesture::ECapacitiveUpUsed));

    stateMachine->enableYadjustment     (!filter ? 0 : conf.Param(stmGesture::EAdjustYPos));

    stateMachine->enableLogging(false);

    stateMachine->EnableWsEventMonitoring(false);

    LOG("Setup recognizers -- DONE");

    }

EXPORT_C void CStmGestureEngine::HandlePointerEventL(

    const TPointerEvent& aPointerEvent,

    void* target)

    {

    iGf->getUiStateMachine()->HandlePointerEventL(aPointerEvent,target);

    }

// =============================================================

CStmGestureContext::CStmGestureContext(

    CStmGestureEngine& aEngine ) :

    iEngine(aEngine),

    iEventSender(NULL)

    {

    }

void CStmGestureContext::ConstructL()

    {

    iEngine.iContexts.AppendL(this);

    iConfig = new(ELeave) CStmGestureParameters();

    }

CStmGestureContext::~CStmGestureContext()

    {

    // Remove all gesture listeners

    for(TInt i = iListeners.Count() - 1; i >= 0; --i)

        {

        MStmGestureListener* listener = iListeners[i];

        iListeners.Remove(i);

        }

    iListeners.Reset();

    // Remove all context's recognizers from the Gesture Engine

    Deactivate();

    if (iEventSender)

        delete iEventSender;

    // Destroy all recognizers

    for(TInt r = 0; r < stmGesture::EStmGestureUid_Count; ++r)

        {

        MStmGestureRecogniser*& rec = iRecognizers[r];

        if(rec)

            {

            delete rec;

            rec = NULL;

            }

        }

    // Remove context from the Gesture Engine

    TInt idx = iEngine.iContexts.Find(this);

    if(idx != -1)

        {

        iEngine.iContexts.Remove(idx);

        }

    delete iConfig;

    }

EXPORT_C void CStmGestureContext::AddListenerL(

    MStmGestureListener* aListener,

    TInt aPos )

    {

    iEventSender = CGestureEventSender::NewL(*aListener);

    iListeners.InsertL(aListener, aPos);

    }

EXPORT_C TInt CStmGestureContext::RemoveListener(

    MStmGestureListener* aListener )

    {

    TInt ind = iListeners.Find(aListener);

    if(ind >= 0)

        {

        iListeners.Remove(ind);

        }

    return ind;

    }

EXPORT_C void CStmGestureContext::SetContext(

    CCoeControl* aControl )

    {

    iOwnerControl = aControl;

    for(TInt i = 0; i < stmGesture::EStmGestureUid_Count; ++i)

        {

        MStmGestureRecogniser* rec = iRecognizers[i];