/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  Touch gesture framework implementation.

*

*/

#include <aknappui.h>

#include <e32base.h>

#include "akntouchgesturefwimpl.h"

#include "akntouchgesturefwdefs.h"

#include "akntouchgesturefwevent.h"

#include "akntouchgesturefwrecognitionengine.h"

using namespace AknTouchGestureFw;

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CAknTouchGestureFwImpl* CAknTouchGestureFwImpl::NewL(

    MAknTouchGestureFwObserver& aObserver,

    CCoeControl* aControl )

    {

    CAknTouchGestureFwImpl* self =

        CAknTouchGestureFwImpl::NewLC( aObserver, aControl );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CAknTouchGestureFwImpl* CAknTouchGestureFwImpl::NewLC(

    MAknTouchGestureFwObserver& aObserver,

    CCoeControl* aControl )

    {

    CAknTouchGestureFwImpl* self =

        new ( ELeave ) CAknTouchGestureFwImpl( aControl );

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CAknTouchGestureFwImpl::~CAknTouchGestureFwImpl()

    {

    if ( iCoeEnv )

        {

        iCoeEnv->RemoveForegroundObserver( *this );

        iCoeEnv->RemoveMessageMonitorObserver( *this );

        }

    delete iRecognitionEngine;

    }

// ---------------------------------------------------------------------------

// Handles simulated pointer events.

// Used only for testing purposes.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::HandleSimulatedPointerEventL(

    const TPointerEventData& pointerData )

    {

    HandlePointerEventL( pointerData );

    iSubscriberControl->HandlePointerEventL( pointerData.iPointerEvent );

    }

// ---------------------------------------------------------------------------

// Sets target control for window server events.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::SetSubscriberControlL( CCoeControl* aControl )

    {

    CCoeControl* subsControl = aControl;

    CCoeControl* windowControl( subsControl );

    while ( windowControl && !windowControl->OwnsWindow() )

        {

        windowControl = windowControl->Parent();

        }

    if ( windowControl )

        {

        iWindowControl = windowControl;

        }

    else

        {

        // The subscriber control or it's parents have no window,

        // so there's no point to continue.

        User::Leave( KErrNotFound );

        }

    iSubscriberControl = subsControl;

    EnableAdditionalEvents();

    }

// ---------------------------------------------------------------------------

// Sets the gesture interest.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::SetGestureInterestL( TUint aGestureGroups )

    {

    TUint gestureInterest( EAknTouchGestureFwNoGroup );

    if ( aGestureGroups )

        {

        gestureInterest = aGestureGroups;

        }

    if ( !iMonitoringWs &&

         gestureInterest != EAknTouchGestureFwNoGroup )

        {

        iCoeEnv->AddMessageMonitorObserverL( *this );

        iMonitoringWs = ETrue;

        }

    else if ( iMonitoringWs &&

              gestureInterest == EAknTouchGestureFwNoGroup )

        {

        iCoeEnv->RemoveMessageMonitorObserver( *this );

        iMonitoringWs = EFalse;

        }

    TRAPD( err,

           iRecognitionEngine->SetGestureInterestL( gestureInterest ) );

    // If setting the gesture interes fails then there's no need to

    // monitor the WS events.

    if ( err != KErrNone && iMonitoringWs )

        {

        iCoeEnv->RemoveMessageMonitorObserver( *this );

        iMonitoringWs = EFalse;

        User::Leave( err );

        }

    EnableAdditionalEvents();

    }

// ---------------------------------------------------------------------------

// Returns the gesture groups which should be recognized.

// ---------------------------------------------------------------------------

//

TUint CAknTouchGestureFwImpl::GestureInterest() const

    {

    TUint gestureInterest( EAknTouchGestureFwNoGroup );

    if ( iRecognitionEngine )

        {

        gestureInterest = iRecognitionEngine->GestureInterest();

        }

    return gestureInterest;

    }

// ---------------------------------------------------------------------------

// Defines gesture groups, which trigger tactile feedback automatically.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::SetFeedbackForGroupsL( TUint aGestureGroups )

    {

    iRecognitionEngine->SetFeedbackForGroupsL( aGestureGroups );

    }

// ---------------------------------------------------------------------------

// Defines gesture types, which trigger tactile feedback automatically.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::SetFeedbackForTypesL(

    TAknTouchGestureFwGroup aGestureGroup,

    TUint aGestureTypesForTactile,

    TUint aGestureTypesForAudio )

    {

    iRecognitionEngine->SetFeedbackForTypesL( aGestureGroup,

        aGestureTypesForTactile, aGestureTypesForAudio );

    }

// ---------------------------------------------------------------------------

// EnableTestingFeatures

// ---------------------------------------------------------------------------

//    

void CAknTouchGestureFwImpl::EnableTestingFeatures()

    {

    iRecognitionEngine->EnableTestingFeatures();

    }

// ----------------------------------------------------------------------------

// C++ Constructor

// ---------------------------------------------------------------------------

//

CAknTouchGestureFwImpl::CAknTouchGestureFwImpl( CCoeControl* aControl )

    :

    iMonitoringWs( EFalse ),

    iCoeEnv( CCoeEnv::Static() ),

    iSubscriberControl( aControl ),

    iWindowControl( NULL ),

    iRecognitionEngine( NULL )

    {

    }

// ---------------------------------------------------------------------------

// Symbian second-phase constructor.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::ConstructL(

    MAknTouchGestureFwObserver& aObserver )

    {

    SetSubscriberControlL( iSubscriberControl );

    iRecognitionEngine =

        CAknTouchGestureFwRecognitionEngine::NewL( aObserver,

            iSubscriberControl );

    iCoeEnv->AddForegroundObserverL( *this );

    }

// ---------------------------------------------------------------------------

// Handles pointer events.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::HandlePointerEventL(

    const TPointerEventData& aPointerData )

    {

#ifdef GFW_DEBUG_TRACE_INPUTOUTPUT

    AknTouchGestureFwUtils::DumpPointerEvent( aEvent, aPointerData.iSimulated );

#endif // GFW_DEBUG_TRACE_INPUTOUTPUT

    const TPointerEvent event = aPointerData.iPointerEvent;

    TInt pointerNumber = 0;

    if ( event.IsAdvancedPointerEvent() )

        {

        pointerNumber = event.AdvancedPointerEvent()->PointerNumber();

        }

    __ASSERT_ALWAYS( pointerNumber >= 0, User::Invariant() );

    __ASSERT_ALWAYS( pointerNumber <= 1, User::Invariant() );

    iRecognitionEngine->HandlePointerEventL( aPointerData );

   }

// ---------------------------------------------------------------------------

// Cancels ongoing recognition.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::CancelRecognition()

    {

    iRecognitionEngine->CancelRecognizing();

    }

// ---------------------------------------------------------------------------

// Enables the necessary events for the subscriber control's window.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::EnableAdditionalEvents()

    {

    // Additional pointer events are needed for the following gesture groups

    TUint gestureInterest( GestureInterest() );

    TBool multiEventsNeeded = gestureInterest & EAknTouchGestureFwGroupPinch;

    TBool dragEventsNeeded =

        gestureInterest & ( EAknTouchGestureFwGroupFlick |

                            EAknTouchGestureFwGroupDrag |

                            EAknTouchGestureFwGroupPinch );

    // Enables drag events and advanced pointer events for window if needed

    if ( iWindowControl )

        {

        RDrawableWindow* window = iWindowControl->DrawableWindow();

        if ( window )

            {

            if ( dragEventsNeeded )

                {

                window->PointerFilter( EPointerFilterDrag, 0 );

                }

            if ( multiEventsNeeded )

                {

                window->EnableAdvancedPointers();

                }

            if ( dragEventsNeeded || multiEventsNeeded )

			    {

                // Set pointer grab when drag or multi pointer events are

                // needed to enable gesture recognition outside gesture control.

                window->SetPointerGrab( ETrue );

				}

            }

        }

    }

// ---------------------------------------------------------------------------

// Checks if pointer event is targeted to the gesture control.

// ---------------------------------------------------------------------------

//

TBool CAknTouchGestureFwImpl::PointerEventTargetedToControl(

    CCoeControl* aTargetControl,

    TPointerEvent& aEvent ) const

    {

    if ( !aTargetControl )

        {

        return EFalse;

        }

    TBool targetedToControl( EFalse );

    TBool eventInControl(

            iSubscriberControl->Rect().Contains( aEvent.iPosition ) );

    // Check if target control is gesture control's window control.

    targetedToControl = aTargetControl == iWindowControl;

    // Check that pointer is in gesture control area.

    if ( targetedToControl &&

         aEvent.iType == TPointerEvent::EButton1Down )

        {

        targetedToControl = eventInControl;

        }

    // Check if pointer is targeted to child window that is on gesture

    // control area.

    else if ( !targetedToControl && eventInControl )

        {

        CCoeControl* windowControl( aTargetControl );

        while ( windowControl )

            {

            windowControl = windowControl->Parent();

            if ( windowControl == iWindowControl )

                {

                targetedToControl = ETrue;

                ConvertPositionToControlWindow(

                        aTargetControl->DrawableWindow(),

                        aEvent.iPosition );

                break;

                }

            }

        }

    return targetedToControl;

    }

// ---------------------------------------------------------------------------

// Converts position in window area according to control window coordinates.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::ConvertPositionToControlWindow(

    RDrawableWindow* aWindow,

    TPoint& aPosition ) const

    {

    if ( aWindow )

        {

        TPoint targetPosition( aWindow->AbsPosition() );

        TPoint windowPosition(

                iWindowControl->DrawableWindow()->AbsPosition() );

        aPosition.iX = aPosition.iX + targetPosition.iX - windowPosition.iX;

        aPosition.iY = aPosition.iY + targetPosition.iY - windowPosition.iY;

        }

    }

// ---------------------------------------------------------------------------

// Called when the application gains foreground.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::HandleGainingForeground()

    {

#ifdef GFW_DEBUG_TRACE_INPUTOUTPUT

    _LIT( KAknTouchGainForeground, "[GFW] IN GAIN FOREGROUND" );

    RDebug::Print( KAknTouchGainForeground );

#endif

    if ( !iMonitoringWs && GestureInterest() != EAknTouchGestureFwNoGroup )

        {

        TRAP_IGNORE( iCoeEnv->AddMessageMonitorObserverL( *this ) );

        iMonitoringWs = ETrue;

        }

    }

// ---------------------------------------------------------------------------

// Called when the application loses foreground.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::HandleLosingForeground()

    {

#ifdef GFW_DEBUG_TRACE_INPUTOUTPUT

    _LIT( KAknTouchLostForeground, "[GFW] IN LOST FOREGROUND" );

    RDebug::Print( KAknTouchLostForeground );

#endif

    // Reset framework state because it might be possible that

    // pointer is down when framework loses background.

    // In this situation corresponding up-event is never received

    // and framework stays to wrong state (assuming pointer is still down)

    // without resetting it.

    CancelRecognition();

    if ( iMonitoringWs )

        {

        iCoeEnv->RemoveMessageMonitorObserver( *this );

        iMonitoringWs = EFalse;

        }

    }

// ---------------------------------------------------------------------------

// Handles window server messages.

// ---------------------------------------------------------------------------

//

void CAknTouchGestureFwImpl::MonitorWsMessage( const TWsEvent& aEvent )

    {

    if ( aEvent.Type() == EEventPointer )

        {

        CCoeControl* targetControl =

            reinterpret_cast<CCoeControl*>( aEvent.Handle() );

        TAdvancedPointerEvent event( *aEvent.Pointer() );

        TBool targetedToControl( PointerEventTargetedToControl(

                targetControl, event ) );

        TPointerEventData pointerData( event, 

                                       event.PointerNumber(), 

                                       aEvent.Time(), 

                                       EFalse, 

                                       targetedToControl );

        TRAP_IGNORE( HandlePointerEventL( pointerData ) );

        }

    else if ( aEvent.Type() == EEventScreenDeviceChanged )

        {

        // Cancel recognition if layout changes

        CancelRecognition();

        }

    }

// End of File