/*

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

*

*/

#include <e32math.h>

#include "xngesturerecogniser.h"

#include "xngesturedefs.h"

#include "xnpointarray.h"

using namespace XnGestureHelper;

/**

 * Vector class (math)

 */

NONSHARABLE_CLASS( TVector )

    {

public:

    /**

     * Constructor

     * @param aFrom starting point of the vector

     * @param aTo ending point of the vector

     */

    TVector( const TPoint& aFrom, const TPoint& aTo )

            : iX( aTo.iX - aFrom.iX ),

              iY( aTo.iY - aFrom.iY )

        {

        }

    /** @return angle of the vector */

    TReal Angle() const

        {

        TReal angle = 0;

        TReal length = Length();

        if ( length != 0 )

            {

            Math::ACos( angle, iX / Length() );

            if ( iY < 0 )

                {

                angle = 2 * KPi - angle;

                }

            }

        return Degrees( angle );

        }

    /** @return length of the vector */

    TReal Length() const

        {

        TReal length = 0;

        Math::Sqrt( length, iX * iX + iY * iY );

        return length;

        }

private:

    /** @return radians in degrees */

    inline TReal Degrees( TReal aRadians ) const

        {

        return aRadians * 180 / KPi;

        }

public:

    /// x coordinate that represent the vector

    TReal iX;

    /// y coordinate that represent the vector

    TReal iY;

    };

/**

 * @return ETrue if points for a tap event

 */

inline TBool IsTap( const TXnPointArray& aPoints )

    {

    // with tap, the pointer is not allowed to leave the tap area and come back

    // therefore, gesture length is not an acceptable test for tap, as it tests

    // only the last point. therefore, check if *any* point is outside tap area.

    TInt i = aPoints.Count(); // latest point if most likely to be outside tap area

    while ( --i >= 0 )

        {

        // use the raw point (from which no axis has been filtered out)

        // because tap should consider both axes even when Code() ignores one axis

        if ( KSamePointTolerance < Abs( aPoints.Raw( i ).iX - aPoints.Raw( 0 ).iX ) ||

             KSamePointTolerance < Abs( aPoints.Raw( i ).iY - aPoints.Raw( 0 ).iY ) )

            {

            return EFalse;

            }

        }

    return ETrue;

    }

/**

 * @return Length of the gesture in points

 */

inline TReal GestureLength( const TXnPointArray& aPoints )

    {

    return TVector( aPoints[0], aPoints[aPoints.Count() - 1] ).Length();

    }

/**

 * @return ETrue if aAngleUnderTest is almost aAngle

 *         Closeness of the angles is controlled by KAngleTolerance

 */

static TBool IsNear( TReal aAngleUnderTest, TReal aAngle )

    {

    return aAngle - KAngleTolerance <= aAngleUnderTest &&

           aAngleUnderTest <= aAngle + KAngleTolerance;

    }

/**

 * @return the angle as a direction flags of TGesture

 */

inline TXnGestureCode Direction( TReal aAngle )

    {

    TXnGestureCode direction = EGestureUnknown;

    if ( IsNear( aAngle, 90.0 ) )

        {

        direction = EGestureSwipeDown;

        }

    else if ( IsNear( aAngle, 180.0 ) )

        {

        direction = EGestureSwipeLeft;

        }

    else if ( IsNear( aAngle, 270.0 ) )

        {

        direction = EGestureSwipeUp;

        }

    else if ( 360.0 - KAngleTolerance <= aAngle || aAngle <= KAngleTolerance )

        {

        direction = EGestureSwipeRight;

        }

    else // for lint warning

        {

        // unknown angle

        }

    return direction;

    }

/** @return direction between points */

inline TXnGestureCode Direction( const TPoint& aFromPoint, const TPoint& aToPoint )

    {

    return Direction( TVector( aFromPoint, aToPoint ).Angle() );

    }

/** @return overall direction between points */

static TXnGestureCode GeneralDirection( const TXnPointArray& aPoints )

    {

    return Direction( aPoints[0], aPoints[aPoints.Count() - 1]);

    }

/**

* @return the last received point that is different that the latest point,

*         or first point if no point is different than latest

*/

inline TPoint PreviousPoint( const TXnPointArray& aPoints )

    {

    TPoint latestPoint = aPoints[aPoints.Count() - 1];

    TInt i = aPoints.Count() - 1;

    while ( --i >= 0 )

        {

        if ( latestPoint != aPoints[i] )

            {

            return aPoints[i];

            }

        }

    return aPoints[0];

    }

/** @return direction between last two points */

inline TXnGestureCode LastDirection( const TXnPointArray& aPoints )

    {

    if ( aPoints.Count() > 1 )

        {

        // return direction between latest and previous points.

        // pick the previous point that is different than the last point

        // because while using an x or y filter array, more than one

        // sequential points may look like the same point because

        // the differing coordinate coordinate is filtered out. For example,

        // if dragging left and slightly up, many y coordinates will have the

        // same value, while only x differs.

        return Direction( PreviousPoint( aPoints ), aPoints[aPoints.Count() - 1] );

        }

    return EGestureUnknown;

    }

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

// Return gesture code of a gesture formed by a sequence of points

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

//

TXnGestureCode TXnGestureRecogniser::GestureCode( const TXnPointArray& aPoints ) const

    {

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

    if (aPoints.Count() <= 0)

        return EGestureUnknown;

    if ( IsTap( aPoints ) )

        {

        return EGestureTap;

        }

    if ( GestureLength( aPoints ) >= KMinSwipeLength )

        {

        TXnGestureCode direction = GeneralDirection( aPoints );

        if ( direction != LastDirection( aPoints ) )

            {

            direction = EGestureUnknown;

            }

        return direction;

        }

    // the pointer was moved but was either not moved far enough, or was

    // brought back to close to the starting point

    return EGestureUnknown;

    }