/*

* 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 utility functions.

*

*/

#include <akntouchgesturefwevents.h>

#include "akntouchgesturefwutils.h"

#include "akntouchgesturefwdefs.h"

using namespace AknTouchGestureFw;

_LIT(KAknTouchPointerEventDown, "[GFW] IN P%d DOWN (%d, %d) %S");

_LIT(KAknTouchPointerEventDrag, "[GFW] IN P%d DRAG (%d, %d) %S");

_LIT(KAknTouchPointerEventUp, "[GFW] IN P%d UP (%d, %d) %S");

_LIT(KAknTouchPointerEventHw, "HW");

_LIT(KAknTouchPointerEventSimulated, "SM");

_LIT(KAknTouchGestureGeneric, "[GFW] OUT S:%d G:%x T:%x %%:%d");

_LIT(KAknTouchGesturePointer,

        "[GFW] ... %d: SP:(%d,%d) CP:(%d,%d) PP:(%d,%d) S:(%d,%d)");

// ======== MEMBER FUNCTIONS ========

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

// TPointerEventData::TPointerEventData

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

//

AknTouchGestureFw::TPointerEventData::TPointerEventData(

        TPointerEvent& aPointerEvent,

        TInt aPointerNumber,

        const TTime& aTimeStamp,

        TBool aSimulated,

        TBool aTargetedToControl )

    : iPointerEvent( aPointerEvent ),

      iPointerNumber( aPointerNumber ),

      iTimeStamp( aTimeStamp ),

      iSimulated( aSimulated ),

      iTargetedToControl( aTargetedToControl )

    {

    }

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

// TPointEntry::TPointEntry

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

//

TPointEntry::TPointEntry( const TPoint& aPos, const TTime& aTime )

    :  iPos( aPos ), iTime( aTime )

    {

    }

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

// TPointEntry::TPointEntry

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

//

TPointEntry::TPointEntry()

    : iPos( TPoint() ), iTime( TTime() )

    {

    }

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

// TVector::TVector

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

//

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

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

    iY( aTo.iY - aFrom.iY )

    {

    }

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

// TVector::TVector

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

//

TVector::TVector( TReal aDeltaX, TReal aDeltaY )

    : iX( aDeltaX ), iY( aDeltaY )

    {

    }

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

// TVector::TVector

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

//

TVector::TVector()

    : iX( 0 ), iY( 0 )

    {

    }

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

// TVector::Angle

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

//

TInt TVector::Angle() const

    {

    TReal angle = 0;

    TReal length = Length();

    if ( Abs( length ) > KEpsilon )

        {

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

        if ( iY < 0 )

            {

            angle = 2 * KPi - angle;

            }

        }

    return Degrees( angle );

    }

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

// TVector::Length

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

//

TReal TVector::Length() const

    {

    TReal length = 0;

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

    return length;

    }

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

// static TVector::Degrees

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

//

TInt TVector::Degrees( TReal aRadians )

    {

    return aRadians * 180 / KPi;

    }

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

// TThresholdArea::TThresholdArea

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

//

TThresholdArea::TThresholdArea()

    : iInitialPosition(), iActive( EFalse )

    {

    Reset();

    }

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

// TThresholdArea::Reset

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

//

void TThresholdArea::Reset()

    {

    iInitialPosition = TPoint();

    iActive = EFalse;

    }

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

// TThresholdArea::IsActive

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

//

TBool TThresholdArea::IsActive() const

    {

    return iActive;

    }

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

// TThresholdArea::InitialPosition

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

//

TPoint TThresholdArea::InitialPosition() const

    {

    TPoint position;

    if ( iActive )

        {

        position = iInitialPosition;

        }

    return position;

    }

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

// TThresholdArea::Start

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

//

void TThresholdArea::Start( const TPoint& aInitialPosition )

    {

    iInitialPosition = aInitialPosition;

    iActive = ETrue;

    }

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

// TThresholdArea::Check

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

//

TBool TThresholdArea::Check( const TPoint& aNewPosition, TInt aMargin ) const

    {

    TBool crossed = EFalse;

    if ( iActive )

        {

        TInt deltaX = aNewPosition.iX - iInitialPosition.iX;

        TInt deltaY = aNewPosition.iY - iInitialPosition.iY;

        deltaX = Abs( deltaX );

        deltaY = Abs( deltaY );

        crossed = deltaX > aMargin || deltaY > aMargin;

        }

    return crossed;

    }

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

// Dumps pointer event data to the debug output.

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

//

void AknTouchGestureFwUtils::DumpPointerEvent( const TPointerEvent& aEvent,

                                               TBool aSimulated )

    {

    TInt pointerNumber = 0;

    if ( aEvent.IsAdvancedPointerEvent() )

        {

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

        }

    const TDesC* source;

    if ( aSimulated )

        {

        source = &KAknTouchPointerEventSimulated;

        }

    else

        {

        source = &KAknTouchPointerEventHw;

        }

    switch ( aEvent.iType )

        {

    case TPointerEvent::EButton1Down:

        RDebug::Print(KAknTouchPointerEventDown, pointerNumber,

                aEvent.iPosition.iX, aEvent.iPosition.iY, source);

        break;

    case TPointerEvent::EDrag:

        RDebug::Print(KAknTouchPointerEventDrag, pointerNumber,

                aEvent.iPosition.iX, aEvent.iPosition.iY, source);

        break;

    case TPointerEvent::EButton1Up:

        RDebug::Print(KAknTouchPointerEventUp, pointerNumber,

                aEvent.iPosition.iX, aEvent.iPosition.iY, source);

        break;

    default:

        break;

        }

    }

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

// Dumps gesture event data to the debug output.

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

//

void AknTouchGestureFwUtils::DumpGestureEvent(

    MAknTouchGestureFwEvent& aEvent )

    {

    TInt movement( 0 );

    TPoint startPos;

    TPoint currentPos;

    TPoint previousPos;

    TPoint speed;

    TAknTouchGestureFwState state( EAknTouchGestureFwOn );

    switch ( aEvent.Group() )

        {

    case EAknTouchGestureFwGroupTap:

        {

        MAknTouchGestureFwTapEvent* tap =

            static_cast<MAknTouchGestureFwTapEvent*>( &aEvent );

        startPos = tap->Position();

        }

        break;

    case EAknTouchGestureFwGroupFlick:

        {

        MAknTouchGestureFwFlickEvent* flick =

            static_cast<MAknTouchGestureFwFlickEvent*>( &aEvent );

        startPos = flick->Position();

        speed = flick->Speed();

        }

        break;

    case EAknTouchGestureFwGroupDrag:

        {

        MAknTouchGestureFwDragEvent* drag =

            static_cast<MAknTouchGestureFwDragEvent*>( &aEvent );

        startPos = drag->StartPosition();

        currentPos = drag->CurrentPosition();

        previousPos = drag->PreviousPosition();

        state = drag->State();

        }

        break;

    case EAknTouchGestureFwGroupPinch:

        {

        MAknTouchGestureFwPinchEvent* pinch =

            static_cast<MAknTouchGestureFwPinchEvent*>( &aEvent );

        movement = pinch->Movement();

        state = pinch->State();

        }

        break;

    default:

        break;

        }

    RDebug::Print( KAknTouchGestureGeneric,

            state, aEvent.Group(),

            aEvent.Type(), movement );

    RDebug::Print(KAknTouchGesturePointer, 0,

            startPos.iX, startPos.iY, currentPos.iX, currentPos.iY,

            previousPos.iX, previousPos.iY, speed.iX, speed.iY );

    }

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

// TDirectionTracer::TDirectionTracer

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

//

TDirectionTracer::TDirectionTracer()

    : iDirection( EDirectionNeutral ), iDirectionChanged( EFalse ), 

      iChangeDirection( EDirectionNeutral ), iChangeCounter( 0 )

    {    

    }

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

// TDirectionTracer::Reset

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

//

void TDirectionTracer::Reset()

    {

    iDirection = EDirectionNeutral;

    iDirectionChanged = EFalse;

    iChangeDirection = EDirectionNeutral;

    iChangeCounter = 0;

    }

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

// TDirectionTracer::Update

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

//

void TDirectionTracer::Update( TInt aDelta, TInt aSensitivity )

    {

    iDirectionChanged = EFalse;

    if ( !aDelta )

        {

        return; // no change, cannot determine direction

        }

    if ( iDirection == EDirectionNeutral )

        {

        TDirection direction = EDirectionNeutral;

        if ( aDelta > 0 )

            {

            direction = EDirectionPositive;

            }

        else

            {

            direction = EDirectionNegative;

            }

        if ( direction == iChangeDirection )

            {

            iChangeCounter++;

            if ( iChangeCounter >= aSensitivity )

                {

                iDirection = iChangeDirection;

                iDirectionChanged = ETrue;

                iChangeCounter = 0;

                }

            }

        else

            {

            iChangeDirection = direction;

            iChangeCounter = 0;

            iChangeCounter++;

            }

        }

    else if ( iDirection == EDirectionPositive )

        {

        // Subsequent direction changes require a couple of movement

        // to same direction

        if ( CheckDirectionChange( -aDelta, aSensitivity, iChangeCounter ) )

            {

            iDirection = EDirectionNegative;

            iDirectionChanged = ETrue;                            

            }

        }

    else // iDirection == EDirectionNegative

        {

        // Subsequent direction changes require a couple of movement

        // to same direction

        if ( CheckDirectionChange( aDelta, aSensitivity, iChangeCounter ) )

            {

            iDirection = EDirectionPositive;

            iDirectionChanged = ETrue;

            }

        }

    }

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

// TDirectionTracer::IsDirectionChanged

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

//

TBool TDirectionTracer::IsDirectionChanged() const

    {

    return iDirectionChanged;

    }

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

// TDirectionTracer::Direction

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

//

TDirectionTracer::TDirection TDirectionTracer::Direction() const

    {

    return iDirection;

    }

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

// TDirectionTracer::CheckDirectionChange

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

//

TBool TDirectionTracer::CheckDirectionChange(

        TInt aDelta, TInt aSensitivity, TInt& aCounter)

    {

    TBool directionChanged = EFalse;

    if ( aDelta > 0 )

        {

        aCounter++;

        }

    else

        {

        aCounter = 0;

        }

    if ( aCounter >= aSensitivity )

        {

        aCounter = 0;

        directionChanged = ETrue;

        }

    return directionChanged;

    }

// End of File