1 /*

     2 * Copyright (c) 2007-2009 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 

    49 

    50 #include "StringLoader.h"

    51 #include "camactivepalettehandler.h"

    52 #include "CameraUiConfigManager.h"

    53 

    54 #include "CamLocalViewIds.h"

    55 #include "OstTraceDefinitions.h"

    56 #ifdef OST_TRACE_COMPILER_IN_USE

    57 #include "CamStillPreCaptureViewTraces.h"

    58 #endif

    59 

    60 

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

    62 

    63 // ---------------------------------------------------------------------------

    64 // CCamStillPreCaptureView::NewLC

    65 // Symbian OS two-phased constructor

    66 // ---------------------------------------------------------------------------

    67 //

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

    69     {

    70     CCamStillPreCaptureView* self = 

    71         new( ELeave ) CCamStillPreCaptureView( aController );

    72 

    73     CleanupStack::PushL( self );

    74     self->ConstructL();

    75 

    76     return self;

    77     }

    78 

    79 // ---------------------------------------------------------------------------

    80 // CCamStillPreCaptureView destructor

    81 // 

    82 // ---------------------------------------------------------------------------

    83 //

    84 CCamStillPreCaptureView::~CCamStillPreCaptureView()

    85   {

    86   }

    87   

    88 // ---------------------------------------------------------------------------

    89 // CCamStillPreCaptureView::Id

    90 // Returns UID of view

    91 // ---------------------------------------------------------------------------

    92 //

    93 TUid CCamStillPreCaptureView::Id() const

    94     {

    95    	return TUid::Uid( ECamViewIdStillPreCapture );	

    96     }

    97 

    98 // ---------------------------------------------------------------------------

    99 // CCamStillPreCaptureView::DoDeactivate

   100 // Deactivate this view

   101 // ---------------------------------------------------------------------------

   102 //

   103 void CCamStillPreCaptureView::DoDeactivate()

   104     {

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

   106     PERF_EVENT_START_L2( EPerfEventStillPreCaptureViewDeactivation );    

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

   108 

   109     CCamPreCaptureViewBase::DoDeactivate();

   110     PERF_EVENT_END_L2( EPerfEventStillPreCaptureViewDeactivation );

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

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

   113     }

   114 

   115 // -----------------------------------------------------------------------------

   116 // CCamStillPreCaptureView::HandleCommandL

   117 // Handle commands

   118 // -----------------------------------------------------------------------------

   119 //

   120 void CCamStillPreCaptureView::HandleCommandL( TInt aCommand )

   121     {

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

   123     TCamOrientation orientation = appUi->CamOrientation();

   124     switch ( aCommand )

   125         {

   126         case ECamMSKCmdSelect:

   127         case ECamMSKCmdAppCapture:

   128         	{

   129         	if( orientation == ECamOrientationCamcorder || 

   130         	    orientation == ECamOrientationCamcorderLeft ||

   131 				orientation == ECamOrientationPortrait )

   132         		{

   133     		    if ( !StartMskCaptureL() )

   134         		    {

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

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

   137             	  	// are selected and respective setting pages are launched

   138             	    TKeyEvent aKeyEvent;

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

   140         			aKeyEvent.iScanCode = EStdKeyDevice3;

   141             		static_cast<CCamStillPreCaptureContainer*>

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

   143         		    }

   144             	}

   145             else if ( aCommand == ECamMSKCmdAppCapture )

   146                // if the Camera in the Portrait mode

   147           	   // MSK event is handled like a capture key

   148           		{

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

   150                 	{

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

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

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

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

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

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

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

   158                 	SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   159                 	iController.Capture();

   160                 	}

   161           		}

   162             break;

   163         	}

   164         case ECamCmdCaptureImage:

   165             {

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

   167                 !iController.CaptureModeTransitionInProgress() &&

   168                 !iController.IsProcessingCapture() ) 

   169             	{

   170             	SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   171 

   172             	// fixed toolbar is used only with touch devices

   173             	if ( iController.IsTouchScreenSupported() )

   174             	    {

   175                     CAknToolbar* fixedToolbar = Toolbar();

   176                     if ( fixedToolbar )

   177                         {

   178                         fixedToolbar->SetToolbarVisibility( EFalse );

   179                         }

   180             	    }

   181             	

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

   183                 // after focus completes

   184                 if ( !appUi->SelfTimerEnabled() 

   185                     && iController.ActiveCamera() != ECamActiveCameraSecondary

   186                     && iController.UiConfigManagerPtr()

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

   188                     && !iController.CurrentSceneHasForcedFocus() )

   189                     {

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

   191                         {

   192                         iController.SetAfNeeded( ETrue );

   193                         }    

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

   195                     iController.StartAutoFocus();

   196                     }

   197             	TKeyEvent keyEvent;

   198             	appUi->StartCaptureL( keyEvent );

   199 

   200             	}

   201             break;

   202             }

   203         case ECamCmdTimeLapseSlider:

   204             {               

   205             TCamTimeLapse settingValue = ECamTimeLapseOff;

   206 

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

   208                 {

   209                 settingValue = ECamTimeLapseMin;

   210                 }                        

   211 

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

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

   214 

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

   216             if( appUi )

   217                 {

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

   219                 }

   220 

   221             // Update timelapse interval

   222             iController.SetTimeLapseInterval( interval ); 

   223 

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

   225             StopViewFinder();

   226             StartViewFinder();

   227             

   228             // fixed toolbar is used only with touch devices

   229             if ( iController.IsTouchScreenSupported() )

   230                 {

   231                 UpdateToolbarIconsL();

   232                 }

   233             

   234             }     

   235             break;

   236             

   237         case ECamCmdCaptureSetupLightSensitivityStill:

   238         // case ECamCmdCaptureSetupLightSensitivityVideo:

   239         	{

   240         	SwitchToInfoListBoxL( EInfoListBoxModeISO );

   241         	}

   242         	break;        	

   243    

   244         case ECamCmdGoToStandby:

   245             {

   246             // SwitchToStandbyModeL( ECamViewIdStillPreCapture, iStandbyError );

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

   248             }

   249             break;

   250         case ECamCmdExitStandby:

   251             {

   252             ExitStandbyModeL();

   253             }

   254             break;

   255         case ECamCmdViewfinderGrid:

   256             {

   257             // Switch grid setting

   258             CCamPreCaptureViewBase::HandleCommandL( aCommand );

   259 			UpdateToolbarIconsL();

   260             }

   261             break;			

   262         case ECamCmdToggleFacetracking: 

   263             {

   264              // Switch facetracking setting

   265              CCamPreCaptureViewBase::HandleCommandL( aCommand );

   266              UpdateToolbarIconsL();

   267             

   268             break;

   269            }    

   270         default:

   271             {

   272             CCamPreCaptureViewBase::HandleCommandL( aCommand ); 

   273             }

   274         }

   275     }   

   276 

   277 // -----------------------------------------------------------------------------

   278 // CCamStillPreCaptureView::HandleForegroundEventL

   279 // Handle foreground event

   280 // -----------------------------------------------------------------------------

   281 //

   282 void 

   283 CCamStillPreCaptureView::HandleForegroundEventL( TBool aForeground )

   284   {

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

   286 

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

   288 

   289   // -------------------------------------------------------

   290   // Foreground

   291   //

   292   // reset menu and cba as appropriate

   293   if( aForeground )

   294     {

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

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

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

   298 

   299 

   300     if( iController.SequenceCaptureInProgress() )

   301       {

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

   303       return;

   304       }

   305 

   306     if ( appUi->IsInPretendExit() )

   307       {

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

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

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

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

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

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

   314       // need to be released

   315       return;

   316       }

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

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

   319         {

   320         ExitAllModesL();

   321         appUi->SetStandbyStatus( KErrInUse );

   322         appUi->HandleCommandL( ECamCmdGoToStandby );

   323         SetTitlePaneTextL();	        

   324         return;

   325         }

   326         

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

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

   329     iController.IsProfileSilent();

   330 

   331     // set embedded flag here

   332     iEmbedded = appUi->IsEmbedded();

   333     // make sure CBA is correct

   334     UpdateCbaL();

   335 

   336     SetMenuBar();

   337     

   338     if ( iContinueInBackground )

   339         {

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

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

   342             {

   343             StartViewFinder();

   344             }

   345         }

   346     }

   347   // -------------------------------------------------------

   348   // Background

   349   //

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

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

   352   // if the key release event is lost.

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

   354   else

   355     {

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

   357     // Cancel any outstanding capture

   358     iController.CancelFocusAndCapture();

   359 

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

   361     if( iController.SequenceCaptureInProgress() 

   362      && ( appUi->AppInBackground( EFalse ) 

   363        || appUi->ForegroundAppIsPhoneApp()

   364         )

   365       )

   366       {

   367       iController.StopSequenceCaptureL();

   368       }

   369      /*

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

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

   372         && iController.SequenceCaptureInProgress() )

   373       {

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

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

   376         {

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

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

   379         iController.StopSequenceCaptureL();

   380         }

   381       }

   382     */

   383     }

   384 

   385   CCamPreCaptureViewBase::HandleForegroundEventL( aForeground );

   386 

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

   388   }

   389     

   390 // -----------------------------------------------------------------------------

   391 // CCamStillPreCaptureView::HandleFocusLossL

   392 // Handle change of focus

   393 // -----------------------------------------------------------------------------

   394 //

   395 void CCamStillPreCaptureView::HandleFocusLossL()

   396     {

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

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

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

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

   401     // HandleForeground() method.

   402     if ( iContinueInBackground )

   403         {

   404         if ( iController.SequenceCaptureInProgress() )

   405             {

   406             iController.StopSequenceCaptureL();

   407             }

   408         }

   409     CCamPreCaptureViewBase::HandleFocusLossL();

   410     PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleFocusLossL" ) );    

   411     }    

   412 

   413 // -----------------------------------------------------------------------------

   414 // CCamStillPreCaptureView::HandleControllerEventL

   415 // Handle controller events

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

   417 //

   418 void CCamStillPreCaptureView::HandleControllerEventL( TCamControllerEvent aEvent, 

   419                                                      TInt aError )

   420     {

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

   422     

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

   424     if ( ECamEventControllerReady == aEvent )

   425             {

   426             iSoftkeyBlankIsNeeded = EFalse;

   427             UpdateCbaL();

   428             }

   429             else if ( aEvent == ECamEventOperationStateChanged )

   430         {

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

   432         TCamCaptureOperation operation = iController.CurrentOperation();

   433         switch ( operation )

   434             {

   435             case ECamCompleting:

   436                 {

   437                 UpdateCbaL();

   438                 break;

   439                 }

   440 

   441             case ECamFocusing:

   442                 {

   443                 // Hide the AP during focussing

   444                 if ( appUi->AlwaysDrawPreCaptureCourtesyUI()

   445                     && !iController.CurrentSceneHasForcedFocus() )

   446                     {

   447                     appUi->SetActivePaletteVisibility( EFalse );

   448                     }

   449                 break;

   450                 }

   451 

   452             case ECamFocused:

   453                 {

   454                 // Hide the AP during focussing

   455                 if ( appUi->AlwaysDrawPreCaptureCourtesyUI()

   456                     && !iController.CurrentSceneHasForcedFocus() )

   457                     {

   458                     appUi->SetActivePaletteVisibility( EFalse );

   459                     }

   460                 UpdateCbaL();

   461                 break;

   462                 }                

   463                 

   464             case ECamNoOperation:

   465                 {

   466                 if( iController.IsAppUiAvailable() )

   467 	                {

   468 	                //Update softkey state.

   469 	                UpdateCbaL();

   470 	                	                

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

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

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

   474 	                     appUi->AlwaysDrawPreCaptureCourtesyUI() &&

   475 	                     !iController.CurrentSceneHasForcedFocus() )

   476 	                    {

   477 	                    appUi->SetActivePaletteVisibility( EFalse );

   478 	                    UpdateCbaL();

   479 	                    }

   480 

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

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

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

   484 	                if ( iPreviousControllerOperation !=ECamStandby &&

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

   486 	                     appUi->AlwaysDrawPreCaptureCourtesyUI() && 

   487 	                     !iSceneSettingModeActive && 

   488 	                     !( iController.UiConfigManagerPtr() && 

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

   490 	                     !iController.IsViewFinding() ) ) 

   491 	                    {

   492 	                    appUi->SetActivePaletteVisibility( ETrue );

   493                         }

   494                     }

   495                     

   496                 break;

   497                 }

   498  

   499             case ECamCapturing:

   500                 {

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

   502                 if( appUi->IsBurstEnabled() )

   503                     {

   504                     UpdateCbaL();

   505                     // show image counter

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

   507                     }

   508                 break;

   509                 }

   510             default:

   511                 {

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

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

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

   515                      appUi->AlwaysDrawPreCaptureCourtesyUI() &&

   516                      !iController.CurrentSceneHasForcedFocus() )

   517                     {

   518                     appUi->SetActivePaletteVisibility( EFalse );

   519                     UpdateCbaL();

   520                     }

   521                 break;

   522                 }

   523             }

   524         

   525         iPreviousControllerOperation = operation;

   526 

   527         }

   528     else

   529         {

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

   531         CCamPreCaptureViewBase::HandleControllerEventL( aEvent, aError );

   532         }

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

   534     }

   535 

   536 

   537 // ---------------------------------------------------------------------------

   538 // CCamStillPreCaptureView::CreateCaptureSetupMenuL

   539 // Creates a photo capture setup menu

   540 // ---------------------------------------------------------------------------

   541 //

   542 void CCamStillPreCaptureView::CreateCaptureSetupMenuL( )

   543     {

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

   545     TInt resource;

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

   547     if ( !AknLayoutUtils::LayoutMirrored() )

   548         {

   549         // Do we need APAC layout

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

   551             {

   552             resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_APAC_ID);

   553             }

   554         else

   555             {

   556             // use Western resource

   557             resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_ID);

   558             }

   559         }

   560     else

   561         {

   562         resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_AH_ID);

   563         }

   564 

   565     // Use capture setup menu for second camera

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

   567         {

   568         resource = ROID(R_CAM_CAPTURE_SETUP_MENU_PHOTO_DATA_ID);

   569         }

   570 

   571     iCaptureSetupMenuContainer = 

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

   573         resource, iCaptureSetupMenuLastItemIndex );        

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

   575     }

   576 

   577 // ---------------------------------------------------------------------------

   578 // CCamStillPreCaptureView::SetMenuBar()

   579 // Sets the menu bar according to camera state

   580 // ---------------------------------------------------------------------------

   581 //

   582 void 

   583 CCamStillPreCaptureView::SetMenuBar()

   584   {

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

   586 

   587   // update menu bar as required

   588   CEikMenuBar* menuBar = MenuBar();

   589 

   590   // if menuBar exists

   591   if ( menuBar )

   592     {       

   593     if ( iStandbyModeActive ) //&& iActivateToStandby )

   594       {

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

   596       menuBar->SetMenuTitleResourceId( R_CAM_STANDBY_MENUBAR );

   597       }

   598     else if ( iEmbedded && !iSceneSettingModeActive )

   599       {

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

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

   602       }

   603     else

   604       {

   605       if ( iSceneSettingModeActive )

   606         {

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

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

   609         }

   610       else

   611         {

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

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

   614 		    }

   615       }

   616     }

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

   618   }

   619 

   620 

   621 // ---------------------------------------------------------------------------

   622 // CCamStillPreCaptureView::CCamStillPreCaptureView

   623 // C++ constructor

   624 // ---------------------------------------------------------------------------

   625 //

   626 CCamStillPreCaptureView::CCamStillPreCaptureView( CCamAppController& aController )

   627     : CCamPreCaptureViewBase( aController ),iSoftkeyBlankIsNeeded( EFalse )

   628     {

   629     }

   630 

   631 // ---------------------------------------------------------------------------

   632 // CCamStillPreCaptureView::ConstructL

   633 // Symbian OS 2nd phase constructor

   634 // ---------------------------------------------------------------------------

   635 //

   636 void CCamStillPreCaptureView::ConstructL()

   637     {

   638     BaseConstructL( ROID(R_CAM_STILL_PRE_CAPTURE_VIEW_ID));

   639 

   640     iPreviousControllerOperation = ECamNoOperation;

   641     

   642     CCamPreCaptureViewBase::ConstructL();

   643     }

   644 

   645 

   646 // ---------------------------------------------------------------------------

   647 // CCamStillPreCaptureView::UpdateCbaL

   648 // Update softkeys to reflect current state

   649 // ---------------------------------------------------------------------------

   650 //

   651 void CCamStillPreCaptureView::UpdateCbaL()

   652   {

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

   654     

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

   656   TBool burstEnabled = appui->IsBurstEnabled();

   657  

   658   TCamCaptureOperation operation = iController.CurrentOperation();

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

   660   if ( iSoftkeyBlankIsNeeded )

   661         {

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

   663         }

   664   // if video call is active

   665   else if ( iController.InVideocallOrRinging() )

   666       {

   667       SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );	

   668       }	

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

   670   else  if ( iCaptureSetupMenuModeActive && 

   671       !iCaptureSetupModeActive  &&

   672       !iSceneSettingModeActive )

   673       {

   674       SetSoftKeysL( R_AVKON_SOFTKEYS_SELECT_BACK );

   675       }          

   676   // if the view is in capture setup mode

   677   else if ( iCaptureSetupModeActive )

   678       {

   679       SetSoftKeysL( R_AVKON_SOFTKEYS_OK_CANCEL__OK );

   680       }

   681   // if the view is in scene settings mode

   682   else if ( iSceneSettingModeActive )

   683       {

   684       SetSoftKeysL( R_AVKON_SOFTKEYS_SELECT_CANCEL );

   685       }

   686   else if ( iStandbyModeActive )

   687     {

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

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

   690       SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CONTINUE );

   691     else

   692       SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );

   693     }

   694   else if( iInfoListBoxActive )

   695   	{

   696   	SetSoftKeysL( R_CAM_SOFTKEYS_SETTINGS_SELECT_BACK__CHANGE );

   697   	}

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

   699          && !iController.CurrentSceneHasForcedFocus() )

   700       {

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

   702       // burst capture

   703       SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   704       }

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

   706   else if ( burstEnabled && 

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

   708             iController.SequenceCaptureInProgress() )

   709     {

   710     SetSoftKeysL( R_CAM_SOFTKEYS_BLANK_STOP );

   711     }

   712   // If "Burst" capture is starting

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

   714     {

   715     

   716     SetSoftKeysL( R_CAM_SOFTKEYS_BLANK_STOP );

   717     

   718     }

   719   // If "Burst" capture is completing

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

   721     {

   722     SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );               

   723     }   

   724   else if ( appui->SelfTimerEnabled() )                   

   725     {

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

   727     // correct CBA state.

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

   729     if ( selftimer->IsActive() )

   730       {

   731         {

   732         SetSoftKeysL( R_CAM_SOFTKEYS_SELFTIMER_BLANK_CANCEL );

   733         }                                

   734       }

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

   736       {

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

   738       }    

   739     else

   740       {

   741       SetSoftKeysL( R_CAM_SOFTKEYS_ACTIVATE_CANCEL__SELECT );                

   742       }

   743     }

   744   else // otherwise, show the default softkeys

   745     {                        

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

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

   748     if ( iController.CaptureModeTransitionInProgress() )

   749       {

   750       SetSoftKeysL( iEmbedded

   751                   ? R_CAM_SOFTKEYS_BACK

   752                   : R_CAM_SOFTKEYS_BLANK_EXIT );

   753       if(iEmbedded )

   754             {

   755             if(isSecondaryPortrait)

   756                 {

   757                 SetSoftKeysL(R_CAM_SOFTKEYS_BACK_SECONDARY);

   758                 }

   759             else

   760                 {

   761                 SetSoftKeysL(R_CAM_SOFTKEYS_BACK);

   762                 }

   763             }

   764         else

   765             {

   766             if(isSecondaryPortrait)

   767                 {

   768                 SetSoftKeysL(R_CAM_SOFTKEYS_BLANK_EXIT_SECONDARY);

   769                 }

   770             else

   771                 {

   772                 SetSoftKeysL(R_CAM_SOFTKEYS_BLANK_EXIT);

   773                 }

   774             }

   775       }

   776     else

   777       {

   778       if ( iEmbedded )

   779         {

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

   781            {

   782            SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   783            }

   784         else 

   785            {

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

   787                {

   788                SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__CAPTURE_SECONDARY );

   789                }

   790            else

   791                {

   792                SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__CAPTURE );

   793                }

   794            		

   795            }

   796         }

   797       else

   798         {

   799         if ( operation != ECamCompleting 

   800             && ( !appui->ShowPostCaptureView() 

   801                 || iController.IsViewFinding() ) )

   802           {

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

   804           if ( iController.IsTouchScreenSupported()

   805                && (ECamOrientationCamcorder     == orientation 

   806                || ECamOrientationCamcorderLeft == orientation) )

   807               {

   808               SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CAPTURE );

   809               }

   810           else 

   811               {

   812               if ( !appui->IsToolBarVisible()

   813                   && appui->IsSecondCameraEnabled()

   814                   && !iController.IsTouchScreenSupported() )

   815                   {

   816                   SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CAPTURE_TXT );

   817                   }

   818               else

   819                   {

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

   821                       SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CAPTURE );

   822                   }

   823               }

   824           }

   825         else // operation == ECamCompleting

   826           {

   827           SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

   828           }

   829 

   830         }

   831       }

   832     }

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

   834   }

   835 

   836 

   837 // ---------------------------------------------------------------------------

   838 // CCamStillPreCaptureView::SetTitlePaneTextL

   839 // Set the view's title text

   840 // ---------------------------------------------------------------------------

   841 //

   842 void CCamStillPreCaptureView::SetTitlePaneTextL()

   843     {

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

   845 #ifndef __WINS__

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

   847         {

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

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

   850         // as embedded

   851         if ( appUi->IsConstructionComplete() )

   852             {

   853             // set title to name of embedding application

   854             appUi->SetTitleEmbeddedL();

   855             }                  

   856         }

   857     else

   858 #endif   

   859         {

   860         TInt titleResourceId = R_CAM_STILL_PRE_CAPTURE_TITLE_NAME;

   861      

   862         if ( iCaptureSetupModeActive || iSceneSettingModeActive || iInfoListBoxActive )

   863             {

   864             titleResourceId = CCamCaptureSetupViewBase::SetupModeTitlePaneResourceId();

   865             }

   866 

   867         appUi->SetTitleL( titleResourceId );

   868         }

   869     }

   870 

   871 // ---------------------------------------------------------------------------

   872 // CCamStillPreCaptureView::StartViewFinder

   873 // Enter viewfinder mode

   874 // ---------------------------------------------------------------------------

   875 //

   876 void CCamStillPreCaptureView::StartViewFinder()

   877     {

   878     iController.EnterViewfinderMode( ECamControllerImage );

   879     }

   880 

   881 // ---------------------------------------------------------------------------

   882 // CCamStillPreCaptureView::StopViewFinder

   883 // Exit viewfinder mode

   884 // ---------------------------------------------------------------------------

   885 //

   886 void CCamStillPreCaptureView::StopViewFinder()

   887     {

   888     iController.ExitViewfinderMode( ECamControllerImage );

   889     }

   890     

   891 // ---------------------------------------------------------------------------

   892 // CCamStillPreCaptureView::CreateContainerL

   893 // Create container control

   894 // ---------------------------------------------------------------------------

   895 //

   896 void CCamStillPreCaptureView::CreateContainerL()

   897     {

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

   899      

   900     TRect screen;

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

   902 

   903     iContainer = CCamStillPreCaptureContainer::NewL(

   904         iController,

   905         *this,

   906         screen );

   907     iContainer->SetMopParent( this );

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

   909     }

   910 

   911 // ---------------------------------------------------------------------------

   912 // CCamStillPreCaptureView::DynInitMenuPaneL

   913 // Changes MenuPane dynamically

   914 // ---------------------------------------------------------------------------

   915 //

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

   917     {

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

   919 

   920     if ( iContainer )

   921         {

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

   923         }

   924 

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

   926 	__ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));

   927     TInt itemPos(0);

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

   929         {

   930         if ( !appUi->AlwaysDrawPreCaptureCourtesyUI() )

   931             {

   932             aMenuPane->SetItemTextL( ECamCmdToggleCourtesyUI, 

   933                                       R_CAM_CAPTURE_DISPLAY_ON_TEXT);

   934             }

   935         }

   936 

   937     // if menu pane is default still capture menu

   938     if ( aResourceId == ROID(R_CAM_STILL_PRE_CAPTURE_MENU_ID))

   939         {

   940         DynInitSwitchCameraMenuItemL( aMenuPane );

   941         }

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

   943     else if ( aResourceId == R_CAM_STANDBY_MENU )

   944         {

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

   946         aMenuPane->SetItemDimmed( ECamCmdExitStandby, ETrue );

   947         }

   948             

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

   950         {

   951         DynInitSwitchCameraMenuItemL( aMenuPane );

   952         

   953 /*#ifndef __WINS__

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

   955         if ( !appUi->IsInCallSend() )

   956 #endif

   957             {

   958             aMenuPane->SetItemDimmed( ECamCmdNewVideo, ETrue );

   959 			}*/

   960 		aMenuPane->SetItemDimmed( ECamCmdNewVideo, ETrue );	

   961         }        

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

   963         {

   964         CCamCaptureSetupViewBase::DynInitMenuPaneL( aResourceId, aMenuPane );        

   965         }

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

   967     }

   968 

   969 

   970 // ---------------------------------------------------------------------------

   971 // CCamPreCaptureViewBase::SwitchToSceneSettingModeL

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

   973 // specific control.

   974 // ---------------------------------------------------------------------------

   975 //

   976 void CCamStillPreCaptureView::SwitchToSceneSettingModeL()

   977     {

   978     if ( !iSceneSettingContainer )

   979     	{

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

   981                                                              *this,

   982                                                              ECamControllerImage,

   983                                                              iController );

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

   985     	}

   986     

   987     iSettingModeTitleResourceId = R_CAM_STILL_SCENE_SETTING_TITLE;

   988 

   989     if ( iEmbedded )

   990         {

   991         iPreviousMenuResourceId = ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID);

   992         }

   993     else

   994         {

   995         iPreviousMenuResourceId = ROID(R_CAM_STILL_PRE_CAPTURE_MENUBAR_ID);

   996         }

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

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

   999     //CCamCaptureSetupViewBase::SwitchToSceneSettingModeL();

  1000     

  1001     CCamPreCaptureViewBase::SwitchToSceneSettingModeL();

  1002   

  1003 

  1004     // only remove the capture setup menu container after 

  1005     // the switch completes successfully

  1006     RemoveCaptureSetupMenuContainers();

  1007 

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

  1009     StopViewFinder();

  1010     }

  1011 

  1012 

  1013 // ---------------------------------------------------------------------------

  1014 // CCamPreCaptureViewBase::SwitchToInfoListBoxL

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

  1016 // specific control.

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

  1018 //

  1019 void CCamStillPreCaptureView::SwitchToInfoListBoxL( TCamInfoListBoxMode aMode )

  1020     {   

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

  1022     

  1023     TBool modeSelected = EFalse;

  1024     TInt listBoxResource;

  1025     TInt summaryResource;

  1026     TInt initialValue;

  1027     TInt titleResource;

  1028     

  1029     switch( aMode )

  1030     		{

  1031     		case EInfoListBoxModeTimeLapse:	

  1032     	 			{

  1033     				// Find out whether we are in burst mode	

  1034     				TBool burstmode = EFalse;

  1035     				

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

  1037     				if ( appUi->IsBurstEnabled() )

  1038     						{

  1039         				burstmode = ETrue;

  1040         				}    

  1041     

  1042     				// Time lapse / sequence mode selector initialization values

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

  1044     				listBoxResource = R_CAM_CAPTURE_SETUP_LIST_SEQUENCE_MODE;

  1045     				summaryResource = R_CAM_CAPTURE_SETUP_LIST_SEQUENCE_MODE_SUMMARY;

  1046     				titleResource = R_CAM_TIME_LAPSE_TITLE;

  1047     				    

  1048     				modeSelected = ETrue;

  1049     				}

  1050     				break;

  1051     		

  1052 				case EInfoListBoxModeISO:

  1053     				{

  1054     				// Light sensitivity selector initialization values	

  1055     				initialValue = iController.IntegerSettingValue( ECamSettingItemDynamicPhotoLightSensitivity );	

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

  1057     				    {

  1058         				listBoxResource = R_CAM_CAPTURE_SETUP_LIST_EXTENDED_LIGHT_SENSITIVITY;

  1059         				summaryResource = R_CAM_CAPTURE_SETUP_LIST_EXTENDED_LIGHT_SENSITIVITY_SUMMARY;

  1060     				    }

  1061     				else

  1062     				    {

  1063         				listBoxResource = R_CAM_CAPTURE_SETUP_LIST_LIGHT_SENSITIVITY;

  1064         				summaryResource = R_CAM_CAPTURE_SETUP_LIST_LIGHT_SENSITIVITY_SUMMARY;

  1065     				    }

  1066     				titleResource = R_CAM_LIGHT_SENSITIVITY_TITLE;   					    				

  1067  					modeSelected = ETrue;

  1068     				}

  1069     				break;

  1070     		

  1071     		default: 

  1072     				break;

  1073 				}    					

  1074     				    	

  1075 		if( modeSelected )

  1076 				{

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

  1078                                                              		*this,                                                            

  1079                                                              		iController,

  1080                                                              		listBoxResource,

  1081                                                              		summaryResource,

  1082                                                              		initialValue, titleResource );		

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

  1084 				iInfoListBoxMode = aMode;          

  1085 				iSettingModeTitleResourceId = titleResource;                                                   					

  1086 

  1087     		if ( iEmbedded )

  1088         		{

  1089         		iPreviousMenuResourceId = ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID);

  1090         		}

  1091     		else

  1092         		{

  1093         		iPreviousMenuResourceId = ROID(R_CAM_STILL_PRE_CAPTURE_MENUBAR_ID);

  1094         		}

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

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

  1097     		CCamCaptureSetupViewBase::SwitchToInfoListBoxL( aMode );

  1098 

  1099     		// only remove the capture setup menu container after 

  1100     		// the switch completes successfully

  1101     		RemoveCaptureSetupMenuContainers();

  1102 

  1103     		// Stop the viewfinder

  1104     		StopViewFinder();    		    	        

  1105     		}

  1106     }

  1107 

  1108 

  1109 // ---------------------------------------------------------------------------

  1110 // CCamStillPreCaptureView::DoActivateL

  1111 // Activate this view

  1112 // ---------------------------------------------------------------------------

  1113 //

  1114 void CCamStillPreCaptureView::DoActivateL( const TVwsViewId& aPrevViewId, 

  1115                                           TUid aCustomMessageId,

  1116                                           const TDesC8& aCustomMessage )

  1117   {

  1118   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMSTILLPRECAPTUREVIEW_DOACTIVATEL, "e_CCamStillPreCaptureView_DoActivateL 1" );

  1119   PRINT( _L("Camera => CCamStillPreCaptureView::DoActivateL") );

  1120   PERF_EVENT_START_L2( EPerfEventStillPreCaptureViewActivation );    

  1121   // Ensure the correct menu is used for the current mode.

  1122 

  1123   // If we are coming back from settings plugin wait for the sequence to complete

  1124     // during that time, update the softkey with BLANK_EXIT softkey

  1125     if ( TUid::Uid ( EAknSoftkeyBack ) == aCustomMessageId )

  1126       {

  1127       iSoftkeyBlankIsNeeded = ETrue;

  1128       }

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

  1130   

  1131   // fixed toolbar is used only with touch devices

  1132   if ( iController.IsTouchScreenSupported() )

  1133       {

  1134       if ( appUi && appUi->IsEmbedded() )