camerauis/cameraapp/generic/src/CamPreCaptureContainerBase.cpp
changeset 0 1ddebce53859
child 1 f5ec9446e5bf
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/src/CamPreCaptureContainerBase.cpp	Thu Jan 07 16:18:56 2010 +0200
@@ -0,0 +1,2537 @@
+/*
+* Copyright (c) 2007-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:  Container base class for pre-capture views*
+*/
+
+
+
+// INCLUDE FILES
+#include <eikmenub.h>
+#include <aknview.h>
+#include <w32std.h>
+#include <gulutil.h>
+#include <AknIconUtils.h>
+#include <barsread.h>    // resource reader
+#include <AknsFrameBackgroundControlContext.h>
+#include <AknsDrawUtils.h>
+#include <eikenv.h>
+#include <eikappui.h> // For CCoeAppUiBase
+#include <eikapp.h>   // For CEikApplication
+#include <layoutmetadata.cdl.h>            
+#include <aknlayoutscalable_apps.cdl.h>    
+
+#include <cameraapp.mbg>
+#include <cameraapp.rsg>
+#include <vgacamsettings.rsg>
+
+
+#include "CamAppUiBase.h"
+#include "CamPreCaptureContainerBase.h"
+#include "CamLogger.h"
+#include "CamSidePane.h"
+#include "CamUtility.h"
+#include "CamPanic.h"
+#include "Cam.hrh"
+#include "CamAppUi.h"   
+#include "CamIndicator.h"
+#include "CamIndicatorResourceReader.h"
+#include "CamIndicatorData.h"
+#include "CamSelfTimer.h"
+#include "CamPreCaptureViewBase.h"
+#include "CamStillPreCaptureView.h"
+#include "CamSettings.hrh"
+#include "CamNaviCounterControl.h"
+#include "CamNaviProgressBarControl.h"
+#include "camuiconstants.h" // KCamDirectColorVal
+#include "camactivepalettehandler.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "CamPreCaptureContainerBaseTraces.h"
+#endif
+#include "camconfiguration.h"
+#include "CameraUiConfigManager.h"
+
+
+// CONSTANTS
+const TInt KZoomPanelTimeout = 4000000;     // 4s 
+const TInt KReticuleFlashTimeout = 250000;  // Quarter of a second (in microseconds).
+const TInt KAFIconCorners = 4; // Hip to be square 
+
+#include "camvfgridinterface.h"
+#include "camlinevfgriddrawer.h"
+
+// Snapshot data is needed in timelapse mode
+const TUint KCameraEventInterest = ( ECamCameraEventClassVfControl      
+                                   | ECamCameraEventClassVfData 
+                                   | ECamCameraEventClassSsData 
+                                   );
+
+
+
+// ================= MEMBER FUNCTIONS =======================
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase
+// Destructor
+// ---------------------------------------------------------
+//
+CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase()
+  {
+  PRINT( _L("Camera => ~CCamPreCaptureContainerBase" ))
+  
+  iController.ViewfinderWindowDeleted( &Window() );
+  
+  iController.RemoveSettingsObserver  ( this );
+  iController.RemoveCameraObserver    ( this );
+  iController.RemoveControllerObserver( this );    
+  
+    if ( iZoomTimer && iZoomTimer->IsActive() )
+    {    
+    iZoomTimer->Cancel();
+    }
+  delete iZoomTimer;
+  delete iVfGridDrawer;
+
+  if ( iController.UiConfigManagerPtr() && 
+       iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+      {
+      iAfIcons.ResetAndDestroy();
+      iLayouts.Close(); 
+      if ( iReticuleTimer && iReticuleTimer->IsActive() )
+        {    
+        iReticuleTimer->Cancel();
+        }
+      delete iReticuleTimer;    
+      }
+
+  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+
+  iResolutionIndicators.ResetAndDestroy();
+  iResolutionIndicators.Close();
+  if ( iController.UiConfigManagerPtr() && 
+       iController.UiConfigManagerPtr()->IsLocationSupported() )
+      {
+      PRINT( _L("Camera => ~CCamPreCaptureContainerBase - delete iLocationIconController" ))
+      delete iLocationIconController;
+      }
+
+  delete iOffScreenBitmap;
+  delete iBitmapDevice;
+  delete iBitmapGc;
+  
+  // if shutting down, observers are removed automatically  
+  if ( 
+      iController.IsAppUiAvailable() &&
+      appUi && !iController.IsInShutdownMode() )
+    {
+    // Deregister as burst mode observer
+    appUi->RemoveBurstModeObserver( this );
+    }
+
+  delete iBatteryPaneController;
+  
+  delete iViewFinderBackup;
+  iViewFinderBackup = NULL;
+  iReceivedVfFrame = EFalse;
+
+  PRINT( _L("Camera <= ~CCamPreCaptureContainerBase" ))
+  }
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::BaseConstructL
+// Symbian OS 2nd phase constructor
+// ---------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::BaseConstructL( const TRect& aRect )
+  {
+  PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL ") );
+  
+  CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+  iZoomPane = appUi->ZoomPane();
+  
+  CCamContainerBase::BaseConstructL( aRect );
+  
+  iViewFinderBackup = NULL;
+  iReceivedVfFrame = EFalse;
+  
+  // Check whether zoom & side pane will be on the left or the right of the screen
+  TInt handedInt;
+  User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiSidePanePosition, handedInt ) );
+  iHandedness = static_cast< TCamHandedness >( handedInt );
+
+  TResourceReader reader;                                                                                     
+  iEikonEnv->CreateResourceReaderLC( reader, ROID(R_CAM_ZOOM_PANE_WIDTH_ID));    
+  iZoomPaneWidth = reader.ReadInt16();
+  CleanupStack::PopAndDestroy(); // reader
+  
+  // Create Zoom Pane based on Rect passed in on creation
+  TRect paneRect( Rect() );
+
+  // if the side pane is on the left
+  if ( iHandedness == ECamHandLeft ) 
+    { 
+    paneRect.iBr.iX = iZoomPaneWidth;
+    }
+  else // the side pane is on the right
+    {
+    paneRect.iTl.iX = paneRect.iBr.iX - iZoomPaneWidth;    
+    }
+  
+  User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiOverLaySidePane, iOverlayViewFinder ) );
+
+  iController.AddControllerObserverL( this ); // For zoom state changes
+  iController.AddCameraObserverL( this, KCameraEventInterest );
+  iController.AddSettingsObserverL( this );
+
+  iZoomPane->MakeVisible( EFalse, EFalse ); // On app startup, it's invisible
+
+  if ( !appUi->IsSecondCameraEnabled() )
+    {
+    iZoomPane->SetZoomKeys( iPrimaryZoomInKeys, iPrimaryZoomOutKeys );
+    }
+  else
+    {     
+    iZoomPane->SetZoomKeys( iSecondaryZoomInKeys, iSecondaryZoomOutKeys );
+    }
+  
+  iZoomTimer = CPeriodic::NewL( CActive::EPriorityUserInput );
+  
+  if ( iController.UiConfigManagerPtr() && 
+       iController.UiConfigManagerPtr()->IsAutoFocusSupported() &&
+       !iController.UiConfigManagerPtr()->IsFaceTrackingSupported() )
+      {
+      iReticuleTimer = CPeriodic::NewL( CActive::EPriorityUserInput );
+    
+      // Layout the reticule.                                                                                           
+      iAfReadyIcon = CreateAfIconL( KRgbWhite );
+      iAfFocusIcon = CreateAfIconL( KRgbGreen );
+      iAfErrIcon   = CreateAfIconL( KRgbRed );
+      }
+
+  iSidePane = appUi->SidePane();
+  iSidePane->SetRect( paneRect );
+
+  // Register as burst mode observer
+  appUi->AddBurstModeObserverL( this );
+  
+  CreateResolutionIndicatorL();
+  
+  if ( iController.UiConfigManagerPtr() && 
+       iController.UiConfigManagerPtr()->IsLocationSupported() )
+      {
+      TRect Locrect = Rect();
+      PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL - create iLocationIconController") )
+      iLocationIconController = CCamLocationIconController::NewL( iController, *this, ETrue, Locrect );
+      SetLocationIndicatorVisibility();
+      }
+
+  TInt color;
+  TInt gray;
+  
+  TDisplayMode displaymode =
+      CEikonEnv::Static()->WsSession().GetDefModeMaxNumColors( color, gray );
+  
+  // set up the offscreen bitmap
+  iOffScreenBitmap = new ( ELeave ) CFbsBitmap();
+  
+  User::LeaveIfError( iOffScreenBitmap->Create( Rect().Size(), EColor16MU/*displaymode*/ ) );
+  
+  PRINT1( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL disp mode (%d)"), displaymode )
+  iBitmapDevice = CFbsBitmapDevice::NewL( iOffScreenBitmap );
+  User::LeaveIfError( iBitmapDevice->CreateContext( iBitmapGc ) );
+
+  iRect = ViewFinderFrameRect();
+  // if using direct viewfinding pass Rect to control
+
+
+  if ( iController.UiConfigManagerPtr() && 
+       iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+      {
+      // Check whether we should be showing the reticule.
+      // NOTE: This will only be showed in still, not video views
+      iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();
+      }
+
+  // Setup viewfinder grid
+  InitVfGridL( iRect );
+
+  // Do not construct battery pane controller, if secondary camera is in use
+  if ( iController.ActiveCamera() != ECamActiveCameraSecondary || 
+       appUi->IsQwerty2ndCamera() ) 
+    {
+    iBatteryPaneController = CCamBatteryPaneController::NewL( 
+                             *this, ETrue);  
+    }
+    // Make sure fixed toolbar is on top of this window
+    DrawableWindow()->SetOrdinalPosition( KCamPreCaptureWindowOrdinalPos );
+
+  iController.SetViewfinderWindowHandle( &Window() );
+  appUi->SetViewFinderInTransit(EFalse);
+  iController.StartIdleTimer();
+  
+  PRINT( _L("Camera <= CCamPreCaptureContainerBase::BaseConstructL ") );
+  }
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::CCamPreCaptureContainerBase
+// C++ constructor
+// ---------------------------------------------------------------------------
+//
+CCamPreCaptureContainerBase::CCamPreCaptureContainerBase(
+        CCamAppController& aController,
+        CAknView& aView )
+  : CCamContainerBase( aController, aView ),   
+    iDisableRedraws( EFalse )
+  {
+  }
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::ZoomTimerCallback
+// Callback for Zoom Pane timer
+// ---------------------------------------------------------------------------
+//
+TInt CCamPreCaptureContainerBase::ZoomTimerCallback( TAny* aObject )
+    {
+    CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );
+    cont->ZoomTimerTick();
+    return KErrNone;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::ReticuleTimerCallback
+// Callback for flashing of the focus reticule
+// ---------------------------------------------------------------------------
+//
+TInt CCamPreCaptureContainerBase::ReticuleTimerCallback( TAny* aObject )
+    {
+    CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );
+    cont->iReticuleFlashOn = !cont->iReticuleFlashOn;
+
+    // This is where we force a redraw of the reticule, if we are using
+    // Direct Viewfinding.  However, if we are in burst mode, we must
+    // use Bitmap Viewfinding, so only draw reticule if NOT in burst mode
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+    if ( appUi && appUi-> IsDirectViewfinderActive() )
+        {
+        cont->DrawDeferred();
+        }
+    return KErrNone;
+    }
+    
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::ShowZoomPaneWithTimer
+// Makes Zoom Pane visible for the period of the pane timer.
+// ---------------------------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::ShowZoomPaneWithTimer()
+    {
+    __ASSERT_DEBUG( iZoomTimer, CamPanic( ECamPanicNullPointer ) );
+    __ASSERT_DEBUG( iZoomPane, CamPanic( ECamPanicNullPointer ) );  
+    __ASSERT_DEBUG( iSidePane, CamPanic( ECamPanicNullPointer ) ); 
+
+    PRINT(_L("Camera => CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    
+
+    // If already active, cancel the timer
+    if ( iZoomTimer->IsActive() )
+        {    
+        iZoomTimer->Cancel();
+        }
+
+    iZoomTimer->Start( KZoomPanelTimeout, KZoomPanelTimeout, TCallBack( ZoomTimerCallback , this) );
+    
+    iZoomPane->MakeVisible( ETrue, ETrue );
+
+    PRINT(_L("Camera <= CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    
+    }
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::ZoomTimerTick
+// Called as a result of the Zoom Pane timer expiring, switches side panes
+// to hide the Zoom pane.
+// ---------------------------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::ZoomTimerTick()
+    {
+    PRINT(_L("Camera => CCamPreCaptureContainerBase::ZoomTimerTick")); 
+    // Cancel the (potentially) recurring timer
+    iZoomTimer->Cancel();
+
+    // If zooming is still in progress (this happens if the zoom key has
+    // been held down longer than the zoom pane timer), keep the pane
+    // visible
+    if ( iZoomPane->IsCurrentlyZooming() )
+        {
+        iZoomTimer->Start( KZoomPanelTimeout,
+                           KZoomPanelTimeout, 
+                           TCallBack( ZoomTimerCallback , this) );
+        }
+    else
+        {
+        // Make Indicator Pane visible again and hide the ZoomPane
+        iZoomPane->MakeVisible( EFalse, ETrue );
+        
+        // background needs redrawing behind zoom pane
+        iRedrawPaneBackground = ETrue;
+        }
+    PRINT(_L("Camera <= CCamPreCaptureContainerBase::ZoomTimerTick")); 
+    }
+
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::OfferKeyEventL
+// Handles this application view's command keys. Forwards other
+// keys to child control(s).
+// ----------------------------------------------------
+//
+TKeyResponse 
+CCamPreCaptureContainerBase::OfferKeyEventL( const TKeyEvent& aKeyEvent,
+                                                   TEventCode aType )
+    {         
+    PRINT2( _L("Camera => CCamPreCaptureContainerBase::OfferKeyEventL type %d) scan code (%d)"), aType, aKeyEvent.iScanCode )
+
+#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT
+    // Log event only if this is the first capture key press and we are in correct state
+    TCamCaptureOperation operation = iController.CurrentOperation();
+
+    TBool isCaptureKeyForUs  = (IsCaptureKeyL( aKeyEvent, aType )
+            && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );
+
+    TBool isOperationStateOk = (ECamNoOperation == operation);
+    if( isCaptureKeyForUs && isOperationStateOk )
+        { 
+        PERF_EVENT_START_L1( EPerfEventKeyToCapture );  
+        }
+#endif      
+
+    TBool isCaptureKeyForSymbTrace  = (IsCaptureKeyL( aKeyEvent, aType )
+            && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );
+    if( isCaptureKeyForSymbTrace )
+        {
+        PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL Symbian Traces Active") );
+        OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );   //CCORAPP_SHOT_TO_SNAPSHOT_START
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );  //CCORAPP_PRI_SHOT_TO_SNAPSHOT_START
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SAVE 1" );  //CCORAPP_PRI_SHOT_TO_SAVE_START
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SHOT 1" );  //CCORAPP_PRI_SHOT_TO_SHOT_START
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_STILL 1" ); //CCORAPP_SHOT_TO_STILL_START
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_CAPTURE_START 1" ); //CCORAPP_CAPTURE_START_START
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP6_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SERIAL_SHOOTING 1" );   //CCORAPP_PRI_SERIAL_SHOOTING_START
+        }
+
+    iController.StartIdleTimer();
+    if( aType == EEventKeyUp )
+        {
+        iController.SetDemandKeyRelease( EFalse ); 
+        }
+
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+
+    if ( appUi && appUi->CheckCourtesyKeyEventL( aKeyEvent, aType, ETrue ) == EKeyWasConsumed )
+        {
+        PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL courtesy key") );
+        return EKeyWasConsumed;
+        }
+
+    // If a control has the focus, give it the first opportunity to
+    // process the key event
+
+    if( iActivePalette 
+            && iActivePalette->CoeControl()
+            && iActivePalette->CoeControl()->OfferKeyEventL(aKeyEvent,aType) == EKeyWasConsumed )
+        {
+        PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL AP consumed") );
+        return EKeyWasConsumed;
+        }
+
+    // The key press has not been handled by a visible control
+    // so will be processed by the container.
+
+    // Handle Zoom in key if we are not saving video
+    PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL B") )
+    if ( IsZoomKeyL( aKeyEvent, aType ) 
+            && ECamCompleting != iController.CurrentOperation() 
+            && !iController.CurrentlySavingVideo()
+            && !appUi->IsSecondCameraEnabled() )
+        {       
+        // Offer the key event to the zoom pane/model
+        TKeyResponse resp = iZoomPane->OfferKeyEventL( aKeyEvent, aType );
+
+        // If it was consumed, we need to keep the zoom pane visible
+        if ( resp == EKeyWasConsumed )
+            {
+            ShowZoomPaneWithTimer();
+            }
+        PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Zoom key") );    
+        return resp;
+        }
+
+    else if ( EEventKey == aType
+            && EKeyOK    == aKeyEvent.iCode
+            && 0         == aKeyEvent.iRepeats )
+        {
+        TBool MSKCapture(EFalse);
+        if ( appUi && !appUi->IsToolBarVisible() && aKeyEvent.iScanCode == EStdKeyDevice3 )
+            {
+            MSKCapture = ETrue;
+            }
+        if( appUi->ActiveCamera() == ECamActiveCameraPrimary
+                && !MSKCapture )
+            {
+            // AP needs to handle this
+            PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Ok key") );    
+            return EKeyWasNotConsumed;
+            }
+        }
+
+    // Handle right and left navi keys. 
+    // Each product defines the behaviour that is mapped to these keys.        
+    else if ( EEventKey == aType
+            && ( EStdKeyRightArrow == aKeyEvent.iScanCode
+                    || EStdKeyLeftArrow  == aKeyEvent.iScanCode ) )
+        {
+        if ( HandleLeftRightNaviKeyL( aKeyEvent, aType ) == EKeyWasConsumed )
+            {
+            PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL left/right navi") );    
+            return EKeyWasConsumed;
+            }
+        }
+
+    else
+        {
+        // empty else statement to remove LINT error
+        }
+
+    TBool captureKey = IsCaptureKeyL( aKeyEvent, aType );
+
+    // Stop any zooming activity if capture key detected
+    if ( captureKey )
+        {
+        CCamZoomPane* zoom_pane = appUi->ZoomPane();
+
+        if ( zoom_pane )
+            {
+            PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL calling StopZoom()") );
+            zoom_pane->StopZoom();
+            }
+        }
+    TBool viewFinderRunning = iReceivedVfFrame;
+    if ( iController.UiConfigManagerPtr() &&
+           ( iController.UiConfigManagerPtr()->
+               IsDSAViewFinderSupported( ETrue ) &&
+               !appUi->IsSecondCameraEnabled() ) ||
+           ( iController.UiConfigManagerPtr()->
+               IsDSAViewFinderSupported( EFalse ) &&
+               appUi->IsSecondCameraEnabled() ) )
+        {
+        viewFinderRunning = appUi->IsDirectViewfinderActive();
+        }
+
+    TBool shutterKey = IsShutterKeyL( aKeyEvent, aType );
+    TBool interruptKey = captureKey;
+    if ( !appUi->IsSecondCameraEnabled() &&
+            iController.UiConfigManagerPtr() && 
+            iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        interruptKey = shutterKey;
+        }
+
+    if(iController.IsProcessingCapture() 
+            // && appUi->CurrentCaptureMode() == ECamCaptureModeStill 
+            && ECamControllerImage == iController.CurrentMode()
+            && EEventKeyDown == aType
+            && interruptKey
+            && appUi->ShowPostCaptureView()
+            && !appUi->IsBurstEnabled() 
+            && !appUi->SelfTimerEnabled()) 
+        {
+        iController.SetCaptureKeyPressedWhileImageSaving(ETrue);
+        PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL 2nd press of capturekey") )
+        return EKeyWasConsumed;
+
+        }
+    // Check if the key is a shutter key and...
+    if ( shutterKey && viewFinderRunning )
+        {
+        if ( EKeyWasConsumed == HandleShutterKeyEventL( aKeyEvent, aType ) )
+            {
+            PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL shutter key") );    
+            return EKeyWasConsumed;
+            }
+        }
+    else if ( captureKey             // Capture key event...
+            && EEventKeyDown == aType // ...it's a key down event and
+            && viewFinderRunning     // ...the viewfinder is running
+            && !iController.Busy()    // CamCameraController is not busy.
+            && !iController.IsDemandKeyRelease() ) // ...and no need to wait key up 
+        {
+        PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. [KEYS] capture key down") )
+        if ( HandleCaptureKeyEventL( aKeyEvent ) == EKeyWasConsumed )
+            {
+            PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL capture key handled") )
+            return EKeyWasConsumed;
+            }
+        }         
+    else if ( captureKey && aType == EEventKeyUp )
+        {      
+        PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. [KEYS] capture key up") )
+        if ( iController.SequenceCaptureInProgress()  // actively capturing or   
+                || appUi->IsBurstEnabled()                  // burst is enabled (for if focusing)
+        )
+            {
+            if ( appUi->CurrentBurstMode() == ECamImageCaptureTimeLapse )
+                {
+                PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. timelapse mode, update CBA") )
+                // if this is a timelapse capture then set the softkeys to blank/cancel.
+                // The next shutter press will stop the capture.
+                TRAP_IGNORE( static_cast<CCamPreCaptureViewBase*>( &iView )->UpdateCbaL() );
+                }
+            else
+                {
+                if ( !appUi->SelfTimerEnabled() )
+                    {
+
+                    if ( !iController.AllSnapshotsReceived() && (iController.CurrentCapturedCount() >= 1) )
+                        {   		
+                        PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. burst mode, soft stop burst..") )
+                        // burst ongoing, still receiving snapshots, end it as soon as possible.
+                        iController.SetKeyUp( ETrue );
+                        iController.SoftStopBurstL();
+                        }
+                    else 
+                        {
+                        // ignore keypress, all snapshot received and processing image data
+                        // processing only stopped from softkey
+                        }
+                    }
+                }
+
+            PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL .. capture key up handled") )
+            return EKeyWasConsumed;
+            }
+        }
+    else 
+        {
+        // remove Lint warning                
+        }
+
+    TKeyResponse response = CCamContainerBase::OfferKeyEventL( aKeyEvent, aType );
+
+    PRINT1( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL, return %d"), response )
+    return response;
+    }
+
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::HandleControllerEventL
+// Handles zoom events from the Controller
+// ---------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase
+::HandleControllerEventL( TCamControllerEvent aEvent, 
+                          TInt                /*aError*/ )
+  {
+  PRINT1(_L("Camera => CCamPreCaptureContainerBase::HandleControllerEventL(%d)"), aEvent );
+
+  __ASSERT_DEBUG( iZoomPane, CamPanic( ECamPanicNullPointer ) );
+  CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+
+  switch( aEvent )
+    {
+    // ---------------------------------------------------
+    case ECamEventSaveCancelled:
+      {
+      // clear the side pane after saving images dialog is dismissed
+      ForceSideZoomPaneDraw();
+      break;
+      }
+    // ---------------------------------------------------
+    case ECamEventCameraChanged:
+      {      
+      SetResolutionIndicator();
+      break;
+      }
+
+    // ---------------------------------------------------
+    case ECamEventCounterUpdated:
+      {
+      if ( iController.UiConfigManagerPtr() &&
+           iController.UiConfigManagerPtr()->IsDSAViewFinderSupported() )
+          {
+          if( iPaneInUse == ECamPaneProgress && appUi && appUi->IsDirectViewfinderActive() )
+            {
+            ActivateGc();
+            CWindowGc& gc = SystemGc();
+            iNaviProgressBarControl->DrawProgressBar( gc );
+            DeactivateGc();
+            }  
+          else if ( iPaneInUse == ECamPaneCounter && iController.SequenceCaptureInProgress() )
+            {
+            DrawDeferred();
+            }
+          else
+            {
+            // Lint
+            }
+          }
+      break;
+      }
+    // ---------------------------------------------------
+    case ECamEventOperationStateChanged:
+      {
+      if( iController.IsAppUiAvailable() && iController.UiConfigManagerPtr()
+          && iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        // ReCheck if we have to draw the reticule.
+        if ( ECamControllerImage == iController.CurrentMode() )
+            {
+            iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();
+            HandleOperationStateChangeEventL();
+            }
+       
+        }
+      break;
+      }
+    // ---------------------------------------------------
+    case ECamEventExitRequested:
+      {
+      iShuttingDown = ETrue;                        
+      break;
+      }
+    // ---------------------------------------------------
+    case ECamEventRecordComplete:
+      {
+      iResolutionIndicators[iCurrentIndicator]->CancelOverridePosition();
+      break;
+      }    
+    // ---------------------------------------------------
+    // Scene has changed
+    case ECamEventSceneStateChanged:
+      {
+      PRINT(_L("Camera <> CCamPreCaptureContainerBase::HandleControllerEventL ECamEventSceneStateChanged"));
+      if ( iController.UiConfigManagerPtr() && 
+           iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        // Scene state has changed, re-check whether we should 
+        // be showing the reticule
+        iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();
+        }
+      ResetVFGridVisibility();
+      appUi->APHandler()->UpdateActivePaletteL();
+      break;
+      }
+    // ---------------------------------------------------
+    case ECamEventImageData:
+        {
+        UpdateBurstProcessingTextL( iController.CapturedImages(), iController.CurrentCapturedCount() );
+        break;
+        }
+    // ---------------------------------------------------  
+    case ECamEventSliderClosed:
+        {
+        //Do nothing
+        }
+		break;
+    // ---------------------------------------------------
+    case ECamEventCaptureComplete:
+        {
+        if ( !appUi->IsSecondCameraEnabled() 
+              && iController.CurrentMode() == ECamControllerImage )
+            {
+            DrawNow();
+            }
+        break;
+        }
+    // ---------------------------------------------------
+    case ECamEventFaceTrackingStateChanged:
+        {
+        if( iController.UiConfigManagerPtr()
+            && iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+            {
+            // ReCheck if we have to draw the reticule.
+            if ( ECamControllerImage == iController.CurrentMode() )
+                {
+                iPhotoSceneUsesReticule = 
+                    !iController.CurrentSceneHasForcedFocus();
+                }
+            }
+        }
+    default:
+      {
+      // Other events => no action.
+      break;
+      }
+    // ---------------------------------------------------
+    }
+  PRINT(_L("Camera <= CCamPreCaptureContainerBase::HandleControllerEventL"));
+  }
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::HandleForegroundEvent
+// Handles change of app foreground state
+// ---------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::HandleForegroundEventL( TBool aForeground )
+    {
+    PRINT1( _L( "Camera => CCamPreCaptureContainerBase::HandleForegroundEventL %d" ), aForeground );            
+    if ( aForeground )
+        {
+/*#ifndef __WINS__
+        CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+        if( appUi->IsInCallSend() )
+            {
+            // force side pane to update
+            appUi->SidePane()->SetInitialState();
+            }
+#endif*/      
+        // Check if we are on a non-standard zoom level.  Also checks if previous 
+        // view was PostCapture or settings, if so, we dont want to show the zoom
+        // pane either 
+        if ( iZoomPane->ZoomValue() != 0  &&
+             !iZoomPane->IsResetPending() &&
+             iPrevViewId != ECamViewIdStillPostCapture &&
+             iPrevViewId != ECamViewIdVideoPostCapture &&
+             iPrevViewId != ECamViewIdPhotoSettings &&
+             iPrevViewId != ECamViewIdVideoSettings )
+            {
+            // If we have moved to the foreground and need to show the zoom level.
+            ShowZoomPaneWithTimer();
+            }            
+
+        ResetVFGridVisibility();
+        }
+    else    
+        {
+        iReceivedVfFrame = EFalse;
+
+        // Cancel timer if we're losing focus
+        iZoomTimer->Cancel();  
+        
+        if ( !iShuttingDown )
+            {
+            iSidePane->MakeVisible( ETrue );
+            iZoomPane->MakeVisible( EFalse, EFalse );
+            
+            // Will stop any ongoing zoom
+            iZoomPane->HandleForegroundEvent( aForeground );
+            }
+        
+        // Update the view ID for when we come back.
+        TCamAppViewIds viewId = static_cast<TCamAppViewIds>( iView.Id().iUid );
+        SetPreviousViewId( viewId );      
+        }
+    PRINT( _L( "Camera <= CCamPreCaptureContainerBase::HandleForegroundEventL" ) );        
+    }
+
+
+// -----------------------------------------------------------------------------
+// HandleAppEvent <<virtual>>
+//
+// -----------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase::HandleAppEvent( const TCamAppEvent& aEvent )
+  {
+  PRINT( _L("Camera => CCamPreCaptureContainerBase::HandleAppEvent") );
+
+  switch( aEvent )
+    {
+    case ECamAppEventFocusGained:
+      {
+      // Clear non-fading flag. It may have been set when showing a note
+      // in CCamAppUi::ShowErrorNoteL().
+
+      CEikMenuBar* menuBar = iView.MenuBar();
+      TBool menuOpened( EFalse );
+      if ( menuBar )
+          {
+          menuOpened = menuBar->IsDisplayed();
+          }
+      
+      RDrawableWindow* window = DrawableWindow();
+      if ( window && !menuOpened )
+          {
+          window->SetNonFading( EFalse );
+          }
+
+      if( iBatteryPaneController )
+        iBatteryPaneController->Pause( EFalse );
+      break;
+      }
+    case ECamAppEventFocusLost:
+      {
+      if( iBatteryPaneController )
+        iBatteryPaneController->Pause( ETrue );
+      break;
+      }
+    default:
+      {
+      break;
+      }
+    }
+
+  PRINT( _L("Camera <= CCamPreCaptureContainerBase::HandleAppEvent") );
+  }
+
+
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::MakeVisible
+// Handles a change to the controls visibility
+// ----------------------------------------------------
+//
+void CCamPreCaptureContainerBase::MakeVisible( TBool aVisible )
+  {
+  PRINT1( _L("Camera => CCamPreCaptureContainerBase::MakeVisible, visible:%d"), aVisible );
+
+  CCamContainerBase::MakeVisible( aVisible );
+
+  PRINT ( _L("Camera <= CCamPreCaptureContainerBase::MakeVisible") );
+  }
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::Draw
+// Draw control
+// ---------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase::Draw( const TRect& /*aRect*/ ) const
+   {
+   PRINT( _L( "Camera => CCamPreCaptureContainerBase::Draw" ) );    
+   
+   CWindowGc& gc = SystemGc(); 
+   CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+  
+   // Is direct viewfinding active
+    TBool directVf = appUi ? appUi->IsDirectViewfinderActive() : EFalse;
+                 
+   // Using bitmap viewfinding and a frame is available
+   TBool bitmapFrame = !directVf && iReceivedVfFrame && iViewFinderBackup;
+
+   if( iCamOrientation != ECamOrientationCamcorder && 
+       iCamOrientation != ECamOrientationCamcorderLeft && 
+    !( iController.UiConfigManagerPtr() && 
+       iController.IsDirectScreenVFSupported( EFalse ) && 
+       iCamOrientation == ECamOrientationPortrait ) )
+      { 
+      // Using secondary camera 
+      }
+   else  if( !bitmapFrame )  
+       {  
+       // Using primary camera and direct viewfinding is active, there's no bitmap
+       // viewfinder frame available, or the frame doesn't cover whole screen
+       // => Paint the background with background color / color key
+                            
+       gc.SetPenStyle( CGraphicsContext::ENullPen );    
+    
+       if( iController.UiConfigManagerPtr() && directVf )
+           {    
+           gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );
+           gc.SetBrushColor( TRgb::Color16MA( 0 ) );
+           }
+       else
+           {
+           // Use the background color
+           gc.SetBrushColor( TRgb( KCamPrecaptureBgColor ) );   
+           }
+            
+       gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
+       gc.DrawRect( Rect() );          
+       }
+      else
+      	{
+      	}
+   if ( bitmapFrame )
+      {
+      // Draw the current bitmap viewfinder frame  
+      DrawFrameNow( gc, iViewFinderBackup );
+      }          
+
+   gc.Reset();        
+   if( directVf 
+   && !iController.IsViewFinding() )
+       {
+       return;
+       }
+   else
+       {
+       //Do nothing
+       }
+   DrawScreenFurniture( gc );
+   DrawNaviControls( gc );
+   PRINT( _L( "Camera <= CCamPreCaptureContainerBase::Draw" ) );        
+   }
+
+
+
+
+
+
+// <CAMERAAPP_CAPI_V2_MIGRATION>
+// ===========================================================================
+// From MCamCameraObserver
+
+// ---------------------------------------------------------------------------
+// virtual HandleCameraEventL
+// ---------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase
+::HandleCameraEventL( TInt              aStatus, 
+                      TCamCameraEventId aEventId, 
+                      TAny*             aEventData /*= NULL*/ )
+  {
+  switch( aEventId )
+    {
+    // -----------------------------------------------------
+    case ECamCameraEventVfStop:
+    case ECamCameraEventVfRelease:
+      // old vf frame being shown when returning from background.
+       if ( ECamActiveCameraSecondary ==  iController.ActiveCamera() )
+        {     
+        ActivateGc();
+        CWindowGc& gc = SystemGc();	      
+        gc.SetBrushColor( KRgbBlack );
+        gc.Clear( Rect() );
+        DeactivateGc();		
+        }    		
+      iReceivedVfFrame = EFalse;
+      break;
+    // -----------------------------------------------------
+    case ECamCameraEventVfFrameReady:
+      {
+      PRINT_FRQ( _L("Camera => CCamPreCaptureContainerBase::HandleCameraEventL: case ECamCameraEventVfFrameReady") );
+      if( KErrNone == aStatus )
+        {
+        // Mark first frame arrived.
+        iReceivedVfFrame = ETrue;
+    
+        // If status is ok, we should always receive a bitmap.
+        CFbsBitmap* frame = static_cast<CFbsBitmap*>( aEventData );    
+        __ASSERT_ALWAYS( frame, CamPanic( ECamPanicNullPointer ) );
+    
+        // Make a duplicate copy of the vfFrame in order to show
+        // it later on where needed.
+        if ( iViewFinderBackup )
+          {
+          iViewFinderBackup->Reset();
+          }
+        else
+          {
+          TRAP_IGNORE ( iViewFinderBackup = new (ELeave) CFbsBitmap() );
+          }
+
+        if ( iViewFinderBackup )
+          {
+          TInt dupeError = iViewFinderBackup->Duplicate(frame->Handle());
+          if ( dupeError )
+            {
+            iViewFinderBackup->Reset();
+            delete iViewFinderBackup;
+            iViewFinderBackup = NULL;
+            }
+          }
+
+        // Do a redraw.
+        ActivateGc();
+        CWindowGc& gc = SystemGc();
+
+        PRINT_FRQ4( _L("ECamCameraEventVfFrameReady - rect is %d,%d - %d,%d"), Rect().iTl.iX, Rect().iTl.iY, Rect().iBr.iX, Rect().iBr.iY ) 
+
+      	if( ECamCapturing == iController.CurrentVideoOperation() )
+      	  {   
+          // -----------------------------------------
+          // Draw all content directly to system gc
+      	  PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase::ShowViewFinderFrame without offscreen bitmap") )   
+      	  RWindow window = Window();
+      	  window.Invalidate( Rect() );
+      	  window.BeginRedraw( Rect() );    
+      		DrawToContext(gc, frame);
+      		window.EndRedraw();
+          // -----------------------------------------
+      	  }
+        else
+          { 
+          if( iBitmapGc )
+            {
+            // -----------------------------------------
+            // Draw all content to the offscreen bitmap
+            DrawToContext( *iBitmapGc, frame );
+      
+            // -----------------------------------------
+            // Draw the offscreen bitmap to screen
+            RWindow window = Window();
+            window.Invalidate( Rect() );
+            window.BeginRedraw( Rect() );
+            gc.BitBlt( TPoint( 0,0 ), iOffScreenBitmap );
+            window.EndRedraw();
+            // -----------------------------------------
+            }
+          else
+            {
+            PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase: iBitmapGc == NULL"));
+            }
+          }
+        DeactivateGc();
+        PRINT_FRQ( _L("Camera <= CCamPreCaptureContainerBase::HandleCameraEventL") );
+        }
+      break;
+      }
+    // -----------------------------------------------------
+    case ECamCameraEventSsReady:
+      {
+      PRINT( _L( "Camera => CCamPreCaptureContainerBase::HandleCameraEventL: case ECamCameraEventSsReady" ) );  
+
+      CCamAppUi* appUi = static_cast<CCamAppUi*>(CEikonEnv::Static()->AppUi());
+
+	  if( KErrNone == aStatus
+       && ( ECamImageCaptureTimeLapse == appUi->CurrentBurstMode() ||
+            ECamImageCaptureBurst     == appUi->CurrentBurstMode() ) )
+        {
+        // In timelapse mode, convert snapshot event to vf frame event
+        PRINT( _L( "In timelapse mode, converting event to ECamCameraEventVfFrameReady" ) );
+        HandleCameraEventL( aStatus, ECamCameraEventVfFrameReady, aEventData );  
+        }
+      else if( KErrNone == aStatus && 
+               ECamControllerImage == iController.CurrentMode() &&
+               appUi->ShowPostCaptureView() )
+        {
+        // use mask mode to draw battery pane when showing snapshot
+        // and hide side pane altogether ( as there is no feasible way to draw
+        // it properly on top of the snapshot because of the current CCamIndicator implementation)
+        iSidePane->MakeVisible( EFalse );
+        // also hide zoom pane at the same time
+        iZoomPane->MakeVisible( EFalse, EFalse );
+        
+        OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_HANDLECAMERAEVENTL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 0" ); //CCORAPP_PRI_SHOT_TO_SNAPSHOT_END
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_HANDLECAMERAEVENTL, "e_CAM_APP_SNAPSHOT_DRAW 1" );   //CCORAPP_SNAPSHOT_DRAW_START
+        HandleCameraEventL( aStatus, ECamCameraEventVfFrameReady, aEventData );
+        OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMPRECAPTURECONTAINERBASE_HANDLECAMERAEVENTL, "e_CAM_APP_SNAPSHOT_DRAW 0" );   //CCORAPP_SNAPSHOT_DRAW_END
+        }
+        
+      PRINT( _L( "Camera <= CCamPreCaptureContainerBase::HandleCameraEventL" ) );  
+      break;
+      }
+    // -----------------------------------------------------
+    default:
+      {
+      break;
+      }
+    // -----------------------------------------------------
+    }                 
+  }
+
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::DrawToContext
+// Draws Screen content to graphics context
+// ---------------------------------------------------------
+//  
+void 
+CCamPreCaptureContainerBase::DrawToContext(       CBitmapContext& aGc, 
+                                            const CFbsBitmap*     aFrame )
+  {
+  	PRINT( _L( "Camera => CCamPreCaptureContainerBase::DrawToContext" ) );  
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+    if ( !appUi->IsWaitDialog() || !appUi->IsQwerty2ndCamera() )
+        {
+        aGc.SetBrushColor( TRgb( KCamPrecaptureBgColor ) );
+   	    aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
+   	    aGc.SetPenColor( TRgb( KCamPrecaptureBgColor ) );
+   	    aGc.SetPenStyle( CGraphicsContext::ESolidPen );
+   	    aGc.DrawRect( Rect() );
+   	    
+
+        DrawFrameNow( aGc, aFrame );
+        aGc.SetBrushStyle(CGraphicsContext::ENullBrush );
+        DrawScreenFurniture( aGc );       
+        DrawActivePalette( aGc );       
+        DrawNaviControls( aGc );
+        }
+  PRINT( _L( "Camera <= CCamPreCaptureContainerBase::DrawToContext" ) );  
+  }
+
+// ===========================================================================
+// From MCamCameraObserver
+
+// ---------------------------------------------------------------------------
+// IntSettingChangedL <<virtual>>
+// ---------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase::IntSettingChangedL( 
+    TCamSettingItemIds aSettingItem, 
+    TInt               aSettingValue )
+  {
+  switch( aSettingItem )
+    {
+    // -----------------------------------------------------
+    case ECamSettingItemViewfinderGrid:
+      {
+      PRINT( _L("Camera <> CCamPreCaptureContainerBase::IntSettingChangedL: ECamSettingItemViewfinderGrid") );
+      CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+
+      if( iVfGridDrawer )
+        {
+        iVfGridDrawer->SetVisible( ECamViewfinderGridOn == aSettingValue );
+        if( appUi && appUi->APHandler() )
+          {
+          // Disable the redrawing requested by AP as we do full redraw right after.
+          // Avoids some unwanted blinking in AP area.
+          iDisableRedraws = ETrue;
+          // Not critical if fails.
+          // Tooltip and icon shown wrong then until next update.
+          // Cannot leave here, as redraws need to be enabled again.
+          TRAP_IGNORE( appUi->APHandler()->UpdateActivePaletteL() );
+          iDisableRedraws = EFalse;
+          }
+        DrawNow();
+        }
+      break;
+      }
+    // -----------------------------------------------------
+    case ECamSettingItemFaceTracking:
+      {
+      PRINT( _L("Camera <> CCamPreCaptureContainerBase::IntSettingChangedL: ECamSettingItemFaceTracking") );
+      CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+      if( appUi && appUi->APHandler() )
+        {
+        // Disable the redrawing requested by AP as we do full redraw right after.
+        // Avoids some unwanted blinking in AP area.
+        iDisableRedraws = ETrue;
+        // Not critical if fails.
+        // Tooltip and icon shown wrong then until next update.
+        // Cannot leave here, as redraws need to be enabled again.
+        TRAP_IGNORE( appUi->APHandler()->UpdateActivePaletteL() );
+        iDisableRedraws = EFalse;
+        }
+      DrawNow();
+      break;
+      }
+    // -----------------------------------------------------
+    default: 
+      break;
+    // -----------------------------------------------------
+    }
+  }
+
+// ---------------------------------------------------------------------------
+// TextSettingChangedL <<virtual>>
+// ---------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase
+::TextSettingChangedL(       TCamSettingItemIds /*aSettingItem */, 
+                       const TDesC&             /*aSettingValue*/ )
+  {
+  /*
+  switch( aSettingItem )
+    {
+    default: 
+      break;
+    }
+  */
+  }
+
+
+// ===========================================================================
+// </CAMERAAPP_CAPI_V2_MIGRATION>
+
+
+
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::DrawFrameNow
+// Blit the bitmap
+// ---------------------------------------------------------
+//
+void
+CCamPreCaptureContainerBase
+::DrawFrameNow(       CBitmapContext& aGc, 
+                const CFbsBitmap*     aFrame ) const
+    {
+//    PRINT( _L("Camera => CCamPreCaptureContainerBase::DrawFrameNow"))  
+    TRect frameRect = ViewFinderFrameRect();
+    TSize fsize     = aFrame->SizeInPixels();  
+
+    // If the viewfinder bitmap is LARGER than the masked bitmap
+    // and we should be masked
+    if ( fsize.iWidth  > frameRect.Width() 
+      || fsize.iHeight > frameRect.Height() )
+        {
+        // Work out the rectangle of the viewfinder bitmap to draw
+        TInt borderX = ( fsize.iWidth - frameRect.Width() ) / 2;
+        TInt borderY = ( fsize.iHeight - frameRect.Height() ) / 2;
+        TRect bmCropRect( borderX, borderY, fsize.iWidth - borderX, fsize.iHeight - borderY );
+
+        // Draw the "crop rect" area of the viewfinder in the cropped frame
+        aGc.BitBlt( frameRect.iTl, aFrame, bmCropRect );
+        }
+    else if( fsize.iWidth  > Rect().Width() 
+          || fsize.iHeight > Rect().Height() )
+      {
+      // Work out the rectangle of the viewfinder bitmap to draw
+        TInt borderX = ( fsize.iWidth - Rect().Width() ) / 2;
+        TInt borderY = ( fsize.iHeight - Rect().Height() ) / 2;
+        TRect bmCropRect( borderX, borderY, fsize.iWidth - borderX, fsize.iHeight - borderY );
+
+        // Draw the "crop rect" area of the viewfinder in the cropped frame
+        aGc.BitBlt( frameRect.iTl, aFrame, bmCropRect );
+      }
+     else
+      {   
+        // Just draw the viewfinder frame in the frame rectangle
+        aGc.BitBlt( frameRect.iTl, aFrame );    
+      }          
+//    PRINT( _L("Camera <= CCamPreCaptureContainerBase::DrawFrameNow"))  
+    }
+
+
+
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::DrawReticule
+// Draw the reticule
+// ---------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::DrawReticule( CBitmapContext& aGc ) const
+  {
+  PRINT_FRQ( _L("Camera => CCamPreCaptureContainerBase::DrawReticule"))  
+  if ( iController.UiConfigManagerPtr() && 
+       iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+    {
+    ReDrawReticule( iReticuleRect, aGc );
+    }
+  PRINT_FRQ( _L("Camera <= CCamPreCaptureContainerBase::DrawReticule"))               
+  }
+
+// ---------------------------------------------------------
+// ReDrawReticule
+//
+// Handle partial redraw of reticule.
+// NOTE: Could be better optimized for partial redraws.
+// ---------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase
+::ReDrawReticule( const TRect&          aRect,
+                        CBitmapContext& aGc   ) const
+  {
+  if( iShowReticule 
+    && iPhotoSceneUsesReticule 
+    && iReticuleRect.Intersects( aRect )
+    && iController.IsViewFinding() 
+    && iController.UiConfigManagerPtr()
+    && iController.UiConfigManagerPtr()->IsAutoFocusSupported()
+    && !iController.UiConfigManagerPtr()->IsFaceTrackingSupported()
+    )
+    {
+    aGc.SetClippingRect( aRect );
+
+    // Overlay reticule (though which bitmap used depends on focus state)
+    switch ( iFocusState )
+      {
+      case EFocusStateFocusFailed:
+          DrawAf( aGc, iAfErrIcon );
+        break;
+      case EFocusStateFocusAchieved:                
+          DrawAf( aGc, iAfFocusIcon );
+        break;
+      }                
+
+    aGc.CancelClippingRect();
+    }
+  else
+    {
+    // Nothing needs to be done.
+    }
+  }
+
+
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::ForceSideZoomPaneDraw
+// Force the side-pane or zoom-pane to redraw.
+// ---------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::ForceSideZoomPaneDraw() const
+    {
+    if( iSidePane->IsVisible() )
+        {
+        ActivateGc();
+        iSidePane->Draw( SystemGc() );       
+        DeactivateGc();
+        }
+    else
+        {
+        ActivateGc();
+        iZoomPane->Draw( SystemGc() );        
+        DeactivateGc();
+        }
+    
+    }
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::CreateResolutionIndicatorL
+// Create the resolution indicator
+// ---------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::CreateResolutionIndicatorL()
+    {
+  RArray<TInt> icons;
+  CleanupClosePushL( icons );
+
+  iController.Configuration()->GetPsiIntArrayL( ResolutionIndicatorIconPsiKey(), icons ); 
+  TInt count = icons.Count();
+
+    // Get the icon rect from the derived class
+    TRect iconRect = ResolutionIndicatorRect();
+    
+    CCamIndicator* indicator;
+  for( TInt i = 0; i < count; i+=2 )
+    {
+    indicator = CCamIndicator::NewL( iconRect );
+    CleanupStack::PushL( indicator );
+    indicator->AddIconL( icons[i], icons[i+1] ); // Bitmap & mask.
+    indicator->SetRect( iconRect );
+    User::LeaveIfError( iResolutionIndicators.Append( indicator ) );
+    CleanupStack::Pop( indicator );
+    }
+  
+  CleanupStack::PopAndDestroy( &icons );
+
+    // initialise the indicator
+    SetResolutionIndicator();
+    }
+
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::BurstModeActiveL
+// Notification that the burst mode has been activated/deactivated
+// ----------------------------------------------------
+//
+void CCamPreCaptureContainerBase::BurstModeActiveL( TBool /*aActive*/, TBool /*aStillModeActive*/ )
+    {
+    SetResolutionIndicator();
+    if ( !iController.IsTouchScreenSupported() )
+        {
+        CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+        if( appUi && appUi->APHandler() )
+            {
+            // Disable the redrawing requested by AP as we do full redraw right after.
+            // Avoids some unwanted blinking in AP area.
+            iDisableRedraws = ETrue;
+            // Not critical if fails.
+            // Tooltip and icon shown wrong then until next update.
+            // Cannot leave here, as redraws need to be enabled again.
+            TRAP_IGNORE( appUi->APHandler()->UpdateActivePaletteL() );
+            iDisableRedraws = EFalse;
+            }
+        DrawNow();
+        }
+    }
+    
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::IncreaseFlashSettingL
+// Move up through the flash settings
+// ----------------------------------------------------
+//
+void CCamPreCaptureContainerBase::IncreaseFlashSettingL()  
+    {
+    // intentionally doing nothing
+    }  
+ 
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::DecreaseFlashSettingL
+// Move down through the flash settings
+// ----------------------------------------------------
+//
+void CCamPreCaptureContainerBase::DecreaseFlashSettingL()   
+    {
+    // intentionally doing nothing
+    }  
+    
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::HandleLeftRightNaviKeyL
+// Initiate behaviour in response to a navi key left/right
+// arrow press 
+// ----------------------------------------------------
+//   
+TKeyResponse CCamPreCaptureContainerBase::HandleLeftRightNaviKeyL( 
+                                                    const TKeyEvent& aKeyEvent,
+        
+                                                    TEventCode /*aType*/ )                                                                     
+    {
+    CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( iEikonEnv->AppUi() );
+    // Find out which behaviour is mapped to the key
+    TCamPsiKey queryValue = ECamPsiLeftNaviKey;
+    if ( aKeyEvent.iScanCode == EStdKeyRightArrow )
+        {
+        queryValue = ECamPsiRightNaviKey;
+        }
+    else if ( appUi->IsSecondCameraEnabled() )
+        {
+        queryValue = ECamPsiLeftNaviKeyCam2;
+        }
+    else
+        {
+        // remove lint warning
+        }
+        
+    TInt keyFunction;
+    User::LeaveIfError( CamUtility::GetPsiInt( queryValue, keyFunction ) );    
+
+    // Handle the key
+    switch ( keyFunction ) 
+        {
+        case ECamNaviKeyIncreaseFlashSetting:
+            {
+            IncreaseFlashSettingL();
+            return EKeyWasConsumed;
+            }
+        // No break as unreachable 
+        case ECamNaviKeyDecreaseFlashSetting:
+            {
+            DecreaseFlashSettingL();
+            return EKeyWasConsumed;
+            }
+        // No break as unreachable 
+
+        default:
+            break;
+        }
+    return EKeyWasNotConsumed;
+    }
+
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::CountComponentControls
+// Return number of child controls owned by this control
+// ----------------------------------------------------
+//
+TInt CCamPreCaptureContainerBase::CountComponentControls() const
+  {
+  TInt count = 0;
+    if(iActivePalette && iActivePalette->CoeControl()->IsVisible())
+        {
+        count++; //Active Palette
+        }   
+    
+  return count;
+  }
+
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::ComponentControl
+// Return requested control
+// ----------------------------------------------------
+//
+CCoeControl* CCamPreCaptureContainerBase::ComponentControl( TInt aIndex ) const
+  {
+  CCoeControl* con = NULL;
+  switch ( aIndex )
+      {
+     
+     /*
+      case ECamTimeLapseControl:
+            {
+            
+            if ( iTimeLapseSlider && static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() )->TimeLapseEnabled() )
+                {
+                con = iTimeLapseSlider;
+                }
+            else
+            
+                {
+                con = iNaviCounterControl;
+                }
+            break;
+            }
+      */
+              
+      case ECamActivePalette:
+          {
+          if(iActivePalette && iActivePalette->CoeControl()->IsVisible())         
+              {
+              con = iActivePalette->CoeControl();
+              }             
+          break;
+          }        
+        default:
+            break;
+      }         
+    return con; 
+  }
+  
+ 
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::HandleCommand
+// Handle CBA key and options menu events for SetupPane
+// ----------------------------------------------------
+//
+
+void CCamPreCaptureContainerBase::HandleCommand( TInt /* aCommand */ )
+    {
+
+    }    
+
+
+// ---------------------------------------------------------
+// CCamPreCaptureContainerBase::GetAutoFocusDelay
+// 
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::DrawScreenFurniture
+// Draw reticule, side or zoom pane and softkeys 
+// ---------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase
+::DrawScreenFurniture( CBitmapContext& aGc ) const 
+  {
+  PRINT_FRQ( _L("Camera => CCamPreCaptureContainerBase::DrawScreenFurniture" ))
+  CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() ); 
+  
+
+  TCamOrientation orientation = appUi->CamOrientation();   
+  if ( iController.ActiveCamera() == ECamActiveCameraPrimary &&
+       ( orientation == ECamOrientationCamcorder || orientation == ECamOrientationCamcorderLeft ) )
+    {
+    // -------------------------------
+    // Viewfinder grid
+    PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase: drawing VF grid" ) );
+    DrawVfGrid( aGc );
+    // -------------------------------
+    // Reticule 
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase: drawing reticule" ) );
+        DrawReticule( aGc );
+        }
+    }
+  else
+    {
+    PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase: No reticule / grid (as secondary/none camera)") );
+    }     
+
+  // -------------------------------------------------------
+  // Zoom pane
+//  PRINT( _L("Camera <> CCamPreCaptureContainerBase: condition zoom pane" ))
+  if ( iZoomPane->IsVisible() && 
+       !iController.SequenceCaptureInProgress() && 
+       iController.ActiveCamera() == ECamActiveCameraPrimary )
+    {
+    PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase: drawing zoom pane" ))
+    iZoomPane->Draw( aGc );
+    }       
+
+
+  // -------------------------------------------------------
+  // Side pane indicators
+  if ( iSidePane->IsVisible() )
+    {
+//    PRINT( _L("Camera <> CCamPreCaptureContainerBase: drawing side pane" ))
+    iSidePane->Draw( aGc );
+    }
+
+//  PRINT( _L("Camera <= CCamPreCaptureContainerBase::DrawScreenFurniture" ))       
+  }
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::DrawNaviControls
+// Draws the navi pane items 
+// ---------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase::DrawNaviControls( CBitmapContext& aGc ) const 
+  {
+//  PRINT( _L("Camera => CCamPreCaptureContainerBase::DrawNaviControls" ))  
+  CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );     
+
+  if( appUi )
+    {
+    TCamCameraMode       mode      = iController.CurrentMode();
+    TCamImageCaptureMode imageMode = iController.CurrentImageModeSetup();
+    TBool seqCapturing   = iController.SequenceCaptureInProgress();
+    TBool precaptureUiOn = appUi->DrawPreCaptureCourtesyUI();
+    TBool paneVisible    = EFalse;
+
+    if( iProcessingText &&  //iProcessingBg && 
+        iController.ActiveCamera() != ECamActiveCameraSecondary &&
+        // ECamCaptureModeStill == appUi->CurrentCaptureMode() &&
+        ECamControllerImage == iController.CurrentMode() &&
+        // ECamOperationCaptureInProgress == iController.OperationState() 
+        ECamImageCaptureNone == appUi->CurrentBurstMode() && // No text for sequence
+        ( ECamCapturing == iController.CurrentOperation() ||
+          ECamCompleting == iController.CurrentOperation() ) 
+     )
+      { 
+      // When iProcessingText exists (and we are in correct state), the processing
+      // image text needs to be drawn.
+      PRINT( _L("Camera <> CCamPreCaptureContainerBase: draw processing text.." ) );
+      //iProcessingBg->Draw( aGc, Rect() );
+      aGc.SetBrushColor( KRgbWhite );
+      aGc.SetBrushStyle( CGraphicsContext::ENullBrush );
+      iProcessingTextLayout.DrawText( aGc, *iProcessingText, ETrue, KRgbBlack ); 
+      }
+    else if( iBurstProcessingText &&         
+             iController.ActiveCamera() != ECamActiveCameraSecondary &&
+             ECamControllerImage == iController.CurrentMode() &&
+           ( ECamImageCaptureBurst == appUi->CurrentBurstMode() &&
+           ( ECamCapturing == iController.CurrentOperation() || 
+             ECamCompleting == iController.CurrentOperation() ) && 
+             iController.AllSnapshotsReceived() ) )
+      {
+      PRINT( _L("Camera <> CCamPreCaptureContainerBase: draw burst processing text.." ) );
+      aGc.SetBrushColor( KRgbWhite );
+      aGc.SetBrushStyle( CGraphicsContext::ENullBrush );
+      // localizing numbers in burst processing string
+      TPtr pointer = iBurstProcessingText->Des();
+      AknTextUtils::LanguageSpecificNumberConversion( pointer );
+      iBurstProcessingTextLayout.DrawText( aGc, *iBurstProcessingText, ETrue, KRgbBlack ); 
+      }
+    else if( ECamPaneCounter == iPaneInUse )
+      {
+      TBool showCounter  = precaptureUiOn || seqCapturing;    
+      TBool focusStateOk = ETrue;
+      if ( iController.UiConfigManagerPtr() && 
+              iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+          {
+
+          focusStateOk = 
+          ( EFocusStateNormal == iFocusState && 
+            !iController.SequenceCaptureInProgress() ) ||
+          ( imageMode == ECamImageCaptureBurst &&
+            ( iController.CurrentOperation() == ECamCapturing  || 
+            ( iController.CurrentOperation() == ECamCompleting 
+              && !iController.AllSnapshotsReceived() ) ) );
+
+          }
+      
+      if( focusStateOk || 
+          ( showCounter && appUi->IsSecondCameraEnabled() ) )
+          {
+          paneVisible = ETrue;
+          iNaviCounterControl->DrawNaviCtr( aGc );
+          }
+      }
+    else if( ECamPaneProgress == iPaneInUse )
+      {
+      paneVisible = ETrue;
+      iNaviProgressBarControl->DrawProgressBar( aGc );
+      iNaviCounterControl->DrawNaviCtr( aGc );
+      }
+    else
+      {      
+      // Navi pane is not shown
+      paneVisible = EFalse;
+      }
+
+    // Do not show if saving / focusing
+    TCamCaptureOperation operation      = iController.CurrentOperation();
+    TCamCaptureOperation videoOperation = iController.CurrentVideoOperation();
+
+    TBool operationOk = ( ECamNoOperation == operation
+                       || ECamCompleting  != videoOperation );
+
+    // In video mode, icon would show without panes when stopping
+    // if viev state is not checked.
+    if(  appUi->CurrentViewState() == ECamViewStatePreCapture
+      && precaptureUiOn
+      && paneVisible
+      &&  operationOk 
+      && !seqCapturing
+      )
+      {
+      // Draw the resolution indicator
+      if ( appUi->ActiveCamera() == ECamActiveCameraPrimary  
+           && ( CamUtility::IsNhdDevice() 
+           || videoOperation == ECamNoOperation ) )
+          {
+          iResolutionIndicators[iCurrentIndicator]->Draw( aGc );
+         }
+
+      DrawAdditionalIcons( aGc );
+    
+      if ( iController.UiConfigManagerPtr() && 
+           iController.UiConfigManagerPtr()->IsLocationSupported() )
+          {
+          if ( iLocationIndicatorVisible ) 
+              {
+              // Draw the location indicator
+              iLocationIconController->Draw( aGc );
+              }
+          }
+      }
+      
+  if( iBatteryPaneController )
+    {
+      iBatteryPaneController->Draw( aGc );
+    }
+
+    }
+
+//  PRINT( _L("Camera <= CCamPreCaptureContainerBase::DrawNaviControls" ))          
+  }
+
+  
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::DrawActivePalette
+// Draws the active palette
+// ---------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase::DrawActivePalette() const 
+  {    
+  
+  PRINT( _L("Camera => CCamPreCaptureContainerBase::DrawActivePalette") );
+  if ( !iController.IsTouchScreenSupported() )
+      {
+      CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+      
+      // draw the active palette if needed
+      if( iActivePalette && appUi->DrawPreCaptureCourtesyUI() )
+        {
+        PRINT( _L("Camera <> drawing active palette") );
+        iActivePalette->RenderActivePalette( Rect() );
+        }
+      }
+   
+  PRINT( _L("Camera <= CCamPreCaptureContainerBase::DrawActivePalette") );
+  }
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::DrawActivePalette
+// Draws the active palette
+// ---------------------------------------------------------------------------
+//
+void 
+CCamPreCaptureContainerBase::DrawActivePalette( CBitmapContext& aGc ) const 
+  {    
+  PRINT_FRQ( _L("Camera => CCamPreCaptureContainerBase::DrawActivePalette( aGc )") );
+  if ( !iController.IsTouchScreenSupported() )
+      {
+      CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+      
+      // draw the active palette if needed
+      if( iActivePalette && appUi->DrawPreCaptureCourtesyUI() )
+        {
+        PRINT_FRQ( _L("Camera <> drawing active palette..") );
+        iActivePalette->SetGc( &aGc );
+        iActivePalette->RenderActivePalette( Rect() );
+        iActivePalette->SetGc();
+        }
+      }
+  PRINT_FRQ( _L("Camera <= CCamPreCaptureContainerBase::DrawActivePalette") );
+  }
+
+
+// -----------------------------------------------------------------------------
+// virtual CCamPreCaptureContainerBase::DrawVfGrid
+// -----------------------------------------------------------------------------
+// 
+void 
+CCamPreCaptureContainerBase::DrawVfGrid( CBitmapContext& aGc ) const 
+  {
+  PRINT_FRQ( _L("Camera => CCamPreCaptureContainerBase::DrawVfGrid") );
+  // Draws nothing if not set visible.
+  if( iVfGridDrawer )
+    {
+    iVfGridDrawer->Draw( iRect, aGc );
+    }
+  PRINT_FRQ( _L("Camera <= CCamPreCaptureContainerBase::DrawVfGrid") );
+  }
+
+// -----------------------------------------------------------------------------
+// virtual CCamPreCaptureContainerBase::ReDrawVfGrid
+// -----------------------------------------------------------------------------
+// 
+void 
+CCamPreCaptureContainerBase::ReDrawVfGrid( const TRect&          aRect, 
+                                                 CBitmapContext& aGc   ) const 
+  {
+  PRINT_FRQ( _L("Camera => CCamPreCaptureContainerBase::ReDrawVfGrid") );
+  // Draws nothing if not set visible.
+  if( iVfGridDrawer 
+   && iVfGridRect.Intersects( aRect ) 
+    )
+    {
+    iVfGridDrawer->Draw( aRect, aGc );
+    }
+  PRINT_FRQ( _L("Camera <= CCamPreCaptureContainerBase::ReDrawVfGrid") );
+  }
+
+// -----------------------------------------------------------------------------
+// virtual GetVFGridVisibilitySetting
+//
+// -----------------------------------------------------------------------------
+//
+TBool 
+CCamPreCaptureContainerBase::GetVFGridVisibilitySetting() const 
+  {
+  TInt value = iController.IntegerSettingValue( ECamSettingItemViewfinderGrid );
+  return (ECamViewfinderGridOn == value);
+  }
+
+
+// -----------------------------------------------------------------------------
+// virtual ResetVFGridVisibility
+//
+// -----------------------------------------------------------------------------
+//
+void
+CCamPreCaptureContainerBase::ResetVFGridVisibility()
+  {
+  if( iVfGridDrawer )
+    {
+    iVfGridDrawer->SetVisible( GetVFGridVisibilitySetting() );
+    }
+  }
+
+
+// -----------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::Redraw
+//
+// Redraw only part of screen. 
+// Active Palette animations need this to update its background.
+// -----------------------------------------------------------------------------
+void CCamPreCaptureContainerBase::Redraw( const TRect& aArea )
+  {
+  PRINT( _L("Camera => CCamPreCaptureContainerBase::Redraw") );  
+
+  if( iDisableRedraws )
+    {
+    PRINT( _L("Camera <= CCamPreCaptureContainerBase: redraw skipped") );  
+    return;
+    }
+
+  CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+
+  if(  appUi &&  appUi->IsDirectViewfinderActive() )
+    {
+    CWindowGc& gc = SystemGc();
+    gc.SetPenStyle( CGraphicsContext::ENullPen );
+    gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
+    gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );
+    gc.SetBrushColor( TRgb::Color16MA( 0 ) );
+    gc.DrawRect( aArea );
+
+    // Viewfinder grid and reticule overlap with tooltips
+    // or Active Palette moving in/out the screen.
+    ReDrawVfGrid( aArea, gc );
+
+    if( iController.ActiveCamera() != ECamActiveCameraSecondary
+        && iController.UiConfigManagerPtr()
+        && iController.UiConfigManagerPtr()->IsAutoFocusSupported()
+        && !iTimeLapseVisible )
+      {
+      ReDrawReticule( aArea, gc );
+      }
+    }
+  else
+    {
+    if ( iBitmapGc )
+      {
+      if ( iReceivedVfFrame && iViewFinderBackup )
+      	{
+      	iBitmapGc->BitBlt( aArea.iTl, iViewFinderBackup, aArea );
+      	}
+      else
+        {
+        iBitmapGc->SetBrushColor( TRgb( KCamPrecaptureBgColor ) );
+        iBitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
+        iBitmapGc->DrawRect( aArea );
+        iBitmapGc->SetBrushStyle( CGraphicsContext::ENullBrush );
+        }
+      ReDrawVfGrid( aArea, *iBitmapGc );
+
+      if ( iController.UiConfigManagerPtr() && 
+           iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        ReDrawReticule( aArea, *iBitmapGc );
+        }
+      }
+    }
+  PRINT( _L("Camera <= CCamPreCaptureContainerBase::Redraw") );  
+  }
+
+
+
+// -----------------------------------------------------------------------------
+// HandleOperationStateChangeEventL
+//
+// Helper method to handle case ECamEventOperationStateChanged in
+// HandleControllerEventL.
+// -----------------------------------------------------------------------------
+//
+void
+CCamPreCaptureContainerBase::HandleOperationStateChangeEventL()
+  {
+  PRINT( _L("Camera => CCamPreCaptureContainerBase::HandleFocusStateChangeEventL") );
+
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+          if( iPhotoSceneUsesReticule )
+            {
+            TBool ftSupported = iController.UiConfigManagerPtr()->IsFaceTrackingSupported();    
+            switch ( iController.CurrentOperation() )
+              {
+              // ---------------------------------------------------
+              case ECamFocusing:
+                {
+                PRINT(_L("Camera <> CCamPreCaptureContainerBase: FOCUSING"));
+                // set focusing icon - flashing
+                iFocusState      = EFocusStateFocusing;
+                if ( !ftSupported )
+                  {
+                  iReticuleFlashOn = ETrue;
+          
+                // Start reticule flashing timer
+                if ( iReticuleTimer->IsActive() )
+                  {
+                  iReticuleTimer->Cancel();
+                  }
+                iReticuleTimer->Start( KReticuleFlashTimeout, 
+                                       KReticuleFlashTimeout,
+                                       TCallBack(ReticuleTimerCallback , this) );
+                  }
+                // Hide the navi counter                                    
+                iNaviCounterControl->MakeVisible( EFalse );
+          
+                DrawDeferred();
+                break;
+                }
+              // ---------------------------------------------------
+              case ECamFocused:
+                {
+                PRINT(_L("Camera <> CCamPreCaptureContainerBase: FOCUSED"));
+                // set focus achieved icon
+                iFocusState = EFocusStateFocusAchieved;
+                if ( !ftSupported )
+                  {
+                  iReticuleTimer->Cancel();
+                  iReticuleFlashOn = ETrue;
+                  }
+                
+                OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_HANDLEOPERATIONSTATECHANGEEVENTL, "e_CAM_APP_OVERLAY_UPD 0" );    //CCORAPP_OVERLAY_UPD_END
+                OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_HANDLEOPERATIONSTATECHANGEEVENTL, "e_CAM_APP_AF 0" );    //CCORAPP_AF_END
+                
+                DrawDeferred();
+                break;
+                }
+              // ---------------------------------------------------
+              case ECamFocusFailed:
+                {
+                PRINT(_L("Camera <> CCamPreCaptureContainerBase: FOCUS FAILED"));
+                // set focus failed icon
+                iFocusState = EFocusStateFocusFailed;
+                if ( !ftSupported )
+                  {
+                  iReticuleTimer->Cancel();
+                  iReticuleFlashOn = ETrue;
+                  }
+                OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMPRECAPTURECONTAINERBASE_HANDLEOPERATIONSTATECHANGEEVENTL, "e_CAM_APP_OVERLAY_UPD 0" );
+                OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMPRECAPTURECONTAINERBASE_HANDLEOPERATIONSTATECHANGEEVENTL, "e_CAM_APP_AF 0" );
+
+                DrawDeferred();
+                break;
+                }
+                // ---------------------------------------------------
+              case ECamCapturing:
+                  {
+                  PRINT(_L("Camera <> CCamPreCaptureContainerBase: Capturing"));
+                  CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );     
+                  if( appUi )
+                      {
+                      // If in burst mode show the navi counter again
+                      if( ECamImageCaptureBurst == appUi->CurrentBurstMode() )
+                          {
+                          iNaviCounterControl->MakeVisible( ETrue );
+                          DrawDeferred();
+                          }
+                      }
+                  break;
+                  }  
+                  // ---------------------------------------------------
+              case ECamNoOperation:
+                  {
+                  PRINT( _L("Camera <> CCamPreCaptureContainerBase:ECamNone"));
+                  // Show the navi counter again
+                  if ( iPaneInUse == ECamPaneCounter 
+                          && iController.IsAppUiAvailable()
+                  )
+                      {
+                      iNaviCounterControl->MakeVisible( ETrue );
+                      }
+                  }
+                  // lint -fallthrough
+                  // Captured and saving or..
+              case ECamCompleting: 
+                  {
+                  PRINT1( _L("Camera <> CCamPreCaptureContainerBase: NOT FOCUSED ANY MORE, iFocusState=%d"), iFocusState );
+                  if ( iFocusState == EFocusStateFocusing )
+                    {
+                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMPRECAPTURECONTAINERBASE_HANDLEOPERATIONSTATECHANGEEVENTL, "e_CAM_APP_OVERLAY_UPD 0" );
+                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMPRECAPTURECONTAINERBASE_HANDLEOPERATIONSTATECHANGEEVENTL, "e_CAM_APP_AF 0" );
+                    }
+                    
+                  // clear focus indicator
+                  iFocusState = EFocusStateNormal;
+                  if ( !ftSupported )
+                    {
+                    iReticuleTimer->Cancel();
+                    iReticuleFlashOn = ETrue;
+                    }
+                  iSidePane->MakeVisible(ETrue);
+                  DrawDeferred();
+                  break;
+                  }
+                  // ---------------------------------------------------
+              default:
+                  break;
+              } // switch
+            } // if
+        }
+
+  PRINT( _L("Camera <= CCamPreCaptureContainerBase::HandleFocusStateChangeEventL") );
+  }
+
+
+
+// -----------------------------------------------------------------------------
+// SetupActivePaletteL
+//
+// (Re)Initializes Active Palette. This includes:
+//   1) Creating Active Palette if needed
+//   2) Clearing Active Palette existing items if needed 
+//      - 1+2 done in CCamContainerBase::CreateActivePaletteL()
+//   3) Setting Active Palette items from resource
+//      - resource is selected in GetAPResourceId which is
+//        implemented in inheriting classes.
+//   4) Registering the view for AP
+//   5) Setting the focus to the default AP item
+// -----------------------------------------------------------------------------
+// 
+void
+CCamPreCaptureContainerBase::SetupActivePaletteL( CCamViewBase* aView )
+  {
+  OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_SETUPACTIVEPALETTEL, "e_CAM_APP_ACTIVEPALETTE_INIT 1" );
+  CCamAppUi* appUi =  static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+  
+  if ( !iController.IsTouchScreenSupported()
+         && ( !appUi->IsSecondCameraEnabled()
+         || ( !appUi->IsEmbedded() && appUi->IsSecondCameraEnabled() ) ) )
+      {
+      // Creates active palette if needed.
+      // Clears items if active palette already exists.
+      CCamContainerBase::CreateActivePaletteL();
+
+      // Video and still precapture containers implement this method.
+      TInt resId = GetAPResourceId();
+
+      CCamActivePaletteHandler* apHandler =
+        static_cast<CCamAppUi*>( iEikonEnv->AppUi() )->APHandler();
+
+      apHandler->InstallAPItemsL( resId );
+      apHandler->SetView( aView );
+      
+      if ( appUi->IsEmbedded() )
+          {
+/*#ifndef __WINS__
+          if ( !appUi->IsInCallSend() )
+#endif*/
+              {
+              // disable still/video mode switching in normal embedded mode
+              apHandler->SetItemVisible( ECamCmdNewVideo, EFalse );
+              apHandler->SetItemVisible( ECamCmdNewPhoto, EFalse );    
+              }
+          }
+      
+      apHandler->ResetToDefaultItem();
+      }
+  OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_SETUPACTIVEPALETTEL, "e_CAM_APP_ACTIVEPALETTE_INIT 0" );
+  }
+
+
+// -----------------------------------------------------------------------------
+// CCamPostCaptureContainer::BatteryPaneUpdated
+//
+// Called by CCamBatteryPaneController when battery pane content has been updated. 
+// Re-draws background under the battery pane and the battery pane itself.
+// -----------------------------------------------------------------------------    
+//
+void
+CCamPreCaptureContainerBase::BatteryPaneUpdated()
+  { 
+  if( !iDisableRedraws && iBatteryPaneController )
+    { 
+    // Activate Gc 
+    ActivateGc(); 
+
+    // Draw the battery pane
+    CWindowGc& gc = SystemGc();
+    iBatteryPaneController->Draw( gc );
+
+    DeactivateGc();        
+    }
+  
+  }
+
+// -----------------------------------------------------------------------------
+// CCamPostCaptureContainer::LocationIconUpdated
+//
+// Called by CCamLocationIconController when battery pane content has been updated. 
+// Re-draws background under the location icon and the location icon itself.
+// -----------------------------------------------------------------------------    
+//
+void CCamPreCaptureContainerBase::LocationIconUpdated()
+  { 
+  PRINT( _L("Camera => CCamPreCaptureContainerBase::LocationIconUpdated()") );
+
+  if ( iController.UiConfigManagerPtr() && 
+       iController.UiConfigManagerPtr()->IsLocationSupported() )
+      {
+      if (  !iDisableRedraws && iLocationIconController 
+            && iController.IsViewFinding()
+          )
+        {
+        // Get the location icon rectangle
+        TRect rect = iLocationIconController->Rect();
+        // Activate Gc
+        ActivateGc();
+    
+        // Invalidate the location icon area
+        RWindow window = Window();
+        window.Invalidate( rect );
+        window.BeginRedraw( rect );
+    
+        // Redraw the background in that area
+        Redraw( rect );
+    
+        // Draw the location icon
+        CWindowGc& gc = SystemGc();
+        // Other navi controls should be drawn also before drawing location icon
+        // The drawing is done through DrawNaviControls() function since
+        // the background decoration should be drawn before the location indicator
+        DrawNaviControls(gc);
+    
+        // Tell the window redraw is finished and deactivate Gc
+        window.EndRedraw();
+        DeactivateGc();
+        }
+      }
+  PRINT( _L("Camera <= CCamPreCaptureContainerBase::LocationIconUpdated()") );
+  }
+
+// -----------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::HandleResourceChange
+//
+// Passes resource changes to battery pane controller
+// -----------------------------------------------------------------------------    
+//  
+void
+CCamPreCaptureContainerBase::HandleResourceChange( TInt aType )
+    {  
+    if( iBatteryPaneController )
+        {
+        // Inform battery pane of the resource change 
+        iBatteryPaneController->HandleResourceChange( aType );
+        } 
+    
+    CCamContainerBase::HandleResourceChange( aType ); 
+    }
+
+
+//
+// CCamPreCaptureContainerBase::HandlePointerEventL
+//
+void CCamPreCaptureContainerBase::HandlePointerEventL( const TPointerEvent& aPointerEvent )
+    {
+    PRINT3( _L("CCamPreCaptureContainerBase::HandlePointerEventL iType=%d iPosition=(%d, %d)"),
+        aPointerEvent.iType,
+        aPointerEvent.iPosition.iX,
+        aPointerEvent.iPosition.iY );
+   CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
+   
+   if ( !appUi->IsSecondCameraEnabled() )
+       {
+       // don't let zoom pane be used when capturing image
+       if ( iController.CurrentMode() != ECamControllerImage ||
+            (iController.CurrentOperation() != ECamCapturing &&
+            iController.CurrentOperation() != ECamCompleting) )
+           {
+           if ( iZoomPane )  
+                {
+                if ( iZoomPane->HandlePointerEventL( aPointerEvent ) )
+                    {
+                    ShowZoomPaneWithTimer(); 
+                    return;
+                    }
+                }
+           }
+
+        if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&
+              !appUi->DrawPreCaptureCourtesyUI() )
+            {
+            appUi->HandleCommandL( ECamCmdRaiseCourtesyUI );
+            }
+
+        CCamContainerBase::HandlePointerEventL( aPointerEvent );
+    }    
+    PRINT( _L("Camera <= CCamPreCaptureContainerBase::HandlePointerEventL") );
+    }
+
+// ---------------------------------------------------------------------------
+//  returns a count, not an error
+// ---------------------------------------------------------------------------
+//
+TInt CCamPreCaptureContainerBase::CreateAfIconL( TRgb aColor ) 
+    {
+    TInt AFIconCount(0);
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        CreateAfCornerL( aColor, EMbmCameraappQgn_indi_cam4_focus_frame_auto_tl );
+        CreateAfCornerL( aColor, EMbmCameraappQgn_indi_cam4_focus_frame_auto_tr );
+        CreateAfCornerL( aColor, EMbmCameraappQgn_indi_cam4_focus_frame_auto_bl );
+        CreateAfCornerL( aColor, EMbmCameraappQgn_indi_cam4_focus_frame_auto_br );
+    
+        AFIconCount = iAfIcons.Count();
+        }
+    return AFIconCount;
+    }
+    
+    
+// ---------------------------------------------------------------------------
+// 
+// ---------------------------------------------------------------------------
+//      
+void CCamPreCaptureContainerBase::CreateAfCornerL( TRgb aColor, 
+                                                   TInt aFileBitmapId )
+    {
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        TFileName mbmFileName;
+        CamUtility::ResourceFileName( mbmFileName );
+        TPtrC resname = mbmFileName; 
+        
+        CFbsBitmap* bitmap = NULL;
+        CFbsBitmap* mask = NULL; 
+           
+        // Create component bitmaps 
+        AknIconUtils::CreateIconL( bitmap, mask, resname, 
+                                   aFileBitmapId, aFileBitmapId+1 );
+        
+        AknIconUtils::SetSize( bitmap, iAfIconCornerSize ); 
+        CleanupStack::PushL( bitmap );
+        CleanupStack::PushL( mask );
+    
+        // Destroys mask, if doesn't leave
+        CamUtility::SetAlphaL( bitmap, mask, aColor ); 
+        CleanupStack::Pop(); // (deleted) mask 
+        User::LeaveIfError( iAfIcons.Append( bitmap ) ); 
+        CleanupStack::Pop(); // bitmap  
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  
+// ---------------------------------------------------------------------------
+//    
+void CCamPreCaptureContainerBase::SetAfIconSize( TInt aOffset )   
+    { 
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() &&
+         aOffset-- && iAfIcons.Count() > aOffset )
+        {
+        for ( TInt i = aOffset; i > aOffset - KAFIconCorners ; i-- ) 
+            {
+            AknIconUtils::SetSize( iAfIcons[i], iAfIconCornerSize );  
+            }
+        }    
+    }
+    
+// ---------------------------------------------------------------------------
+//  
+// ---------------------------------------------------------------------------
+//
+void CCamPreCaptureContainerBase::DrawAf( CBitmapContext& aGc, 
+                                          TInt aOffset ) const  
+    {
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        TInt indx = aOffset - KAFIconCorners;
+        TInt corners = 0;
+        if ( aOffset && iAfIcons.Count() >= aOffset ) 
+            {
+            while ( corners < KAFIconCorners && iLayouts.Count() > corners )
+                {
+                TAknLayoutRect layout = iLayouts[corners];
+    
+                aGc.BitBlt( layout.Rect().iTl, iAfIcons[ indx + corners ]);
+                corners++;
+                }
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// 
+// ---------------------------------------------------------------------------
+//        
+void CCamPreCaptureContainerBase::SizeChanged() 
+    {
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        if ( CamUtility::IsNhdDevice() ) 
+            {
+            TouchLayout();
+            }
+        else
+            {
+            NonTouchLayout();
+            }
+			
+        if( !iController.UiConfigManagerPtr()->IsFaceTrackingSupported() )
+            {
+            SetAfIconSize( iAfReadyIcon );
+            SetAfIconSize( iAfFocusIcon );
+            SetAfIconSize( iAfErrIcon );
+            }
+        }
+    else
+        {
+        CCoeControl::SizeChanged();
+        }
+    } 
+    
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::NonTouchLayout
+// ---------------------------------------------------------------------------
+void CCamPreCaptureContainerBase::NonTouchLayout() 
+    {
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        iLayouts.Reset(); 
+        TAknLayoutRect parent;  
+        TAknLayoutRect tmp;  
+        TBool variant = Layout_Meta_Data::IsLandscapeOrientation(); 
+        TRect vfRect = ViewFinderFrameRect(); 
+       
+        // Autofocus parent rectangle
+        parent.LayoutRect( vfRect, 
+            AknLayoutScalable_Apps::cam6_autofocus_pane( variant ).LayoutLine() ); 
+        iReticuleRect = parent.Rect();
+        iReticuleRect.Move( vfRect.Center() - parent.Rect().Center() );
+        
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam6_autofocus_pane_g1().LayoutLine() );
+        iAfIconCornerSize = tmp.Rect().Size();
+        iLayouts.Append( tmp ); // First corner   
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam6_autofocus_pane_g2().LayoutLine() ); 
+        iLayouts.Append( tmp );
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam6_autofocus_pane_g3().LayoutLine() ); 
+        iLayouts.Append( tmp );
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam6_autofocus_pane_g4().LayoutLine() ); 
+        iLayouts.Append( tmp );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CCamPreCaptureContainerBase::TouchLayout
+// ---------------------------------------------------------------------------
+void CCamPreCaptureContainerBase::TouchLayout() 
+    {
+    if ( iController.UiConfigManagerPtr() && 
+         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )
+        {
+        iLayouts.Reset(); 
+        TAknLayoutRect parent;  
+        TAknLayoutRect tmp;  
+        TBool variant = Layout_Meta_Data::IsLandscapeOrientation(); 
+        TRect vfRect = ViewFinderFrameRect(); 
+       
+        // Autofocus parent rectangle
+        parent.LayoutRect( vfRect, 
+            AknLayoutScalable_Apps::cam4_autofocus_pane( variant ).LayoutLine() ); 
+        iReticuleRect = parent.Rect();
+        iReticuleRect.Move( vfRect.Center() - parent.Rect().Center() );
+        
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam4_autofocus_pane_g1().LayoutLine() );
+        iAfIconCornerSize = tmp.Rect().Size();
+        iLayouts.Append( tmp ); // First corner   
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam4_autofocus_pane_g2().LayoutLine() ); 
+        iLayouts.Append( tmp );
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam4_autofocus_pane_g3().LayoutLine() ); 
+        iLayouts.Append( tmp );
+        tmp.LayoutRect( iReticuleRect, AknLayoutScalable_Apps::
+                        cam4_autofocus_pane_g3_copy1().LayoutLine() ); 
+        iLayouts.Append( tmp );
+        }
+    }
+
+// ----------------------------------------------------
+// CCamPreCaptureContainerBase::ResolutionIndicatorRect
+// Returns the rectangle defining the position and size
+// of the resolution icon
+// ----------------------------------------------------
+//
+TRect CCamPreCaptureContainerBase::ResolutionIndicatorRect() const 
+    {
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+    TAknLayoutRect resolutionIconLayout;
+    TAknLayoutRect indicatorPane;
+    if ( CamUtility::IsNhdDevice() )
+        {
+        TInt variant = Layout_Meta_Data::IsLandscapeOrientation();
+        indicatorPane.LayoutRect( Rect(),
+            AknLayoutScalable_Apps::cam4_indicators_pane( variant ) ); 
+
+        resolutionIconLayout.LayoutRect( indicatorPane.Rect(),
+            AknLayoutScalable_Apps::cam4_indicators_pane_g1() );
+        }
+    else
+        {
+        TInt cba =  AknLayoutUtils::CbaLocation() == 
+                    AknLayoutUtils::EAknCbaLocationLeft? 
+                    AknLayoutUtils::EAknCbaLocationLeft : 0;
+
+        if ( appUi->TargetMode() ==  ECamControllerVideo )
+            {
+            indicatorPane.LayoutRect( Rect(), 
+                AknLayoutScalable_Apps::vid6_indi_pane( cba ));
+
+            resolutionIconLayout.LayoutRect( indicatorPane.Rect(),
+                AknLayoutScalable_Apps::vid6_indi_pane_g1( cba ) );             
+            }
+        else
+            {
+            indicatorPane.LayoutRect( Rect(), 
+                AknLayoutScalable_Apps::cam6_indi_pane( cba ));
+
+            resolutionIconLayout.LayoutRect( indicatorPane.Rect(),
+                AknLayoutScalable_Apps::cam6_indi_pane_g1( cba ) );
+            }
+        }
+    return resolutionIconLayout.Rect();
+    }
+
+// End of File  
+