1 /*

     2 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Still image pre-capture view class for Camera application*

    15 */

    16 

    17 

    18 // INCLUDE FILES

    19 #include "CamAppUi.h"

    20 #include "CamAppController.h"

    21 #include "CamStillPreCaptureView.h"

    22 #include "CamLogger.h"

    23 #include "CamUtility.h"

    24 #include "CamContainerBase.h"

    25 #include "CamAppUiBase.h"

    26 #include <eikmenub.h>

    27 #include <eikapp.h>

    28 #include <avkon.rsg>

    29 #include "CamCaptureSetupMenu.h"

    30 #include "CamPanic.h"

    31 #include "Cam.hrh"

    32 #include "CamAppUid.h"

    33 #include <csxhelp/lcam.hlp.hrh>

    34 #include "CamShootingModeContainer.h"

    35 #include "CamInfoListBoxContainer.h"

    36 #include "CamStillPreCaptureContainer.h"

    37 #include "CamSelfTimer.h"

    38 #include "CamTimeLapseUtility.h"

    39 #include <CaeEngine.h>

    40 #include <cameraapp.rsg>

    41 #include <vgacamsettings.rsg>

    42 #include <akntoolbar.h>

    43 #include <akntoolbarextension.h>

    44 #include <aknbutton.h>

    45 #include <AknsUtils.h>

    46 #include <cameraapp.mbg>

    47 #include <AknIconUtils.h>

    48 #include <gulicon.h>

    49 

    50 

    51 #include "StringLoader.h"

    52 #include "camactivepalettehandler.h"

    53 #include "CameraUiConfigManager.h"

    54 #include "CamSidePane.h"

    55 

    56 #include "CamLocalViewIds.h"

    57 #include "OstTraceDefinitions.h"

    58 #ifdef OST_TRACE_COMPILER_IN_USE

    59 #include "CamStillPreCaptureViewTraces.h"

    60 #endif

    61 

    62 

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

    64 

    65 // ---------------------------------------------------------------------------

    66 // CCamStillPreCaptureView::NewLC

    67 // Symbian OS two-phased constructor

    68 // ---------------------------------------------------------------------------

    69 //

    70 CCamStillPreCaptureView* CCamStillPreCaptureView::NewLC( CCamAppController& aController )

    71     {

    72     CCamStillPreCaptureView* self = 

    73         new( ELeave ) CCamStillPreCaptureView( aController );

    74 

    75     CleanupStack::PushL( self );

    76     self->ConstructL();

    77 

    78     return self;

    79     }

    80 

    81 // ---------------------------------------------------------------------------

    82 // CCamStillPreCaptureView destructor

    83 // 

    84 // ---------------------------------------------------------------------------

    85 //

    86 CCamStillPreCaptureView::~CCamStillPreCaptureView()

    87   {

    88   }

    89   

    90 // ---------------------------------------------------------------------------

    91 // CCamStillPreCaptureView::Id

    92 // Returns UID of view

    93 // ---------------------------------------------------------------------------

    94 //

    95 TUid CCamStillPreCaptureView::Id() const

    96     {

    97    	return TUid::Uid( ECamViewIdStillPreCapture );	

    98     }

    99 

   100 // ---------------------------------------------------------------------------

   101 // CCamStillPreCaptureView::DoDeactivate

   102 // Deactivate this view

   103 // ---------------------------------------------------------------------------

   104 //

   105 void CCamStillPreCaptureView::DoDeactivate()

   106     {

   107     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMSTILLPRECAPTUREVIEW_DODEACTIVATE, "e_CCamStillPreCaptureView_DoDeactivate 1" );

   108     PERF_EVENT_START_L2( EPerfEventStillPreCaptureViewDeactivation );    

   109     PRINT( _L("Camera => CCamStillPreCaptureView::DoDeactivate" ) )

   110 

   111     CCamPreCaptureViewBase::DoDeactivate();

   112     PERF_EVENT_END_L2( EPerfEventStillPreCaptureViewDeactivation );

   113     PRINT( _L("Camera <= CCamStillPreCaptureView::DoDeactivate" ) )

   114     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMSTILLPRECAPTUREVIEW_DODEACTIVATE, "e_CCamStillPreCaptureView_DoDeactivate 0" );

   115     }

   116 

   117 // -----------------------------------------------------------------------------

   118 // CCamStillPreCaptureView::HandleCommandL

   119 // Handle commands

   120 // -----------------------------------------------------------------------------

   121 //

   122 void CCamStillPreCaptureView::HandleCommandL( TInt aCommand )

   123     {

   124     PRINT( _L("Camera => CCamStillPreCaptureView::HandleCommandL") );

   125     CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

   126     TCamOrientation orientation = appUi->CamOrientation();

   127     switch ( aCommand )

   128         {

   129         case ECamMSKCmdSelect:

   130         case ECamMSKCmdAppCapture:

   131         	{

   132         	if( orientation == ECamOrientationCamcorder || 

   133         	    orientation == ECamOrientationCamcorderLeft ||

   134 				orientation == ECamOrientationPortrait )

   135         		{

   136     		    if ( !StartMskCaptureL() )

   137         		    {

   138             		// If in the Landscape mode, MSK event is mapped 

   139             	  	// like a normal selection key so that AP items

   140             	  	// are selected and respective setting pages are launched

   141             	    TKeyEvent aKeyEvent;

   142     	    		aKeyEvent.iCode =  aKeyEvent.iRepeats = aKeyEvent.iModifiers = 0;

   143         			aKeyEvent.iScanCode = EStdKeyDevice3;

   144             		static_cast<CCamStillPreCaptureContainer*>

   145             				( Container() )->OfferKeyEventL( aKeyEvent, EEventKey );	

   146         		    }

   147             	}

   148             else if ( aCommand == ECamMSKCmdAppCapture )

   149                // if the Camera in the Portrait mode

   150           	   // MSK event is handled like a capture key

   151           		{

   152           		OstTrace0( CAMERAAPP_PERFORMANCE, DUP8_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHUTTER_RELEASE_LAG 1" );

   153           		if ( iController.IsViewFinding() && appUi->CheckMemoryL() )

   154                 	{

   155                     OstTrace0( CAMERAAPP_PERFORMANCE, CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );

   156                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );

   157                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SAVE 1" );

   158                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SHOT 1" );

   159                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_STILL 1" );

   160                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_CAPTURE_START 1" );

   161                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP6_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SERIAL_SHOOTING 1" );

   162                 	SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   163                 	iController.Capture();

   164                 	}

   165           		}

   166             break;

   167         	}

   168         case ECamCmdCaptureImage:

   169             {

   170       	    OstTrace0( CAMERAAPP_PERFORMANCE, DUP10_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHUTTER_RELEASE_LAG 1" );

   171       	    if ( iController.IsViewFinding() && appUi->CheckMemoryL() &&

   172                 !iController.CaptureModeTransitionInProgress() &&

   173                 !iController.IsProcessingCapture() ) 

   174             	{

   175             	SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   176 

   177             	// fixed toolbar is used only with touch devices

   178             	if ( iController.IsTouchScreenSupported() )

   179             	    {

   180                     CAknToolbar* fixedToolbar = Toolbar();

   181                     if ( fixedToolbar )

   182                         {

   183                         fixedToolbar->SetToolbarVisibility( EFalse );

   184                         }

   185             	    }

   186             	

   187                 // Start the autofocus operation now, the capture will be queued

   188                 // after focus completes

   189                 if ( !appUi->SelfTimerEnabled() 

   190                     && iController.ActiveCamera() != ECamActiveCameraSecondary

   191                     && iController.UiConfigManagerPtr()

   192                     && iController.UiConfigManagerPtr()->IsAutoFocusSupported()

   193                     && !iController.CurrentSceneHasForcedFocus() )

   194                     {

   195                     // Next trace should be just before "e_CAM_PRI_SHUTTER_RELEASE_LAG 1", but only when AF is supported

   196                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP9_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_AF_LOCK 1" );

   197                     if( iController.CurrentOperation() == ECamNoOperation )

   198                         {

   199                         iController.SetAfNeeded( ETrue );

   200                         }    

   201                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP7_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_AF 1" );

   202                     iController.StartAutoFocus();

   203                     }

   204                 else // AF not needed, capture will start next

   205                     {

   206                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP11_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );

   207                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP12_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );

   208                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP13_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SAVE 1" );

   209                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP14_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SHOT 1" );

   210                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP15_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_STILL 1" );

   211                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP16_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_CAPTURE_START 1" );

   212                     OstTrace0( CAMERAAPP_PERFORMANCE, DUP17_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SERIAL_SHOOTING 1" );

   213                     }

   214             	TKeyEvent keyEvent;

   215             	appUi->StartCaptureL( keyEvent );

   216 

   217             	}

   218             break;

   219             }

   220         case ECamCmdTimeLapseSlider:

   221             {               

   222             TCamTimeLapse settingValue = ECamTimeLapseOff;

   223 

   224             if ( appUi && !appUi->IsBurstEnabled() )

   225                 {

   226                 settingValue = ECamTimeLapseMin;

   227                 }                        

   228 

   229             TInt command = CamTimeLapseUtility::EnumToCommand( settingValue ); 

   230             TTimeIntervalMicroSeconds interval = CamTimeLapseUtility::EnumToInterval( settingValue );  

   231 

   232             // Update the current mode (single/burst/timelapse)

   233             if( appUi )

   234                 {

   235                 TRAP_IGNORE( appUi->HandleCommandL( command ) );                    

   236                 }

   237 

   238             // Update timelapse interval

   239             iController.SetTimeLapseInterval( interval ); 

   240 

   241             // stop and start the viewfinder in order to update the settings

   242             StopViewFinder();

   243             StartViewFinder();

   244             

   245             // fixed toolbar is used only with touch devices

   246             if ( iController.IsTouchScreenSupported() )

   247                 {

   248                 UpdateToolbarIconsL();

   249                 }

   250             

   251             }     

   252             break;

   253             

   254         case ECamCmdCaptureSetupLightSensitivityStill:

   255         // case ECamCmdCaptureSetupLightSensitivityVideo:

   256         	{

   257         	SwitchToInfoListBoxL( EInfoListBoxModeISO );

   258         	}

   259         	break;        	

   260    

   261         case ECamCmdGoToStandby:

   262             {

   263             // SwitchToStandbyModeL( ECamViewIdStillPreCapture, iStandbyError );

   264             SwitchToStandbyModeL( ECamViewIdStillPreCapture, appUi->StandbyStatus() );

   265             }

   266             break;

   267         case ECamCmdExitStandby:

   268             {

   269             ExitStandbyModeL();

   270             }

   271             break;

   272         case ECamCmdViewfinderGrid:

   273             {

   274             // Switch grid setting

   275             CCamPreCaptureViewBase::HandleCommandL( aCommand );

   276 			UpdateToolbarIconsL();

   277             }

   278             break;			

   279         case ECamCmdToggleFacetracking: 

   280             {

   281              // Switch facetracking setting

   282              CCamPreCaptureViewBase::HandleCommandL( aCommand );

   283              UpdateToolbarIconsL();

   284             

   285             break;

   286            }    

   287         default:

   288             {

   289             CCamPreCaptureViewBase::HandleCommandL( aCommand ); 

   290             }

   291         }

   292     PRINT( _L("Camera <= CCamStillPreCaptureView::HandleCommandL") );

   293     }   

   294 

   295 // -----------------------------------------------------------------------------

   296 // CCamStillPreCaptureView::HandleForegroundEventL

   297 // Handle foreground event

   298 // -----------------------------------------------------------------------------

   299 //

   300 void 

   301 CCamStillPreCaptureView::HandleForegroundEventL( TBool aForeground )

   302   {

   303   PRINT( _L("Camera => CCamStillPreCaptureView::HandleForegroundEventL") );

   304 

   305   CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

   306 

   307   // -------------------------------------------------------

   308   // Foreground

   309   //

   310   // reset menu and cba as appropriate

   311   if( aForeground )

   312     {

   313     PRINT( _L("Camera <> CCamStillPreCaptureView::HandleForegroundEventL: to foreground") );

   314     PRINT1( _L("Camera <> CCamStillPreCaptureView .. Current controller operation [%s]"), KCamCaptureOperationNames[iController.CurrentOperation()] );

   315     PRINT1( _L("Camera <> CCamStillPreCaptureView .. Current controller mode      [%s]"), KCamModeNames[iController.CurrentMode()] );

   316     if( ECamViewStateStandby == appUi->CurrentViewState() )

   317       {

   318       CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();

   319       if( fixedToolbar )

   320         {

   321         fixedToolbar->SetToolbarVisibility( EFalse );    

   322         }

   323       }

   324 

   325 

   326     if( iController.SequenceCaptureInProgress() )

   327       {

   328       PRINT( _L("Camera <= CCamStillPreCaptureView::HandleForegroundEventL: sequence capture ongoing") );

   329       return;

   330       }

   331 

   332     if ( appUi->IsInPretendExit() )

   333       {

   334       PRINT( _L("Camera <= CCamStillPreCaptureView::HandleForegroundEventL: app in pretend exit so not grabbing resources") )

   335       // The view can get a foreground event while the application is

   336       // actually in a pretend exit situation. This occurs when the view switch

   337       // was called before the exit event, but didn't complete until after the

   338       // exit event. In this case the view should not register an interest in

   339       // the engine as the application is really in the background and the resources

   340       // need to be released

   341       return;

   342       }

   343     // if foreground event is received while in videocall, go to standby with error

   344     if ( iController.InVideocallOrRinging() && ECamNoOperation == iController.CurrentOperation() )

   345         {

   346         ExitAllModesL();

   347         appUi->SetStandbyStatus( KErrInUse );

   348         appUi->HandleCommandL( ECamCmdGoToStandby );

   349         SetTitlePaneTextL();	        

   350         return;

   351         }

   352         

   353     // check for silent profile whenever we come to foreground, we dont need it here,

   354     // but we keep track of this in appcontroller.

   355     iController.IsProfileSilent();

   356 

   357     // set embedded flag here

   358     iEmbedded = appUi->IsEmbedded();

   359     // make sure CBA is correct

   360     UpdateCbaL();

   361 

   362     SetMenuBar();

   363     

   364     if ( iContinueInBackground && !iStandbyModeActive )

   365         {

   366         // make sure that CCamAppController is in view finder mode

   367         if ( iController.CurrentImageMode() == ECamImageCaptureNone )

   368             {

   369             StartViewFinder();

   370             }

   371         }

   372     }

   373   // -------------------------------------------------------

   374   // Background

   375   //

   376   // If going to the background, cancel any current autofocus.

   377   // This makes sure that the focus indicator is removed from the side pane

   378   // if the key release event is lost.

   379   // Cancelling focus does nothing if a capture has already been requested

   380   else

   381     {

   382     PRINT( _L("Camera <> CCamStillPreCaptureView::HandleForegroundEventL: to background") );

   383     // Cancel any outstanding capture

   384     iController.CancelFocusAndCapture();

   385 

   386     // stop any current sequence capture unless it is only a notification

   387     if( iController.SequenceCaptureInProgress() 

   388      && ( appUi->AppInBackground( EFalse ) 

   389        || appUi->ForegroundAppIsPhoneApp()

   390         )

   391       )

   392       {

   393       iController.StopSequenceCaptureL();

   394       }

   395      /*

   396     // stop any current sequence capture unless it is only an eikon server or AknCapServer window

   397     if ( iCoeEnv->WsSession().GetFocusWindowGroup() != iEikonServerWindowGroupId

   398         && iController.SequenceCaptureInProgress() )

   399       {

   400       TInt groupId = iCoeEnv->WsSession().GetFocusWindowGroup();

   401       if ( !CamUtility::IdMatchesName( groupId, KAknCapServer ) )

   402         {

   403         // If AknCapServer has NOT got foreground, (which would possibly 

   404         // indicate a "charging" note) stop sequence capture

   405         iController.StopSequenceCaptureL();

   406         }

   407       }

   408     */

   409     }

   410 

   411   CCamPreCaptureViewBase::HandleForegroundEventL( aForeground );

   412 

   413   PRINT( _L("Camera <= CCamStillPreCaptureView::HandleForegroundEventL") );

   414   }

   415     

   416 // -----------------------------------------------------------------------------

   417 // CCamStillPreCaptureView::HandleFocusLossL

   418 // Handle change of focus

   419 // -----------------------------------------------------------------------------

   420 //

   421 void CCamStillPreCaptureView::HandleFocusLossL()

   422     {

   423     PRINT( _L( "Camera => CCamStillPreCaptureView::HandleFocusLossL" ) );    

   424     // if the application was already in the background, but behind an

   425     // eikon server window, then handle backgrounding properly now.

   426     // Otherwise the backgrounding will be handled in the normal

   427     // HandleForeground() method.

   428     if ( iContinueInBackground )

   429         {

   430         if ( iController.SequenceCaptureInProgress() )

   431             {

   432             iController.StopSequenceCaptureL();

   433             }

   434         }

   435     CCamPreCaptureViewBase::HandleFocusLossL();

   436     PRINT( _L( "Camera <= CCamStillPreCaptureView::HandleFocusLossL" ) );    

   437     }    

   438 

   439 // -----------------------------------------------------------------------------

   440 // CCamStillPreCaptureView::HandleControllerEventL

   441 // Handle controller events

   442 // -----------------------------------------------------------------------------

   443 //

   444 void CCamStillPreCaptureView::HandleControllerEventL( TCamControllerEvent aEvent, 

   445                                                      TInt aError )

   446     {

   447     PRINT( _L("Camera => CCamStillPreCaptureView::HandleControllerEventL") );

   448     

   449     CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

   450     if ( ECamEventControllerReady == aEvent )

   451             {

   452             iSoftkeyBlankIsNeeded = EFalse;

   453             UpdateCbaL();

   454             }

   455             else if ( aEvent == ECamEventOperationStateChanged )

   456         {

   457         PRINT( _L("Camera <> CCamStillPreCaptureView: ECamEventOperationStateChanged") );

   458         TCamCaptureOperation operation = iController.CurrentOperation();

   459         switch ( operation )

   460             {

   461             case ECamCompleting:

   462                 {

   463                 iController.SetTouchCapture( EFalse );

   464                 UpdateCbaL();

   465                 break;

   466                 }

   467 

   468             case ECamFocusing:

   469                 {

   470                 // Hide the AP during focussing

   471                 if ( appUi->AlwaysDrawPreCaptureCourtesyUI()

   472                     && !iController.CurrentSceneHasForcedFocus() )

   473                     {

   474                     appUi->SetActivePaletteVisibility( EFalse );

   475                     }

   476                 break;

   477                 }

   478 

   479             case ECamFocused:

   480                 {

   481                 // Hide the AP during focussing

   482                 if ( appUi->AlwaysDrawPreCaptureCourtesyUI()

   483                     && !iController.CurrentSceneHasForcedFocus() )

   484                     {

   485                     appUi->SetActivePaletteVisibility( EFalse );

   486                     }

   487                 UpdateCbaL();

   488                 break;

   489                 }                

   490                 

   491             case ECamNoOperation:

   492                 {

   493                 if( iController.IsAppUiAvailable() )

   494 	                {

   495 	                //Update softkey state.

   496 	                UpdateCbaL();

   497 	                	                

   498 	                // Hide the AP if we already have an autofocus request but operation doesn't

   499 	                // have it (likely shutter was half-pressed before precap view opened)

   500 	                if ( iController.PendingAFRequest() != 0 && 

   501 	                     appUi->AlwaysDrawPreCaptureCourtesyUI() &&

   502 	                     !iController.CurrentSceneHasForcedFocus() )

   503 	                    {

   504 	                    appUi->SetActivePaletteVisibility( EFalse );

   505 	                    UpdateCbaL();

   506 	                    }

   507 

   508 	                // Show the AP again if the shutter key is released

   509 	                // without taking a picture, don't show if uiorientationoverride

   510 	                // feature is on and VF not running (prevents AP flashing in startup)

   511 	                if ( iPreviousControllerOperation !=ECamStandby &&

   512 	                     appUi->CurrentViewState() == ECamViewStatePreCapture && 

   513 	                     appUi->AlwaysDrawPreCaptureCourtesyUI() && 

   514 	                     !iSceneSettingModeActive && 

   515 	                     !( iController.UiConfigManagerPtr() && 

   516 	                     iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() && 

   517 	                     !iController.IsViewFinding() ) ) 

   518 	                    {

   519 	                    appUi->SetActivePaletteVisibility( ETrue );

   520                         }

   521                     }

   522                     

   523                 break;

   524                 }

   525  

   526             case ECamCapturing:

   527                 {

   528                 // If in burst, make sure the correct CBA is shown

   529                 if( appUi->IsBurstEnabled() )

   530                     {

   531                     UpdateCbaL();

   532                     // show image counter

   533                     iContainer->SetupNaviPanesL( CCamContainerBase::ECamPaneCounter );

   534                     }

   535                 break;

   536                 }

   537             default:

   538                 {

   539                 // Hide the AP if we already have an autofocus request but operation doesn't

   540                 // have it (likely shutter was half-pressed before precap view opened)

   541                 if ( iController.PendingAFRequest() != 0 && 

   542                      appUi->AlwaysDrawPreCaptureCourtesyUI() &&

   543                      !iController.CurrentSceneHasForcedFocus() )

   544                     {

   545                     appUi->SetActivePaletteVisibility( EFalse );

   546                     UpdateCbaL();

   547                     }

   548                 break;

   549                 }

   550             }

   551         

   552         iPreviousControllerOperation = operation;

   553 

   554         }

   555     else

   556         {

   557         PRINT( _L("Camera <> CCamStillPreCaptureView: call CCamPreCaptureViewBase::HandleControllerEventL") );

   558         CCamPreCaptureViewBase::HandleControllerEventL( aEvent, aError );

   559         }

   560     PRINT( _L("Camera <= CCamStillPreCaptureView::HandleControllerEventL") );        

   561     }

   562 

   563 

   564 // ---------------------------------------------------------------------------

   565 // CCamStillPreCaptureView::CreateCaptureSetupMenuL

   566 // Creates a photo capture setup menu

   567 // ---------------------------------------------------------------------------

   568 //

   569 void CCamStillPreCaptureView::CreateCaptureSetupMenuL( )

   570     {

   571     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMSTILLPRECAPTUREVIEW_CREATECAPTURESETUPMENUL, "e_CCamStillPreCaptureView_CreateCaptureSetupMenuL 1" );

   572     TInt resource;

   573     // check if we are Western or Arabic/Hebrew layout

   574     if ( !AknLayoutUtils::LayoutMirrored() )

   575         {

   576         // Do we need APAC layout

   577         if( AknLayoutUtils::Variant() == EApacVariant )

   578             {

   579             resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_APAC_ID);

   580             }

   581         else

   582             {

   583             // use Western resource

   584             resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_ID);

   585             }

   586         }

   587     else

   588         {

   589         resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_AH_ID);

   590         }

   591 

   592     // Use capture setup menu for second camera

   593     if ( static_cast<CCamAppUiBase*>( AppUi() )->IsSecondCameraEnabled() )

   594         {

   595         resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_ID);

   596         }

   597 

   598     iCaptureSetupMenuContainer = 

   599         CCamCaptureSetupMenu::NewL( iController, *this, AppUi()->ClientRect(),

   600         resource, iCaptureSetupMenuLastItemIndex );        

   601     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMSTILLPRECAPTUREVIEW_CREATECAPTURESETUPMENUL, "e_CCamStillPreCaptureView_CreateCaptureSetupMenuL 0" );

   602     }

   603 

   604 // ---------------------------------------------------------------------------

   605 // CCamStillPreCaptureView::SetMenuBar()

   606 // Sets the menu bar according to camera state

   607 // ---------------------------------------------------------------------------

   608 //

   609 void 

   610 CCamStillPreCaptureView::SetMenuBar()

   611   {

   612   PRINT( _L("Camera => CCamStillPreCaptureView::SetMenuBar") );

   613 

   614   // update menu bar as required

   615   CEikMenuBar* menuBar = MenuBar();

   616 

   617   // if menuBar exists

   618   if ( menuBar )

   619     {       

   620     if ( iStandbyModeActive ) //&& iActivateToStandby )

   621       {

   622       PRINT( _L("Camera <> CCamStillPreCaptureView::SetMenuBar: setting standby menubar..") );

   623       menuBar->SetMenuTitleResourceId( R_CAM_STANDBY_MENUBAR );

   624       }

   625     else if ( iEmbedded && !iSceneSettingModeActive )

   626       {

   627       PRINT( _L("Camera <> CCamStillPreCaptureView::SetMenuBar: setting embedded menubar..") );

   628       menuBar->SetMenuTitleResourceId( ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID));

   629       }

   630     else

   631       {

   632       if ( iSceneSettingModeActive )

   633         {

   634         PRINT( _L("Camera <> CCamStillPreCaptureView::SetMenuBar: setting scene setting menubar..") );

   635         menuBar->SetMenuTitleResourceId( ROID(R_CAM_SCENE_SETTING_MENUBAR_ID));

   636         }

   637       else

   638         {

   639         PRINT( _L("Camera <> CCamStillPreCaptureView::SetMenuBar: setting normal menubar..") );

   640 		    menuBar->SetMenuTitleResourceId( ROID(R_CAM_STILL_PRE_CAPTURE_MENUBAR_ID));

   641 		    }

   642       }

   643     }

   644   PRINT( _L("Camera <= CCamStillPreCaptureView::SetMenuBar") );

   645   }

   646 

   647 

   648 // ---------------------------------------------------------------------------

   649 // CCamStillPreCaptureView::CCamStillPreCaptureView

   650 // C++ constructor

   651 // ---------------------------------------------------------------------------

   652 //

   653 CCamStillPreCaptureView::CCamStillPreCaptureView( CCamAppController& aController )

   654     : CCamPreCaptureViewBase( aController ),iSoftkeyBlankIsNeeded( EFalse )

   655     {

   656     }

   657 

   658 // ---------------------------------------------------------------------------

   659 // CCamStillPreCaptureView::ConstructL

   660 // Symbian OS 2nd phase constructor

   661 // ---------------------------------------------------------------------------

   662 //

   663 void CCamStillPreCaptureView::ConstructL()

   664     {

   665     BaseConstructL( ROID(R_CAM_STILL_PRE_CAPTURE_VIEW_ID));

   666 

   667     iPreviousControllerOperation = ECamNoOperation;

   668     

   669     CAknToolbar* toolbar = Toolbar();

   670     if ( toolbar )

   671         {

   672         //Hide toolbar for first camera startup.        

   673         toolbar->SetToolbarVisibility(EFalse);

   674         }

   675         

   676     CCamPreCaptureViewBase::ConstructL();

   677     }

   678 

   679 

   680 // ---------------------------------------------------------------------------

   681 // CCamStillPreCaptureView::UpdateCbaL

   682 // Update softkeys to reflect current state

   683 // ---------------------------------------------------------------------------

   684 //

   685 void CCamStillPreCaptureView::UpdateCbaL()

   686   {

   687   PRINT( _L("Camera => CCamStillPreCaptureView::UpdateCbaL") );        

   688     

   689   CCamAppUi* appui = static_cast<CCamAppUi*>( AppUi() );

   690   TBool burstEnabled = appui->IsBurstEnabled();

   691  

   692   TCamCaptureOperation operation = iController.CurrentOperation();

   693   TBool isSecondaryPortrait = appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera();

   694   if ( iSoftkeyBlankIsNeeded )

   695         {

   696         isSecondaryPortrait?SetSoftKeysL( R_CAM_SOFTKEYS_BLANK_EXIT_SECONDARY ):SetSoftKeysL( R_CAM_SOFTKEYS_BLANK_EXIT );

   697         }

   698   // if video call is active

   699   else if ( iController.InVideocallOrRinging() )

   700       {

   701       SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );	

   702       }	

   703   // if the view is in capture setup menu mode

   704   else  if ( iCaptureSetupMenuModeActive && 

   705       !iCaptureSetupModeActive  &&

   706       !iSceneSettingModeActive )

   707       {

   708       SetSoftKeysL( R_AVKON_SOFTKEYS_SELECT_BACK );

   709       }          

   710   // if the view is in capture setup mode

   711   else if ( iCaptureSetupModeActive )

   712       {

   713       SetSoftKeysL( R_CAM_SOFTKEYS_SETTINGS_SELECT_BACK__CHANGE_TRANSPARENT );

   714       }

   715   // if the view is in scene settings mode

   716   else if ( iSceneSettingModeActive )

   717       {

   718       SetSoftKeysL( R_AVKON_SOFTKEYS_SELECT_CANCEL );

   719       }

   720   else if ( iStandbyModeActive )

   721     {

   722     PRINT( _L("Camera <> CCamStillPreCaptureView::UpdateCbaL: Setting standby softkeys..") );        

   723     if( KErrNone == appui->StandbyStatus() )

   724 	  {

   725       SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CONTINUE );

   726 	  }

   727     else if( appui->IsRecoverableStatus() )

   728 	  {

   729 	  SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );

   730 	  }

   731     }

   732   else if( iInfoListBoxActive )

   733   	{

   734     if( !iForceAvkonCBA )

   735         {

   736         SetSoftKeysL( R_CAM_SOFTKEYS_SETTINGS_SELECT_BACK__CHANGE_TRANSPARENT );    

   737         }

   738     else

   739         {

   740         SetSoftKeysL( R_CAM_SOFTKEYS_SETTINGS_SELECT_BACK__CHANGE );    

   741         }    

   742   	}

   743   else if (  ( operation == ECamFocusing || operation == ECamFocused  || operation == ECamFocusFailed )

   744          && !iController.CurrentSceneHasForcedFocus() )

   745       {

   746       // If AutoFocus operation in progress.  Can occur for still or

   747       // burst capture

   748       SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   749       }

   750   // If timelapse capture is ongoing the keys should be blank and cancel

   751   else if ( burstEnabled && 

   752             appui->CurrentBurstMode() == ECamImageCaptureTimeLapse && 

   753             iController.SequenceCaptureInProgress() )

   754     {

   755     SetSoftKeysL( R_CAM_SOFTKEYS_BLANK_STOP );

   756     }

   757   // If "Burst" capture is starting

   758   else if ( burstEnabled && operation == ECamCapturing ) 

   759     {

   760     

   761     SetSoftKeysL( R_CAM_SOFTKEYS_BLANK_STOP );

   762     }

   763   // If "Burst" capture is completing

   764   else if ( burstEnabled && operation == ECamCompleting )   

   765     {

   766     SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );               

   767     }   

   768   else if ( appui->SelfTimerEnabled() )                   

   769     {

   770     // If self-timer enabled, check the precise state to show the 

   771     // correct CBA state.

   772     CCamSelfTimer* selftimer = appui->SelfTimer();

   773     if ( selftimer->IsActive() )

   774       {

   775         {

   776         SetSoftKeysL( R_CAM_SOFTKEYS_SELFTIMER_BLANK_CANCEL );

   777         }                                

   778       }

   779     else if( iEmbedded && operation == ECamCompleting )

   780       {

   781       isSecondaryPortrait?SetSoftKeysL( R_CAM_SOFTKEYS_BLANK_SECONDARY ):SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   782       }    

   783     else

   784       {

   785       ViewCba()->MakeVisible( ETrue );

   786       SetSoftKeysL( R_CAM_SOFTKEYS_ACTIVATE_CANCEL__SELECT );                

   787       }

   788     }

   789   else // otherwise, show the default softkeys

   790     {                        

   791     // options key is disabled if currently in capture mode

   792     // transition (i.e. switching to video mode)

   793     if ( iController.CaptureModeTransitionInProgress() )

   794       {

   795       SetSoftKeysL( iEmbedded

   796                   ? R_CAM_SOFTKEYS_BACK

   797                   : R_CAM_SOFTKEYS_BLANK_EXIT );

   798       if(iEmbedded )

   799             {

   800             if(isSecondaryPortrait)

   801                 {

   802                 SetSoftKeysL(R_CAM_SOFTKEYS_BACK_SECONDARY);

   803                 }

   804             else

   805                 {

   806                 SetSoftKeysL(R_CAM_SOFTKEYS_BACK);

   807                 }

   808             }

   809         else

   810             {

   811             if(isSecondaryPortrait)

   812                 {

   813                 SetSoftKeysL(R_CAM_SOFTKEYS_BLANK_EXIT_SECONDARY);

   814                 }

   815             else

   816                 {

   817                 SetSoftKeysL(R_CAM_SOFTKEYS_BLANK_EXIT);

   818                 }

   819             }

   820       }

   821     else

   822       {

   823       if ( iEmbedded )

   824         {

   825         if ( operation == ECamCapturing || operation == ECamCompleting )

   826            {

   827            SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   828            }

   829         else 

   830            {

   831            if(appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera())

   832                {

   833                SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__CAPTURE_SECONDARY );

   834                }

   835            else

   836                {

   837                SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__CAPTURE );

   838                }

   839            		

   840            }

   841         }

   842       else

   843         {

   844         if ( operation != ECamCompleting 

   845             && ( !appui->ShowPostCaptureView() 

   846                 || iController.IsViewFinding() ) )

   847           {

   848           const TCamOrientation orientation = appui->CamOrientation();

   849           if ( iController.IsTouchScreenSupported()

   850                && (ECamOrientationCamcorder     == orientation 

   851                || ECamOrientationCamcorderLeft == orientation) )

   852               {

   853               SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CAPTURE );

   854               }

   855           else 

   856               {

   857               if ( !appui->IsToolBarVisible()

   858                   && appui->IsSecondCameraEnabled()

   859                   && !iController.IsTouchScreenSupported() )

   860                   {

   861                   SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CAPTURE_TXT );

   862                   }

   863               else

   864                   {

   865                   appui->IsSecondCameraEnabled()?SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CAPTURE_SECONDARY ):

   866                       SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CAPTURE );

   867                   }

   868               }

   869           }

   870         else // operation == ECamCompleting

   871           {

   872           SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   873           }

   874 

   875         }

   876       }

   877     }

   878   PRINT( _L("Camera <= CCamStillPreCaptureView::UpdateCbaL") );        

   879   }

   880 

   881 

   882 // ---------------------------------------------------------------------------

   883 // CCamStillPreCaptureView::SetTitlePaneTextL

   884 // Set the view's title text

   885 // ---------------------------------------------------------------------------

   886 //

   887 void CCamStillPreCaptureView::SetTitlePaneTextL()

   888     {

   889     CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

   890 #ifndef __WINS__

   891     if ( iEmbedded /*&& !appUi->IsInCallSend()*/ )

   892         {

   893         // only set the title if the construction is complete

   894         // otherwise the application is not yet set up correctly

   895         // as embedded

   896         if ( appUi->IsConstructionComplete() )

   897             {

   898             // set title to name of embedding application

   899             appUi->SetTitleEmbeddedL();

   900             }                  

   901         }

   902     else

   903 #endif   

   904         {

   905         TInt titleResourceId = R_CAM_STILL_PRE_CAPTURE_TITLE_NAME;

   906      

   907         if ( iCaptureSetupModeActive || iSceneSettingModeActive || iInfoListBoxActive )

   908             {

   909             titleResourceId = CCamCaptureSetupViewBase::SetupModeTitlePaneResourceId();

   910             }

   911 

   912         appUi->SetTitleL( titleResourceId );

   913         }

   914     }

   915 

   916 // ---------------------------------------------------------------------------

   917 // CCamStillPreCaptureView::StartViewFinder

   918 // Enter viewfinder mode

   919 // ---------------------------------------------------------------------------

   920 //

   921 void CCamStillPreCaptureView::StartViewFinder()

   922     {

   923     iController.EnterViewfinderMode( ECamControllerImage );

   924     }

   925 

   926 // ---------------------------------------------------------------------------

   927 // CCamStillPreCaptureView::StopViewFinder

   928 // Exit viewfinder mode

   929 // ---------------------------------------------------------------------------

   930 //

   931 void CCamStillPreCaptureView::StopViewFinder()

   932     {

   933     iController.ExitViewfinderMode( ECamControllerImage );

   934     }

   935     

   936 // ---------------------------------------------------------------------------

   937 // CCamStillPreCaptureView::CreateContainerL

   938 // Create container control

   939 // ---------------------------------------------------------------------------

   940 //

   941 void CCamStillPreCaptureView::CreateContainerL()

   942     {

   943     PRINT( _L("Camera => CCamStillPreCaptureView::CreateContainerL" ) )

   944      

   945     TRect screen;

   946     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screen );

   947 

   948     iContainer = CCamStillPreCaptureContainer::NewL(

   949         iController,

   950         *this,

   951         screen );

   952     iContainer->SetMopParent( this );

   953     

   954     CCamPreCaptureViewBase::CreateContainerL();

   955     PRINT( _L("Camera <= CCamStillPreCaptureView::CreateContainerL" ) )

   956     }

   957 

   958 // ---------------------------------------------------------------------------

   959 // CCamStillPreCaptureView::DynInitMenuPaneL

   960 // Changes MenuPane dynamically

   961 // ---------------------------------------------------------------------------

   962 //

   963 void CCamStillPreCaptureView::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

   964     {

   965     PRINT( _L("Camera => CamStillPreCaptureView::DynInitMenuPaneL"))

   966 

   967     if ( iContainer )

   968         {

   969         iContainer->Window().SetNonFading( ETrue );

   970         }

   971 

   972     CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

   973 	__ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));

   974     TInt itemPos(0);

   975     if( aMenuPane->MenuItemExists(ECamCmdToggleCourtesyUI, itemPos) )

   976         {

   977         if ( !appUi->AlwaysDrawPreCaptureCourtesyUI() )

   978             {

   979             aMenuPane->SetItemTextL( ECamCmdToggleCourtesyUI, 

   980                                       R_CAM_CAPTURE_DISPLAY_ON_TEXT);

   981             }

   982         }

   983 

   984     // if menu pane is default still capture menu

   985     if ( aResourceId == ROID(R_CAM_STILL_PRE_CAPTURE_MENU_ID))

   986         {

   987         DynInitSwitchCameraMenuItemL( aMenuPane );

   988         }

   989 //    else if ( aResourceId == R_CAM_STANDBY_MENU && iStandbyError != KErrNone )

   990     else if ( aResourceId == R_CAM_STANDBY_MENU )

   991         {

   992         if( appUi->StandbyStatus() != KErrNone )

   993         aMenuPane->SetItemDimmed( ECamCmdExitStandby, ETrue );

   994         }

   995             

   996     else if( aResourceId == ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENU_ID))

   997         {

   998         DynInitSwitchCameraMenuItemL( aMenuPane );

   999         

  1000 /*#ifndef __WINS__

  1001         // if embedded and not in in-call send

  1002         if ( !appUi->IsInCallSend() )

  1003 #endif

  1004             {

  1005             aMenuPane->SetItemDimmed( ECamCmdNewVideo, ETrue );

  1006 			}*/

  1007 		aMenuPane->SetItemDimmed( ECamCmdNewVideo, ETrue );	

  1008         }        

  1009     else // otherwise, not embedded, not in burst mode or menu pane is not default

  1010         {

  1011         CCamCaptureSetupViewBase::DynInitMenuPaneL( aResourceId, aMenuPane );        

  1012         }

  1013     PRINT( _L("Camera <= CamStillPreCaptureView::DynInitMenuPaneL"))

  1014     }

  1015 

  1016 

  1017 // ---------------------------------------------------------------------------

  1018 // CCamPreCaptureViewBase::SwitchToSceneSettingModeL

  1019 // Switches the current mode to scene setting and activates a 

  1020 // specific control.

  1021 // ---------------------------------------------------------------------------

  1022 //

  1023 void CCamStillPreCaptureView::SwitchToSceneSettingModeL()

  1024     {

  1025     if ( !iSceneSettingContainer )

  1026     	{

  1027     	iSceneSettingContainer = CCamShootingModeContainer::NewL( AppUi()->ApplicationRect(),

  1028                                                              *this,

  1029                                                              ECamControllerImage,

  1030                                                              iController );

  1031         iSceneSettingContainer->DrawableWindow()->SetOrdinalPosition(-1);

  1032     	}

  1033     

  1034     iSettingModeTitleResourceId = R_CAM_STILL_SCENE_SETTING_TITLE;

  1035 

  1036     if ( iEmbedded )

  1037         {

  1038         iPreviousMenuResourceId = ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID);

  1039         }

  1040     else

  1041         {

  1042         iPreviousMenuResourceId = ROID(R_CAM_STILL_PRE_CAPTURE_MENUBAR_ID);

  1043         }

  1044     // Remove the view's main container, and add the capture setup 

  1045     // control associated with the input command to the container stack.

  1046     //CCamCaptureSetupViewBase::SwitchToSceneSettingModeL();

  1047     

  1048     CCamPreCaptureViewBase::SwitchToSceneSettingModeL();

  1049   

  1050 

  1051     // only remove the capture setup menu container after 

  1052     // the switch completes successfully

  1053     RemoveCaptureSetupMenuContainers();

  1054 

  1055     // Stop the viewfinder as it isn't required for scene settings

  1056     StopViewFinder();

  1057     }

  1058 

  1059 

  1060 // ---------------------------------------------------------------------------

  1061 // CCamPreCaptureViewBase::SwitchToInfoListBoxL

  1062 // Switches the current mode to scene setting and activates a 

  1063 // specific control.

  1064 // ---------------------------------------------------------------------------

  1065 //

  1066 void CCamStillPreCaptureView::SwitchToInfoListBoxL( TCamInfoListBoxMode aMode )

  1067     {   

  1068     CCamAppUi* appUi = static_cast<CCamAppUi*>( iCoeEnv->AppUi() );  	

  1069     

  1070     TBool modeSelected = EFalse;

  1071     TInt listBoxResource;

  1072     TInt summaryResource;

  1073     TInt initialValue;

  1074     TInt titleResource;

  1075     TBool skinnedbackground = EFalse;

  1076     

  1077     switch( aMode )

  1078     		{

  1079     		case EInfoListBoxModeTimeLapse:	

  1080     	 			{

  1081     				// Find out whether we are in burst mode	

  1082     				TBool burstmode = EFalse;

  1083     				

  1084     				// if capturing burst with 0 interval then this is normal sequence mode  

  1085     				if ( appUi->IsBurstEnabled() )

  1086     						{

  1087         				burstmode = ETrue;

  1088         				}    

  1089     

  1090     				// Time lapse / sequence mode selector initialization values

  1091     				initialValue = CamTimeLapseUtility::IntervalToEnum( iController.TimeLapseInterval(), burstmode );	

  1092     				listBoxResource = R_CAM_CAPTURE_SETUP_LIST_SEQUENCE_MODE;

  1093     				summaryResource = R_CAM_CAPTURE_SETUP_LIST_SEQUENCE_MODE_SUMMARY;

  1094     				titleResource = R_CAM_TIME_LAPSE_TITLE;

  1095     				    

  1096     				modeSelected = ETrue;

  1097     				}

  1098     				break;

  1099     		

  1100 				case EInfoListBoxModeISO:

  1101     				{

  1102     				// Light sensitivity selector initialization values	

  1103     				initialValue = iController.IntegerSettingValue( ECamSettingItemDynamicPhotoLightSensitivity );	

  1104     				if ( iController.UiConfigManagerPtr()->IsExtendedLightSensitivitySupported() ) 

  1105     				    {

  1106         				listBoxResource = R_CAM_CAPTURE_SETUP_LIST_EXTENDED_LIGHT_SENSITIVITY;

  1107         				summaryResource = R_CAM_CAPTURE_SETUP_LIST_EXTENDED_LIGHT_SENSITIVITY_SUMMARY;

  1108     				    }

  1109     				else

  1110     				    {

  1111         				listBoxResource = R_CAM_CAPTURE_SETUP_LIST_LIGHT_SENSITIVITY;

  1112         				summaryResource = R_CAM_CAPTURE_SETUP_LIST_LIGHT_SENSITIVITY_SUMMARY;

  1113     				    }

  1114     				titleResource = R_CAM_LIGHT_SENSITIVITY_TITLE;   					    				

  1115  					modeSelected = ETrue;

  1116  					skinnedbackground = EFalse;

  1117     				}

  1118     				break;

  1119     		

  1120     		default: 

  1121     				break;

  1122 				}    					

  1123     				    	

  1124 		if( modeSelected )

  1125 				{

  1126 				iInfoListBoxContainer = CCamInfoListBoxContainer::NewL( AppUi()->ApplicationRect(),

  1127                                                              		*this,                                                            

  1128                                                              		iController,

  1129                                                              		listBoxResource,

  1130                                                              		summaryResource,

  1131                                                              		initialValue, titleResource,

  1132                                                              		skinnedbackground );		

  1133 				

  1134 				iInfoListBoxContainer->DrawableWindow()->SetOrdinalPosition(-1);