diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/src/CamZoomModel.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/src/CamZoomModel.cpp	Wed Sep 01 12:30:54 2010 +0100
@@ -0,0 +1,1538 @@
+/*
+* 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;        
+
+    // Default zoom jump multiplier
+    iZoomStepMultiplier = 1;
+
+    // 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
+        {
+        // Don't restart timer (Auto-stop) timer when no zoom was done
+        if( optZoomJump || digZoomJump || extZoomJump )
+            {
+            // Start the timer to zoom-in again when timer expires
+            PRINT( _L( "CCamZoomModel::ZoomIn start zoom timer" ) );
+            StartZoomTimer();
+            }
+        else
+            {
+            PRINT( _L("Camera <> CCamZoomModel::ZoomOut - stopping zoom at boundary") );
+            StopZoom();
+            }
+        }
+    
+    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 = iZoomStepMultiplier * 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;                            
+                    }                    
+                }
+            else if ( mode == ECamZoomModeDigital && AllowDigZoom() )
+                {
+                aDig = steps;    
+                if ( iCurZoomStepDigital + aDig < 0 )
+                    {
+                    aDig = -iCurZoomStepDigital;                
+                    }                    
+                }
+            else if ( mode == ECamZoomModeExtended && AllowExtZoom() )
+                {
+                aExt = steps;                        
+                if ( iCurZoomStepDigital + aExt < iMaxZoomStepDig )
+					{
+                    aExt = iMaxZoomStepDig - iCurZoomStepDigital;
+					}
+                }        
+            else
+                {
+                // Do nothing (as invalid state)
+                }                        
+            }
+		else
+			{
+			// Lint
+			}            
+        }       
+    else // ECamZoomBoundaryUndefined
+        {
+        // If undefined boundary, this would result in an invalid
+        // zoom valid if we zoom, so set all steps to zero.        
+        // This will stop any zoom operation from changing state.
+        aOpt = 0;
+        aDig = 0;
+        aExt = 0;
+        }
+        
+    PRINT( _L( "Camera <= CCamZoomModel::ZoomStepsToJump " ) );
+    }
+    
+    
+// ---------------------------------------------------------------------------
+// CCamZoomModel::CurrentZoomType
+// Returns the zoom type (opt/dig/ext) based on current zoom levels modified
+// by the specified optical/digital valies
+// ---------------------------------------------------------------------------
+//   
+TCamZoomMode CCamZoomModel::CurrentZoomType( TInt aStepModifier ) const
+    {
+    PRINT( _L( "Camera => CCamZoomModel::CurrentZoomType " ) );
+    
+    TInt maxOptZoomStep = ( iMaxZoomStepOpt == KErrNotSupported || !AllowOptZoom() )? 0 : iMaxZoomStepOpt;
+    TInt maxStdZoomStep = ( iMaxZoomStepDig == KErrNotSupported || !AllowDigZoom() )? maxOptZoomStep : maxOptZoomStep + iMaxZoomStepDig;
+    TInt maxExtZoomStep = ( iMaxZoomStepExt == KErrNotSupported || !AllowExtZoom() )? maxStdZoomStep : maxStdZoomStep + iMaxZoomStepExt;   
+    
+    // 
+    TInt step = CurrentZoom() + aStepModifier;    
+        
+    // Optical runs from step 0 to maxOptZoomStep
+    if ( step <= maxOptZoomStep && // Not at max opt zoom level        
+         AllowOptZoom() )          // ... and optical zoom is allowed        
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::CurrentZoomType ECamZoomModeOptical" ) );
+        return ECamZoomModeOptical;
+        }
+    // Digital runs from maxOptZoomStep to maxOptZoomStep+maxStdZoomStep
+    else if ( step >= maxOptZoomStep &&
+              step <= maxStdZoomStep && // Inside std zoom step limits
+              AllowDigZoom() )          // ...and is allowed by user setting
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::CurrentZoomType ECamZoomModeDigital" ) );
+        return ECamZoomModeDigital;
+        }
+    // Extended runs from maxOptZoomStep+maxStdZoomStep to maxOptZoomStep+maxStdZoomStep        
+    else if ( step >= maxStdZoomStep &&
+              step <= maxExtZoomStep &&   // Inside ext zoom step limits
+              AllowExtZoom() )            // ...and ext zoom is allowed by user
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::CurrentZoomType ECamZoomModeExtended" ) );
+        return ECamZoomModeExtended;
+        }
+    else
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::CurrentZoomType ECamZoomModeUndefined" ) );
+        return ECamZoomModeUndefined;
+        }                   
+    }
+
+// -----------------------------------------------------------------------------
+// CCamZoomModel::ZoomOut
+// Attempts to zoom out one step (if one more step available).
+// -----------------------------------------------------------------------------
+//
+void CCamZoomModel::ZoomOut( TBool aOneClick )
+    {        
+    PRINT( _L( "Camera => CCamZoomModel::ZoomOut " ) );
+    iState = ECamZoomModelStateZoomOut;
+    TInt optZoomJump = 0;
+    TInt digZoomJump = 0;    
+    TInt extZoomJump = 0; 
+    
+    ZoomStepsToJump( optZoomJump, digZoomJump, extZoomJump );
+    PRINT3( _L( "CCamZoomModel::ZoomOut steps opt(%d) dig(%d) ext(%d) " ), optZoomJump, digZoomJump, extZoomJump );
+    
+    if ( optZoomJump )        
+        {
+        CheckZoomMode( ECamZoomModeOptical );
+        iCurZoomStepOptical += optZoomJump;
+        PRINT1( _L( "Camera => CCamZoomModel::ZoomOut opt to %d" ), iCurZoomStepOptical );
+        //iController.SetZoomValue( iCurZoomStepOptical );            
+        iCamZoomUpdateManager->SetZoomValue( iCurZoomStepOptical );
+        }
+        
+    if ( digZoomJump )        
+        {
+        CheckZoomMode( ECamZoomModeDigital );
+        iCurZoomStepDigital += digZoomJump;
+        PRINT1( _L( "Camera => CCamZoomModel::ZoomOut dig to %d" ), iCurZoomStepDigital );
+        //iController.SetZoomValue( iCurZoomStepDigital );              
+        iCamZoomUpdateManager->SetZoomValue( iCurZoomStepDigital );
+        }
+        
+    if ( extZoomJump )
+        {
+        CheckZoomMode( ECamZoomModeExtended );
+        iCurZoomStepDigital += extZoomJump;
+        PRINT1( _L( "Camera => CCamZoomModel::ZoomOut ext to %d" ), iCurZoomStepDigital );
+        //iController.SetZoomValue( iCurZoomStepDigital );           
+        iCamZoomUpdateManager->SetZoomValue( iCurZoomStepDigital );   
+        }    
+
+    // Tell the zoom pane the value to show.
+    PRINT1( _L( "ZoomOut set zoom pane %d" ), CurrentZoom() );
+    iPane->SetZoomValue( CurrentZoom() );    
+
+    if ( aOneClick )
+        {
+        // Do not start zoom timer
+        PRINT( _L( "CCamZoomModel::ZoomIn one click" ) );
+        iState = ECamZoomModelStateZoomNone;
+        }
+    else
+        {
+        // Don't restart timer (auto-stop) timer when no zoom was done
+        if( optZoomJump || digZoomJump || extZoomJump )
+            {
+            // Start the timer to zoom-in again when timer expires
+            PRINT( _L( "CCamZoomModel::ZoomIn start zoom timer" ) );
+            StartZoomTimer();
+            }
+        else
+            {
+            PRINT( _L("Camera <> CCamZoomModel::ZoomOut - stopping zoom at boundary") );
+            StopZoom();
+            }
+        }
+    
+    PRINT( _L( "Camera <= CCamZoomModel::ZoomOut " ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CCamZoomModel::CheckZoomMode
+// Checks to see if the zoom mode needs to be changed.
+// The purpose is to avoid unneccessary calls to SetZoomMode where possible
+// -----------------------------------------------------------------------------
+//
+void CCamZoomModel::CheckZoomMode( TCamZoomMode aMode )
+  {
+  PRINT( _L( "Camera => CCamZoomModel::CheckZoomMode " ) );
+  if ( iZoomMode             != aMode 
+    && ECamZoomModeUndefined != aMode )
+    {
+    //iController.SetZoomMode( aMode );
+    PRINT2( _L( "Camera <> CCamZoomModel::CheckZoomMode iZoomMode changed (%d) -> (%d) " ), aMode, iZoomMode );
+    iZoomMode = aMode;
+    }
+  PRINT( _L( "Camera <= CCamZoomModel::CheckZoomMode " ) );  
+  }
+
+// -----------------------------------------------------------------------------
+// CCamZoomModel::RefreshSettings
+// Checks the current state of the Camera application, and adjusts the min/max
+// range of the zoom pane accordingly.
+// -----------------------------------------------------------------------------
+//
+void CCamZoomModel::RefreshSettings()
+  {
+  PRINT( _L("Camera => CCamZoomModel::RefreshSettings") );
+  // If there is no active camera yet, or engine is not 
+  // in a prepared state yet, do not try to refresh settings
+  // as we can't work out what to base it on.
+
+  // <CAMERAAPP_CAPI_V2_MIGRATION/>
+  if( iController.ActiveCamera() == ECamActiveCameraNone 
+   || !( iCameraState & (ECamImageOn|ECamVideoOn) ) 
+    ) 
+    {
+    return;
+    }        
+
+  // Cache the current resolution to be used when 
+  // determining zoom limits and steps.
+  ReadCurrentResolution();      
+
+  // Read settings to update internal state        
+  ReadOpticalZoomSetting();
+  ReadDigitalZoomSetting();
+
+  iMaxZoomStepOpt = MaxZoomStep( iOptZoomSteps );
+  iMaxZoomStepDig = MaxZoomStep( iDigZoomSteps );
+  iMaxZoomStepExt = MaxZoomStep( iExtZoomSteps );
+      
+  iMaxZoomStep = 0;
+
+  PRINT3( _L("Camera <> CCamZoomModel: max steps opt:%d dig:%d ext:%d"), iMaxZoomStepOpt, iMaxZoomStepDig, iMaxZoomStepExt );
+
+  if ( AllowOptZoom() )
+    {        
+    iMaxZoomStep += iMaxZoomStepOpt;        
+    }
+    
+  // Check if Digital zoom is allowed
+  if ( AllowDigZoom() )
+    {                
+    // Check if EXTENDED zoom is allowed by user setting
+    // and the value is valid.  For secondary camera, it may
+    // be that it is not supported.
+    if ( AllowExtZoom() ) // done in AllowExtZoom: && iMaxZoomStepExt != KErrNotSupported)
+      {                                        
+      iMaxZoomStep += iMaxZoomStepExt;        
+      }
+    else
+      {            
+      iMaxZoomStep += iMaxZoomStepDig;        
+      }
+    }
+
+  TInt optSteps = ( AllowOptZoom() ) ? iMaxZoomStepOpt : 0; 
+  TInt stdSteps = ( AllowDigZoom() ) ? iMaxZoomStepDig : 0;
+  TInt extSteps = ( AllowExtZoom() ) ? Max( (iMaxZoomStepExt - iMaxZoomStepDig), 0 ) : 0;
+          
+  // Check that the max zoom is within (possibly new) limits
+  CheckZoomLimit();
+  
+  if ( iPane )
+    {
+    // Inform the zoom pane of the new range of zoom steps
+    iPane->SetZoomRange( 0, iMaxZoomStep ); 
+    iPane->SetZoomSteps( optSteps, stdSteps, extSteps );        
+    iPane->SetZoomValue( CurrentZoom() );
+    }
+
+  PRINT( _L("Camera <= CCamZoomModel::RefreshSettings") );
+  }
+    
+    
+// -----------------------------------------------------------------------------
+// CCamZoomModel::ReadDigitalZoomSetting
+// Updates the setting for digital/extended zoom or not depending if user 
+// setting for it is on AND we have a valid setting for it.
+// -----------------------------------------------------------------------------
+//    
+void CCamZoomModel::ReadDigitalZoomSetting()
+    {        
+    iZoomSetting = static_cast<TCamSettingsDigitalZoom>(
+        iController.IntegerSettingValue( ECamSettingItemPhotoDigitalZoom ) );    
+    }
+
+
+
+// -----------------------------------------------------------------------------
+// CCamZoomModel::ReadOpticalZoomSetting
+// Reads whether optical zoom is allowed
+// -----------------------------------------------------------------------------
+//    
+void CCamZoomModel::ReadOpticalZoomSetting()
+    {     
+    }    
+    
+    
+// -----------------------------------------------------------------------------
+// CCamZoomModel::CheckZoomLimit
+// Checks whether the current zoom level is too great for the limits.
+// This can happen if the resolution is changed, as this may result in new limits
+// The zoom level should be cropped to where appropriate
+// -----------------------------------------------------------------------------
+//      
+void CCamZoomModel::CheckZoomLimit()
+    {    
+    TInt maxOptZoomStep = MaxZoomStep( iOptZoomSteps );
+    TInt maxStdZoomStep = MaxZoomStep( iDigZoomSteps );
+    TInt maxExtZoomStep = MaxZoomStep( iExtZoomSteps );
+
+    if ( AllowOptZoom() &&                      // If settings allow optical zoom, 
+         iCurZoomStepOptical > maxOptZoomStep ) // ...and value now too high
+        {
+        iCurZoomStepOptical = maxOptZoomStep;
+        // iController.SetZoomMode ( ECamZoomModeOptical );
+        iController.SetZoomValue( iCurZoomStepOptical );                                         
+        }
+
+    if ( AllowDigZoom()                        // If digital zoom is allowed
+      && iCurZoomStepDigital > maxStdZoomStep  // and value now too high
+      && !AllowExtZoom() )                     // and extended not allowed
+        {
+        // If we get here, digital zoom IS allowed, but extended isn't
+        // and the digital zoom is too high.
+        iCurZoomStepDigital = maxStdZoomStep;
+        //iController.SetZoomMode ( ECamZoomModeDigital );
+        iController.SetZoomValue( iCurZoomStepDigital );                                                        
+        }
+    else if ( AllowExtZoom()                         // If extended digitial zoom is allowed
+           && iCurZoomStepDigital > maxExtZoomStep ) // but over the max extended range
+        {        
+        iCurZoomStepDigital = maxExtZoomStep;
+        // iController.SetZoomMode ( ECamZoomModeDigital );
+        iController.SetZoomValue( iCurZoomStepDigital );                                                                    
+        }
+    // otherwise, do nothing
+    else
+        {
+        // empty statement to remove Lint error.
+        }
+        
+    // If we have had to manually set the mode and value of zoom, 
+    // make sure that the zoom mode is still set to what internal state
+    // dictates it should be.    
+
+    /*
+    if ( iZoomMode == ECamZoomModeOptical )
+        {
+        iController.SetZoomMode( ECamZoomModeOptical );
+        }
+    else if ( iZoomMode == ECamZoomModeDigital ||
+              iZoomMode == ECamZoomModeExtended )
+        {
+        iController.SetZoomMode( ECamZoomModeDigital );
+        }            
+    // otherwise, do nothing
+    else
+        {
+        // empty statement to remove Lint error.
+    */
+    }
+ 
+// -----------------------------------------------------------------------------
+// CCamZoomModel::ResetZoomTo1x
+// Resets the zoom level to 1x.
+// -----------------------------------------------------------------------------
+//    
+void CCamZoomModel::ResetZoomTo1x()
+  {
+  PRINT( _L( "Camera => CCamZoomModel::ResetZoomTo1x " ) );
+  // Recalculates the min/max values for the zoom pane and
+  // forwards them to the control.
+  RefreshSettings();        
+  
+  // Reset the actual values used by the engine
+  iCurZoomStepOptical = 0;
+  iCurZoomStepDigital = 0;
+  
+  iZoomMode = ECamZoomModeUndefined;
+  
+  // Only digital mode supported for now.        
+  //iController.SetZoomMode( ECamZoomModeDigital );
+  iController.SetZoomValue( iCurZoomStepDigital );                                
+  if ( iPane )
+    {
+    iPane->SetZoomValue( 0 );
+    iPane->MakeVisible( EFalse, EFalse );
+    }
+    
+  PRINT( _L( "Camera <= CCamZoomModel::ResetZoomTo1x " ) );
+  }        
+        
+
+// -----------------------------------------------------------------------------
+// CCamZoomModel::MaxZoomStep
+// Returns the maximum zoom step for the supplied step array 
+// (optical/digital/extended), based on current camera state.
+// -----------------------------------------------------------------------------
+//
+TInt CCamZoomModel::MaxZoomStep( const TCamMaxZoomSteps& aStepArray ) const
+    {        
+    PRINT( _L( "Camera => CCamZoomModel::MaxZoomStep " ) );
+    
+    TInt maxStep = KErrNotSupported;
+    if ( iCameraState & ECamImageOn )
+        {                
+        // TCamPhotoSizeId  sizeId = iController.GetCurrentImageResolution();
+        TCamActiveCamera camera = iController.ActiveCamera();
+        if ( ECamActiveCameraPrimary == camera )
+            {
+            // switch ( sizeId )
+            switch ( iCurrentResolution )
+                {
+                case ECamPhotoSizeVGA:       // 640 x 480
+                    maxStep = aStepArray.iMaxPhotoStepVGA;
+                    break;
+                case ECamPhotoSizeXGA: 	// 0.8MegaPixel (1024 x 768 )
+                    maxStep = aStepArray.iMaxPhotoStep0_8MP;
+                    break;
+                case ECamPhotoSize1MP:
+                    maxStep = aStepArray.iMaxPhotoStep1MP;
+                    break;
+                case ECamPhotoSize1_3MP:     // 1280x960
+                    maxStep = aStepArray.iMaxPhotoStep1_3MP;
+                    break;
+                case ECamPhotoSize2MP:       // 1600x1200
+                    maxStep = aStepArray.iMaxPhotoStep2MP;
+                    break;
+                case ECamPhotoSize3MP:       // 
+                    maxStep = aStepArray.iMaxPhotoStep3MP;
+                    break;  
+                case ECamPhotoSize5MP:
+                    maxStep = aStepArray.iMaxPhotoStep5MP;
+                    break;
+                case ECamPhotoSize8MP:
+                    maxStep = aStepArray.iMaxPhotoStep8MP;
+                    break;                    
+                case ECamPhotoSize12MP:
+                    maxStep = aStepArray.iMaxPhotoStep12MP;
+                    break;
+                case ECamPhotoSizeW6MP: // 3264x1832
+                    maxStep = aStepArray.iMaxPhotoStepW6MP;
+                    break;                    
+                case ECamPhotoSizeW9MP: // 4000x2248
+                    maxStep = aStepArray.iMaxPhotoStepW9MP;
+                    break;                    
+                default: 
+                    break;
+                }                
+            }
+        else if ( ECamActiveCameraSecondary == camera  )
+            {
+            maxStep = aStepArray.iMax2ndCamPhotoStep;
+            }  
+        // otherwise, do nothing
+        else
+            {
+            // empty statement to remove Lint error.
+            }      
+        }
+    else if ( iCameraState & ECamVideoOn )
+        {
+        // TCamVideoResolution resId = iController.GetCurrentVideoResolution();        
+
+        if ( iController.ActiveCamera() == ECamActiveCameraPrimary )
+            {        
+            // switch ( resId )
+            switch ( iCurrentResolution )            
+                {
+                case ECamVideoResolutionSubQCIF:     // Small (128 x 96)
+                    maxStep = aStepArray.iMaxVideoStepSQCIF;
+                    break;
+                case ECamVideoResolutionQCIF:        // Medium (176 x 144)
+                    maxStep = aStepArray.iMaxVideoStepQCIF;
+                    break;
+                case ECamVideoResolutionCIF:         // Large (352 x 288) (Default)
+                    maxStep = aStepArray.iMaxVideoStepCIF;
+                    break;            
+                case ECamVideoResolutionVGA:         // VGA (640 x 480)
+                    maxStep = aStepArray.iMaxVideoStepVGA;            
+                    break;            
+                case ECamVideoResolutionQVGA:         // QVGA ( 320 x 240 )
+                    maxStep = aStepArray.iMaxVideoStepQVGA;
+                    break;                                        
+                case ECamVideoResolutionNHD:         // NHD ( 640 x 352 )
+                    maxStep = aStepArray.iMaxVideoStepNHD;
+                    break;                                            
+                case ECamVideoResolutionWVGA:         // WVGA ( 864 x 480 )
+                    maxStep = aStepArray.iMaxVideoStepWVGA;
+                    break;                                                
+                case ECamVideoResolutionHD:           // HD ( 1280 x 720 )
+                    maxStep = aStepArray.iMaxVideoStepHD;
+                    break;                                                
+                default: 
+                    break;
+                }
+            }
+        else if ( iController.ActiveCamera() == ECamActiveCameraSecondary )
+            {
+            switch ( iCurrentResolution )
+                {
+                case ECamVideoResolutionCIF:         // Large (352 x 288) (Default)
+                    maxStep = aStepArray.iMax2ndCamVideoStepCIF;
+                    break;
+                case ECamVideoResolutionQCIF:        // Medium (176 x 144)
+                    maxStep = aStepArray.iMax2ndCamVideoStepQCIF;
+                    break;
+                case ECamVideoResolutionSubQCIF:     // Small (128 x 96)
+                    maxStep = aStepArray.iMax2ndCamVideoStepSQCIF;
+                    break;
+                default:
+                    break;
+                }                        
+            }  
+        // otherwise, do nothing
+        else
+            {
+            // empty statement to remove Lint error.
+            }      
+        }                
+    // otherwise, do nothing
+    else
+        {
+        // empty statement to remove Lint error.
+        }
+
+    PRINT1( _L( "Camera <= CCamZoomModel::MaxZoomStep maxStep=%d" ), maxStep );
+    return maxStep;
+    }
+
+
+    
+
+// -----------------------------------------------------------------------------
+// CCamZoomModel::StopZoom
+// Called when the user releases the zoom key to stop an ongoing zoom operation.
+// -----------------------------------------------------------------------------
+//
+void CCamZoomModel::StopZoom()
+    {    
+    PRINT( _L( "Camera => CCamZoomModel::StopZoom " ) );
+    
+    if ( iZoomTimer->IsActive() )
+        {
+        iZoomTimer->Cancel();
+        }
+
+    // Clear the zoom state
+    iState = ECamZoomModelStateZoomNone;
+
+    // Reset zoom multiplier
+    iZoomStepMultiplier = 1;
+
+    if ( iPauseState == EPauseStatePaused )
+        {
+        iPauseState = EPauseStateReleased;
+        }
+    else
+        {
+        iPauseState = EPauseStateNone;
+        }
+        
+    PRINT( _L( "Camera <= CCamZoomModel::StopZoom " ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CCamZoomModel::HandleControllerEventL
+// Called when a controller event occurs
+// -----------------------------------------------------------------------------
+//
+void CCamZoomModel::HandleControllerEventL( TCamControllerEvent aEvent, 
+                                            TInt /*aError*/ )
+  {
+  PRINT( _L( "Camera => CCamZoomModel::HandleControllerEventL " ) );
+  switch( aEvent )
+    {
+    // -----------------------------------------
+    case ECamEventEngineStateChanged:
+      {
+      iCameraState = iController.CameraControllerState();  
+      
+      // If a reset is waiting. This happens if the application 'pretends to exit' 
+      // but this occurred when the engine was not prepared e.g. in standby.
+      // The zoom needs to be set back to default when prepared, and the engine has
+      // now entered a prepared state
+      if ( iResetPending 
+        && ( iCameraState & (ECamImageOn|ECamVideoOn) ) )
+          {
+          // The zoom pane will not be redrawn while the iResetPending flag is on.
+          // This calls RefreshSettings()
+          ResetZoomTo1x();
+          // In this situation the zoom pane should not be shown.
+          /*if ( iPane->IsVisible() )
+              {
+              iPane->MakeVisible( EFalse, ETrue );
+              }*/
+          iResetPending = EFalse;                
+          }     
+      else
+          {
+          // If state changes (video <-> photo) refresh settings
+          RefreshSettings();
+          }
+      }
+      break;
+    // -----------------------------------------
+    case ECamEventCameraChanged:
+      {        
+      // If state changes (camera change) refresh settings
+      RefreshSettings();
+      
+      ResetZoomTo1x();
+      }       
+      break;
+    // -----------------------------------------
+    // Zoom settings now involve basic digital zoom too.
+    // Event name changed ECamEventExtZoomStateChanged => ECamEventZoomSetupChanged
+    case ECamEventImageQualityChanged:
+    case ECamEventZoomSetupChanged:    // Digital/Extended zoom turned on/off/paused/continuous
+      {
+      // If image quality has changed, this may update zoom levels.
+      RefreshSettings();
+      }
+      break;
+    // -----------------------------------------
+    case ECamEventOperationStateChanged:
+      {
+      // As the iRecordingVideo state has changed, need to update
+      // the settings, as this may disable the optical zoom 
+      RefreshSettings();                                            
+      }
+      break;
+    // -----------------------------------------
+    // otherwise, do nothing
+    default:
+      break;
+    } // switch
+    
+  PRINT( _L( "Camera <= CCamZoomModel::HandleControllerEventL " ) );
+  }
+
+// ---------------------------------------------------------------------------
+// CCamZoomModel::ZoomTimerCallback
+// Callback for Zoom Pane timer, used to give smooth zooming
+// ---------------------------------------------------------------------------
+//
+TInt CCamZoomModel::ZoomTimerCallback( TAny* aObject )
+    {    
+    CCamZoomModel* model = static_cast< CCamZoomModel* >( aObject );
+    model->ZoomTimerTick();
+    return KErrNone;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamZoomModel::ZoomTimerTick
+// Called each timer period while the zoom in/out key is held down.
+// ---------------------------------------------------------------------------
+//
+void CCamZoomModel::ZoomTimerTick()
+    {        
+    PRINT( _L("Camera => CCamZoomModel::ZoomTimerTick") );
+    TCamZoomMode modeBefore = iZoomMode;
+                   
+    // Continue the ongoing zoom operation
+    if ( iState == ECamZoomModelStateZoomIn )
+        {
+        ZoomIn();
+        }
+    else if ( iState == ECamZoomModelStateZoomOut )
+        {
+        ZoomOut();
+        }    
+    else
+        {
+        // Do nothing
+        }               
+    
+    // Check if we're currently on a boundary, in which case we need 
+    // to stop and re-initialise the timer for the (potentially) new
+    // interval.                            
+    TCamZoomMode modeAfter = iZoomMode;
+    
+    if ( modeBefore != modeAfter )
+        {
+        // Restart zoom;
+        if ( iZoomTimer->IsActive() )
+            {
+            iZoomTimer->Cancel();
+            }
+        StartZoomTimer();
+        }   
+    PRINT( _L("Camera <= CCamZoomModel::ZoomTimerTick") );
+    }        
+
+
+
+// ---------------------------------------------------------------------------
+// CCamZoomModel::StartZoomTimer
+// Called each timer period while the zoom in/out key is held down.
+// ---------------------------------------------------------------------------
+//
+void CCamZoomModel::StartZoomTimer()
+    {
+    PRINT( _L( "Camera => CCamZoomModel::StartZoomTimer " ) );
+    
+    if ( iZoomTimer->IsActive() )
+        {
+        return; // If only one speed, we're already running so just return.        
+        }
+          
+    TCamZoomMode mode = CurrentZoomType();                
+    
+    TInt stepPeriod = 0;
+    
+    switch ( mode )
+        {            
+        case ECamZoomModeOptical:
+            {
+            stepPeriod = iZoomLAF.iZoomSpeedOpt * 1000;
+            break;        
+            }
+        
+        case ECamZoomModeDigital:
+            {
+            if( iCameraState & ECamImageOn )
+                {    
+                stepPeriod = iZoomLAF.iZoomSpeedDig * 1000;
+                }
+            else
+                {
+                // use slower speed for videomode        
+                stepPeriod = iZoomLAF.iZoomSpeedDig * 2500;
+                }
+            break;        
+            }
+        
+        case ECamZoomModeExtended:
+            {
+            stepPeriod = iZoomLAF.iZoomSpeedExt * 1000;
+            break;        
+            }
+                    
+        case ECamZoomModeUndefined:
+        default:
+            {
+            stepPeriod = 1000000;
+            break;        
+            }        
+        }
+    
+    
+    iZoomTimer->Start( stepPeriod, stepPeriod, TCallBack( ZoomTimerCallback , this) );
+    iZoomMode = mode;
+    
+    PRINT( _L( "Camera <= CCamZoomModel::StartZoomTimer " ) );
+    }
+
+// ---------------------------------------------------------------------------
+// CCamZoomModel::AllowExtZoom
+// Returns whether extended zoom is allowed or not, based on current settings
+// ---------------------------------------------------------------------------
+//
+TBool CCamZoomModel::AllowExtZoom() const
+    {
+    PRINT( _L( "Camera => CCamZoomModel::AllowExtZoom " ) );
+    
+    TInt extendedStep = MaxZoomStep( iExtZoomSteps );    
+    
+    // Check there is a valid extended zoom step to allow to first, and that
+    // we are not in embedded mode (extended zoom not allowed in embedded)
+    if (  KErrNotSupported != extendedStep )
+        {
+        if ( iZoomSetting == ECamSettDigZoomExtendPause
+          || iZoomSetting == ECamSettDigZoomExtendCont )
+            {
+            // If setting allows extended zoom, return true
+            PRINT( _L( "Camera <= CCamZoomModel::AllowExtZoom ETrue" ) );
+            return ETrue;
+            }
+        else
+            {
+            // else user setting disallows it, so return false
+            PRINT( _L( "Camera <= CCamZoomModel::AllowExtZoom EFalse" ) );
+            return EFalse;
+            }
+        }
+    else
+        {
+        // No valid extended zoom, so not allowed even if user said so.
+        PRINT( _L( "Camera <= CCamZoomModel::AllowExtZoom EFalse" ) );
+        return EFalse;
+        }
+    }
+    
+// ---------------------------------------------------------------------------
+// CCamZoomModel::AllowOptZoom
+// Returns whether optical zoom is allowed
+// ---------------------------------------------------------------------------
+// 
+TBool CCamZoomModel::AllowOptZoom() const
+    {        
+    PRINT( _L( "Camera => CCamZoomModel::AllowOptZoom " ) ); 
+    TInt maxOptZoomStep = MaxZoomStep( iOptZoomSteps );
+    if ( KErrNotSupported == maxOptZoomStep // Zoom is NOT supported or
+      || ( !iAllowOptZoom                   // Settings dont allow zoom during recording 
+        && iRecordingVideo ) )              // ...and we're recording now
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::AllowOptZoom EFalse" ) );
+        return EFalse;   
+        }
+    else
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::AllowOptZoom ETrue" ) );
+        return ETrue;                 
+        }      
+    }
+
+// ---------------------------------------------------------------------------
+// CCamZoomModel::AllowDigZoom
+// Returns whether digital zoom is allowed
+// ---------------------------------------------------------------------------
+//
+TBool CCamZoomModel::AllowDigZoom() const
+    {         
+    PRINT( _L( "Camera => CCamZoomModel::AllowDigZoom " ) );
+    TInt maxStdZoomStep = MaxZoomStep( iDigZoomSteps );
+
+    if ( KErrNotSupported    != maxStdZoomStep   // Zoom is supported in current state         
+      && ECamSettDigZoomNone != iZoomSetting   ) // ...and is allowed by user setting
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::AllowDigZoom ETrue" ) );
+        return ETrue;         
+        }
+    else
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::AllowDigZoom False" ) );
+        return EFalse;   
+        }      
+    }
+
+
+// ---------------------------------------------------------------------------
+// CCamZoomModel::CurrentZoom
+// Returns the current zoom level, taking into account optical (if allowed)
+// *and* digital zooms.
+// ---------------------------------------------------------------------------
+//
+TInt CCamZoomModel::CurrentZoom() const
+    {
+    PRINT( _L( "Camera => CCamZoomModel::CurrentZoom" ) );
+    // If we are recording video, and optical isn't allowed while recording
+    // then we only need to represent the Digital zoom in the zoom pane.    
+    if ( iRecordingVideo && !iAllowOptZoom )
+        {
+        // Only use digital value if optical not allowed
+        PRINT( _L( "Camera <= CCamZoomModel::CurrentZoom digital" ) );
+        return iCurZoomStepDigital;
+        }
+    else
+        {
+        // Return the combined zoom value
+        PRINT( _L( "Camera <= CCamZoomModel::CurrentZoom optical+digital" ) );
+        return (iCurZoomStepOptical + iCurZoomStepDigital);
+        }
+    }
+
+
+// ---------------------------------------------------------------------------
+// CCamZoomModel::PauseAtBoundary
+// Returns whether to pause at the specified boundary
+// ---------------------------------------------------------------------------
+//
+TBool CCamZoomModel::PauseAtBoundary( TCamZoomBoundary aBoundary ) const
+  {
+  PRINT( _L( "Camera => CCamZoomModel::PauseAtBoundary" ) );
+  if ( iCameraState & ECamVideoOn )
+  	{
+    // Always return false for video, as we do not want to 
+    // force the zoom operation to pause at any boundary
+    // in video mode. 
+    PRINT( _L( "Camera <= CCamZoomModel::PauseAtBoundary EFalse" ) );  
+    return EFalse;
+    }
+  else
+  	{
+  	if ( ECamZoomBoundaryOptDig == aBoundary )
+      {
+      // Reason to *not* pause at the optical/digital boundary is if
+      // user set the "On (continuous)" or "Extended on (continuous) setting
+      if ( ECamSettDigZoomNormalCont == iZoomSetting
+        || ECamSettDigZoomExtendCont == iZoomSetting )
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::PauseAtBoundary EFalse" ) );  
+        return EFalse;            
+        }
+      else 
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::PauseAtBoundary ETrue" ) );  
+        return ETrue;
+        }
+      }
+    else if ( ECamZoomBoundaryDigExt == aBoundary ) 
+      {
+      // Only reason *not* to pause in digital/extended boundary is if
+      // user zoom setting states "extended on without pauses".
+      if ( ECamSettDigZoomExtendCont == iZoomSetting )
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::PauseAtBoundary EFalse" ) );  
+        return EFalse;
+        }
+      else
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::PauseAtBoundary ETrue" ) );  
+        return ETrue;    
+        }
+      }
+    else // No other boundaries known, return "no pause".
+      {
+      PRINT( _L( "Camera <= CCamZoomModel::PauseAtBoundary EFalse" ) );  
+      return EFalse;
+      }     
+    }	
+  }
+  
+    
+// -----------------------------------------------------------------------------
+// CCamZoomPane::IsCurrentlyZooming
+// Returns ETrue if the zoom model is currently zooming in/out,
+// else returns EFalse
+// -----------------------------------------------------------------------------
+//
+TBool CCamZoomModel::IsCurrentlyZooming() const
+    {    
+    PRINT( _L( "Camera => CCamZoomModel::IsCurrentlyZooming" ) );
+    if ( ECamZoomModelStateZoomIn  == iState 
+      || ECamZoomModelStateZoomOut == iState )
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::IsCurrentlyZooming ETrue" ) );
+        return ETrue;
+        }
+    else
+        {
+        PRINT( _L( "Camera <= CCamZoomModel::IsCurrentlyZooming EFalse" ) );
+        return EFalse;
+        }
+    }
+    
+// -----------------------------------------------------------------------------
+// CCamZoomModel::ZoomingState
+// -----------------------------------------------------------------------------
+//
+CCamZoomModel::TCamZoomModelState CCamZoomModel::ZoomingState()
+    {    
+    return iState;  
+    }
+ 
+
+// -----------------------------------------------------------------------------
+// CCamZoomPane::ResetToDefaultAfterPrepare
+// Sets the zoompane to reset the zoom level to default values
+// next time the engine is prepared
+// -----------------------------------------------------------------------------
+//
+void CCamZoomModel::ResetToDefaultAfterPrepare( TBool aReset )
+    {
+    iResetPending = aReset;
+    }     
+
+// -----------------------------------------------------------------------------
+// CCamZoomPane::IsResetPending
+// Whether or not the zoom level is waiting to be reset to default
+// -----------------------------------------------------------------------------
+//
+TBool CCamZoomModel::IsResetPending() const
+    {
+    return iResetPending;
+    }
+
+// -----------------------------------------------------------------------------
+// ReadCurrentResolution
+// -----------------------------------------------------------------------------
+//
+void 
+CCamZoomModel::ReadCurrentResolution()
+  {
+  PRINT1( _L("Camera => CCamZoomModel::ReadCurrentResolution, now:%d"), iCurrentResolution );
+  if ( iCameraState & ECamImageOn )
+    {                
+    iCurrentResolution = iController.GetCurrentImageResolution();
+    }
+  else if( iCameraState & ECamVideoOn )
+    {
+    iCurrentResolution = iController.GetCurrentVideoResolution();
+    }
+  else
+    {
+    iCurrentResolution = KErrNotReady;
+    }
+  PRINT1( _L("Camera <= CCamZoomModel::ReadCurrentResolution, got:%d"), iCurrentResolution );
+  }
+
+// -----------------------------------------------------------------------------
+// SetZoomMultiplier
+// -----------------------------------------------------------------------------
+//
+void CCamZoomModel::SetZoomMultiplier( TInt aZoomStepMultiplier )
+    {
+    iZoomStepMultiplier = aZoomStepMultiplier;
+    if ( iCameraState & ECamVideoOn )
+        {
+        iZoomStepMultiplier *= 2;
+        }
+    }
+
+//  End of File