/*

* Copyright (c) 2008-2008 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:  Gesture class

*

*/

#include "gesture.h"

#include <e32math.h>

#include "gesturedefs.h"

#include "utils.h"

using namespace GestureHelper;

/** 

 * Point array for which only x axis is relevant

 */

class TXAxisPointArray : public TPointArray

    {

public:

    TXAxisPointArray( const RArray< TPointEntry >& aPoints )

            : TPointArray( aPoints ) {}

    // from TPointArray

    TPoint operator[]( TInt aIndex ) const 

        {

        return TPoint( Raw( aIndex ).iX, 0 );

        }

    };

/** 

 * Point array for which only y axis is relevant

 */

class TYAxisPointArray : public TPointArray

    {

public:

    TYAxisPointArray( const RArray< TPointEntry >& aPoints )

            : TPointArray( aPoints ) {}

    // from TPointArray

    TPoint operator[]( TInt aIndex ) const 

        {

        return TPoint( 0, Raw( aIndex ).iY );

        }

    };

namespace 

    {

    /** @return the current time */

    TTime CurrentTime()

        {

        TTime time;

        time.UniversalTime();

        return time;

        }

    /**

     * @param aRelevantAxis See @ref MGestureEvent::Code

     * @return gesture code by analysing the sequence of points

     */

    TGestureCode CodeFromPoints( const RArray< TPointEntry >& aPoints, 

            MGestureEvent::TAxis aRelevantAxis ) 

        {

        // select the correct filter based on aRelevantAxis

        // these filter_ objects are array decorators that will eliminate either 

        // x, y or neither coordinate of each point

        TXAxisPointArray filterY( aPoints );

        TYAxisPointArray filterX( aPoints );

        TPointArray filterNone( aPoints );

        TPointArray& filter = 

            aRelevantAxis == MGestureEvent::EAxisHorizontal ? static_cast< TPointArray& >( filterY ) : 

            aRelevantAxis == MGestureEvent::EAxisVertical   ? static_cast< TPointArray& >( filterX ) :

            /* otherwise EAxisBoth */                         filterNone;

        // currently the gesture recogniser does not have any state, so it is fast

        // to instantiate. The call is not static however, to allow the recogniser

        // to be replaced by a more complicated implementation that has state.

        // then it may make sense to make the recogniser a member variable.

        return TGestureRecogniser().GestureCode( filter, aRelevantAxis );

        }

    /**

     * @param aPoints Sequence of points representing 1st pointer movement

     * @param aSecondaryPoints Sequence of points representing 2nd pointer movement

     * @param aPreviousDistance contains the previous distance aftre this function execution 

     * @return gesture code by analysing the sequence of points

     */

    TGestureCode MultiTouchCode( const RArray< TPointEntry >& aPoints, 

            const RArray< TPointEntry >& aSecondaryPoints, TInt aPreviousDistance, TBool aIsFirstPinch ) 

        {

        TPointArray filter(aPoints);

        TPointArray secondaryFilter(aSecondaryPoints);

        return TGestureRecogniser().MultiTouchGestureCode( filter, secondaryFilter, aPreviousDistance, aIsFirstPinch );

        }

    } // unnamed namespace

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

// constructor

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

//

CGesture::CGesture()

    {

    iPinchStartDistance = -1;

    iPinchEndDistance = -1;

    iPinchDetected = EFalse ; 

    }

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

// destructor

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

//

CGesture::~CGesture()

    {

    iPoints.Close();

    iSecondaryPoints.Close();

    }

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

// AsStartEventL

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

//

CGesture* CGesture::AsStartEventLC() const

    {

    __ASSERT_DEBUG( 0 < iPoints.Count(), Panic( EGesturePanicIllegalLogic ) );

    CGesture* gesture = new ( ELeave ) CGesture;

    CleanupStack::PushL( gesture );

    User::LeaveIfError( gesture->AddPoint( iPoints[0].iPos ) );

    return gesture;

    }

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

// ResetToLastPoint

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

//

void CGesture::ResetToLastPoint(TBool aSetPointerZero,TBool aSetToZero)

    {

    TPointEntry lastEntry(TPoint(0,0),TTime());

    if( aSetToZero )

        {

        __ASSERT_DEBUG( 0 < iPoints.Count(), Panic( EGesturePanicIllegalLogic ) );

        lastEntry = LastPoint( iPoints);

        }

    else

        {

        __ASSERT_DEBUG( 0 < iSecondaryPoints.Count(), Panic( EGesturePanicIllegalLogic ) );

        lastEntry = LastPoint( iSecondaryPoints);

        }

    Reset();

    if( aSetPointerZero )

        {

        iPoints.Append(lastEntry);

        }

    else

        {

        iSecondaryPoints.Append(lastEntry);  

        }     

    }

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

// LastPoint

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

//

inline const TPointEntry CGesture::LastPoint( const RArray< TPointEntry >& aPoints ) const

    {

    return aPoints[aPoints.Count() - 1];

    }

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

// IsPinchToleranceHigh

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

//

inline TBool CGesture::IsHighPinchTolerance() const

    {

    if( iPinchEndDistance == -1 )

        {

        return ETrue;

        }

    else

        {

        TInt currentDistance = TGestureRecogniser().Length( LastPoint(iPoints).iPos, LastPoint(iSecondaryPoints).iPos );

        // if previously zooming out and current distance corresponds to zooming in or viceversa

        if( ( iZoomState == EZoomOut && currentDistance < iPinchStartDistance) || 

                ( iZoomState == EZoomIn && currentDistance > iPinchStartDistance))

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// Reset

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

//

void CGesture::Reset()

    {

    iPoints.Reset();

    iSecondaryPoints.Reset();

    iHoldingState = ENotHolding;

    iState = ENotActive;

    iHoldingPointIndex = 0;

    iVisual = NULL;

    iIsDoubleTap = EFalse;

    iPinchStartDistance = -1;

    iPinchEndDistance = -1;

    iPinchDetected = EFalse;

    iZoomState = ENoZoom;

    }

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

// IsEmpty

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

//

TBool CGesture::IsEmpty() const

    {

    return iPoints.Count() == 0;

    }

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

// IsMultiTouch

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

//

TBool CGesture::IsMultiTouch() const

    {

    return iSecondaryPoints.Count() == 0;

    }

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

// Add a point to the sequence of points that together make up the gesture

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

//

TInt CGesture::AddPoint( const TPoint& aPoint )

    {

    if ( !IsLatestPoint( aPoint ) )

        {

        return iPoints.Append( TPointEntry( aPoint, CurrentTime() ) );

        }

    return KErrNone;

    }

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

// AddSecondaryPoint

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

//

TInt CGesture::AddSecondaryPoint( const TPoint& aPoint )

    {

    if ( !IsLatestSecondaryPoint( aPoint ) )

        {

        return iSecondaryPoints.Append( TPointEntry( aPoint, CurrentTime() ) );

        }

    return KErrNone;

    }

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

// SetVisual

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

//

void CGesture::SetVisual( CAlfVisual* aVisual )

    {

    iVisual = aVisual;

    }

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

// IsNearHoldingPoint

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

//

TBool CGesture::IsNearHoldingPoint( const TPoint& aPoint ) const

    {

    return ToleranceRect( iPoints[ iHoldingPointIndex ].iPos ).Contains( aPoint );

    }

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

// IsLatestPoint

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

//

TBool CGesture::IsLatestPoint( const TPoint& aPoint ) const

    {

    if ( iPoints.Count() > 0 )

        {

        return aPoint == CurrentPos();

        }

    return EFalse;

    }

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

// IsLatestSecondaryPoint

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

//

TBool CGesture::IsLatestSecondaryPoint( const TPoint& aPoint ) const

    {

    if ( iSecondaryPoints.Count() > 0 )

        {

        return aPoint == iSecondaryPoints[ iSecondaryPoints.Count() - 1 ].iPos;

        }

    return EFalse;

    }

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

// StartHolding

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

//

void CGesture::StartHolding()

    {

    iHoldingState = EHoldStarting;

    // remove all points that were introduced after holding started

    for ( TInt i = iPoints.Count() - 1; i > iHoldingPointIndex; i-- )

        {

        iPoints.Remove( i );

        }

    }

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

// SetHoldingPoint

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

//

void CGesture::SetHoldingPoint()

    {

    iHoldingPointIndex = iPoints.Count() - 1;

    }

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

// ContinueHolding

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

//

void CGesture::ContinueHolding()

    {

    iHoldingState = EHolding;

    }

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

// SetSingleTouchActive

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

//

void CGesture::SetSingleTouchActive()

    {

    __ASSERT_DEBUG( ENotActive == iState, Panic( EGesturePanicIllegalLogic ) );

    iState = ESingleTouchActive;

    }

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

// SetMultiTouchActive

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

//

void CGesture::SetMultiTouchActive()

    {

    iState = EMultiTouchActive;

    iIsMultiTouched = ETrue;

    }

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

// SetSingleTouchReleased

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

//

void CGesture::SetSingleTouchReleased()

    {

    // IsMovementStopped expects corresponding SetComplete to be called before SetRelease

    __ASSERT_DEBUG( ESingleTouchComplete == iState, Panic( EGesturePanicIllegalLogic ) );

    iState = ESingleTouchReleased;

    iIsMultiTouched = EFalse;

    }

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

// SetMultiTouchReleased

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

//

void CGesture::SetMultiTouchReleased()

    {

    // IsMovementStopped expects corresponding SetComplete to be called before SetRelease

    __ASSERT_DEBUG( EMultiTouchComplete == iState, Panic( EGesturePanicIllegalLogic ) );

    iState = EMultiTouchReleased;

    }

/**

 * @return elapsed time between aStartTime and aEndTime

 */

inline TTimeIntervalMicroSeconds32 Elapsed( const TTime& aStartTime, 

                                            const TTime& aEndTime )

    {

    return aEndTime.MicroSecondsFrom( aStartTime ).Int64();

    }

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

// SetSingleTouchComplete

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

//

void CGesture::SetSingleTouchComplete()

    {

    __ASSERT_DEBUG( iPoints.Count() > 0, Panic( EGesturePanicIllegalLogic ) );

    iState = ESingleTouchComplete;

    iCompletionTime = CurrentTime();

    }

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

// SetMultiTouchComplete

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

//

void CGesture::SetMultiTouchComplete()

    {

    __ASSERT_DEBUG( iSecondaryPoints.Count() > 0, Panic( EGesturePanicIllegalLogic ) );

    iState = EMultiTouchComplete;

    }

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

// SetCancelled

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

//

void CGesture::SetCancelled()

    {

    iState = ECancelled;

    }

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

// SetDoubleTap

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

//

void CGesture::SetDoubleTap() 

    { 

    iIsDoubleTap = ETrue; 

    }

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

// IsTap

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

//

TBool CGesture::IsTap() const

    {

    if(iIsMultiTouched)

        {

        return EFalse;

        }

    return CodeFromPoints( iPoints, EAxisBoth ) == EGestureTap;

    }

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

// IsPinch

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

//

TBool CGesture::IsPinch()

    {

    if (iPinchStartDistance  == -1 )

        {

        iPinchStartDistance = TGestureRecogniser().Length( iPoints[0].iPos, iSecondaryPoints[0].iPos ) ;

        }

    // if there is a pinch detected in the last attempt then update the start distance.

    // henceforth this new distance is used as reference for calculating the pinch.

    if( iPinchDetected )

        {

        iPinchStartDistance = iPinchEndDistance;

        }

    iPinchDetected = MultiTouchCode( iPoints, iSecondaryPoints, iPinchStartDistance,IsHighPinchTolerance()) == EGesturePinch;

    if( iPinchDetected )

        {

        // This end distance is updated the first time the pinch is detected.

        // This is done the save the value of pinch end distnce for further refernce to

        // update the pinch start distance next time any pointer position changes.

        iPinchEndDistance = TGestureRecogniser().Length( 

                LastPoint(iPoints).iPos,LastPoint(iSecondaryPoints).iPos );

        iZoomState = iPinchEndDistance > iPinchStartDistance ? EZoomOut : EZoomIn;

        }

    return iPinchDetected;

    }

/**

 * Translates a non-holding code into a holding code

 * @param aCode original gesture code

 * @return a gesture code with hold flag applied

 */

inline TGestureCode Hold( TGestureCode aCode )

    {

    if ( aCode != EGestureStart && 

         aCode != EGestureDrag && 

         aCode != EGestureReleased && 

         aCode != EGestureUnknown )

        {

        return static_cast< TGestureCode >( aCode | EFlagHold );

        }

    return aCode;

    }

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

// Code

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

//

TGestureCode CGesture::Code( TAxis aRelevantAxis ) const

    {

    switch ( iState )

        {

        case ESingleTouchActive:           

            // "start" event if only first point received

            // need to check that not holding, in case user pressed stylus

            // down, and activated holding without moving the stylus

            if ( iPoints.Count() == 1 && !IsHolding() )

                {

                return EGestureStart;

                }

            // "drag" event if holding not started or holding started earlier

            else if ( iHoldingState != EHoldStarting )

                {

                // select the correct filter based on aRelevantAxis

                // these filter_ objects are array decorators that will eliminate either 

                // x, y or neither coordinate of each point

                TXAxisPointArray filterY( iPoints );

                TYAxisPointArray filterX( iPoints );

                TPointArray filterNone( iPoints );

                TPointArray& filter = 

                    aRelevantAxis == MGestureEvent::EAxisHorizontal ? static_cast< TPointArray& >( filterY ) : 

                    aRelevantAxis == MGestureEvent::EAxisVertical   ? static_cast< TPointArray& >( filterX ) :

                    /* otherwise EAxisBoth */                         filterNone;

                return TGestureRecogniser().ValidateDrag( filter, aRelevantAxis );

                }

            // holding was just started

            else 

                {

                return Hold( CodeFromPoints( iPoints, aRelevantAxis ) );

                }

        case EMultiTouchActive: