/*
* 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 pre capture views*
*/


// INCLUDE FILES
#include <eikbtgpc.h>
#include <eikmenub.h>
#include <musresourceproperties.h>
#include <cameraplatpskeys.h>
#include <cameraapp.rsg>
#include <vgacamsettings.rsg>
#include <akntoolbar.h>
#include <akntoolbarextension.h>
#include <aknbutton.h>
#include <eiksoftkeypostingtransparency.h>
#include <AknsUtils.h>
#include <gulicon.h>

#include "Cam.hrh"
#include "CamAppUi.h"
#include "CamUtility.h"
#include "CamAppController.h"
#include "CamPreCaptureContainerBase.h"
#include "CamLogger.h"
#include "CamPanic.h"
#include "CamCaptureSetupMenu.h"
#include "CamStandbyContainer.h"
#include "CamSelfTimer.h"
#include "CamTimer.h"
#include "camactivepalettehandler.h"
#include "CamPreCaptureViewBase.h"
#include "CameraUiConfigManager.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "CamPreCaptureViewBaseTraces.h"
#endif

#include "camstartuplogocontroller.h" 

// ===========================================================================
// Constants



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

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase destructor
// 
// ---------------------------------------------------------------------------
//
CCamPreCaptureViewBase::~CCamPreCaptureViewBase()
  {
  PRINT( _L("Camera => ~CCamPreCaptureViewBase") );
  if ( iGestureFw ) 
      {
      delete iGestureFw;
      }
  PRINT( _L("Camera <= ~CCamPreCaptureViewBase") );
  }

// -----------------------------------------------------------------------------
// CCamPreCaptureViewBase::HandleCommandL
// Handle commands
// -----------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::HandleCommandL( TInt aCommand )
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::HandleCommandL") );

    iLastMovement = 0;
    switch ( aCommand )
        {              
        case ECamCmdShootSetup:
            {
            CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );
            TBool selfTimerEnabled = appUi->SelfTimerEnabled();

            if ( selfTimerEnabled )
                {                
                CCamSelfTimer* selftimer = appUi->SelfTimer();

                // If self-timer is enabled, we need to check that it is in
                // self-timer standby, ie Enabled but not Active (ie not 
                // counting down)
                if ( selftimer && !selftimer->IsActive() )
                    {
                    // In self-timer standby, pressing "select" button starts 
                    // self-timer count down.  Pass this event on to AppUi.
                    appUi->HandleCommandL( ECamCmdSelfTimerActivate );
                    }
                }
            else 
                {
                // we are not in self -timer mode and check we are
                // not already in capture setup mode
                if ( !iCaptureSetupMenuModeActive )
                    {
                    // Ensure first item is selected in CSM.
                    iCaptureSetupMenuLastItemIndex = 0;
                    SwitchToCaptureSetupMenuModeL();
                    }
                    
                }            
            }
            break;

        // If an item in the capture setup menu has been selected.
        case EAknSoftkeySelect:  
            {
            if ( ActiveSettingMode() == ECamSettingModeCaptureMenu )
                {
                iCaptureSetupMenuContainer->HandleCommandL( aCommand );
                }
            else
                {          
                CCamCaptureSetupViewBase::HandleCommandL( aCommand );             
                }
            }
            break;
            
        // If capture setup menu is active and user presses softkey back,
        //  deactivate the menu. This is EEikBidCancel which has the same
        //  enumeration value as EAknSoftkeyCancel.
        case EAknSoftkeyCancel:
            {            
            if ( ActiveSettingMode() == ECamSettingModeCaptureMenu )
                {
                ExitCaptureSetupMenuModeL();
                }
            else if ( iController.SequenceCaptureInProgress() )                         
                // Check if currently capturing a burst, if so, cancel it
                {
                // If already received all the snapshots
                if ( iController.AllSnapshotsReceived() ) 
                    {
                    // stop burst immediately
                    iController.StopSequenceCaptureL();
                    }
                else
                    {
                    // capture the min images (2), before stopping the burst
                    iController.SetKeyUp( ETrue );
                    iController.SoftStopBurstL( ETrue );
                    }
                // Update CBA for setup pane usage
                SetSoftKeysL( R_CAM_SOFTKEYS_BLANK ); 
                }     
            else
                {
                CCamCaptureSetupViewBase::HandleCommandL( aCommand );                                                                                       
                }                        
            }
            break;
        case EAknSoftkeyOptions:
            {
            // do nothing, the command is handled by the framework
            }
            break;
            
        // Note: CaptureSetupMenu mode also uses a 'Back' softkey but this has
        // the command value EEikBidCancel            
        case EAknSoftkeyBack:
            {                                          
            // exit to embedded app if we're embedded and in plain pre-capture
            if ( iEmbedded 
                && ActiveSettingMode() != ECamSettingModeScene 
                && ActiveSettingMode() != ECamSettingModeInfoListBox )
                {
                CCamCaptureSetupViewBase::HandleCommandL( ECamCmdInternalExit );
                }
            else
                {
                CCamCaptureSetupViewBase::HandleCommandL( aCommand );              
                }                           
               
            }
            break;
            
        case EAknSoftkeyOk:
            {                                                                
                // Else pass on to lower levels
                CCamCaptureSetupViewBase::HandleCommandL( aCommand );                                     
            }
            break;
            
        case ECamCmdToggleCourtesyUI:
            {
            CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
            
            if ( appUi )
                {
                appUi->SetAlwaysDrawPreCaptureCourtesyUI( !appUi->AlwaysDrawPreCaptureCourtesyUI() );
                }
            }
            break;
       case ECamCmdPopUpMenuZoom: 
            {
            if ( iContainer )
                {
                iContainer->ShowZoomPaneWithTimer();
                }
            }     
            break;
        case ECamCmdCaptureSetupFlashStill:
            {
            iToolbarExtensionInvisible = ETrue;
           	CCamCaptureSetupViewBase::HandleCommandL( aCommand );
            }     
            break;
        case ECamCmdInternalExit:
            {
            const TCamCaptureOperation operation( 
                    iController.CurrentOperation() );
            
                 if ( ECamPaused == operation )
                   {
                   iController.StopVideoRecording();
                   iController.SetCaptureKeyPressedWhileImageSaving( ETrue );
                   }
            StopViewFinder();
            CCamCaptureSetupViewBase::HandleCommandL( aCommand );
            if ( iController.IsTouchScreenSupported() )
                {
                CAknToolbar* fixedToolbar = Toolbar();
                if ( fixedToolbar )
                    {
                    CAknToolbarExtension* extension = 
                        fixedToolbar->ToolbarExtension();
                    if ( extension )
                        {
                        // Reset toolbar extension button and view to closed state
                        extension->SetShown( EFalse );
                        extension->SetCurrentState( 0, EFalse );
                        }
                    }
                }
            }     
            break;
        case ECamCmdSettings:
            // Hide the capture button
            if ( iContainer )
                {
                iContainer->SetFocus( EFalse );
                }
            // fall-through
        default:
            {                                       
            CCamCaptureSetupViewBase::HandleCommandL( aCommand );                            
            }
        }
    PRINT( _L("Camera <= CCamPreCaptureViewBase::HandleCommandL") );
    }

// -----------------------------------------------------------------------------
// CCamPreCaptureViewBase::HandleForegroundEventL
// Handle a move to the foreground
// -----------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::HandleForegroundEventL( TBool aForeground )
  {
  PRINT1( _L( "Camera => CCamPreCaptureViewBase::HandleForegroundEventL %d" ), aForeground );    

  iLastMovement = 0;
  CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );                
  __ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));

  // -----------------------------------------------------
  // coming to the foreground
  if ( aForeground )
    {
    // Ignore foregrounding if view switch to postcapture anyway in progress.
    if( appUi->TargetViewState() == ECamViewStatePostCapture
     || appUi->TargetViewState() == ECamViewStateBurstThumbnail 
     || ( iStandbyModeActive && !appUi->IsRecoverableStatus() ) ) {
      PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL, ignored states") );    
      return;
    }
    
    
    if ( !( iController.UiConfigManagerPtr() && 
            iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )
        {
        if ( !iController.IsTouchScreenSupported() )
            {
            if ( !appUi->ActivePalette() )
                {
                SetupActivePaletteL();
                }
            else
                {
                appUi->APHandler()->UpdateActivePaletteL();
                }
            }
        }
    UpdateCbaL();
    
    // restart idle timer in any case
     iController.StartIdleTimer();
                                 
    // If capture setup menu is active then ensure background is faded.
    if ( iCaptureSetupMenuContainer )
      {
      iCaptureSetupMenuContainer->FadeBehind( ETrue );
      }       

    // coming to the foreground from an eikon server window
    if ( iContinueInBackground )
      {
      iContinueInBackground = EFalse;

      if ( !iController.IsViewFinding()  && !iSceneSettingModeActive )
        {
      	iController.StartViewFinder();
        }
      else if( iLocationTrailConnecting )
          {
          iLocationTrailConnecting = EFalse;
          iController.StopViewFinder();
          iController.StartViewFinder();
          }
      CCamCaptureSetupViewBase::HandleForegroundEventL( aForeground );

      UpdateCbaL();
      if ( iController.CameraSwitchQueued() )
          {
          appUi->HandleCommandL( ECamCmdSwitchCamera );
          }
      PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL - continuing in background" ) );            
      return;
      }
    
    // This only happens when the app is first launched        
    if ( !appUi->IsConstructionComplete() && 
         !iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported())    
      {
      iActivateToStandby = ETrue;
      if ( !iStandbyModeActive )
        {
        //iStandbyError = KErrNone;
        appUi->SetStandbyStatus( KErrNone );        
        PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: sending ECamCmdGoToStandby" ) );    
        HandleCommandL( ECamCmdGoToStandby );
        SetTitlePaneTextL();
        }            
      }

    // Register that we want to use the engine
    IncrementCameraUsers();
    
    if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() )
        {
        if ( iController.CameraSwitchQueued() )
            {
            appUi->HandleCommandL( ECamCmdSwitchCamera );
            }
        else if ( appUi->TargetViewState() != ECamViewStatePostCapture )      
            {   
            TCamCameraMode mode = iController.CurrentMode(); 
            if ( mode == ECamControllerVideo )
                {
                iController.EnterViewfinderMode( ECamControllerVideo );
                }       
            else if( mode == ECamControllerImage && !iSceneSettingModeActive )
                {
                iController.EnterViewfinderMode( ECamControllerImage );
                }  
            }
        UpdateCbaL();
        }
      else
        {
        // Lens cover is not supported
        if ( iController.CameraSwitchQueued() )   
            {
            appUi->HandleCommandL( ECamCmdSwitchCamera );
            }
        }


      // Start the viewfinder unless the view is activating into standby mode
      // in other modes than scene setting mode (there is no VF and this causes problems with DSA VF)
      if ( ( !iStandbyModeActive || !iActivateToStandby )  && !iSceneSettingModeActive )
        {
        // If in embedded mode and image has been captured but view is not yet in
        // postcapture view VF should not be started.
        if( !iAssumePostCaptureView ) 
            {
            PRINT( _L("Camera <> CCamPreCaptureViewBase::HandleForegroundEventL start VF"))
            StartViewFinder();
            }
        }
    // Check if currently selected storagemedia has available memory for next capturing
    appUi->CheckMemoryAvailableForCapturing();                                   
    
    // <CAMERAAPP_CAPI_V2_MIGRATION/>
    // if ( iController.EngineState() == ECamEngineStillCapturePrepared ||
    //      iController.EngineState() == ECamEngineVideoCapturePrepared )
    // if ( ( ECamImageOn|ECamVideoOn )& ( iController.CameraState() ) )
    TCamCameraState state = iController.CameraState();
    if( ECamCameraPreparedImage == state ||
        ECamCameraPreparedVideo == state )     
      {
      // Now that the view is initialised, we may need to put up the
      // mmc removal note. Perform this is required.
      appUi->ShowMMCRemovalNoteIfRequiredL();                        
      
      if ( appUi && !iSceneSettingModeActive &&
           !( iController.UiConfigManagerPtr() && 
           iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )
        {
        appUi->RaisePreCaptureCourtesyUI(ETrue);
        }
      }
    }
  // -----------------------------------------------------
  // Going to the background
  else 
      {
      PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: to background" ) );    
      // Not behind an eikon/avkon server window
	  // or keylock on when camera needs to be released.
      TBool totalBackground = ETrue;
      if ( iController.IsAppUiAvailable() && !iController.IsKeyLockOn() )
          {
          totalBackground    = appUi->AppInBackground( EFalse );
          }
      // Either in foreground (moving to another view of our's)
      // or if in background, then not just behind a notifier dialog.
      if ( totalBackground )
          {
          ReleaseResources();
          // hide the AP to avoid blinking when coming back from bg
         if ( iController.UiConfigManagerPtr() && iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )
            {
            appUi->SetActivePaletteVisibility( EFalse );	
            }      
          }
      // Behind a server window
      else 
          {
          iContinueInBackground = ETrue;            
          }

      // reset post capture assumption flag since post capture is not
      // used when video is stopped for usb 
      if ( iController.IsCaptureStoppedForUsb() )
          {
          iAssumePostCaptureView = EFalse;
          }
      }
  // -----------------------------------------------------

  if ( !iStandbyModeActive )
    {
    // Inform the container of foreground state change
    PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: inform container.." ) );        
    iContainer->HandleForegroundEventL( aForeground );
    }
  else
    {
    // if in videocall, don't exit standby	
    if ( iController.InVideocallOrRinging() )
        {
        iActivateToStandby = EFalse;
        }
    else    		
        {   	
        // If the view has been set to standby at activation then
        // the first foreground event should not be used to exit standby
        if ( !iActivateToStandby )
           {
           // inform standby container
           PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: inform standby container.." ) );        
           iStandbyContainer->HandleForegroundEventL( aForeground );
           }  
        else
           {
           iActivateToStandby = EFalse;
           }
        }
    }
         CCamCaptureSetupViewBase::HandleForegroundEventL( aForeground );
  PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL" ) );        
  }

// -----------------------------------------------------------------------------
// CCamPreCaptureViewBase::SetLocationTrailConnecting
// Set iLocationTrailConnecting flag.
// -----------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SetLocationTrailConnecting()
    {
    iLocationTrailConnecting = ETrue;
    }

// -----------------------------------------------------------------------------
// CCamPreCaptureViewBase::SetPostCaptureViewAsumption
// Set iAssumePostCaptureView flag.
// -----------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SetPostCaptureViewAsumption( TBool aAssumePostCaptureView )
    {
    iAssumePostCaptureView = aAssumePostCaptureView;
    }


// -----------------------------------------------------------------------------
// CCamPreCaptureViewBase::HandleControllerEventL
// Handle controller events
// -----------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::HandleControllerEventL( TCamControllerEvent aEvent, 
                                                     TInt /*aError*/ )
  {
  PRINT( _L( "Camera => CCamPreCaptureViewBase::HandleControllerEventL" ) );        
  CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

  switch( aEvent )
    { 
    // ---------------------------------------------------
    case ECamEventEngineStateChanged:
      {
      // Do not do softkey update if we are already exiting
      // (AppUi is not available)
      if( iController.IsAppUiAvailable() )
      {          
      PRINT( _L( "Camera <> case ECamEventEngineStateChanged" ) );        
      if ( ECamCameraPreparedVideo == iController.CameraState() || 
           ECamCameraPreparedImage == iController.CameraState() )
        {
        // Now that the view is initialised, we may need to put up the
        // mmc removal note. Perform this is required.
        PRINT( _L( "Camera <> show mmc note if needed" ) );        
        appUi->ShowMMCRemovalNoteIfRequiredL();

        // Do not update (show) precapture view toolbar if capturing is almost
        // finished, otherwise there is flickering and finally inactive toolbar 
        // when returning to prepactureview after image deletion. 
        // This will happen only if camera is started directly to portrait 
        // secondary camera i.e. Lens cover feature is supported
        TBool noToolbar = ( ECamCompleting == iController.CurrentOperation() ) && appUi->IsSecondCameraEnabled();

        TBool showVideoModeToolbar = ( ECamCameraPreparedVideo == iController.CameraState() && 
                ( iController.CurrentOperation() != ECamCapturing && iController.CurrentOperation() != ECamPaused ) );

        TBool precaptureToolbarState = !appUi->IsBurstEnabled()
                && !iStandbyModeActive && !appUi->IsInPretendExit();
        
        if ( ( ECamCameraPreparedImage == iController.CameraState() || 
                showVideoModeToolbar ) &&     
               !noToolbar && precaptureToolbarState )
            {
            // Also fixed toolbar might need to be enabled.
            appUi->SetToolbarVisibility();
            }
        }
      //Do not update CBA if we are capturing or paused to prevent blinking
	  //during video capture saving and completing
      if ( iController.CurrentVideoOperation() != ECamCapturing
             && iController.CurrentVideoOperation() != ECamPaused )
          {
          PRINT( _L( "Camera <> Update CBA" ) );        
          UpdateCbaL();
          }
      }
      break;
      }

    case ECamEventSliderClosed:
      {
      // if embedded and the slider is closed, 
      // the menu items may change, close the menu   
      if( iEmbedded )
        {
        PRINT( _L("Camera <> CCamPreCaptureViewBase: calling StopDisplayingMenuBar") );
        StopDisplayingMenuBar();
        }
      break;
      }
    default:
      {
      // Other events => no action.
      break;
      }
    } // switch
  PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleControllerEventL" ) );        
  }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::DoActivateL
// Activate this view
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::DoActivateL( const TVwsViewId& aPrevViewId, 
                                          TUid aCustomMessageId,
                                          const TDesC8& aCustomMessage )                                                                                    
    {
    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMPRECAPTUREVIEWBASE_DOACTIVATEL, "e_CCamPreCaptureViewBase_DoActivateL 1" );
    PRINT( _L( "Camera => CCamPreCaptureViewBase::DoActivateL" ) );
    iAssumePostCaptureView = EFalse;
    iLastMovement = 0;

    ShowToolbarOnViewActivation( EFalse );
    /*if ( iController.UiConfigManagerPtr() && 
         iController.UiConfigManagerPtr()->IsLocationSupported() )
        {
        if( ECamLocationOn == iController.IntegerSettingValue( ECamSettingItemRecLocation ) )
            {
            if( ECamActiveCameraPrimary == iController.ActiveCamera() && ECamStandby != iController.CurrentOperation() )
                {
                PRINT( _L("Camera: CCamPreCaptureViewBase::DoActivateL - primary camera, start location/gps") )
                iController.StartLocationTrailL();
                }
            else // Secondary camera 
                {
                PRINT( _L("Camera: CCamPreCaptureViewBase::DoActivateL - secondary camera, stop location trail") )
                iController.StopLocationTrail();
                }
            }
        }*/
 
    CCamAppUi* appUi =  static_cast<CCamAppUi*>( AppUi() );
	__ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));
    if(!appUi->DrawPreCaptureCourtesyUI() && !iController.IsTouchScreenSupported())
        {
        if ( !appUi->IsSecondCameraEnabled() )
            {	
            SetCourtesySoftKeysL();
            }
        appUi->SetActivePaletteVisibility( EFalse );
        }
    else if (appUi->DrawPreCaptureCourtesyUI())
        {
         Cba()->MakeVisible( ETrue );
        }

    if ( appUi->SettingsLaunchedFromCamera() )
    	{
    	if ( TUid::Uid( ECamCmdInternalExit ) == aCustomMessageId )
    	    {
            appUi->SettingsPluginExitedL( ECameraInternalExit );
    	    }
    	else if ( TUid::Uid ( EAknSoftkeyBack ) == aCustomMessageId )
    	    {
    	    appUi->SettingsPluginExitedL( ECameraPluginExit );
    	    }
    	else
    	    {
    	    // do nothing
    	    }
    	}

    CCamCaptureSetupViewBase::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage );

    if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() )  
        {
        StatusPane()->MakeVisible( ETrue );
        }
    else
        {
        StatusPane()->MakeVisible( EFalse );
        }
    
    if ( iController.IsTouchScreenSupported() )
        {
        // Make sure that icons are upto date
        UpdateToolbarIconsL();
    
        CAknToolbar* fixedToolbar = Toolbar();
        if ( fixedToolbar )
            {
            // If video call is active, toolbar is set to dimmed, that user cannot use it
            TInt callType( EPSCTsyCallTypeUninitialized );
            RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType, callType );
            if ( callType == EPSCTsyCallTypeH324Multimedia)
                {
                fixedToolbar->SetDimmed( ETrue ); 
                }
            else
                {
                fixedToolbar->SetDimmed( EFalse ); 
                }
            fixedToolbar->SetToolbarObserver( this );
            // avoid toolbar flicker when returning from user scene setup 
            // after adjusting a setting
            if ( !iSceneSettingModeActive )
                {
                appUi->SetToolbarVisibility( );
                }
   
            // Make sure toolbar extension button has no background
            CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension();
            if ( extension )
                {
                extension->SetButtonFlags(
                    extension->ButtonFlags() | KAknButtonNoFrame );
                extension->DrawDeferred();
                }
            }
        }

    appUi->PushNaviPaneCounterL();

    // Pass on the ID of the previous view to the container    
    TCamAppViewIds viewId = static_cast<TCamAppViewIds>( aPrevViewId.iViewUid.iUid );
    iContainer->SetPreviousViewId( viewId );

    iController.AddControllerObserverL( this );    

    TBool transparentCba = EFalse;

    UpdateCbaL();
    
    switch( aCustomMessageId.iUid )
      {
      // -------------------------------
      // Standby with or without error
      case ECamViewMessageStandby:
        PRINT( _L( "Camera <> CCamPreCaptureViewBase::DoActivateL: custom message ECamViewMessageStandby" ) );
        //iStandbyError = KErrNone;
        //appUi->SetStandbyStatus( KErrNone );
        SetSceneSettingMode( EFalse );
        iActivateToStandby = ETrue;
        HandleCommandL( ECamCmdGoToStandby );
        return;
//        break;
      // -------------------------------
      // Scene setting mode
      case ECamViewMessageSceneSettingList:
        PRINT( _L( "Camera <> CCamPreCaptureViewBase::DoActivateL: custom message ECamViewMessageSceneSettingList" ) );
        SwitchToSceneSettingModeL();
        break;
      // -------------------------------
      default:
        // Other precapture modes have transparent CBA buttons
        // except secondary camera
        if ( !appUi->IsSecondCameraEnabled() || appUi->IsQwerty2ndCamera() )  
            {
            transparentCba = ETrue;
            }
        // don't start VF if faster startup is used when cameraswitch is queued,
        // need to switch to maincamera first
        if ( !( iController.UiConfigManagerPtr() && 
                iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() &&
                iController.CameraSwitchQueued() ) )
            {
            StartViewFinder();
            }
        
        break;
      // -------------------------------
      }
    
    // Here we check if the previous view is ViaPlayer play mode
    if ( !iSceneSettingModeActive  && 
         ( aPrevViewId.iViewUid.iUid != ECamViewIdViaPlayerPlayBack ) && 
         !( iController.UiConfigManagerPtr() && 
         iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )
        {
        appUi->RaisePreCaptureCourtesyUI(ETrue);
        }
    
    // Reset iContinueInBackground flag, which is set when app temporarily
    // goes behind a system window and there's no need to free resources.
    // Resetting this flag only in ReleaseResources causes problems (at least)
    // if power key is pressed during burst capture.
    iContinueInBackground = EFalse;
    
    // Reset iDeactivateToStandby flag, which is used when the PreCapture view
    // goes to the Standby mode, at which point the UI should not reactivate the
    // viewfinder.
    iDeactivateToStandby = EFalse;


    EikSoftkeyPostingTransparency::MakeTransparent(
        *Cba(), transparentCba );
    // Make sure appuis CBA is not visible
    CEikButtonGroupContainer* cba = AppUi()->Cba();
    if( cba )
        {
        cba->MakeVisible( EFalse );
        }

    PRINT( _L( "Camera <= CCamPreCaptureViewBase::DoActivateL" ) );
    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMPRECAPTUREVIEWBASE_DOACTIVATEL, "e_CCamPreCaptureViewBase_DoActivateL 0" );
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::DoDeactivate
// Deactivate this view
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::DoDeactivate()
    {                              
    PRINT( _L( "Camera => CCamPreCaptureViewBase::DoDeactivate" ) );
    
    delete iGestureFw;
    iGestureFw = NULL;

    CCamCaptureSetupViewBase::DoDeactivate();
                               
    iController.RemoveControllerObserver( this );
    
    if ( iController.IsTouchScreenSupported() )
        {
        CAknToolbar* fixedToolbar = Toolbar();
        if ( fixedToolbar )
            {
            CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension();
            if ( extension )
                {
                // Reset toolbar extension button and view to closed state
                extension->SetShown( EFalse );
                extension->SetCurrentState( 0, EFalse );
                }
            }
        }
    ReleaseResources();

    if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() &&
         iController.ActiveCamera() == ECamActiveCameraSecondary ) 
        {
        if ( iController.CameraSwitchQueued() )
            {
            CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
            // If camera switch fails, main camera is used instead
            TRAP_IGNORE( appUi->HandleCommandL( ECamCmdSwitchCamera ) );
            }
        }

    PRINT( _L( "Camera <= CCamPreCaptureViewBase::DoDeactivate" ) );
    }

// -----------------------------------------------------------------------------
// CCamPreCaptureViewBase::HandleFocusLossL
// Handle change of focus
// -----------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::HandleFocusLossL()
    {
    PRINT( _L( "Camera => CCamPreCaptureViewBase::HandleFocusLossL" ) );    
    // if the application was already in the background, but behind an
    // eikon server window, then handle backgrounding properly now.
    // Otherwise the backgrounding will be handled in the normal
    // HandleForeground() method.
    if ( iContinueInBackground )
        {
        ReleaseResources();
        // Inform the container of foreground state change
        iContainer->HandleForegroundEventL( EFalse );
        }
    CCamCaptureSetupViewBase::HandleFocusLossL();

    // dismiss menu bar if open
    StopDisplayingMenuBar();
    PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleFocusLossL" ) );
    }
                          
// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::SwitchToCaptureSetupModeL
// Switches the current mode to capture setup and activates a 
// specific control..
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SwitchToCaptureSetupModeL( TInt aSetupCommand )
    {
    
    PRINT( _L("Camera => CCamPreCaptureViewBase::SwitchToCaptureSetupModeL") );
    
    // Remove the view's main container, and add the capture setup 
    // control associated with the input command to the container stack.
    CCamCaptureSetupViewBase::SwitchToCaptureSetupModeL( aSetupCommand );

    // only remove the capture setup menu container after 
    // the switch completes successfully
    RemoveCaptureSetupMenuContainers();

    SetCaptureSetupModeActive(ETrue);
    
    PRINT( _L("Camera <= CCamPreCaptureViewBase::SwitchToCaptureSetupModeL") );
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::SwitchToSceneSettingModeL
// Switches the current mode to scene setting and activates a 
// specific control.
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SwitchToSceneSettingModeL()
    {
    // Remove the view's main container, and add the capture setup 
    // control associated with the input command to the container stack.
    CCamCaptureSetupViewBase::SwitchToSceneSettingModeL();
 
    // only remove the capture setup menu container after 
    // the switch completes successfully
    RemoveCaptureSetupMenuContainers();
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ExitCaptureSetupModeL
// Exits capture setup mode and activates the capture setup menu control.
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::ExitCaptureSetupModeL()
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL") )
     
    CCamCaptureSetupViewBase::ExitCaptureSetupModeL();    
    iController.SetViewfinderWindowHandle( &iContainer->Window() );

    
    if( !iController.IsViewFinding() && !iController.InVideocallOrRinging() )
      {
      TCamCameraMode mode = iController.CurrentMode();    
	  PRINT1( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL - CurrentMode %d"), mode );        
      if (mode == ECamControllerVideo )
    	{
   	    PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL - ECamControllerVideo") );        
    	iController.EnterViewfinderMode( ECamControllerVideo );
    	}    	
      else
    	{
   	    PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL - ECamControllerImage") );        
      iController.EnterViewfinderMode( ECamControllerImage );
    	}    	               
      }
    
    // make sure app is not left in an invalid state if a leave
    // occurs after exiting the capture setup
    iCaptureSetupMenuModeActive = EFalse;
    static_cast<CCamAppUiBase*>( AppUi() )->PushNaviPaneCounterL();
	CCamAppUiBase* appUi =  static_cast<CCamAppUiBase*>( AppUi() );
	if( appUi->ActiveCamera() == ECamActiveCameraSecondary )
		{
		PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL ###") )
    	SwitchToCaptureSetupMenuModeL();
		}
	
	UpdateCbaL();
    PRINT( _L("Camera <= CCamPreCaptureViewBase::ExitCaptureSetupModeL") )
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ExitSceneSettingModeL
// Exits scene setting mode and activates the capture setup menu control.
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::ExitSceneSettingModeL()
    {
    CCamCaptureSetupViewBase::ExitSceneSettingModeL();
    // make sure app is not left in an invalid state if a leave
    // occurs after exiting the scene setting mode
    iCaptureSetupMenuModeActive = EFalse;
    static_cast<CCamAppUiBase*>( AppUi() )->PushNaviPaneCounterL();

	CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );
    if ( appUi->ActiveCamera() == ECamActiveCameraPrimary )
        {
        if ( iDeactivateToStandby || iController.InVideocallOrRinging() )
            {
            // don't restart VF if we are going to standby mode
            }
        else
            {
            StartViewFinder();
            }
        }
    else
		{
		SwitchToCaptureSetupMenuModeL();
		}
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ExitInfoListBoxL
// Exits InfoListBox
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::ExitInfoListBoxL()
    {
    CCamCaptureSetupViewBase::ExitInfoListBoxL();
    // make sure app is not left in an invalid state if a leave
    // occurs after exiting the scene setting mode
    iCaptureSetupMenuModeActive = EFalse;
    static_cast<CCamAppUiBase*>( AppUi() )->PushNaviPaneCounterL();

	CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );
    if ( appUi->ActiveCamera() == ECamActiveCameraPrimary )
        {
        StartViewFinder();
        }
    else
		{
		SwitchToCaptureSetupMenuModeL();
		}
    }


// -----------------------------------------------------------------------------
// CCamPreCaptureViewBase::ExitAllModesL
// Revert to normal mode
// -----------------------------------------------------------------------------
//
void 
CCamPreCaptureViewBase::ExitAllModesL()
  {
  PRINT( _L("Camera => CCamPreCaptureViewBase::ExitAllModesL" ) );
  iController.DeepSleepTimerCancel();
  TCamSettingMode currentMode = ActiveSettingMode();
  
  CCamAppUi* appUi =  static_cast<CCamAppUi*>( AppUi() );
  
  switch ( currentMode )
    {
    case ECamSettingModeCaptureMenu:
      {
      PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL cap setup menu" ))
      ExitCaptureSetupMenuModeL();
      break;
      }
    case ECamSettingModeCapture:
      {
      PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL capture" ))
      
      ExitCaptureSetupModeL();
      if( appUi->ActiveCamera() == ECamActiveCameraSecondary  )
        {
        PRINT( _L("Camera <> CamPreCaptureViewBase::ExitAllModesL ##" )) 
        ExitCaptureSetupMenuModeL();
        }
      break;
      }
    case ECamSettingModeScene:
      {
      PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL scene" ))
	  ExitSceneSettingModeL();
      if( appUi->ActiveCamera() == ECamActiveCameraSecondary  )
        {
        PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL ##" )) 
        ExitCaptureSetupMenuModeL();
        }
	  if( Id() == TUid::Uid( ECamViewIdVideoPreCapture ) &&
          iController.UiConfigManagerPtr() &&
          iController.UiConfigManagerPtr()->IsXenonFlashSupported() )
		{
		iToolbarExtensionInvisible = ETrue;
		}
      break;
      }
    case ECamSettingModeInfoListBox:
      {
      PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL generic" ))
      ExitInfoListBoxL();
      if( appUi->ActiveCamera() == ECamActiveCameraSecondary  )
        {
        PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL ##" )) 
        ExitCaptureSetupMenuModeL();
        }            
      break;
      }            
    default:
      {
      iToolbarExtensionInvisible = ETrue;    	
      }
      break;
    }

  if ( iController.InVideocallOrRinging() || !iController.IssueModeChangeSequenceSucceeded() )
      {
      return;
      }	
  
  appUi->HandleCommandL(ECamCmdSwitchToPrecapture);
  

  if ( !( iController.UiConfigManagerPtr() && 
            iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )
    {
    TCamOrientation orientation = appUi->CamOrientation();
    if ( orientation == ECamOrientationCamcorder || orientation == ECamOrientationCamcorderLeft )
      {
      // force update of active palette
      appUi->APHandler()->UpdateActivePaletteL();                    
      }

    if ( appUi && !iSceneSettingModeActive )
      {
      appUi->RaisePreCaptureCourtesyUI(ETrue);
      }
    }
    
  if ( iController.IsTouchScreenSupported() )
      {
      CAknToolbar* fixedToolbar = Toolbar();
      CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension();
      
      // Only active view will set toolbar extension visibility.
      if( this->IsForeground() )
          {
          if ( extension && iToolbarExtensionInvisible == EFalse )
              {
              extension->SetShown( ETrue );
              }
          else if( extension )
              {
              extension->SetShown( EFalse );
              }
          }

      iToolbarExtensionInvisible = EFalse;
      }
    
  PRINT( _L("Camera <= CCamPreCaptureViewBase::ExitAllModesL" ) );
  }


// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ActiveSettingMode
// Returns the active setting mode
// ---------------------------------------------------------------------------
//
CCamPreCaptureViewBase::TCamSettingMode 
CCamPreCaptureViewBase::ActiveSettingMode()
    {
    if ( iCaptureSetupModeActive )
        {
        return ECamSettingModeCapture;
        }
    else if ( iSceneSettingModeActive )
        {
        return ECamSettingModeScene;
        }
    else if ( iCaptureSetupMenuModeActive )
        {
        return ECamSettingModeCaptureMenu;
        }
    else if ( iInfoListBoxActive )
      {
      return ECamSettingModeInfoListBox;
        }
    else
        {
        return ECamSettingModeNone;
        }
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::CCamPreCaptureViewBase
// C++ constructor
// ---------------------------------------------------------------------------
//
CCamPreCaptureViewBase::CCamPreCaptureViewBase( CCamAppController& aController )
    : CCamCaptureSetupViewBase( aController )   
    {
    iCaptureSetupMenuModeActive = EFalse;
    iAssumePostCaptureView = EFalse;
    }                          

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ConstructL
// Symbian OS 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::ConstructL()
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::ConstructL") )    
    /* Use AppUi to get this info.
    // Get the id of Eikon Server window group
    iEikonServerWindowGroupId =
        iCoeEnv->WsSession().FindWindowGroupIdentifier( 0, KEikonServer );

    iBTServerWindowGroupId =  
    		static_cast<CCamAppUi*>( iEikonEnv->AppUi() )->BTServerId();
    */
    UpdateToolbarIconsL();
    PRINT( _L("Camera <= CCamPreCaptureViewBase::ConstructL") )    
    }
                          
// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::CleanupCaptureSetupMenu
// Cleanup the capture menu control if a leave occurs
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::CleanupCaptureSetupMenu( TAny* aAny )
    {
    CCamPreCaptureViewBase* view = static_cast<CCamPreCaptureViewBase*>( aAny );
    if ( view->iCaptureSetupMenuContainer )
        {
        view->AppUi()->RemoveFromStack( view->iCaptureSetupMenuContainer );
        delete view->iCaptureSetupMenuContainer;
        view->iCaptureSetupMenuContainer = NULL;
        }
    // reset the active mode
    view->iCaptureSetupMenuModeActive = EFalse;
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::SwitchToCaptureSetupMenuModeL
// Switches the current mode to capture setup menu and activates 
// the capture setup menu control
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SwitchToCaptureSetupMenuModeL()
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::SwitchToCaptureSetupMenuModeL"))
    __ASSERT_DEBUG( !iCaptureSetupMenuContainer, CamPanic( ECamPanicResourceLeak ) );

    // Create the relevant capture setup menu, e.g. video or photo...
    CreateCaptureSetupMenuL();

    // Cleanup the view correctly if a leave occurs
    CleanupStack::PushL( TCleanupItem( CleanupCaptureSetupMenu, this ) );
    
    PRINT( _L("Camera => CCamPreCaptureViewBase::SwitchToCaptureSetupMenuModeL start vf"))
    StartViewFinder();
    iCaptureSetupMenuContainer->SetMopParent( this );   
    // Activate the menu control and mode.
    AppUi()->AddToStackL( *this, iCaptureSetupMenuContainer );
    iCaptureSetupMenuContainer->ActivateL();
    // UpdateCbaL need this boolean to be set in
    // order for the correct CBA to be returned
    iCaptureSetupMenuModeActive = ETrue;
    UpdateCbaL();
    CleanupStack::Pop(); // CleanupCaptureSetupMenu

    // Fade the container that is behind.
    iCaptureSetupMenuContainer->FadeBehind( ETrue );
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ExitCaptureSetupMenuModeL
// Exits capture setup menu mode and activates the original precapture
// view container that was active before entering this mode.
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::ExitCaptureSetupMenuModeL()
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupMenuModeL() ") );
    
    if ( !iCaptureSetupMenuModeActive )
        {
        return;
        }
    iCaptureSetupMenuModeActive = EFalse;
    iContainer->MakeVisible( ETrue );  

    iCaptureSetupMenuContainer->FadeBehind( EFalse );
    AppUi()->RemoveFromStack( iCaptureSetupMenuContainer );
    delete iCaptureSetupMenuContainer;
    iCaptureSetupMenuContainer = NULL;
    UpdateCbaL();
    SetTitlePaneTextL();
    
    PRINT( _L("Camera <= CCamPreCaptureViewBase::ExitCaptureSetupMenuModeL() ") );
    }                         

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::SwitchToStandbyModeL
// Exits pre capture mode and activates the standby container
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SwitchToStandbyModeL( TCamAppViewIds aViewId, TInt aError )
    {
    iAssumePostCaptureView = EFalse;
    iDeactivateToStandby = ETrue; // avoid viewfinder startup
    iContinueInBackground = EFalse; 
    
    switch ( ActiveSettingMode() )
        {
        case ECamSettingModeCaptureMenu:   
            {
            ExitCaptureSetupMenuModeL();            
            }
            break;
        case ECamSettingModeScene:
            {
            ExitSceneSettingModeL();
            ExitCaptureSetupMenuModeL();
            }
            break;
        case ECamSettingModeCapture:
            {
            ExitCaptureSetupModeL();
            ExitCaptureSetupMenuModeL();
            }
            break;
			case ECamSettingModeInfoListBox:
            {
            ExitInfoListBoxL();
            ExitCaptureSetupMenuModeL();
            }				            
            break;
        default:  
            break;
        }    


    // Hide the active palette
    static_cast<CCamAppUi*>( iEikonEnv->AppUi() )
        ->SetActivePaletteVisibility( EFalse );
    
    // Hide the toolbar in standby mode
    if ( iController.IsTouchScreenSupported() )
        {
        CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
        CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();
        if ( fixedToolbar )
            {
            fixedToolbar->SetToolbarVisibility( EFalse );
            }
        }

    // Hide the startup logo in standby mode. 
    // Camera application will enter standby mode if it detect camera hardware is in use
    // by another application (such as video call) when camera application is starting up. 
    // If this, we need hiding startup logo in standby mode.
    CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() ); 
    if ( appUi->StartupLogoController() )
      {
      appUi->StartupLogoController()->HideLogo();
      }
      
    // stop viewfinding
    StopViewFinder();

    CCamViewBase::SwitchToStandbyModeL( aViewId, aError );
    
    iDeactivateToStandby = EFalse;
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ExitStandbyModeL
// Exits standby mode and activates the previous pre-capture container
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::ExitStandbyModeL()
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::ExitStandbyModeL" ) )
    // start view finding
    iAssumePostCaptureView = EFalse;
    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
    if( appUi->AppInBackground(ETrue ))
        {
        PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitStandbyModeL: global note in foreground." ) )
        return;
        }
    if( iController.UiConfigManagerPtr() && 
        iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() &&
        iController.CurrentMode() != ECamControllerIdle )
        {
        PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitStandbyModeL: not in standby, returning without exit" ) )    
        return;    
        } 
    
    if( !appUi->DrawPreCaptureCourtesyUI() && 
        !iController.IsTouchScreenSupported() &&
        !appUi->IsSecondCameraEnabled() )
        {
        SetCourtesySoftKeysL();
        }
    
    // In case coming back after dismissing videocall, need
    // to register as using engine    
    if( !appUi->IsInPretendExit() )
        {
        IncrementCameraUsers();
        }
        
    PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitStandbyModeL: start vf" ) )
    StartViewFinder();

    //static_cast<CCamAppUi*>( iEikonEnv->AppUi() )
    //    ->APHandler()->UpdateActivePaletteL();
    TBool uiOverride = iController.UiConfigManagerPtr() && iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported();
    if ( !uiOverride )
        {
        SetupActivePaletteL();
        }

    // Dimming is set if video call is active, remove dimming if video call is not active any more
    TInt callType( EPSCTsyCallTypeUninitialized );
    RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType, callType );
    if ( callType != EPSCTsyCallTypeH324Multimedia
         && iController.IsTouchScreenSupported() )
        {
        CAknToolbar* toolbar = Toolbar();
        if (toolbar)
            {
            toolbar->SetDimmed( EFalse );
            }
        }    
    CCamViewBase::ExitStandbyModeL();
    
    // Need to update appui viewstate
    PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitStandbyModeL: emit ECamCmdSwitchToPrecapture" ) )
    appUi->HandleCommandL( ECamCmdSwitchToPrecapture );
    // Check if currently selected storagemedia has available memory for next capturing
    appUi->CheckMemoryAvailableForCapturing();      
        
    if ( uiOverride )
        {
        appUi->SetActivePaletteVisibility( EFalse );    
        }
    else
        {    
        appUi->RaisePreCaptureCourtesyUI(ETrue);
        }
    PRINT( _L("Camera <= CCamPreCaptureViewBase::ExitStandbyModeL" ) )
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::IsOkOptionsMenuAllowed
// Checks whether or not the ok aoptions menu should be displayed
// ---------------------------------------------------------------------------
//
#if 0
TBool CCamPreCaptureViewBase::IsOkOptionsMenuAllowed()
    {
    CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );
    // Check if we are in selftimer mode, scene setting mode,
    // capture setup menu mode or if a capture mode preparation is
    // taking place.  If so, do NOT show the menu
    if ( ( appUi && !appUi->SelfTimerEnabled() ) &&
        !iController.CaptureModeTransitionInProgress() &&
            ActiveSettingMode() == ECamSettingModeNone && !appUi->IsEmbedded() )
        {
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }
#endif // 0

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::RemoveCaptureSetupMenuContainers
// Removes the capture setup menu and original container from
// the container stack
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::RemoveCaptureSetupMenuContainers()
    {
    // Store the current item index value for the menu, so that it can
    // be reused when the CSM container is reactivated from leaving
    // a capture setup control.
    if ( iCaptureSetupMenuContainer )
        {
        iCaptureSetupMenuLastItemIndex = 
            iCaptureSetupMenuContainer->CurrentItemIndex();
        iCaptureSetupMenuContainer->FadeBehind( EFalse );
        
        // Remove the Capture Setup Menu from the container stack.
        AppUi()->RemoveFromStack( iCaptureSetupMenuContainer );
        }
    delete iCaptureSetupMenuContainer;
    iCaptureSetupMenuContainer = NULL;
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::DynInitSwitchCameraMenuItemL
// Set up the text for switch camera in the options menu
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::DynInitSwitchCameraMenuItemL( CEikMenuPane* aMenuPane )
    {
    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
    // Check if only 1 camera available
    if ( !iController.UiConfigManagerPtr()->IsSecondaryCameraSupported() )
        {
        aMenuPane->SetItemDimmed( ECamCmdSwitchCamera, ETrue );
        }
    else 
        {
        // if secondary camera is enabled
        if ( appUi->IsSecondCameraEnabled() )
            {
            if( iController.UiConfigManagerPtr()->IsLensCoverSupported() )
                {
                TInt slideState = iController.CameraSlideState();
                if ( slideState == CameraPlatPSKeys::EClosed )
                    {
                    aMenuPane->SetItemDimmed( ECamCmdSwitchCamera, ETrue );
                    }
                else
                    {                               
                    aMenuPane->SetItemTextL( ECamCmdSwitchCamera, 
                            R_CAM_PRE_CAPTURE_MENU_PRIMARY_CAMERA );
                    }   
                }
            else
                {
                aMenuPane->SetItemTextL( ECamCmdSwitchCamera, 
                        R_CAM_PRE_CAPTURE_MENU_PRIMARY_CAMERA );
                }
            }
        }
    }


// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ReleaseResources
// Stop the viewfinder and inform the controller that this view has finished
// with the engine
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::ReleaseResources()
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::ReleaseResources") );
    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
    if( iStandbyModeActive && !appUi->IsRecoverableStatus() )
        {
        PRINT( _L("Camera <= CCamPreCaptureViewBase::ReleaseResources Standbymode") );
        return;
        }
    iContinueInBackground = EFalse;
    StopViewFinder();
  
    // Make sure that video recording is stopped (if ongoing).
    iController.StopVideoRecording();
    
    // if the application is not closing then self-timer mode must be disabled.
    // otherwise it will be deleted as part of the application shut down process
    if ( !iController.IsInShutdownMode() )
        {
        // Do not do softkey update if we are already exiting
        // (AppUi is not available)
        if( iController.IsAppUiAvailable() )
            {
            // Ensure AppUi has had self-timer mode disabled
            if ( appUi )
                {
                TRAP_IGNORE( appUi->SelfTimerEnableL( ECamSelfTimerDisabled ) );
                }
            }
        }
    // Register that we no longer need the engine
    // Checks if we incremented the count.
    DecrementCameraUsers();
    PRINT( _L("Camera <= CCamPreCaptureViewBase::ReleaseResources") );
    }
  
// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::IsPreCapture
// Returns whether the view is a precapture view
// ---------------------------------------------------------------------------
//
TBool CCamPreCaptureViewBase::IsPreCapture()
    {
    return ETrue;
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::OfferToolbarEventL
// Handle fixed toolbar and toolbar extension events
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::OfferToolbarEventL( TInt aCommand )
    {
    iController.StartIdleTimer();
    HandleCommandAoL( aCommand );
    
    if ( aCommand == ECamCmdSceneSettingList ||
         aCommand == ECamCmdCaptureSetupFlashStill ||
         aCommand == ECamCmdCaptureSetupSelfTimer ||
         aCommand == ECamCmdCaptureSetupSceneStill ||
         aCommand == ECamCmdCaptureSetupSceneVideo ||
         aCommand == ECamCmdCaptureSetupColourFilterStill ||
         aCommand == ECamCmdCaptureSetupColourFilterVideo ||
         aCommand == ECamCmdCaptureSetupWhiteBalanceStill ||
         aCommand == ECamCmdCaptureSetupWhiteBalanceVideo ||
         aCommand == ECamCmdCaptureSetupExposureStill ||
         aCommand == ECamCmdCaptureSetupLightSensitivityStill ||
         aCommand == ECamCmdCaptureSetupContrastStill ||
         aCommand == ECamCmdCaptureSetupImageSharpnessStill )
        {
        // These commands imply a container switch.
        // iItemAccessedViaAP must be set so that softkeys work correctly.
        CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );
        appUi->APHandler()->iItemAccessedViaAP = ETrue;
        iController.DeepSleepTimerStart();
        }
    }


// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::SetIconL
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SetIconL(
        CAknButton* aButton,
        const TDesC& aIconFilename,
        TInt aIconId,
        TInt aMaskId,
        MAknsSkinInstance* aSkinInstance, 
        const TAknsItemID& aSkinItemId )
    {
    CGulIcon* icon = AknsUtils::CreateGulIconL(
        aSkinInstance,
        aSkinItemId,
        aIconFilename,
        aIconId,
        aMaskId );
    icon->SetBitmapsOwnedExternally( EFalse ); // CGulIcon owns bitmaps
    CAknButtonState* state = aButton->State( 0 );
    if ( state )
        {
        state->SetIcon( icon );
        icon = NULL;
        }
    else
        {
        delete icon;
        icon = NULL;
        }
	
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::HandleAppEvent <<virtual>>
//
// ---------------------------------------------------------------------------
//
void 
CCamPreCaptureViewBase::HandleAppEvent( const TCamAppEvent& aEvent )
    {
    PRINT1( _L("Camera => CCamPreCaptureViewBase::HandleAppEvent, event:%d"), aEvent );
    // Reset last pinch movement direction
    iLastMovement = 0;
    CCamViewBase::HandleAppEvent( aEvent );

    if ( aEvent == ECamAppEventFocusGained && iController.InVideocallOrRinging() )
        {
        TRAP_IGNORE( BlankSoftkeysL() );
        if ( iController.IsTouchScreenSupported() )
            {
            CAknToolbar* toolbar = Toolbar();
            if ( toolbar )
                {
                toolbar->SetToolbarVisibility( EFalse );
                }
            }
        }
    
    if ( aEvent == ECamAppEventFocusGained )
        {
        if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() && 
             iController.CameraSwitchQueued() ) // fake exit done
            {
            iController.CheckSlideStatus(); // Do we still need to change cam?
            CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
            // How about portrait/landscape 2nd camera? 
            if ( !iController.CameraSwitchQueued() && 
                 appUi->IsSecondCameraEnabled() ) 
                {
                TBool landscape2ndCam = appUi->IsQwerty2ndCamera( ETrue );
                if( appUi->CamOrientation() != ECamOrientationPortrait )
                    {
                    if ( !landscape2ndCam )
                        {
                        PRINT( _L("Camera => CCamPreCaptureViewBase::HandleAppEvent, change to portrait 2nd cam."));
                        iController.SetCameraSwitchRequired( 
                                                 ESwitchSecondaryOrientation );  
                        }
                    }
                else
                    {
                    if ( landscape2ndCam )
                        {
                        PRINT( _L("Camera => CCamPreCaptureViewBase::HandleAppEvent, change to landscape 2nd cam."));
                        iController.SetCameraSwitchRequired( 
                                                 ESwitchSecondaryOrientation );
                        }
                    }
                }
            }
        if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() && 
             iController.ActiveCamera() == ECamActiveCameraPrimary )
            {
            if ( iController.CameraSwitchQueued() )
                {
                CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
                // If camera switch fails, main camera is used instead
                TRAP_IGNORE( appUi->HandleCommandL( ECamCmdSwitchCamera ) );
                }
            }
        }
     
    PRINT( _L("Camera <= CCamPreCaptureViewBase::HandleAppEvent") );
    }

// ---------------------------------------------------------------------------
// SetupActivePaletteL
// 
// Helper method to set up the Active Palette.
// If needed, a new instance of AP is created.
// Otherwise the existing AP items are cleared.
// New AP items are setup with resource from GetAPResourceId.
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::SetupActivePaletteL()
    {
    if( iContainer && !iController.IsTouchScreenSupported() )
        {
        CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );
        TCamOrientation orientation = appUi->CamOrientation();

        if( ECamOrientationCamcorder == orientation
                || ECamOrientationCamcorderLeft == orientation 
                || ECamOrientationPortrait == orientation )
            {
            // Creates Active Palette, sets items and sets view.
            // Only AP2 supported.
            static_cast<CCamPreCaptureContainerBase*>( iContainer )
            ->SetupActivePaletteL( this );
            }
        else
            {
            // No AP  
            }
        }
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::ToolbarButtonById
//
// ---------------------------------------------------------------------------
//
 CAknButton* CCamPreCaptureViewBase::ToolbarButtonById(const TCamCmd aCommandId) const
     {
     CAknButton* button = NULL;
     if(iController.IsTouchScreenSupported())
         {
         CAknToolbar* toolbar = Toolbar();
         if(toolbar)
             {
             button = static_cast<CAknButton*>
                         (toolbar->ControlOrNull(aCommandId));
			 if(NULL == button)
                 {
                 CAknToolbarExtension* extension = toolbar->ToolbarExtension();
                 if(extension)
                     {
                     button = static_cast<CAknButton*>
                                 (extension->ControlOrNull(aCommandId));
					 }
                 }
             }
         }
     return button;
     }
     
// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::HideButton
//
// ---------------------------------------------------------------------------
//
 void CCamPreCaptureViewBase::HideButton(const TCamCmd aCommandId)
     {
     if(iController.IsTouchScreenSupported())
          {
          CAknToolbar* toolbar = Toolbar();
          if(toolbar)
              {
              if(toolbar->ControlOrNull(aCommandId))            
                  {
                  toolbar->HideItem(aCommandId,ETrue,ETrue);
                  }
              else if( toolbar->ToolbarExtension() && 
				toolbar->ToolbarExtension()->ControlOrNull(aCommandId))
                  {
                  TRAP_IGNORE(toolbar->ToolbarExtension()->HideItemL(aCommandId,ETrue));
                  }
			  else
				 {
				 //Do Nothing
				 }
              }
          }
     }
	 
// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::RedrawToolBar
//
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::RedrawToolBar()
	{
	CEikonEnv::Static()->WsSession().ClearAllRedrawStores();
	}

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::CreateContainerL
//
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::CreateContainerL()
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::CreateContainerL") );

    // Create gesture fw object, set observer and gesture interest
    if ( iGestureFw ) 
        {
        delete iGestureFw;
        iGestureFw = NULL;
        }

    iGestureFw = CAknTouchGestureFw::NewL( *this, *iContainer );
    iGestureFw->SetGestureInterestL( EAknTouchGestureFwGroupPinch | EAknTouchGestureFwGroupTap );

    PRINT( _L("Camera <= CCamPreCaptureViewBase::CreateContainerL") );            
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::HandleTouchGestureL
//
// ---------------------------------------------------------------------------
//
void CCamPreCaptureViewBase::HandleTouchGestureL( MAknTouchGestureFwEvent& aEvent )
    {
    PRINT( _L("Camera => CCamPreCaptureViewBase::HandleTouchGestureL") );
    
    // Skipped modes here
    if ( iController.ActiveCamera() == ECamActiveCameraSecondary )
        {
        PRINT( _L("Camera <= CCamPreCaptureViewBase::HandleTouchGestureL - skipped") );
        return;
        }

    MAknTouchGestureFwPinchEvent *pinch = AknTouchGestureFwEventPinch( aEvent );
    CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
    if ( pinch && (ECamNoOperation == iController.CurrentOperation()) && appUi 
               && !appUi->ZoomPane()->IsCurrentlyZooming() )
        {
        // Determine the direction of pinch: +ve -> pinch outward / zoom / widen VF
        TInt currMove = pinch->Movement();
        TBool wide = (currMove > 0) ? ETrue : EFalse;  
        PRINT1( _L("Camera <> CCamPreCaptureViewBase::HandleTouchGestureL - pinch, movement:%d"), currMove );

        if ( ( iLastMovement >= 0 && currMove < 0 ) || 
             ( iLastMovement <= 0 && currMove > 0 ) )
            {
            // Enable the blinking for resolution indicators and toggle image/video quality
            // level between top widescreen and vga levels
            CCamPreCaptureContainerBase* container = static_cast<CCamPreCaptureContainerBase*>( iContainer );
            container->BlinkResolutionIndicatorOnChange( ETrue );

            // Hide the zoom pane in case of pinch
           // CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
           // appUi->ZoomPane()->MakeVisible( EFalse, ETrue );

            if ( iController.ToggleWideScreenQuality( wide ) )
                {
                iLastMovement = currMove;
                }
            else
                {
                // if the quality level wasn't changed, then disable the blinking
                container->BlinkResolutionIndicatorOnChange( EFalse );
                }
            }
        }
    else if ( EAknTouchGestureFwDoubleTap == aEvent.Type() 
              && ( ECamNoOperation == iController.CurrentOperation() 
                   || ( ECamCapturing   == iController.CurrentOperation() 
                        && iController.CurrentMode() == ECamControllerVideo ) ) )
        {
        PRINT( _L("Camera <> double tap event") );
        CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
        CCamZoomPane *zoomPane = appUi->ZoomPane();
        
        CCamPreCaptureContainerBase* container = static_cast<CCamPreCaptureContainerBase*>( iContainer );
        if ( container && zoomPane )
            {
            container->ShowZoomPaneWithTimer();

            // Zoom to min (if not already at min) zoom level, otherwise zoom in to max level
            if ( !zoomPane->IsZoomAtMinimum() )
                {
                PRINT( _L("Camera <> Zooming out to min level") );
                zoomPane->ZoomToMinimum();
                }
            else
                {
                PRINT( _L("Camera <> Zooming to max level") );
                zoomPane->ZoomToMaximum();
                }
            }
        }
    else
        {
        PRINT1( _L("Camera <> HandleTouchGestureL - gesture not used, type:%d"), aEvent.Type() );
        }

    PRINT( _L("Camera <= CCamPreCaptureViewBase::HandleTouchGestureL") );
    }

// ---------------------------------------------------------------------------
// CCamPreCaptureViewBase::IsCaptureSetupMenuModeActive
//
// ---------------------------------------------------------------------------
//
TBool CCamPreCaptureViewBase::IsSetupModeActive()
    {
    TBool trueValue = ETrue;
    TBool ret = ( iCaptureSetupModeActive == trueValue ||
             iCaptureSetupMenuModeActive == trueValue || 
             iSceneSettingModeActive == trueValue ||
             iInfoListBoxActive == trueValue
             );
    PRINT1( _L("Camera <> CCamPreCaptureViewBase::IsSetupModeActive %d"), ret );
    return ret;
    }
//  End of File  

