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

#ifndef _GESTURE_H_
#define _GESTURE_H_

#include <e32base.h>

#include "gestureobserver.h"
#include "gesturerecogniser.h"
#include "pointarray.h"

namespace GestureHelper
{

/**  
 * TGesture represents the gesture that the user has made.
 * Implements MGestureEvent interface to allow clients to 
 * inspect the gesture
 */
NONSHARABLE_CLASS( CGesture ) : public CBase, public MGestureEvent
    {
public:
    /** constructor */
     CGesture();
    /** destructor */
    ~CGesture();
    
    /** 
     * @return a new gesture that will have only the first point
     * of this gesture. Can be used to create gesture's a "start" event
     * after some other points have been received. 
     */ 
    CGesture* AsStartEventLC() const;
    
    /** 
     * Sets the gesture as empty. resets timers to receive points
     * immediately
     */
    void Reset();
    
    /** @return ETrue if the gesture has no points */
    TBool IsEmpty() const;
    
    /** @return ETrue if there are no points in the second array */
    TBool IsMultiTouch() const;
    
    /**
     * Add a point to the sequence of points that forms the gesture
     * Call Reset() just before adding the first point
     * @param aPoint the point to add
     * @return error code
     */
    TInt AddPoint( const TPoint& aPoint );
 
    /**
     * Add a point to the sequence of points that forms the gesture
     * Adds the point to the secondray pointer array.
     * Used to add second pointer movement in case of multi touch
     * Call Reset() just before adding the first point
     * @param aPoint the point to add
     * @return error code
     */
    TInt AddSecondaryPoint( const TPoint& aPoint );
    
    /** Set the visual of this gesture. Should be called when gesture starts */
    void SetVisual( CAlfVisual* aVisual );
    
    /** @return ETrue if the point is very near the holding point */
    TBool IsNearHoldingPoint( const TPoint& aPoint ) const;
    /** Set the latest point as the holding point */
    void SetHoldingPoint();
    /** @return ETrue if aPoint is the same as point added last */
    TBool IsLatestPoint( const TPoint& aPoint ) const;
    /** @return ETrue if aPoint is the same as point added last in the secondary array */
    TBool IsLatestSecondaryPoint( const TPoint& aPoint ) const;
    
    /** 
     * After call, Code(...) will return appropriate holding gesture code.
     */
    void StartHolding();
    /** 
     * After call, Code(...) will return a "hold released" gesture code when
     * the gesture is completed. Meanwhile, code will be drag.
     */
    void ContinueHolding(); 
    /** Set as single touch gesture started */
    void SetSingleTouchActive();
    /** Set as multitouch gesture started */
    void SetMultiTouchActive();    
	/** Set as stylus released when there was only one stylus pressed */
    void SetSingleTouchReleased();
    /** Set as stylus released when there were two pointers, one pointer is still pressed down */
    void SetMultiTouchReleased();
    /** Set the single touch gesture as complete. Gesture is completed at pointer up */
    void SetSingleTouchComplete();
    /** Set the multitouch gesture as complete. Single touch still continues */
    void SetMultiTouchComplete();    
    /** After call, Code(...) will return a "cancelled" gesture code */
    void SetCancelled();
    
    /** force returning a code as double tap when gesture is complete */
    void SetDoubleTap();
    
    /** 
     * @return Whether the current gesture is a tap (and hence not a swipe)
     *         Does not consider holding or other state information (such as
     *         whether the gesture was just started or is dragging).  
     *         Results are based purely on the current stream of points.
     */ 
    TBool IsTap() const;
 
    /** 
     * Checks if the current points in primary and secondary pointer array results in
     * a pinch gesture. If yes updates the previous distance.
     * @return Whether the current gesture is a pinch
     *         Returns EFalse if multitouch is not active currently.  
     *         Results are based purely on the current stream of points.
     */ 
    TBool IsPinch();
    
    /** 
     * Reset all the events recieved in the current gesture.
     * Calls Reset() internally.
     * create a new points starting from the last point of the
     * earlier gesture
     * Used when the multitouch point is released to start the 
     * single touch operations.
     * @param aFirstPointer, Should reset to the first pointers last point or to the 2d pointers.
     *          false (2nd pointers last point) when multitouch is going on and user releases the first point and
     *          continues to hold the second point
     */ 
    void ResetToLastPoint(TBool aSetPointerZero,TBool aSetToZero); 
  
// From MGestureEvent
    TGestureCode Code( TAxis aRelevantAxis ) const;
    TBool IsHolding() const;
    TPoint StartPos() const;
    TPoint CurrentPos() const; 
    TRealPoint Speed() const;
    TRealPoint SpeedPercent( const TRect& aEdges ) const;
    TPoint Distance() const; 
    CAlfVisual* Visual() const;
    TInt PinchPercent() const;
    TPoint PinchCentrePoint()const;
    
private:
    /** @return elapsed time between the latest and previous points */
    inline TTimeIntervalMicroSeconds32 TimeFromPreviousPoint() const; 
    
    /** @return elapsed time between the latest and first points */
    inline TTimeIntervalMicroSeconds32 TimeFromStart() const; 
    
    /** @return ETrue if user has stopped moving the stylus before lifting it */
    inline TBool IsMovementStopped() const;
    
    /** @return aOffset'th last entry in the list of points */
    inline const TPointEntry& NthLastEntry( TInt aOffset ) const;
    
    /** @return previous point (may not be exactly the point before last) */
    inline const TPointEntry& PreviousEntry() const;
    
    /** @return position of point received just before the latest point */
    inline TPoint PreviousPos() const;
    
    /** @return the last point in the given pointer array */
    inline const TPointEntry LastPoint( const RArray< TPointEntry >& aPoints ) const;
    
    /** @return whether a slightly higher tolarence needs to be used for pinch or not*/
    inline TBool IsHighPinchTolerance() const;
    
private: 

    /// sequence of points that make up the gesture. own.
    /// Single touch pointer variations.
    RArray< TPointEntry > iPoints;
	
    /// sequence of points that make up the gesture. own.
    /// Second touch pointer variations.
    RArray< TPointEntry > iSecondaryPoints;
    
    /// index in iPoints of the point in which user started holding
    TInt iHoldingPointIndex;

    /// the different states that indicate whether user has made a holding gesture 
    enum THoldingState
        {
        ENotHolding = 0, // before holding activated (i.e., holding not activated)
        EHoldStarting,   // holding activated just now (lasts just one callback round)
        EHolding         // holding activated earlier 
        };
  
    /// state that indicates is user has held the pointer down in one position 
    /// for long time to indicate a holding gesture    
    THoldingState iHoldingState;
    
    /// Whether the gesture completion code will be forcefully overridden to be double tap,
    /// regardless of what the points are
    TBool iIsDoubleTap;
    
    /// If in the current gesture, there was a multi touch at any in between point.
    /// This is required, if after doing a multitouch, release one pointer and do some 
    /// operation with the other pointer still touched down. Though the new variations
    /// of pointer results in a tap, tap is not possible after a multitouch.
    TBool iIsMultiTouched;
        
    enum TCompletionState 
        {
        ENotActive = 0,
        ESingleTouchActive,
        EMultiTouchActive,
        ECancelled,
        EMultiTouchComplete,
        EMultiTouchReleased,
        ESingleTouchComplete,        
        ESingleTouchReleased       
        };
      
    /// gesture only becomes complete when user lifts the pointer
    TCompletionState iState;

    /// time when the stylus was lifted.
    TTime iCompletionTime;
    
    /// visual relevant to this gesture. null if not known.
    CAlfVisual* iVisual;
    
    /// The distance between the two points, at the time of last identified pinch gesture
    /// This will also be the start distance for next pinch. At start it will
    /// be the distance between touch down points
    TInt iPinchStartDistance;

    /// The distance between the two points, at the time of pinch identified
    TInt iPinchEndDistance;
    
    /// Pinch detcted, true for one cycle,untill a new point is recieved.
    TBool iPinchDetected;
 
    enum TZoomState 
        {
        ENoZoom = 0,
        EZoomOut,
        EZoomIn    
        };
  
    /// gesture only becomes complete when user lifts the pointer
    TZoomState iZoomState;
    
    };

} // namespace GestureHelper

#endif // _GESTURE_H_