/*

* Copyright (c) 2007 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:  Controls the state of the zoom*

*/

// Defining this will reduce the wait period between repeated

// zoom in/out events being sent.  This is just a development

// test feature.

// INCLUDE FILES

#include    "CamZoomModel.h"

#include    "CamZoomPane.h"

#include    "CamPSI.h"

#include    "CamUtility.h"

#include    "CamAppUi.h"

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CCamZoomModel::CCamZoomModel

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCamZoomModel::CCamZoomModel( CCamAppController& aController, 

                              CCamZoomPane*      aPane ) 

  : iCurrentResolution( KErrNotReady ),

    iController( aController ),

    iPane( aPane )

  {

  }

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

// CCamZoomModel::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCamZoomModel::ConstructL()

    {    

    PRINT( _L( "Camera => CCamZoomModel::ConstructL " ) );

    // Retrieve the max digital zoom levels

    TPckgBuf <TCamMaxZoomSteps> pckg;

    CamUtility::GetPsiAnyL( ECamPsiMaxZoomSteps, &pckg );

    iDigZoomSteps = pckg();

    // Retrieve the max EXTENDED zoom levels

    TPckgBuf <TCamMaxZoomSteps> pckg2;

    CamUtility::GetPsiAnyL( ECamPsiMaxExtendedZoomSteps, &pckg2 );

    iExtZoomSteps = pckg2();

    // Retrieve the max OPTICAL zoom levels

    TPckgBuf <TCamMaxZoomSteps> pckg3;

    CamUtility::GetPsiAnyL( ECamPsiMaxOpticalZoomSteps, &pckg3 );

    iOptZoomSteps = pckg3();

    // Retrieve the timing and step values for each of the zoom bar 

    // modes for Optical/Digital/Extended    

    TPckgBuf <TCamZoomLAF> pckg4;

    CamUtility::GetPsiAnyL( ECamPsiZoomBarLAF, &pckg4);

    iZoomLAF = pckg4();

    // Setting up initial internal values for zoom levels

    iCurZoomStepOptical = 0;

    iCurZoomStepDigital = 0;        

    // Timer used to give smooth zooming    

    iZoomTimer = CPeriodic::NewL( CActive::EPriorityHigh );          

    // Register for controller events

    iController.AddControllerObserverL( this );

    // Create Zoom Update manager, which is used to 

    // minimize the amount of times we send updates to

    // the camera driver.

    iCamZoomUpdateManager = CCamZoomUpdateManager::NewL( iController );

    // This class and zoom pane are created on application start.

    // On app start, we should be setting the zoom to 1x, to 

    // tidy up incase a previous app has not reset to defaults.

    ResetZoomTo1x();

    PRINT( _L( "Camera <= CCamZoomModel::ConstructL " ) );

    }

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

// CCamZoomModel::NewL

// Two-phased constructor.

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

//

CCamZoomModel* CCamZoomModel::NewL( CCamAppController& aController, CCamZoomPane* aPane )

    {

    CCamZoomModel* self = new( ELeave ) CCamZoomModel( aController, aPane );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCamZoomModel::~CCamZoomModel

// Destructor.

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

//

CCamZoomModel::~CCamZoomModel()

  {

  PRINT( _L("Camera => ~CCamZoomModel" ))  

  iController.RemoveControllerObserver( this );

  if ( iZoomTimer && iZoomTimer->IsActive() )

    {    

    iZoomTimer->Cancel();

    }

  delete iZoomTimer;    

  if ( iCamZoomUpdateManager && iCamZoomUpdateManager->IsActive() )

    {    

    iCamZoomUpdateManager->Cancel();

    }

  delete iCamZoomUpdateManager;    

  iPane = NULL;   // Not owned

  PRINT( _L("Camera <= ~CCamZoomModel" ))  

  }

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

// CCamZoomModel::ZoomTo

// Attempts to zoom to a specified value.

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

//

void CCamZoomModel::ZoomTo( TInt aValue )

    {    

    PRINT( _L( "Camera => CCamZoomModel::ZoomTo " ) );

    // Note: The following code only supports digital or 

    // digital+extended zoom combinations.  

    // Optical zoom is not taken into consideration.

    // avoid mixups between button and touch presses

    if ( ZoomingState() != ECamZoomModelStateZoomNone )

        {

        PRINT( _L( "Camera <> CCamZoomModel::ZoomTo stopping keypress zoom" ) );

        StopZoom();

        }

    // Start the zoom state

    iState = ECamZoomModelStateZoomTo;

    // We don't support pausing between boundaries.  If the 

    // user experience so requires, it should be implemented here.

    // Update the zoom values

    // Note: Both digital and extended zoom are represented by iCurZoomStepDigital.

    // We assume the maximum value is already checked 

    // in CCamZoomPane::StartTouchZoomL

    PRINT1( _L( "Camera <> CCamZoomModel::ZoomTo iMaxZoomStepDig=%d" ), iMaxZoomStepDig ); 

    PRINT1( _L( "Camera <> CCamZoomModel::ZoomTo iMaxZoomStepExt=%d" ), iMaxZoomStepExt ); 

    PRINT1( _L( "Camera <> CCamZoomModel::ZoomTo iCurZoomStepDigital=%d" ), iCurZoomStepDigital ); 

    iCurZoomStepDigital = aValue;

    if ( iCurZoomStepDigital < iMaxZoomStepDig )

        {

        CheckZoomMode( ECamZoomModeExtended );

        }

    else

        {

        CheckZoomMode( ECamZoomModeDigital );

        }

    // Notify the camera driver

    PRINT1( _L( "Camera <> CCamZoomModel::ZoomTo to (aValue) %d" ), aValue );

    iCamZoomUpdateManager->SetZoomValue( iCurZoomStepDigital );

    // Tell the zoom pane the value to show.

    PRINT1( _L( "CCamZoomModel::ZoomTo set zoom pane %d" ), CurrentZoom() );

    iPane->SetZoomValue( CurrentZoom() );

    // Clear the zoom state

    iState = ECamZoomModelStateZoomNone; 

    PRINT( _L( "Camera <= CCamZoomModel::ZoomTo " ) );

    }

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

// CCamZoomModel::ZoomIn

// Attempts to zoom in one step (if one more step available).

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

//

void CCamZoomModel::ZoomIn( TBool aOneClick )

    {    

    PRINT( _L( "Camera => CCamZoomModel::ZoomIn " ) );

    iState = ECamZoomModelStateZoomIn;

    TInt optZoomJump = 0;

    TInt digZoomJump = 0;    

    TInt extZoomJump = 0;

    ZoomStepsToJump( optZoomJump, digZoomJump, extZoomJump );

    PRINT3( _L( "CCamZoomModel::ZoomIn steps opt(%d) dig(%d) ext(%d) " ), optZoomJump, digZoomJump, extZoomJump );

    // First of all, check what the current boundary condition is

    // then check if we need to pause at that boundary.

    PRINT( _L( "ZoomIn boundary check start" ) );

    TCamZoomBoundary boundary = CheckBoundary();

    if ( PauseAtBoundary( boundary ) )

        {        

        if ( iPauseState == EPauseStateNone )

            {

            PRINT( _L( "ZoomIn at boundary EPauseStateNone return" ) );

            // If this is a new pause, update the state and return

            // (no zoom allowed until release)

            iPauseState = EPauseStatePaused;

            return;

            }

        else if ( iPauseState == EPauseStatePaused )

            {

            PRINT( _L( "ZoomIn at boundary EPauseStatePaused return" ) );

            // If still paused, return (no zoom allowed until release)

            return;

            }

        else // EPauseStateReleased

            {

            PRINT( _L( "ZoomIn at boundary EPauseStateReleased allow" ) );

            // If released, allow the zoom, but set the state

            // back to none.  

            iPauseState = EPauseStateNone;

            }

        }

    PRINT( _L( "ZoomIn at boundary EPauseStateNone boundary check end" ) );

    if ( optZoomJump )        

        {

        CheckZoomMode( ECamZoomModeOptical );

        iCurZoomStepOptical += optZoomJump;

        PRINT1( _L( "Camera => CCamZoomModel::ZoomIn opt to %d" ), iCurZoomStepOptical );

        //iController.SetZoomValue( iCurZoomStepOptical );            

        iCamZoomUpdateManager->SetZoomValue( iCurZoomStepOptical );

        }

    if ( digZoomJump )        

        {

        CheckZoomMode( ECamZoomModeDigital );

        iCurZoomStepDigital += digZoomJump;

        PRINT1( _L( "Camera => CCamZoomModel::ZoomIn dig to %d" ), iCurZoomStepDigital );

        //iController.SetZoomValue( iCurZoomStepDigital );              

        iCamZoomUpdateManager->SetZoomValue( iCurZoomStepDigital );

        }

    if ( extZoomJump )

        {

        CheckZoomMode( ECamZoomModeExtended );

        iCurZoomStepDigital += extZoomJump;

        PRINT1( _L( "Camera => CCamZoomModel::ZoomIn ext to %d" ), iCurZoomStepDigital );

        //iController.SetZoomValue( iCurZoomStepDigital );              

        iCamZoomUpdateManager->SetZoomValue( iCurZoomStepDigital );

        }

    // Tell the zoom pane the value to show.

    PRINT1( _L( "CCamZoomModel::ZoomIn set zoom pane %d" ), CurrentZoom() );

    iPane->SetZoomValue( CurrentZoom() );

    if ( aOneClick )

        {

        // Do not start zoom timer

        PRINT( _L( "CCamZoomModel::ZoomIn one click" ) );

        iState = ECamZoomModelStateZoomNone;

        }

    else

        {

        // Start the timer to zoom-in again when timer expires

        PRINT( _L( "CCamZoomModel::ZoomIn start zoom timer" ) );

        StartZoomTimer();

        }

    PRINT( _L( "Camera <= CCamZoomModel::ZoomIn " ) );

    }

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

// CCamZoomModel::CheckBoundary

// Checks whether the next zoom operation will cross a zoom mode boundary.

// For example from Optical to Digital or from Digital to Extended

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

//    

CCamZoomModel::TCamZoomBoundary CCamZoomModel::CheckBoundary() const

    {

    PRINT( _L( "Camera => CCamZoomModel::CheckBoundary " ) );

    TCamZoomBoundary retVal = ECamZoomBoundaryNone;        

    TCamZoomMode modeBefore = CurrentZoomType();

    TCamZoomMode modeAfter  = CurrentZoomType( ZoomStepsToJump() );

    if ( modeBefore != modeAfter )

        {

        if ( modeBefore == ECamZoomModeOptical && modeAfter  == ECamZoomModeDigital ||

             modeBefore == ECamZoomModeDigital && modeAfter  == ECamZoomModeOptical )

            {

            PRINT( _L( "Camera <> CCamZoomModel::CheckBoundary ECamZoomBoundaryOptDig" ) );

            retVal = ECamZoomBoundaryOptDig;

            }

        else if ( modeBefore == ECamZoomModeExtended && modeAfter  == ECamZoomModeDigital ||

                  modeBefore == ECamZoomModeDigital && modeAfter  == ECamZoomModeExtended )

            {

            PRINT( _L( "Camera <> CCamZoomModel::CheckBoundary ECamZoomBoundaryDigExt" ) );

            retVal = ECamZoomBoundaryDigExt;

            }        

        else

            {

            // Undefined boundary, should not allow further zooming

            PRINT( _L( "Camera <> CCamZoomModel::CheckBoundary ECamZoomBoundaryUndefined" ) );

            retVal = ECamZoomBoundaryUndefined;

            }

        }

     else

        {

        PRINT( _L( "Camera <> CCamZoomModel::CheckBoundary ECamZoomBoundaryNone" ) );

        retVal = ECamZoomBoundaryNone;

        }

    PRINT( _L( "Camera <= CCamZoomModel::CheckBoundary " ) );

    return retVal;   

    }

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

// CCamZoomModel::ZoomStepsToJump

// Returns the total number of zoom steps to jump based on the current 

// zoom mode (opt/dig/ext). Does not break these steps into optical/digital

// steps to jump, as may be the case on a boundary.

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

//      

TInt CCamZoomModel::ZoomStepsToJump() const

    {      

    PRINT( _L( "Camera => CCamZoomModel::ZoomStepsToJump " ) );

    TInt steps = 0;

    if ( iController.ActiveCamera() == ECamActiveCameraPrimary )    

        {            

        // Works out the current zoom mode (opt/dig/ext)

        TCamZoomMode mode = CurrentZoomType();    

        PRINT1( _L( "Camera <> CCamZoomModel::ZoomStepsToJump mode = %d" ), mode );

        if ( mode == ECamZoomModeOptical )

            {        

            steps = iZoomLAF.iZoomStepsOpt;

            PRINT1( _L( "Camera <> CCamZoomModel::ZoomStepsToJump ECamZoomModeOptical steps = %d" ), steps );

            }

        else if ( mode == ECamZoomModeDigital )

            {

            steps = iZoomLAF.iZoomStepsDig;

            PRINT1( _L( "Camera <> CCamZoomModel::ZoomStepsToJump ECamZoomModeDigital steps = %d" ), steps );

            }

        else if ( mode == ECamZoomModeExtended )    

            {

            steps = iZoomLAF.iZoomStepsExt;

            PRINT1( _L( "Camera <> CCamZoomModel::ZoomStepsToJump ECamZoomModeExtended steps = %d" ), steps );

            }    

        else

            {

            steps = 0;            

            }   

        }

    else if ( iController.ActiveCamera() == ECamActiveCameraSecondary )

        {

        //steps = K2ndCamZoomStepSize;

        steps = iZoomLAF.iSecondCameraZoomSteps;

        PRINT1( _L( "Camera <> CCamZoomModel::ZoomStepsToJump K2ndCamZoomStepSize steps = %d" ), steps );

        }

    else

        {            

        }

    if ( iState == ECamZoomModelStateZoomOut )        

        {

        steps = -steps;    

        PRINT1( _L( "Camera <> CCamZoomModel::ZoomStepsToJump Inverse, since ZoomOut: steps = %d" ), steps );

        }

    PRINT( _L( "Camera <= CCamZoomModel::ZoomStepsToJump " ) );

    return steps;                           

    }

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

// CCamZoomModel::ZoomStepsToJump

// Returns the number of Optical, Digital and Extended zoom steps to jump

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

//  

void CCamZoomModel::ZoomStepsToJump( TInt& aOpt, TInt& aDig, TInt& aExt ) const

    {  

    PRINT( _L( "Camera => CCamZoomModel::ZoomStepsToJump (by reference)" ) );

    TInt steps = ZoomStepsToJump();

    TCamZoomBoundary boundary = CheckBoundary();

    // If jumping this number of steps will make us cross the boundary, 

    // we need to split the steps up into the composite opt/dig steps.

    // Depending on if we are pausing or not, we may not want to cross

    // the boundary yet

    if ( boundary == ECamZoomBoundaryOptDig )

        {

        if ( iState == ECamZoomModelStateZoomIn )

            {

            // Zooming in, then assign what we can to Optical, to get to max step

            // any remainder then goes to digital

            TInt optJumpMax = iMaxZoomStepOpt - iCurZoomStepOptical;

            aOpt = optJumpMax;

            aDig = steps - optJumpMax;

            // If the zoom in was going to take the digital zoom beyond the max

            // allowed, clip it

            if ( aDig > iMaxZoomStepDig )

                aDig = iMaxZoomStepDig;

            }

        else if ( iState == ECamZoomModelStateZoomOut )        

            {

            // Zooming out, then assign what we can to Digital, to get to min step

            // any remainder then goes to optical            

            aDig = -iCurZoomStepDigital;                

            aOpt = steps + iCurZoomStepDigital; // zooming out, steps is -ve

            }

		else

			{

			// Lint

			}

        }

    else if ( boundary == ECamZoomBoundaryDigExt )

        {

        if ( iState == ECamZoomModelStateZoomIn )

            {

            // Zooming in, then assign what we can to Optical, to get to max step

            // any remainder then goes to digital

            TInt digJumpMax = iMaxZoomStepDig - iCurZoomStepDigital;

            aDig = digJumpMax;

            aExt = steps - digJumpMax;

            // If the zoom in was going to take the digital zoom beyond the max

            // allowed, clip it

            if ( aExt > iMaxZoomStepExt )

                aExt = iMaxZoomStepExt;            

            }

        else if ( iState == ECamZoomModelStateZoomOut )        

            {

            // Zooming out, then assign what we can to Digital, to get to min step

            // any remainder then goes to optical            

            //aDig = iCurZoomStepDigital;

            aDig = steps;

            //aExt = steps - iCurZoomStepDigital;                            

            }

        else

        	{

        	// Lint

        	}

        }        

    else if ( boundary == ECamZoomBoundaryNone )

        {

        // No boundary crossed.  Can assign the steps to the current

        // mode        

        TCamZoomMode mode = CurrentZoomType();

        if ( iState == ECamZoomModelStateZoomIn )

            {           

            if ( mode == ECamZoomModeOptical && AllowOptZoom() )

                {

                aOpt = steps;

                if ( iCurZoomStepOptical + aOpt > iMaxZoomStepOpt )

                    {

                    aOpt = iMaxZoomStepOpt - iCurZoomStepOptical;                            

                    }                    

                }

            else if ( mode == ECamZoomModeDigital && AllowDigZoom() )

                {

                aDig = steps;    

                if ( iCurZoomStepDigital + aDig > iMaxZoomStepDig )

                    {

                    aDig = iMaxZoomStepDig - iCurZoomStepDigital;                

                    }                    

                }

            else if ( mode == ECamZoomModeExtended && AllowExtZoom() )

                {

                aExt = steps;                        

                if ( iCurZoomStepDigital + aExt > iMaxZoomStepExt )

                    {

                    aExt = iMaxZoomStepExt - iCurZoomStepDigital;    

                    }                    

                }               

            else

                {

                // Do nothing (as invalid state)

                }                                             

            }

        else if ( iState == ECamZoomModelStateZoomOut ) 

            {                

            if ( mode == ECamZoomModeOptical && AllowOptZoom() )

                {

                aOpt = steps;

                if ( iCurZoomStepOptical + aOpt < 0 )

                    {

                    aOpt = -iCurZoomStepOptical;                            

                    }