/*

* 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 "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:    Implementation of Zoom Event Handler

*

*/

// Avkon 

#include <eikon.hrh>

// Antariksh

#include <alf/alfutil.h>                    // AlfUtil

#include <mul/mulevent.h>                   //  For Slider events

//Photos Headers

#include <glxtracer.h>                      //  For Tracer

#include <glxlog.h>                         //  For Log

#include <mglxuicommandhandler.h>           //  For MGlxUiCommandHandler

#include <glxzoomeventhandler.h>

#include <glxzoommathsengine.h>

#include <glxzoomcontrol.h>

#include <glxzoomeventhandler.h>

// LOCAL CONSTANTS AND MACROS

const TInt KTimerLengthInMicroseconds   = 100000    ;

const TInt KGlxScreenTimeout            = 2000000	;      // 2 seconds timer for UI On/Off

const TInt KGlxAnimationTimeDrag        = 30        ;

const TInt KGlxAnimationTimekeyPan      = 50	    ;

const TInt KGlxZoomPanInc               = 5         ; // Min number of pixels panned in one keypress. This value is incremented exponentially by multiples of iPanFactor 

// Anime Speed changes in inverse proportion to KGlxAnimeFrameInmS. 

// Steps increase with KGlxAnimeFrameCount.

// Total time taken = (KGlxAnimeFrameInmS * KGlxAnimeFrameCount)microseconds.

const TInt KGlxAnimeFrameInmS           = 10000     ;

const TInt KGlxAnimeFrameCount          = 10        ;                 

const TInt KGlxPanInertiaFrameInmS      = 20000     ;

using namespace GestureHelper;

// ============================ CGlxZoomPanEventHandler===============================

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

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

// NewL

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

//

CGlxZoomPanEventHandler* CGlxZoomPanEventHandler::NewL(MGlxZoomEventHandlers& aZoomEventHandler)

    {

    TRACER("CGlxZoomPanEventHandler::NewL");

    CGlxZoomPanEventHandler* self = new (ELeave) CGlxZoomPanEventHandler(aZoomEventHandler);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CGlxZoomPanEventHandler constructor

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

//

CGlxZoomPanEventHandler::CGlxZoomPanEventHandler(MGlxZoomEventHandlers& aZoomEventHandler):

        iZoomEventHandler(aZoomEventHandler)

    {

    TRACER("CGlxZoomPanEventHandler::CGlxZoomPanEventHandler()");

    // No Implementation

    }

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

// CGlxZoomPanEventHandlerDestructor

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

//

CGlxZoomPanEventHandler::~CGlxZoomPanEventHandler()

    {

    TRACER("CGlxZoomPanEventHandler::~CGlxZoomPanEventHandler()");

    if(iZoomPanTimer)

    	{

        CancelZoomPanTimer();

        delete iZoomPanTimer;

        iZoomPanTimer = NULL;

        }

    if (iUiTimer)

        {

        CancelUITimer();

        delete iUiTimer;

        iUiTimer = NULL;

  		}

    if(iZoomAnimationTimer)

        {

        CancelAnimationTimer();

        delete iZoomAnimationTimer;

        iZoomAnimationTimer = NULL;

        }

    }

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

// CGlxZoomPanEventHandler Constructl

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

//

void CGlxZoomPanEventHandler::ConstructL()

    {

    TRACER("CGlxZoomPanEventHandler::ConstructL()");

    if(!iUiTimer)

        {

        iUiTimer = CPeriodic::NewL(EPriorityNormal);

        }

    if(!iZoomPanTimer)

        {

        iZoomPanTimer = CPeriodic::NewL(EPriorityNormal);

        }

    if(!iZoomAnimationTimer)

        {

        iZoomAnimationTimer = CPeriodic::NewL(EPriorityNormal);

        }

    }

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

// CGlxZoomPanEventHandler SetupAnimatedZoom

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

//

// Todo: Combine logics of setting up animated zoom and pan.

void CGlxZoomPanEventHandler::SetupAnimatedZoom(TZoomMode aZoomMode, TPoint* /*aZoomFocus*/)

    {

    TRACER("CGlxZoomPanEventHandler::SetupAnimatedZoom");

    iTargetAnimatedZoomRatio = (iMaxZoomRatio + iMinZoomRatio)/2 ;

    CancelAnimationTimer();

    //ToDo: Verify this with images slightly smaller or slightly larger than fullscreen size. 

    if (EZoomIn == aZoomMode)

        {

        // the '1+' is to take care of the situation when there the rest of the equation returns something betn 0 and 1

        iZoomPerInterval = 1 + (iTargetAnimatedZoomRatio - iZoomRatio)/KGlxAnimeFrameCount ; 

        }

    else

        {

        iZoomPerInterval = 1 + (iZoomRatio - iMinZoomRatio)/KGlxAnimeFrameCount;

        }

    if (1 < iZoomPerInterval)

        {

        iIsZoomingInAnimatedState = ETrue;

        switch(aZoomMode)

            {

            case EZoomIn:

                iAnimatedZoomMode = EAnimationModeZoomIn;

                break;

            case EZoomOut:

                iAnimatedZoomMode = EAnimationModeZoomOut;

                break;

            }

        iZoomAnimationTimer->Start( 0,  

                KGlxAnimeFrameInmS, 

                TCallBack( ActivationIntervalElapsed,(TAny*)this) );

        }

    else

        // Cant zoom in/out at less than 1 percent. so directly jump to the target zoom ratio.

        // This happens in cases where there is not much difference between the source and target zoom levels

        {

        TInt targetZoomRatio = 0;  

        if (EZoomIn == aZoomMode)

            {

            targetZoomRatio = iTargetAnimatedZoomRatio ;

            }

        else

            {

            targetZoomRatio = iMinZoomRatio ;

            }

        Zoom(targetZoomRatio, 0) ;

        }

    }

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

// CGlxZoomPanEventHandler ActivationIntervalElapsed

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

//

TInt CGlxZoomPanEventHandler::ActivationIntervalElapsed(TAny* aPtr)

    {

    TRACER("CGlxZoomPanEventHandler::ActivationIntervalElapsed");

    CGlxZoomPanEventHandler* self = static_cast<CGlxZoomPanEventHandler*>(aPtr);

    self->NextStepAnimatedZoom();

    return 0;

    }

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

// CGlxZoomPanEventHandler NextStepAmimatedZoom

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

//

void CGlxZoomPanEventHandler::NextStepAnimatedZoom()

    {

    TRACER("CGlxZoomPanEventHandler::NextStepAmimatedZoom");

    TInt targetZoomLevel = 0 ;

    if (EAnimationModeZoomIn == iAnimatedZoomMode)

        {

        targetZoomLevel = iZoomRatio + iZoomPerInterval;

        }

    else

        {

        targetZoomLevel = iZoomRatio - iZoomPerInterval;

        }

    Zoom(targetZoomLevel, 0, EZoomIn, &iZoomFocus );

    // The boundary conditions. 

    if ( (( targetZoomLevel >= iTargetAnimatedZoomRatio ) && (EAnimationModeZoomIn == iAnimatedZoomMode ) ) 

            || ((targetZoomLevel <= iMinZoomRatio) && (EAnimationModeZoomOut == iAnimatedZoomMode)))

        {

        iIsZoomingInAnimatedState = EFalse;

        CancelAnimationTimer();

        TSize screensize = iMathsEngine.ScreenSize();

        iZoomFocus = TPoint(screensize.iWidth>>1,screensize.iHeight>>1) ;

        }

    }

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

// StartPanTimer:Starts the Pan timer for continous Panning

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

//

void CGlxZoomPanEventHandler::StartPanTimer()

    {

    TRACER("CGlxZoomPanEventHandler::StartPanTimer ");

    //After Panning in one direction for a long time by holding the key and 

    //then if panning is started in another direction,the panning will be done in more pixels.

    iPanTime.HomeTime();

    GLX_LOG_INFO("CGlxZoomPanEventHandler::StartPanTimer: Cancelling timers ");

    if (iZoomPanTimer->IsActive())

        {

        iZoomPanTimer->Cancel();

        }

    iZoomPanTimer->Start( 0,  

            KTimerLengthInMicroseconds, 

            TCallBack( PanIntervalExpired,(TAny*)this) );

    }

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

// CancelZoomPanTimer: Cancels the Zoom timer for continous zoom

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

//

void CGlxZoomPanEventHandler::CancelZoomPanTimer()

    {

    TRACER("CGlxZoomPanEventHandler::CancelZoomPanTimer ");

    if (iZoomPanTimer->IsActive())

        {

        iZoomPanTimer->Cancel();

        }

    }

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

// CancelUITimer

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

//

void CGlxZoomPanEventHandler::CancelUITimer()

    {

    TRACER("CGlxZoomPanEventHandler::CancelUITimer ");

    if (iUiTimer->IsActive())

        {

        iUiTimer->Cancel();

        }

    }

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

// CancelUITimer

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

//

void CGlxZoomPanEventHandler::CancelAnimationTimer()

    {

    TRACER("CGlxZoomPanEventHandler::CancelAnimationTimer ");

    // This will set the timer to false if it is being used for zoom. For Pan

    // this flag is immaterial

    iIsZoomingInAnimatedState = EFalse;

    if (iZoomAnimationTimer->IsActive())

        {

        iZoomAnimationTimer->Cancel();

        }

    }

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

// StartUITimer

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

//

void CGlxZoomPanEventHandler::StartUITimer(TTimeIntervalMicroSeconds32 aDelay,

        TTimeIntervalMicroSeconds32 anInterval,

        TCallBack aCallBack)

    {

    TRACER("CGlxZoomPanEventHandler::StartUITimer ");

    if (iUiTimer->IsActive())

        {

        iUiTimer->Cancel();

        }

    iUiTimer->Start(aDelay,anInterval,aCallBack);

    }

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

// HandlekeyEvents:This function handles the key Events.

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

//

TBool CGlxZoomPanEventHandler::HandlekeyEvents(const TAlfEvent &aEvent)

    {

    TRACER("CGlxZoomControl::HandlekeyEvents()");

    GLX_LOG_INFO1("CGlxZoomPanEventHandler::HandlekeyEvents. Scancode = %d   ", aEvent.KeyEvent().iScanCode);

    TBool consumed = EFalse;

    if (!iIsZoomingInAnimatedState)

        {

        switch (aEvent.KeyEvent().iScanCode)

            {

            case EStdKeyDevice10: //Listen to EStdKeyDevice10 as EKeyLeftUpArrow key is mapped to TKeyCode::EKeyDevice10 for which TStdScancode is EStdKeyDevice10

            case EKeyLeftUpArrow :

            case EStdKeyDevice13: //Listen to EStdKeyDevice13 as EKeyLeftDownArrow key is mapped to TKeyCode::EKeyDevice13 for which TStdScancode is EStdKeyDevice13    

            case EKeyLeftDownArrow :

            case EStdKeyDevice11://Listen to EStdKeyDevice11 as EKeyRightUpArrow key is mapped to TKeyCode::EKeyDevice11 for which TStdScancode is EStdKeyDevice11            

            case EKeyRightUpArrow :

            case EStdKeyDevice12: //Listen to EStdKeyDevice12 as EKeyRightDownArrow key is mapped to TKeyCode::EKeyDevice12 for which TStdScancode is EStdKeyDevice12

            case EKeyRightDownArrow :

            case EStdKeyLeftArrow :

            case EStdKeyRightArrow :

			case EStdKeyUpArrow :

			case EStdKeyDownArrow :

                {

                HandlePanKey(aEvent);

                consumed = ETrue;

                }

                break;

            case EStdKeyDevice0:

            case EStdKeyDevice1:                

            case EStdKeyDevice3:

                {

                //Center button/MSK changes the UI State

                if (aEvent.Code() == EEventKeyDown)

                    {

                    if (EUiOff == iZoomUiState )

                        {

                        ShowScreenFurniture(KGlxScreenTimeout);

                        }

                    else

                        {

                        HideScreenFurniture();

                        }

                    }

                consumed = ETrue;

                }

                break;

            //Listen EStdKeyApplicationC as EKeyZoomIn key is mapped to TKeyCode:: EKeyApplicationC for which TStdScancode is EStdKeyApplicatoinC

            case EStdKeyApplicationC :

                {

                consumed = ETrue;

                break ;

                }

            //Listen EStdKeyApplicationD as EKeyZoomOut key is mapped to TKeyCode:: EKeyApplicationD for which TStdScancode is EStdKeyApplicatoinD

            case EStdKeyApplicationD :

                {

                consumed = ETrue;

                break ;

                }                

            default:

                break;

            }

        }

    return consumed;

    }

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

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

//

        TEventCode aEventCode)

    {

    if ( iZoomActivated )

        {

        switch(aEventCode)

            {

            case EEventKey :

                {

                iZoomMode = aZoomMode ;

                Zoom(0, 0, aZoomMode) ;

                ShowScreenFurniture(KGlxScreenTimeout);

                break ;

                }

            default :

            break ;

            }

        }

    }

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

// SetupPanOperation: start the pan operation for Key based pan. 

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

//

void CGlxZoomPanEventHandler::SetupPanOperation(TPoint& aPanDirection)

    {

    TRACER("CGlxZoomPanEventHandler::SetupPanOperation ");

    iPanDirection = TPoint(aPanDirection);

    if(EUiOn == iZoomUiState )

        {

        HideScreenFurniture();

        }

    StartPanTimer();

    iMathsEngine.SetupPanOperation();

    }

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

// HandlePanKey :handles the keys related to pan and starts the pan Timer

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

//

TBool CGlxZoomPanEventHandler::HandlePanKey( const TAlfEvent &aEvent )

    {

    TRACER("CGlxZoomPanEventHandler::HandlePanKey ");

    TSize imageVirtualSize   = iMathsEngine.ImageVirtualSize();

    TSize screenSize         = iMathsEngine.ScreenSize();

    TBool safeToPan          = EFalse ;

    TPoint panDirection(0,0);

    TBool handled = EFalse;

    if ( aEvent.Code() == EEventKeyDown )

        {

        //if height and/or width of the zoomed image is greater than the screen height and screen width ,

        //then this paning should be posssible 

        switch(aEvent.KeyEvent().iScanCode )

            {

            case EStdKeyDevice10:

            case EKeyLeftUpArrow:

                {

                if ((imageVirtualSize.iHeight>screenSize.iHeight)

                        &&(imageVirtualSize.iWidth > screenSize.iWidth))

                    {

                    safeToPan = ETrue;

                    panDirection = TPoint(-KGlxZoomPanInc, -KGlxZoomPanInc);

                    }

                }

                break;    

            case EStdKeyDevice11:

            case EKeyRightUpArrow:

                {

                if ((imageVirtualSize.iHeight>screenSize.iHeight)

                        &&(imageVirtualSize.iWidth > screenSize.iWidth))

                    {

                    safeToPan = ETrue;

                    panDirection = TPoint(KGlxZoomPanInc, -KGlxZoomPanInc);

                    }

                }

                break;    

            case EStdKeyDevice12:

            case EKeyLeftDownArrow:

                {

                if ((imageVirtualSize.iHeight>screenSize.iHeight)

                        &&(imageVirtualSize.iWidth > screenSize.iWidth))

                    {

                    safeToPan = ETrue;

                    panDirection = TPoint(-KGlxZoomPanInc, KGlxZoomPanInc);

                    }

                }

                break;    

            case EStdKeyDevice13:

            case EKeyRightDownArrow:

                {

                if ((imageVirtualSize.iHeight>screenSize.iHeight)

                        &&(imageVirtualSize.iWidth > screenSize.iWidth))

                    {

                    safeToPan = ETrue;

                    panDirection = TPoint(KGlxZoomPanInc, KGlxZoomPanInc);

                    }

                }

                break;    

            case EStdKeyUpArrow:

                {

                if( (imageVirtualSize.iHeight ) > screenSize.iHeight )

                    {

                    safeToPan = ETrue;

                    panDirection = TPoint(0, -KGlxZoomPanInc);

                    }

                }

                break;      

            case EStdKeyDownArrow:

                {