/*

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

*

*/

#include "gesture.h"

#include <e32math.h>

#include <coemain.h>

#include "gesturedefs.h"

#include "utils.h"

using namespace RT_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.HomeTime();

        return time;

        }

    /**

     * @param aRelevantAxis See @ref MGestureEvent::Code

     * @return gesture code by analysing the sequence of points

     */

    TGestureCode CodeFromPoints( const RArray< TPointEntry >& aPoints, 

                                 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 == EAxisHorizontal ? static_cast< TPointArray& >( filterY ) : 

            aRelevantAxis == 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 );

        }

    } // unnamed namespace

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

// destructor

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

//

CGesture::~CGesture()

    {

    iPoints.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, CCoeEnv::Static()->LastEvent().Time()));

    return gesture;

    }

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

// Reset

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

//

void CGesture::Reset()

    {

    iPoints.Reset();

    iHoldingState = ENotHolding;

    iState = ENotComplete;

    iHoldingPointIndex = 0;

    iIsDoubleTap = EFalse;

    iIsLongTap = EFalse;

    }

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

// Reset

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

//

TBool CGesture::IsEmpty() const

    {

    return iPoints.Count() == 0;

    }

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

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

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

//

TInt CGesture::AddPoint( const TPoint& aPoint, const TTime& aEventTime )

    {

    if ( !IsLatestPoint( aPoint ) )

        {

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

        }

    return KErrNone;

    }

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

// SetVisual

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

//

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

// 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;

    }

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

// 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;

    }

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

// SetReleased

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

//

void CGesture::SetReleased()

    {

    // IsMovementStopped expects SetComplete to be called before SetRelea

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

    iState = EReleased;

    }

/**

 * @return elapsed time between aStartTime and aEndTime

 */

inline TTimeIntervalMicroSeconds32 Elapsed( const TTime& aStartTime, 

                                            const TTime& aEndTime )

    {

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

    }

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

// SetComplete

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

//

void CGesture::SetComplete()

    {

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

    iState = EComplete;

    iCompletionTime = CurrentTime();

    }

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

// SetComplete

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

//

void CGesture::SetCancelled()

    {

    iState = ECancelled;

    }

void CGesture::SetDoubleTap() 

    { 

    iIsDoubleTap = ETrue; 

    }

void CGesture::SetLongTap(TBool aLongTap) 

    { 

    iIsLongTap = aLongTap; 

    }

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

// IsTap

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

//

TBool CGesture::IsTap() const

    {

    return CodeFromPoints( iPoints, EAxisBoth ) == EGestureTap;

    }

/**

 * 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 */

    {

    TGestureCode code;

    switch ( iState )

        {

        case ENotComplete:

            {

            // "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() )

                {

                code = EGestureStart;

                }

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

            else if ( iHoldingState != EHoldStarting )

                {

                code = EGestureDrag; 

                }

            // holding was just started

            else 

                {

                code = Hold( CodeFromPoints( iPoints, aRelevantAxis ) );

                }

            iPrevGestureCode = code;

            break;

            }

        case EComplete:

            {

            if ( iIsDoubleTap )

                {

                code = EGestureDoubleTap;

                }

            else if ( iIsLongTap )

                {

                code = EGestureLongTap;

                }

            else if (iPrevGestureCode == EGestureDrag)

                {

                //code = IsFlick() ? EGestureFlick : EGestureDrop;

                if (IsFlick()) 

                    {

                    code = EGestureFlick ;

                    }

                  else

                    {

                    // Check if it is a swipe.  In this case a swipe is a gesture where 

                    // - the direction is close to the axes (up, down, left, right)

                    // - speed is slower than flick 

                    code = CodeFromPoints( iPoints, aRelevantAxis );

                    if (code == EGestureUnknown)    

                      {

                      code = EGestureDrop ; // It was not a swipe, so then it is the drop gesture 

                      }

                    }

                }

            else

                {

                code = CodeFromPoints( iPoints, aRelevantAxis );

                }

            iPrevGestureCode = code;

            break;

            }

        case EReleased:

            {

            code = EGestureReleased;

            break;

            }

        case ECancelled: // fallthrough

        default: 

            code = EGestureUnknown;

        }

    return code;

    }

TBool CGesture::IsFlick() const

    {

    bool flick = EFalse;

    TRealPoint speed = Speed();

    TReal32 xSpeed = speed.iX;

    TReal32 ySpeed = speed.iY;

    flick = (Abs(xSpeed) > KFlickSpeed || 

             Abs(ySpeed) > KFlickSpeed);

    return flick;

    }

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

// IsHolding

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

//

TBool CGesture::IsHolding() const

    {

    return iHoldingState >= EHoldStarting;

    }

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

// StartPos

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

//

TPoint CGesture::StartPos() const

    {

    // at least one point will be in the array during callback (pointer down pos)

    return iPoints[ 0 ].iPos;

    }

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

// CurrentPos

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

//

TPoint CGesture::CurrentPos() const

    {

    // at least on point will be in the array during callback (pointer down pos)

    return iPoints.Count() > 0 ? iPoints[ iPoints.Count() - 1 ].iPos : TPoint(-1, -1);

    }

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

// IsMovementStopped

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

//

inline TBool CGesture::IsMovementStopped() const

    {

    // iCompletionTime is only only valid if client has called SetComplete 

    if ( iState >= EComplete )

        {

        TInt el = Elapsed( NthLastEntry( 1 ).iTime, iCompletionTime ).Int(); 

        return el > KSpeedStopTime;

        }

    return EFalse;

    }

namespace 

    {

    const TInt KFloatingPointAccuracy = 0.000001;

    /** @return percentage (0.0-1.0) how far aPos is from aEdge1 towards aEdge2 */

    inline TReal32 Proportion( TReal32 aPos, TReal32 aEdge1, TReal32 aEdge2 )

        {

        if ( Abs( aEdge2 - aEdge1 ) > KFloatingPointAccuracy )

            {

            return ( aPos - aEdge1 ) / ( aEdge2 - aEdge1 );

            }

        return 0; // avoid division by zero 

        }

    /** Edges (pixels) at which speed should be -100% or 100% */

    NONSHARABLE_STRUCT( TEdges )

        {

        TReal32 iMin;

        TReal32 iMax;

        };

    /** 

     * scale which allows different (coordinate -> percentage) mapping

     * between -100% to 0% and 0 and 100%

     */

    NONSHARABLE_STRUCT( TScale )

        {

        TScale( TInt aZero, const TEdges& aEdges )

                : iMin( aEdges.iMin ), iZero( aZero ), iMax( aEdges.iMax )

            {

            }

        /** @return aPos as a percentage between -100% and 100% in aScale */

        TReal32 Percent( TReal32 aPos ) const;

        /// coordinate where speed is -100%

        TReal32 iMin;

        /// coordinate where speed is 0%

        TReal32 iZero;

        /// coordinate where speed is 100%

        TReal32 iMax;

        };

    /** @convert aPos into a percentage between -100% and 100% in aScale */

    TReal32 TScale::Percent( TReal32 aPos ) const

        {

        TReal32 percent;

        if ( aPos < iZero )

            {

            // return negative percentages on the lower side of zero point

            percent = -1 * Proportion( aPos, iZero, iMin );

            }

        else 

            {

            percent = Proportion( aPos, iZero, iMax );

            }

        // constrain between -100% and 100%

        return Min( Max( percent, -1.0F ), 1.0F );

        }

    /** Scale in x and y dimensions */

    NONSHARABLE_STRUCT( TScale2D )

        {

        TRealPoint Percent( const TPoint& aPos ) const

            {

            return TRealPoint( iX.Percent( aPos.iX ),

                               iY.Percent( aPos.iY ) );

            }

        TScale iX;

        TScale iY;

        };

    enum TDirection { ESmaller, ELarger };

    /** @return the direction of pos compared to the previous pos */

    inline TDirection Direction( TInt aPos, TInt aPreviousPos )

        {

        return aPos < aPreviousPos ? ESmaller : ELarger;    

        }

    /** Direction in x and y dimensions */

    NONSHARABLE_STRUCT( TDirection2D )

        {

        TDirection iX;

        TDirection iY;

        };

    /** Return the direction (up/down) of signal at aIndex */

    inline TDirection2D Direction( TInt aIndex, const RArray< TPointEntry >& aPoints )

        {

        const TPoint& pos = aPoints[ aIndex ].iPos;

        const TPoint& prevPos = aPoints[ aIndex - 1 ].iPos;

        TDirection2D dir = { Direction( pos.iX, prevPos.iX ),

                             Direction( pos.iY, prevPos.iY ) };