diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/src/CamViewBase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/src/CamViewBase.cpp	Wed Sep 01 12:30:54 2010 +0100
@@ -0,0 +1,1187 @@
+/*
+* Copyright (c) 2007-2010 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:  Base class for all views used in the Camera application*
+*/
+
+
+// INCLUDE FILES
+
+#include "CamAppUi.h"
+#include "CamViewBase.h"
+#include "CamContainerBase.h"
+#include "CamStandbyContainer.h"
+#include "CamUtility.h"
+#include "CamPanic.h"
+#include <eikmenub.h>
+ 
+
+#include <StringLoader.h>
+#include <AknQueryDialog.h>
+#include <aknnotewrappers.h>
+
+#include <cameraapp.rsg>
+#include <vgacamsettings.rsg>
+#include <akntoolbar.h>
+
+#include "CamUtility.h"
+#include <AknWaitDialog.h>
+#include "CamWaitDialog.h"
+#include "CamCommandHandlerAo.h"
+#include "CameraUiConfigManager.h"
+#include "CamNaviProgressBarModel.h"
+
+
+static const TRect KCamCbaHiddenRect = TRect(640,640,640,640);
+
+
+// ========================= MEMBER FUNCTIONS ================================
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase destructor
+// 
+// ---------------------------------------------------------------------------
+//
+CCamViewBase::~CCamViewBase()
+  {
+  PRINT( _L("Camera => ~CCamViewBase" ))  
+  if ( iStandbyContainer )
+    {
+    CAknViewAppUi* appUi = AppUi();
+    
+    if ( appUi )
+      {
+      appUi->RemoveFromStack( iStandbyContainer );
+      }
+        
+    delete iStandbyContainer;
+    iStandbyContainer = NULL;
+    }
+
+  delete iContainer;
+  iContainer = NULL;
+  
+  delete iCommandHandlerAo;
+  iCommandHandlerAo = NULL;
+  
+  PRINT( _L("Camera <= ~CCamViewBase" ))  
+  }
+
+// -----------------------------------------------------------------------------
+// CCamViewBase::HandleFocusLossL
+// Handle focus loss
+// -----------------------------------------------------------------------------
+//
+void CCamViewBase::HandleFocusLossL()
+    {
+    // intentionally doing nothing
+    }
+    
+// ---------------------------------------------------------------------------
+// HandleAppEvent <<virtual>>
+//
+// ---------------------------------------------------------------------------
+//
+void 
+CCamViewBase::HandleAppEvent( const TCamAppEvent& aEvent )
+  {
+  PRINT1( _L("Camera => CCamViewBase::HandleAppEvent, event:%d"), aEvent );
+  if( iContainer )
+    {
+    iContainer->HandleAppEvent( aEvent );
+    }
+  PRINT( _L("Camera <= CCamViewBase::HandleAppEvent") );
+  }
+
+
+// -----------------------------------------------------------------------------
+// CCamViewBase::PrepareForModeChange
+// Prepare for mode change
+// -----------------------------------------------------------------------------
+//
+void CCamViewBase::PrepareForModeChange()   
+    {
+    // intentionally doing nothing
+    }
+  
+// -----------------------------------------------------------------------------
+// CCamViewBase::HandleCommandL
+// Handle commands
+// -----------------------------------------------------------------------------
+//
+void CCamViewBase::HandleCommandL( TInt aCommand )
+    {
+    PRINT( _L("Camera => CCamViewBase::HandleCommandL"))
+    CCamAppUi* appUi =  static_cast<CCamAppUi*>( AppUi() );
+
+    switch(aCommand)
+        {
+        case ECamCmdInternalExit:
+            {   
+            TInt standbyError = KErrNone;        
+            if ( iStandbyModeActive && iStandbyContainer )
+                {
+                standbyError = iStandbyContainer->GetStandbyError();
+                ExitStandbyModeL();
+                }
+
+            if ( standbyError != KErrNone )
+                {
+                AppUi()->HandleCommandL( EEikCmdExit );
+                }
+            else
+                {
+                AppUi()->HandleCommandL( aCommand );
+                }
+
+            // dismiss menu - if open
+            StopDisplayingMenuBar();
+            }
+            break;
+            
+        case ECamCmdRedrawScreen:
+            {
+            if( iContainer )
+            	{
+            	iContainer->DrawDeferred();
+            	}           
+            }
+            break;
+
+        case ECamCmdRedrawVideoTime:
+            {
+            if( iContainer )
+            	{
+            	if(appUi)
+            	    {
+            	    iContainer->DrawNow( appUi->NaviProgressBarModel()->ProgPaneRect() );    
+            	    }
+                else
+                    {
+            	    iContainer->DrawDeferred();
+            	    }
+            	}           
+            }
+            break;
+
+        case ECamCmdRedrawZoom:
+            {    
+            if( iContainer )
+            	{
+            	if(appUi)
+            	    {
+            	    iContainer->DrawNow( appUi->ZoomPane()->Rect() );    
+            	    }
+            	else
+            	    {
+            	    PRINT( _L("Camera <> CCamViewBase::HandleCommandL ECamCmdRedrawZoom zoomRect"))                	        
+            	    iContainer->DrawDeferred();
+            	    }
+            	}           
+            }
+            break;
+
+        default:
+            {
+            AppUi()->HandleCommandL( aCommand );
+            break;
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CCamViewBase::HandleForegroundEventL
+// Handle foreground event
+// -----------------------------------------------------------------------------
+//
+void CCamViewBase::HandleForegroundEventL( TBool /*aForeground*/ )
+    {
+    PRINT( _L("CCamViewBase::HandleForegroundEventL") );
+    CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );  
+    iEmbedded = appUi->IsEmbedded();
+    PRINT1( _L("CCamViewBase::HandleForegroundEventL embedded %d"), iEmbedded );    
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::DoActivateL
+// Activate this view
+// ---------------------------------------------------------------------------
+//
+void 
+CCamViewBase::DoActivateL( const TVwsViewId& /*aPostvViewId*/, 
+                                 TUid        aCustomMessageId, 
+                           const TDesC8&     /*aCustomMessage*/ )
+  {
+  PRINT( _L("Camera => CCamViewBase::DoActivateL"));    
+
+  CCamContainerBase::DestroyActivePalette();     
+
+
+  if(ECamViewMessageDeactivateFirst == aCustomMessageId.iUid)
+    {
+    PRINT( _L("CCamViewBase::DoActivateL call deactivate"));    
+    TBool wasCameraUser = IsCameraUser();    
+
+    PrepareDeactivate();
+    // since we still use it
+    if( wasCameraUser )
+      {
+      IncrementCameraUsers();
+      }
+    }
+  
+  CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );  
+  iEmbedded = appUi->IsEmbedded();
+
+  PRINT1( _L("CCamViewBase::DoActivateL Embedded %d"), iEmbedded);    
+  if ( !iContainer )
+    {
+    CreateContainerL();
+    
+    if( iTempContainer )
+        {
+        AppUi()->RemoveFromStack( iTempContainer );
+        }
+    AppUi()->AddToStackL( *this, iContainer );
+    iContainer->ActivateL();
+    }
+  PostDeactivate();
+  
+  SetTitlePaneTextL();
+  
+  TInt orientation;
+  TCamPsiKey queryValue = ECamPsiOrientation;
+  CCameraUiConfigManager* configManager = iController.UiConfigManagerPtr(); 
+
+  if ( configManager && configManager->IsSecondaryCameraSupported() )
+      {
+      if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() ) // if front camera is active         
+          {
+          queryValue = ECamPsiSecondaryCameraOrientation;
+          }
+      else // back camera is active
+          {
+          queryValue = ECamPsiPrimaryCameraOrientation;
+          }
+      }
+    
+  CamUtility::GetPsiInt( queryValue, orientation );
+
+  AppUi()->SetOrientationL( ( CAknAppUiBase::TAppUiOrientation ) orientation );
+
+  TCamOrientation camOrientation = appUi->CamOrientation();
+
+  // if in camcorder mode need to show navi-ctr
+  if( camOrientation == ECamOrientationCamcorder ||  
+      camOrientation == ECamOrientationCamcorderLeft || 
+      camOrientation == ECamOrientationPortrait )
+    {
+		iContainer->SetupNaviPanesL( CCamContainerBase::ECamPaneCounter );
+		}
+  PRINT( _L("Camera <= CCamViewBase::DoActivateL"));    
+  }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::DoDeactivate
+// Deactivate this view
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::DoDeactivate()
+  {
+  PRINT( _L("Camera => CCamViewBase::DoDeactivate" ))
+	// Both standard container and standby container should be deactivated
+    if ( iStandbyContainer ) // implies IsInStandbyMode
+        {
+        AppUi()->RemoveFromStack( iStandbyContainer );
+        delete iStandbyContainer;
+        iStandbyContainer = NULL;
+        SetStandbyModeActive( EFalse );
+        }
+
+	if ( iContainer )
+		{
+  		AppUi()->RemoveFromStack( iContainer );
+    	delete iContainer;
+    	iContainer = NULL;
+    	}
+    	
+	PRINT( _L("Camera <= CCamViewBase::DoDeactivate" ))
+	}
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::PrepareDeactivate
+// Prepare deactivation of this view
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::PrepareDeactivate()
+    {
+    PRINT( _L("Camera => CCamViewBase::PrepareDeactivate" ));
+      // Both standard container and standby container should be deactivated
+      // Store them for temporal variables until new containers have been
+      // created.
+      if ( iStandbyContainer ) // implies IsInStandbyMode
+          {
+          AppUi()->RemoveFromStack( iStandbyContainer );
+          iTempStandbyContainer=iStandbyContainer;
+          iStandbyContainer = NULL;
+          SetStandbyModeActive( EFalse );
+          }
+
+      if ( iContainer )
+          {
+          iTempContainer=iContainer;
+          iContainer = NULL;
+          }          
+    PRINT( _L("Camera <= CCamViewBase::PrepareDeactivate" ));    
+    }
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::PostDeactivate
+// Completed prepared deactivation of this view
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::PostDeactivate()
+    {
+    PRINT( _L("Camera => CCamViewBase::PostDeactivate" ));    
+    // Both standard container and standby container should be deactivated
+    if ( iTempStandbyContainer ) // implies IsInStandbyMode
+        {
+        delete iTempStandbyContainer;
+        iTempStandbyContainer = NULL;
+        }
+
+    if ( iTempContainer )
+        {
+        delete iTempContainer;
+        iTempContainer = NULL;
+        }              
+    PRINT( _L("Camera <= CCamViewBase::PostDeactivate" ));    
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::CCamViewBase
+// C++ constructor
+// ---------------------------------------------------------------------------
+//
+CCamViewBase::CCamViewBase( CCamAppController& aController )
+    : iController( aController )
+    {
+    }
+    
+// ---------------------------------------------------------------------------
+// CCamViewBase::UpdateCbaL
+// Update softkeys to reflect current state
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::UpdateCbaL()
+    {
+    }
+    
+
+// ----------------------------------------------------
+// CCamViewBase::BlankSoftKeysL
+// Blank the softkeys
+// ----------------------------------------------------
+//
+void CCamViewBase::BlankSoftkeysL()
+    {
+    // blank the cba 
+    SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );
+    }
+
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::SwitchToStandbyModeL
+// Switches to standby mode
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::SwitchToStandbyModeL( TCamAppViewIds aViewId, TInt aError )
+    {
+    PRINT( _L("Camera => CCamViewBase::SwitchToStandbyModeL") );
+    // check if already in standby mode
+    if( iStandbyModeActive )
+    	{
+    	PRINT( _L("Camera <= CCamViewBase::SwitchToStandbyModeL: already in standby") );
+    	return;
+    	}
+
+    StatusPane()->MakeVisible( ETrue );
+    delete iStandbyContainer;
+    iStandbyContainer = NULL;
+    iStandbyContainer = CCamStandbyContainer::NewL( AppUi()->ClientRect(),
+                                                    *this, iController, aError );
+    // dismiss menu - if open
+    StopDisplayingMenuBar();
+
+    // save options menu id for reactivation
+    if ( aViewId == ECamViewIdStillPreCapture )
+        {
+        if ( iEmbedded )
+            {
+            iPreviousMenuResourceId = ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID);
+            }
+        else
+            {
+            iPreviousMenuResourceId = ROID(R_CAM_STILL_PRE_CAPTURE_MENUBAR_ID);
+            }
+        }
+    else if ( aViewId == ECamViewIdVideoPreCapture )
+        {
+        if ( iEmbedded )
+            {
+            iPreviousMenuResourceId = ROID(R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENUBAR_ID);
+            }
+        else
+            {
+            iPreviousMenuResourceId = ROID(R_CAM_VIDEO_PRE_CAPTURE_MENUBAR_ID);
+            }
+        }
+    else if ( aViewId == ECamViewIdVideoSettings )
+        {
+        iPreviousMenuResourceId = ROID(R_CAM_SETTINGS_LIST_MENUBAR_ID);
+        }
+    else if ( aViewId == ECamViewIdPhotoSettings )
+        {
+        iPreviousMenuResourceId = ROID(R_CAM_SETTINGS_LIST_MENUBAR_ID);
+        }
+    else
+        {
+        // remove Lint error
+        }
+
+    // activate standby container and deactivate current container
+    iStandbyContainer->SetMopParent( this );   
+    
+    CCamAppUi* appUi =  static_cast<CCamAppUi*>( AppUi() );
+    appUi->AddToStackL( *this, iStandbyContainer );
+    iStandbyContainer->ActivateL();
+    appUi->RemoveFromStack( iContainer );
+    iContainer->MakeVisible( EFalse );   
+    iStandbyContainer->MakeVisible( ETrue );
+    iStandbyContainer->DrawNow();
+
+    UnsetCourtesySoftKeysL();
+
+    // update softkeys
+    if ( !appUi->IsConstructionComplete() )
+    	{
+    	BlankSoftkeysL();
+    	}
+    else if ( appUi->StandbyStatus() == KErrInUse ||
+              appUi->StandbyStatus() == KErrPermissionDenied ||
+              appUi->StandbyStatus() == KErrAccessDenied )
+        {
+        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );	
+        }	
+    else if ( iEmbedded )
+        {
+        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__CONTINUE );
+        }
+    else
+        {
+        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CONTINUE );
+        if( Cba() && !appUi->IsRecoverableStatus() )
+            {
+            Cba()->MakeCommandVisible( ECamCmdExitStandby, EFalse );
+            }
+        }
+
+    // change options menu
+    CEikMenuBar* menuBar = MenuBar();
+    if ( menuBar )
+        {
+        menuBar->SetMenuTitleResourceId( R_CAM_STANDBY_MENUBAR );
+        }
+
+//    if ( iStandbyError != KErrNone )
+    if ( appUi->StandbyStatus() != KErrNone && appUi->IsRecoverableStatus())
+        {
+        // stop idle timer - non recoverable error
+        iController.StopIdleTimer();
+        }
+
+    SetStandbyModeActive(ETrue);
+
+    UpdateCbaL();
+    if ( Cba() )
+        {
+        Cba()->DrawNow();
+        }
+        
+    
+    // Release the camera hardware
+    iController.ReleaseCamera();
+    
+
+    // cancel self timer mode if active
+    if ( appUi->SelfTimerEnabled() )
+        {
+        appUi->SelfTimerEnableL( ECamSelfTimerDisabled );
+        }
+  	PRINT( _L("Camera <= CCamViewBase::SwitchToStandbyModeL") );
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::ExitStandbyModeL
+// Exits standby mode
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::ExitStandbyModeL()
+    {
+    PRINT( _L("Camera => CCamViewBase::ExitStandbyModeL") );    
+    if ( !iStandbyModeActive )
+        {
+        return;
+        }
+
+    // delete standby container and reactivate previous container
+    TRAPD( err, AppUi()->AddToStackL( *this, iContainer ) )
+    iStandbyContainer->MakeVisible( EFalse );
+    AppUi()->RemoveFromStack( iStandbyContainer );
+    delete iStandbyContainer;
+    iStandbyContainer = NULL;
+    User::LeaveIfError( err );
+
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
+
+
+    iContainer->MakeVisible( ETrue );   
+    SetStandbyModeActive( EFalse );
+    
+    if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() ) 
+        {
+        StatusPane()->MakeVisible( ETrue );
+        }
+    else
+        {
+        StatusPane()->MakeVisible( EFalse );
+        }
+
+    CCameraUiConfigManager* configManager = iController.UiConfigManagerPtr();
+    if ( !( configManager && configManager->IsUIOrientationOverrideSupported() ) ) 
+        {
+        appUi->RaisePreCaptureCourtesyUI(ETrue);
+        }
+
+    if ( iPreviousMenuResourceId == ROID(R_CAM_SETTINGS_LIST_MENUBAR_ID)
+            || iPreviousMenuResourceId == ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID)
+            || iPreviousMenuResourceId == ROID(R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENUBAR_ID))
+        {
+        if ( iController.CaptureModeTransitionInProgress() )
+            {
+            SetSoftKeysL( R_AVKON_SOFTKEYS_BACK ); 
+            }
+        else
+            {
+            SetSoftKeysL( R_AVKON_SOFTKEYS_OPTIONS_BACK );
+            }
+        }
+    else
+        {
+        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );
+        }
+
+    // restore options menu
+    CEikMenuBar* menuBar = MenuBar();
+    if ( menuBar )
+        {
+        menuBar->SetMenuTitleResourceId( iPreviousMenuResourceId );
+        }
+
+    //SetStandbyModeActive(EFalse);
+    SetTitlePaneTextL();    
+
+    // restart idle timer
+    iController.StartIdleTimer();
+    PRINT( _L("Camera <= CCamViewBase::ExitStandbyModeL") );    
+    }
+
+
+// ---------------------------------------------------------------------------
+// ExitAllModesL <<virtual>>
+// ---------------------------------------------------------------------------
+//
+void 
+CCamViewBase::ExitAllModesL()
+  {
+  // Empty default implementation.
+  }
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::GetHelpContext
+// Called to identify the help context for this view
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::GetHelpContext( TCoeHelpContext& /*aContext*/ ) const
+    {
+    // No context
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::QueryRenameL
+// Switches orientation if required - calls DoQueryRenameL
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::QueryRenameL( TCamCameraMode aMode )
+    {
+    // Ensure application is in editing orientation
+    TInt error = KErrNone;
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
+    TInt editingOrientation = CAknAppUiBase::EAppUiOrientationUnspecified;
+
+    error = CamUtility::GetPsiInt( ECamPsiOrientation, editingOrientation );   
+    
+    if ( !error )
+        {
+        appUi->SwitchOrientationIfRequiredL( editingOrientation );
+        }    
+    // Trap this to make sure the orientation is reverted back to normal        
+    TRAPD( leaveErr, DoQueryRenameL( aMode ) )
+    appUi->SwitchOrientationIfRequiredL( CAknAppUiBase::EAppUiOrientationUnspecified );
+    User::LeaveIfError( leaveErr );    
+    }
+    
+// ---------------------------------------------------------------------------
+// CCamViewBase:DoQueryRenameL
+// Show rename query and rename file.
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::DoQueryRenameL( TCamCameraMode aMode )
+  {
+  TBool done = EFalse;
+  HBufC* lastFilePath = HBufC::NewLC( iController.CurrentFullFileName().Length() );
+  TBuf<KMaxNameBaseLengthPlusNumbering> filename( iController.CurrentImageName() );
+  
+  // Repeat until successfully renamed or cancelled
+  while ( !done )
+    {
+    // Show rename query
+    if ( ShowRenameQueryL( filename, aMode ) )
+      {
+      // Try to rename file
+      TRAPD( err, done = RenameCurrentFileL( filename, aMode ) );
+      if ( KErrAlreadyExists == err )
+        {
+        // File exists -> show overwrite confirmation query
+        if ( ShowOverwriteConfirmationQueryL( filename ) )
+          {
+          // Yes, overwrite
+          TPtr lastFilePathPtr = lastFilePath->Des();
+          lastFilePathPtr = iController.CurrentFullFileName();
+          TParsePtr parseptr( lastFilePathPtr );
+          TFileName fullpath = parseptr.DriveAndPath();
+          fullpath.Append( filename );
+          fullpath.Append( parseptr.Ext() );
+
+          // Delete the file that gets overwritten.
+          if ( ECamControllerVideo != aMode )
+            {
+            CamUtility::DeleteStillImageL( fullpath );
+            }
+          else
+            {
+            CamUtility::DeleteVideoL( fullpath );
+            }
+
+          // Rename
+          RenameCurrentFileL( filename, aMode );
+          done = ETrue;
+          }
+        else  // No, don't overwrite
+          {
+          // Generate a suitable suggestion for an unique name
+          TInt key             = ( ECamControllerVideo == aMode )
+                                 ? ECamSettingItemVideoNumber
+                                 : ECamSettingItemPhotoNumber;         
+          TInt fileNameCounter = iController.IntegerSettingValue( key );
+
+          TParsePtrC parse( iController.CurrentFullFileName() );
+          TFileName filePath = parse.DriveAndPath();
+          
+          const TUint KMax3Digits = 999;
+
+          //if  0 < fileNameCounter <= 999, formatted file name like "Photo001", the length of number part ("001") is fixed 3
+          const TUint KFixedNumberLength = 3; 
+        
+          TBool exceedMaxFileNameLength = EFalse;
+          //if  0 < fileNameCounter <= 999, formatted file name like "Photo001"
+          if ( fileNameCounter > 0 && 
+             fileNameCounter <= KMax3Digits && 
+             filename.Length() + KFixedNumberLength > filename.MaxLength() )
+            {
+            exceedMaxFileNameLength = ETrue;
+            }         
+          //if  fileNameCounter > 999, formatted file name like "Photo1234"
+          else if ( fileNameCounter > KMax3Digits )
+            {
+            _LIT( KCamNameFormatFileNameCounter, "%d" );
+            TBuf<KMaxNameBaseLengthPlusNumbering> strFileNameCounter;
+            strFileNameCounter.Format( KCamNameFormatFileNameCounter, fileNameCounter );
+            if ( filename.Length() + strFileNameCounter.Length() > filename.MaxLength() )
+              {
+              exceedMaxFileNameLength = ETrue;
+              }
+            }
+        
+          if ( !exceedMaxFileNameLength )
+            {
+            CamUtility::GetUniqueNameL( filePath, filename, fileNameCounter, parse.Ext() );
+            }
+                    
+
+          }       
+        }
+      else
+        {
+        // If unknown error
+        User::LeaveIfError( err );
+        }
+      }
+    else
+      {
+      // User cancelled (ShowRenameQueryL() returned false)
+      done = ETrue;
+      }
+    }
+  CleanupStack::PopAndDestroy(); // lastFilePath
+  }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::ShowOverwriteConfirmationQueryL
+// Show an overwrite confirmation query. This is used
+// when trying to overwrite a file using rename.
+// ---------------------------------------------------------------------------
+//
+TBool CCamViewBase::ShowOverwriteConfirmationQueryL( 
+    const TDesC& aFilename )
+    {
+    HBufC* prompt =  StringLoader::LoadLC( R_QTN_FLDR_OVERWRITE_QUERY, 
+                                           aFilename, CEikonEnv::Static() );
+
+    CAknQueryDialog* overwriteQuery = 
+        new ( ELeave ) CAknQueryDialog( *prompt );
+    TBool result = overwriteQuery->ExecuteLD( R_CAM_OVERWRITE_QUERY );
+
+    CleanupStack::PopAndDestroy(); // prompt
+
+    return result;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::ShowRenameQueryL
+// Show rename query.
+// ---------------------------------------------------------------------------
+//
+TBool CCamViewBase::ShowRenameQueryL( TDes& aFilename, TCamCameraMode aMode )
+    {
+    TBool done = EFalse;
+    TBool res = ETrue;
+
+    while ( !done )
+        {
+        // Show data query
+        HBufC* prompt = NULL;
+        if ( ECamControllerVideo == aMode )
+            {
+            prompt = 
+                StringLoader::LoadLC( R_CAM_QUERY_VIDEO_NAME );
+            }
+        else
+            {
+            prompt = 
+                StringLoader::LoadLC( R_CAM_QUERY_IMAGE_NAME );
+            }
+
+        CAknTextQueryDialog* nameQuery = 
+            CAknTextQueryDialog::NewL( aFilename );
+        nameQuery->SetMaxLength( KMaxNameBaseLengthPlusNumbering );   
+        nameQuery->PrepareLC( R_CAM_RENAME_QUERY );
+        nameQuery->SetPromptL( *prompt );
+
+        TBool dialogRes = ( nameQuery->RunLD() == EAknSoftkeyOk );
+        if ( dialogRes )
+            {
+            if ( !IsNewNameValidL( aFilename ) )
+                {
+                // New name is not valid for another reason.
+                // In practise, the user has attempted to overwrite
+                // an image already existing in the burst grid.
+
+                HBufC* text = StringLoader::LoadLC(
+                    	R_QTN_FLDR_CANT_RENAME_ITEM,
+                    	iController.CurrentImageName() );
+
+                CAknNoteWrapper* note = new ( ELeave ) CAknNoteWrapper();
+                note->ExecuteLD( R_CAM_UNABLE_TO_RENAME, *text );
+
+                CleanupStack::PopAndDestroy(); // text
+
+                // Don't show dialog again
+                res = EFalse;
+                done = ETrue;
+                }
+            else if ( CamUtility::CheckFileNameValidityL( aFilename ) )
+                {
+                // New file name seems ok
+                res = ETrue;
+                done = ETrue;
+                }
+            else
+                {
+                // File name is not suitable, ask again
+                }
+            }
+        else
+            {
+            // User cancelled rename
+            res = EFalse;
+            done = ETrue;
+            }
+
+        CleanupStack::PopAndDestroy(); // prompt
+        }
+
+    return res;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::IsNewNameValidL
+// Check if renaming to the given name is valid.
+// ---------------------------------------------------------------------------
+//
+TBool CCamViewBase::IsNewNameValidL( const TDesC& /* aFilename */ )
+    {
+    // This should be overridden in derived classes if needed
+    return ETrue;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::RenameCurrentFileL
+// Renames the current capture array file.
+// ---------------------------------------------------------------------------
+//
+TBool 
+CCamViewBase::RenameCurrentFileL( const TDesC& aNewName, 
+                                  TCamCameraMode aMode )
+  {
+  return iController.RenameCurrentFileL( aNewName, aMode );
+  }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::Container
+// Returns the currently used container in the view.
+// ---------------------------------------------------------------------------
+//
+CCamContainerBase* CCamViewBase::Container()
+    {
+    if ( iStandbyContainer )
+        {
+        return iStandbyContainer;
+        }
+    else
+        {
+        return iContainer;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::SetSoftKeysL
+// Sets the softkeys to the specified Resource ID
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::SetSoftKeysL(TInt aResource)
+	{
+    PRINT1( _L("Camera => CCamViewBase::SetSoftKeysL SoftKeys:0x%x"), aResource );
+
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );	  
+    // If courtesy softkeys are enabled, check whether the UI can be drawn without being explicitly raised
+    // (rare, but possible: e.g. when video recording starts
+    if(aResource == R_CAM_SOFTKEYS_BLANK &&
+       appUi->IsSecondCameraEnabled() &&
+       !appUi->IsQwerty2ndCamera())
+        {
+        aResource = R_CAM_SOFTKEYS_BLANK_SECONDARY;
+        }
+    if ( iCourtesySoftkeys )
+        {
+        if ( appUi )
+            {
+            if (   (IsPreCapture()  && appUi->DrawPreCaptureCourtesyUI())
+                || (IsPostCapture() && appUi->DrawPostCaptureCourtesyUI()) )
+                {
+                // Disable the courtesy softkeys, otherwise nothing will be drawn when the rest of the
+                // courtesy UI has been turned back on
+                iCourtesySoftkeys = EFalse;
+
+                //when disabling the courtesy softkeys, Cba should be recovered to be visible
+                Cba()->MakeVisible( ETrue );
+                }
+            }
+        }
+        
+    if ( iCourtesySoftkeys || !Cba() )
+        {
+        // If the courtesy (blank) softkeys are being shown, make a note of what to change back to.
+        iPreviousCbaResource = aResource;
+        }
+    else if ( iCurrentCbaResource != aResource )
+        {
+        iPreviousCbaResource = iCurrentCbaResource;
+        iCurrentCbaResource = aResource;
+
+        Cba()->SetCommandSetL( aResource );
+        Cba()->DrawDeferred();
+
+        }
+
+    PRINT( _L("Camera <= CCamViewBase::SetSoftKeysL") );
+	}
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::SetCourtesySoftKeysL
+// Blanks the softkeys for the Courtesy UI Off state. 
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::SetCourtesySoftKeysL()
+    {
+    if ( !iCourtesySoftkeys )
+        {
+        Cba()->MakeVisible( EFalse );
+        iPreviousCbaResource = iCurrentCbaResource;
+        iCourtesySoftkeys = ETrue;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::UnsetCourtesySoftKeysL
+// Returns the softkeys to their previous state after UI has been turned back on
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::UnsetCourtesySoftKeysL()
+    {
+    if ( iCourtesySoftkeys )
+        {
+        iCourtesySoftkeys = EFalse;
+        SetSoftKeysL(iPreviousCbaResource);
+        Cba()->MakeVisible( ETrue );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::IsPreCapture
+// Returns whether the view is a precapture view
+// ---------------------------------------------------------------------------
+//
+TBool CCamViewBase::IsPreCapture()
+    {
+    return EFalse;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::IsPostCapture
+// Returns whether the view is a postcapture view
+// ---------------------------------------------------------------------------
+//
+TBool CCamViewBase::IsPostCapture()
+    {
+    return EFalse;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::IsBurstPostCapture
+// Returns whether the view is a burst mode postcapture view
+// ---------------------------------------------------------------------------
+//
+TBool CCamViewBase::IsBurstPostCapture()
+    {
+    return EFalse;
+    }
+
+    
+// ---------------------------------------------------------------------------
+// CCamViewBase::IsInStandbyMode
+// Returns whether the view is in standby mode
+// ---------------------------------------------------------------------------
+//
+TBool CCamViewBase::IsInStandbyMode()
+    {
+    return iStandbyModeActive;
+    }
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::SetStandbyModeActive
+// Sets the iStandbyModeActive flag
+// ---------------------------------------------------------------------------
+//
+void CCamViewBase::SetStandbyModeActive(TBool aActive)
+    {
+    // This should be the only place iStandbyModeActive is set!
+    // We need to inform the AppUi
+    iStandbyModeActive = aActive;
+     if( iController.IsAppUiAvailable() )
+     {
+    CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );
+    
+    if ( appUi)
+        {
+        if ( aActive )
+            {
+            appUi->SetPreCaptureMode(ECamPreCapStandby);
+            }
+        else
+            {
+            appUi->SetPreCaptureMode(ECamPreCapViewfinder);
+            }        
+        }
+        }
+    }
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::IncrementCameraUsers
+//
+// ---------------------------------------------------------------------------
+//
+void 
+CCamViewBase::IncrementCameraUsers()
+    {
+    if( !iIncEngineCount ) 
+        {
+        PRINT( _L("Camera == CCamViewBase::IncrementCameraUsers - incrementing") );
+        iIncEngineCount = ETrue;
+        iController.IncCameraUsers();
+        }
+    else
+        {
+        PRINT( _L("Camera == CCamViewBase::IncrementCameraUsers - already incremented, skipping") );
+        }
+    }
+        
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::DecrementCameraUsers
+//
+// ---------------------------------------------------------------------------
+//
+void 
+CCamViewBase::DecrementCameraUsers()
+    {
+    if( iIncEngineCount ) 
+        {
+        PRINT( _L("Camera == CCamViewBase::DecrementCameraUsers - decrementing") );
+        iIncEngineCount = EFalse;
+        iController.DecCameraUsers();
+        }
+    else
+        {
+        PRINT( _L("Camera == CCamViewBase::DecrementCameraUsers - not using camera, skipped") );
+        }
+    }
+
+
+// ---------------------------------------------------------------------------
+// CCamViewBase::IsCameraUser
+//
+// ---------------------------------------------------------------------------
+//
+TBool 
+CCamViewBase::IsCameraUser() const
+    {
+    return iIncEngineCount;
+    }
+
+
+
+// -----------------------------------------------------------------------------
+// CCamViewBase::RedrawAPArea
+// -----------------------------------------------------------------------------
+void CCamViewBase::RedrawAPArea(const TRect& aArea)
+    {
+    if ( iContainer )
+        {
+        iContainer->Redraw(aArea);
+        }
+    }
+
+
+// -----------------------------------------------------------------------------
+// CCamViewBase::ViewCba
+// -----------------------------------------------------------------------------
+CEikButtonGroupContainer* CCamViewBase::ViewCba()
+    {
+    return Cba();
+    }
+
+// -----------------------------------------------------------------------------
+// CCamViewBase::UpdateToolbarIconsL
+// 
+void CCamViewBase::UpdateToolbarIconsL()
+    {
+    
+    }
+// -----------------------------------------------------------------------------
+// CCamViewBase::HandleCommandAoL
+// -----------------------------------------------------------------------------    
+    
+void CCamViewBase::HandleCommandAoL( TInt aCommand )
+    {
+    if ( !iCommandHandlerAo )
+        {
+        iCommandHandlerAo = CCamCommandHandlerAo::NewL( this );
+        }
+    iCommandHandlerAo->HandleCommandL( aCommand );
+    }    
+
+// -----------------------------------------------------------------------------
+// CCamViewBase::SetStandbyStatusL
+// -----------------------------------------------------------------------------    
+ 
+void CCamViewBase::SetStandbyStatusL( TInt aError )
+    {
+    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
+    __ASSERT_DEBUG( appUi, CamPanic( ECamPanicNullPointer ) );
+    if( iStandbyModeActive )
+        {
+        appUi->SetStandbyStatus( aError );
+        iStandbyContainer->SetStandbyErrorL( aError );
+        if ( aError == KErrInUse ||
+             aError == KErrPermissionDenied ||
+             aError == KErrAccessDenied )
+            {
+            SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );    
+            }   
+        else if ( iEmbedded )
+            {
+            SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__CONTINUE );
+            }
+        else
+            {
+            SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CONTINUE );
+            if( Cba() && !appUi->IsRecoverableStatus() )
+                {
+                Cba()->MakeCommandVisible( ECamCmdExitStandby, EFalse );
+                }
+            else
+                {
+                Cba()->MakeCommandVisible( ECamCmdExitStandby, ETrue );
+                }
+            }
+        }
+    }
+//  End of File