diff -r 000000000000 -r 1ddebce53859 camerauis/cameraapp/generic/src/CamVideoPreCaptureView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/src/CamVideoPreCaptureView.cpp Thu Jan 07 16:18:56 2010 +0200 @@ -0,0 +1,1586 @@ +/* +* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Video pre-capture view class for Camera application* +*/ + + +// INCLUDE FILES + + +#include "CamUtility.h" +#include "CamAppUiBase.h" +#include "CamAppController.h" +#include "CamVideoPreCaptureView.h" +#include "CamLogger.h" +#include "CamContainerBase.h" +#include "CamAppUi.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "CamCaptureSetupMenu.h" +#include "CamPanic.h" + +#include "CamShootingModeContainer.h" +#include "CamVideoPreCaptureContainer.h" +#include "Cam.hrh" +#include "CamAppUid.h" +#include +#include +#include +#include "CamUtility.h" +#include "camactivepalettehandler.h" +#include "CameraUiConfigManager.h" +#include "CamLocalViewIds.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "CamVideoPreCaptureViewTraces.h" +#endif + + + + +// ========================= MEMBER FUNCTIONS ================================ +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::NewLC +// Symbian OS two-phased constructor +// --------------------------------------------------------------------------- +// +CCamVideoPreCaptureView* CCamVideoPreCaptureView::NewLC( CCamAppController& aController ) + { + CCamVideoPreCaptureView* self = + new( ELeave ) CCamVideoPreCaptureView( aController ); + + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView destructor +// +// --------------------------------------------------------------------------- +// +CCamVideoPreCaptureView::~CCamVideoPreCaptureView() + { + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::Id +// Returns UID of view +// --------------------------------------------------------------------------- +// +TUid CCamVideoPreCaptureView::Id() const + { + return TUid::Uid( ECamViewIdVideoPreCapture ); + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::DoDeactivate +// Deactivate this view +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::DoDeactivate() + { + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMVIDEOPRECAPTUREVIEW_DODEACTIVATE, "e_CCamVideoPreCaptureView_DoDeactivate 1" ); + PERF_EVENT_START_L2( EPerfEventVideoPreCaptureViewDeactivation ); + CCamPreCaptureViewBase::DoDeactivate(); + PERF_EVENT_END_L2( EPerfEventVideoPreCaptureViewDeactivation ); + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMVIDEOPRECAPTUREVIEW_DODEACTIVATE, "e_CCamVideoPreCaptureView_DoDeactivate 0" ); + } + +// ----------------------------------------------------------------------------- +// CCamVideoPreCaptureView::HandleCommandL +// Handle commands +// ----------------------------------------------------------------------------- +// +void +CCamVideoPreCaptureView::HandleCommandL( TInt aCommand ) + { + PRINT( _L("Camera => CCamVideoPreCaptureView::HandleCommandL") ); + // check our current operation state + TCamCaptureOperation operation = iController.CurrentVideoOperation(); + CCamAppUi* appUi = static_cast( iEikonEnv->AppUi() ); + TCamOrientation orientation = appUi->CamOrientation(); + switch ( aCommand ) + { + case ECamMSKCmdSelect: + case ECamMSKCmdAppRecord: + { + if( orientation == ECamOrientationCamcorder || + orientation == ECamOrientationCamcorderLeft || + orientation == ECamOrientationPortrait ) + { + if ( !StartMskCaptureL() ) + { + // If in the Landscape mode, MSK event is mapped + // like a normal selection key so that AP items + // are selected and respective setting pages are launched + TKeyEvent aKeyEvent; + aKeyEvent.iCode = aKeyEvent.iRepeats = aKeyEvent.iModifiers = 0; + aKeyEvent.iScanCode = EStdKeyDevice3; + static_cast + ( Container() )->OfferKeyEventL( aKeyEvent, EEventKey ); + } + } + else if ( aCommand == ECamMSKCmdAppRecord ) + // if the Camera in the Portrait mode + // MSK event is handled like a capture key + { + if ( iController.IsViewFinding() && appUi->CheckMemoryL() ) + { + iController.StartVideoRecordingL(); + // fixed toolbar is used only with touch devices + if ( iController.IsTouchScreenSupported() ) + { + CAknToolbar* fixedToolbar = Toolbar(); + if ( fixedToolbar ) + { + fixedToolbar->SetToolbarVisibility( EFalse ); + } + } + } + } + break; + } + case ECamCmdRecord: + { + TInt callType( EPSCTsyCallTypeUninitialized ); + RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType, callType ); + if ( callType != EPSCTsyCallTypeH324Multimedia && iController.IsViewFinding() && appUi->CheckMemoryL() ) + { + SetSoftKeysL( R_CAM_SOFTKEYS_BLANK ); + appUi->SetLensCoverExit( EFalse ); + iController.StartVideoRecordingL(); + // fixed toolbar is used only with touch devices + if ( iController.IsTouchScreenSupported() ) + { + CAknToolbar* fixedToolbar = Toolbar(); + if ( fixedToolbar ) + { + fixedToolbar->SetToolbarVisibility( EFalse ); + } + } + } + break; + } + + case EAknSoftkeySelect: + { + switch( operation ) + { + // ------------------------- + case ECamNoOperation: + { + if ( !iController.VideoRecordPending() ) + { + CCamPreCaptureViewBase::HandleCommandL( aCommand ); + } + break; + } + // ------------------------- + // ...Otherwise, if we are in video recording or paused mode + // ...then stop the recording. + case ECamCapturing: + case ECamPaused: + { + iController.StopVideoRecording(); + break; + } + // ------------------------- + default: + break; + // ------------------------- + } + break; + } + // --------------------------------------------------- + case ECamCmdPause: + { + iController.PauseVideoRecording(); + break; + } + // --------------------------------------------------- + case ECamCmdContinue: + { + iController.ContinueVideoRecording(); + break; + } + // --------------------------------------------------- + case ECamCmdShootSetup: + { + // If currently recording or paused recording then don't + // popup the capture setup menu. + if ( ECamPaused == operation + || ECamCapturing == operation ) + { + return; + } + // Otherwise popup the capture setup menu + else + { + CCamPreCaptureViewBase::HandleCommandL( aCommand ); + } + break; + } + // --------------------------------------------------- + case ECamCmdGoToStandby: + { + PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleCommandL: case ECamCmdGoToStandby") ); + + //PRINT1( _L("Camera => CCamVideoPreCaptureView::HandleCommandL standby error (%d)"), iStandbyError) + //SwitchToStandbyModeL( ECamViewIdVideoPreCapture, iStandbyError ); + SwitchToStandbyModeL( ECamViewIdVideoPreCapture, appUi->StandbyStatus() ); + break; + } + // --------------------------------------------------- + case ECamCmdExitStandby: + { + PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleCommandL: case ECamCmdExitStandby") ); + ExitStandbyModeL(); + break; + } + // --------------------------------------------------- + case ECamCmdMute: + { + MuteEmbeddedAudioL( ETrue ); + break; + } + // --------------------------------------------------- + case ECamCmdUnmute: + { + MuteEmbeddedAudioL( EFalse ); + break; + } + // --------------------------------------------------- + case ECamCmdStop: + { + CCamAppUi* appUi = static_cast( AppUi() ); + appUi->EndCapture(); + break; + } + // --------------------------------------------------- + case ECamCmdToggleVideoFlash: + { + if ( iController.UiConfigManagerPtr()->IsVideoLightSupported() ) + { + TCamFlashId flash = static_cast< TCamFlashId > + ( iController.IntegerSettingValue( ECamSettingItemDynamicVideoFlash ) ); + if( flash == ECamFlashForced ) + { + flash = ECamFlashOff; + } + else + { + flash = ECamFlashForced; + } + iController.SetIntegerSettingValueL(ECamSettingItemDynamicVideoFlash, flash); + + CCamAppUi* appUi = static_cast( AppUi() ); + if ( appUi && + appUi->APHandler() && + ( appUi->CamOrientation() == ECamOrientationCamcorder || appUi->CamOrientation() == ECamOrientationCamcorderLeft ) ) + { + appUi->APHandler()->UpdateActivePaletteL(); + } + } + UpdateToolbarIconsL(); + break; + } + // --------------------------------------------------- + default: + { + CCamPreCaptureViewBase::HandleCommandL( aCommand ); + break; + } + // --------------------------------------------------- + } + + PRINT( _L("Camera <= CCamVideoPreCaptureView::HandleCommandL") ); + } + +// ----------------------------------------------------------------------------- +// CCamVideoPreCaptureView::HandleForegroundEventL +// Handle foreground event +// ----------------------------------------------------------------------------- +// +void +CCamVideoPreCaptureView::HandleForegroundEventL( TBool aForeground ) + { + PRINT1( _L( "Camera => CCamVideoPreCaptureView::HandleForegroundEventL %d" ), aForeground ); + + CCamAppUi* appUi = static_cast( AppUi() ); + + // ------------------------------------------------------- + // reset menu and cba as appropriate + if( aForeground ) + { + // ignore event if received in postcapture or if uiorientationoverride + // is supported and going to stillmode + if ( ECamViewStatePostCapture == appUi->CurrentViewState() || + ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() && + appUi->TargetMode() == ECamControllerImage ) ) + { + return; + } + + if ( appUi->IsInPretendExit() ) + { + // The view can get a foreground event while the application is + // actually in a pretend exit situation. This occurs when the view switch + // was called before the exit event, but didn't complete until after the + // exit event. In this case the view should not register an interest in + // the engine as the application is really in the background and the resources + // need to be released + PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleForegroundEventL, in pretend exit" ) ); + return; + } + // if foreground event is received while in videocall, go to standby with error + if ( iController.InVideocallOrRinging() && ECamNoOperation == iController.CurrentOperation() ) + { + ExitAllModesL(); + appUi->SetStandbyStatus( KErrInUse ); + appUi->HandleCommandL( ECamCmdGoToStandby ); + SetTitlePaneTextL(); + return; + } + + // make sure CBA is correct + UpdateCbaL(); + + // check for silent profile whenever we come to foreground, we dont need it here, + // but we keep track of this in appcontroller. + iController.IsProfileSilent(); + + // set embedded flag here + iEmbedded = appUi->IsEmbedded(); + PRINT1( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL - iEmbedded:%d"), iEmbedded ); + + // update menu bar as required + SetMenuBar(); + + // if video is currently saving, it can be in either of the states: + // ECamVideoRecordInProgress orECamVideoRecordPaused + // but the recording has already been stopped + if ( iController.CurrentlySavingVideo() ) + { + UpdateCbaL(); + // if the app was behind an eikon server window then the resources + // were not released. + if ( iContinueInBackground ) + { + iContinueInBackground = EFalse; + PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleForegroundEvent, returned behind notification" ) ); + return; + } + + // Register that we want to use the engine + IncrementCameraUsers(); + PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleForegroundEvent, waiting for postcapture" ) ); + return; + } + + } + // ------------------------------------------------------- + // if going to the background, stop any current video recording + // unless already saving or it is only an eikon server window + else + { + TCamCaptureOperation operation( iController.CurrentVideoOperation() ); + + PRINT1( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL - operation=%d"), operation ); + if( !iController.CurrentlySavingVideo() && + ( ( ECamCapturing == operation || ECamPaused == operation ) + && appUi->AppInBackground( EFalse ) + || ( iController.UiConfigManagerPtr()->IsKeyLockWatcherSupported() && iController.IsKeyLockOn() ) ) ) + { + PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL stopping video") ); + // If the video stops for an active call then inform the controller + // this info is needed so that the stop tone isn't played + if ( appUi->ForegroundAppIsPhoneApp() ) + { + PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL SetVideoStoppedForPhoneApp") ); + iController.SetVideoStoppedForPhoneApp( ETrue ); + } + + // If AknCapServer has NOT got foreground, (which would possibly + // indicate a "charging" note) stop video recording + iController.StopVideoRecording(); + // reset the stopped for call flag + iController.SetVideoStoppedForPhoneApp( EFalse ); + } + + /* + const TInt KWindowGroupId( iCoeEnv->WsSession().GetFocusWindowGroup() ); + TCamCaptureOperation operation( iController.CurrentVideoOperation() ); + + if ( KWindowGroupId != iEikonServerWindowGroupId + && KWindowGroupId != iBTServerWindowGroupId + && ( ECamCapturing == operation + || ECamPaused == operation ) ) + { + if ( !CamUtility::IdMatchesName( KWindowGroupId, KAknCapServer ) ) + { + // If the video stops for an active call then inform the controller + // this info is needed so that the stop tone isn't played + if ( appUi->ForegroundAppIsPhoneApp() ) + { + iController.SetVideoStoppedForPhoneApp( ETrue ); + } + + // If AknCapServer has NOT got foreground, (which would possibly + // indicate a "charging" note) stop video recording + iController.StopVideoRecording(); + // reset the stopped for call flag + iController.SetVideoStoppedForPhoneApp( EFalse ); + } + } + */ + } + // ------------------------------------------------------- + + CCamPreCaptureViewBase::HandleForegroundEventL( aForeground ); + + PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleForegroundEventL" ) ); + } + +// ----------------------------------------------------------------------------- +// CCamVideoPreCaptureView::HandleFocusLossL +// Handle change of focus +// ----------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::HandleFocusLossL() + { + PRINT( _L( "Camera => CCamVideoPreCaptureView::HandleFocusLossL" ) ); + // if the application was already in the background, but behind an + // eikon server window, then handle backgrounding properly now. + // Otherwise the backgrounding will be handled in the normal + // HandleForeground() method. + if ( iContinueInBackground ) + { + const TCamCaptureOperation operation( iController.CurrentOperation() ); + if ( ECamCapturing == operation + || ECamPaused == operation ) + { + iController.StopVideoRecording(); + } + } + CCamPreCaptureViewBase::HandleFocusLossL(); + PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleFocusLossL" ) ); + } + +// ----------------------------------------------------------------------------- +// CCamVideoPreCaptureView::HandleControllerEventL +// Handle controller events +// ----------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::HandleControllerEventL( TCamControllerEvent aEvent, + TInt aError ) + { + PRINT2( _L("Camera => CCamVideoPreCaptureView::HandleControllerEventL event (%d) error (%d)"), aEvent, aError ); + switch( aEvent ) + { + // ----------------------------------------------------- + // If the recording state of the camera has changed (started/paused/stopped) + // we may need to update the CBA labels + case ECamEventOperationStateChanged: + { + if( iController.IsAppUiAvailable() ) + { + const TCamCaptureOperation operation( iController.CurrentOperation() ); + if ( ECamCapturing == operation ) + { + const TCamOrientation camOrientation = + static_cast( AppUi() )->CamOrientation(); + // if in camcorder mode need to show navi-ctr + if( ECamOrientationCamcorder == camOrientation + || ECamOrientationCamcorderLeft == camOrientation + || ECamOrientationPortrait == camOrientation ) + { + iContainer->SetupNaviPanesL( CCamContainerBase::ECamPaneProgress ); + } + else + { + static_cast( AppUi() )->PushNaviPaneProgressBarL(); + } + } + else if ( ECamCompleting == operation ) + { + iContainer->SetupNaviPanesL( CCamContainerBase::ECamPaneCounter ); + } + else + { + // empty else statement to remove LINT error + } + UpdateCbaL(); + } + break; + } + // ----------------------------------------------------- + case ECamEventRecordComplete: + { + static_cast( AppUi() )->PushNaviPaneCounterL(); + // if the recording failed due to a problem with the MMC + if ( KErrNone != aError + && iController.IntegerSettingValue( ECamSettingItemVideoMediaStorage ) + == ECamMediaStorageCard + && CamUtility::MemoryCardStatus() != ECamMemoryCardInserted ) + { + StopViewFinder(); + StartViewFinder(); + } + if ( static_cast( AppUi() )->ShowPostCaptureView() == EFalse + && !iController.IsCaptureStoppedForUsb() ) + { + // fixed toolbar is used only with touch devices + if ( iController.IsTouchScreenSupported() ) + { + CAknToolbar* toolbar = Toolbar(); + if ( toolbar ) + { + toolbar->SetToolbarVisibility( ETrue ); + } + } + } + + if ( iController.IsCaptureStoppedForUsb() ) + { + iContainer->SetupNaviPanesL( CCamContainerBase::ECamPaneCounter ); + } + + if ( EFalse == static_cast( AppUi() )->ShowPostCaptureView() ) + { + // Vf was stopped when stopping video recording, need to restart here + // if postcapture is off. + StartViewFinder(); + } + break; + } + // ----------------------------------------------------- + case ECamEventEngineStateChanged: + { + CCamPreCaptureViewBase::HandleControllerEventL( aEvent, aError ); + break; + } + // ----------------------------------------------------- + case ECamEventSliderOpen: + { + iController.StartViewFinder(); + break; + } + default: + { + // Other events ignored + break; + } + // ----------------------------------------------------- + } + PRINT ( _L("Camera <= CCamVideoPreCaptureView::HandleControllerEventL") ); + } + + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::CCamVideoPreCaptureView +// C++ constructor +// --------------------------------------------------------------------------- +// +CCamVideoPreCaptureView::CCamVideoPreCaptureView( CCamAppController& aController ) + : CCamPreCaptureViewBase( aController ) + { + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::ConstructL +// Symbian OS 2nd phase constructor +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::ConstructL() + { + BaseConstructL( ROID(R_CAM_VIDEO_PRE_CAPTURE_VIEW_ID)); + if(iController.UiConfigManagerPtr()->IsXenonFlashSupported()) + { + CreateAndSetToolbarL(R_CAM_VIDEO_PRECAPTURE_TOOLBAR); + UpdateToolbarIconsL(); + } + else + { + CreateAndSetToolbarL(R_CAM_VIDEO_PRECAPTURE_TOOLBAR_VIDEOLIGHT); + } + CCamPreCaptureViewBase::ConstructL(); + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::UpdateCbaL +// Update softkeys to reflect current state +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::UpdateCbaL() + { + PRINT( _L("Camera => CCamVideoPreCaptureView::UpdateCbaL") ); + + CCamAppUi* appui = static_cast( AppUi() ); + + // if videocall is active, set the softkeys already here + if ( iController.InVideocallOrRinging() ) + { + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT ); + } + // if the view is in capture setup menu mode + if ( iCaptureSetupMenuModeActive + && !iCaptureSetupModeActive + && !iSceneSettingModeActive ) + { + SetSoftKeysL( R_AVKON_SOFTKEYS_SELECT_BACK ); + } + // if the view is in capture setup mode + else if ( iCaptureSetupModeActive ) + { + SetSoftKeysL( R_AVKON_SOFTKEYS_OK_CANCEL__OK ); + } + // if the view is in scene settings mode + else if ( iSceneSettingModeActive ) + { + // R_AVKON_SOFTKEYS_OPTIONS_BACK + SetSoftKeysL( R_CAM_SOFTKEYS_SETTINGS_SELECT_BACK__CHANGE ); //R_CAM_SOFTKEYS_OPTIONS_BACK__CHANGE ); + } + else if ( iStandbyModeActive ) + { + if( KErrNone == appui->StandbyStatus() ) + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CONTINUE ); + else + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT ); + } + + else // otherwise, show the default softkeys + { + switch ( iController.CurrentVideoOperation() ) + { + // ------------------------------- + case ECamCapturing: + { + if(appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera()) + { + SetSoftKeysL( R_CAM_SOFTKEYS_PAUSE_STOP_SECONDARY ); + } + else + { + SetSoftKeysL( R_CAM_SOFTKEYS_PAUSE_STOP ); + } + break; + } + // ------------------------------- + case ECamPaused: + { + if(appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera()) + { + SetSoftKeysL( R_CAM_SOFTKEYS_CONTINUE_STOP_SECONDARY ); + } + else + { + SetSoftKeysL( R_CAM_SOFTKEYS_CONTINUE_STOP ); + } + break; + } + // ------------------------------- + case ECamNoOperation: + { + if ( iController.CaptureModeTransitionInProgress() ) + { + if(iEmbedded ) + { + if(appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera()) + { + SetSoftKeysL(R_CAM_SOFTKEYS_BACK_SECONDARY); + } + else + { + SetSoftKeysL(R_CAM_SOFTKEYS_BACK); + } + } + else + { + if(appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera()) + { + SetSoftKeysL(R_CAM_SOFTKEYS_BLANK_EXIT_SECONDARY); + } + else + { + SetSoftKeysL(R_CAM_SOFTKEYS_BLANK_EXIT); + } + } + } + else + { + if ( appui->TargetViewState() != ECamViewStatePostCapture ) + { + if ( iEmbedded ) + { + if(appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera()) + { + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__RECORD_SECONDARY ); + } + else + { + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__RECORD ); + } + + } + else + { + if ( !appui->IsToolBarVisible() + && appui->IsSecondCameraEnabled() + && !appui->IsQwerty2ndCamera()) + { + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__RECORD_TXT ); + } + else if ( appui->DrawPreCaptureCourtesyUI() ) + { + if(appui->IsSecondCameraEnabled() && !appui->IsQwerty2ndCamera()) + { + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__RECORD_SECONDARY ); + } + else + { + SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__RECORD ); + } + } + else + { + SetSoftKeysL( R_CAM_SOFTKEYS_BLANK ); + } + } + } + } + break; + } + // ------------------------------- + case ECamCompleting: + { + if ( iController.IntegerSettingValue( ECamSettingItemVideoShowCapturedVideo ) == ECamSettOn && + !iController.IsCaptureStoppedForUsb() && appui->TargetViewState() == ECamViewStatePostCapture ) + { + //We need to blank the precapture view CBA here to prevent + //blinking when changing back to precapture from postcapture. + SetSoftKeysL( R_CAM_SOFTKEYS_BLANK ); + } + break; + } + // ------------------------------- + default: + { + // do nothing + break; + } + // ------------------------------- + } + } + PRINT( _L("Camera <= CCamVideoPreCaptureView::UpdateCbaL") ); + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::SetTitlePaneTextL +// Set the view's title text +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::SetTitlePaneTextL() + { + CCamAppUi* appUi = static_cast( AppUi() ); +#ifndef __WINS__ + if ( iEmbedded /*&& !appUi->IsInCallSend()*/ ) + { + // only set the title if the construction is complete + // otherwise the application is not yet set up correctly + // as embedded + if ( appUi->IsConstructionComplete() ) + { + // set title to name of embedding application + appUi->SetTitleEmbeddedL(); + } + } + else +#endif + { + TInt titleResourceId = R_CAM_VIDEO_PRE_CAPTURE_TITLE_NAME; + + if ( iCaptureSetupModeActive || iSceneSettingModeActive ) + { + titleResourceId = CCamCaptureSetupViewBase::SetupModeTitlePaneResourceId(); + } + + appUi->SetTitleL( titleResourceId ); + } + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::StartViewFinder +// Enter viewfinder mode +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::StartViewFinder() + { + iController.EnterViewfinderMode( ECamControllerVideo ); + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::StopViewFinder +// Exit viewfinder mode +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::StopViewFinder() + { + iController.ExitViewfinderMode( ECamControllerVideo ); + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::CreateContainerL +// Create container control +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::CreateContainerL() + { + TRect screen; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screen ); + + iContainer = CCamVideoPreCaptureContainer::NewL( + iController, + *this, + screen ); + + iContainer->SetMopParent( this ); + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::DynInitMenuPaneL +// Changes MenuPane dynamically +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane ) + { + PRINT( _L("Camera => CCamVideoPreCaptureView::DynInitMenuPaneL" )); + + if ( iContainer ) + { + iContainer->Window().SetNonFading( ETrue ); + } + + CCamAppUi* appUi = static_cast( AppUi() ); + __ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer)); + TInt itemPos(0); + if( aMenuPane->MenuItemExists(ECamCmdToggleCourtesyUI, itemPos) ) + { + if ( !appUi->AlwaysDrawPreCaptureCourtesyUI() ) + { + aMenuPane->SetItemTextL( ECamCmdToggleCourtesyUI, + R_CAM_CAPTURE_DISPLAY_ON_TEXT); + } + } + +// if ( aResourceId == R_CAM_STANDBY_MENU && iStandbyError != KErrNone ) + if ( aResourceId == R_CAM_STANDBY_MENU && appUi->StandbyStatus() != KErrNone ) + { + aMenuPane->SetItemDimmed( ECamCmdExitStandby, ETrue ); + } + else if ( aResourceId == ROID(R_CAM_VIDEO_PRE_CAPTURE_MENU_ID)) + { + DynInitSwitchCameraMenuItemL( aMenuPane ); + } + else // otherwise, not in burst mode or menu pane is not default + { + // if embedded video set mute/unmute option appropriately, and set up + // Switch camera item + if( aResourceId == ROID(R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENU_ID)) + { + DynInitSwitchCameraMenuItemL( aMenuPane ); + iAudioEnabled = iController.IntegerSettingValue( ECamSettingItemVideoAudioRec ); + // if audio off replace mute with unmute + if( iAudioEnabled == ECamSettOff ) + { + aMenuPane->SetItemDimmed( ECamCmdMute, ETrue ); + aMenuPane->SetItemDimmed( ECamCmdUnmute, EFalse ); + } + else + { + aMenuPane->SetItemDimmed( ECamCmdMute, EFalse ); + aMenuPane->SetItemDimmed( ECamCmdUnmute, ETrue ); + } +/*#ifndef __WINS__ + // if embedded and not in in-call send + if ( !appUi->IsInCallSend() ) +#endif*/ + // { + aMenuPane->SetItemDimmed( ECamCmdNewPhoto, ETrue ); + // } + } + + CCamCaptureSetupViewBase::DynInitMenuPaneL( aResourceId, aMenuPane ); + } + PRINT( _L("Camera <= CCamVideoPreCaptureView::DynInitMenuPaneL" )) + } + + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::CreateCaptureSetupMenuL +// Creates a video capture setup menu +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::CreateCaptureSetupMenuL() + { + TInt resource; + // check if we are Western or Arabic/Hebrew layout + if ( !AknLayoutUtils::LayoutMirrored() ) + { + if( AknLayoutUtils::Variant() == EApacVariant ) + { + resource = ROID(R_CAM_CAPTURE_SETUP_MENU_VIDEO_DATA_APAC_ID); + } + else + { + // use Western resource + resource = ROID(R_CAM_CAPTURE_SETUP_MENU_VIDEO_DATA_ID); + } + } + else + { + resource = ROID(R_CAM_CAPTURE_SETUP_MENU_VIDEO_DATA_AH_ID); + } + + // Use capture setup menu for second camera + if ( static_cast( AppUi() )->IsSecondCameraEnabled() ) + { + resource = ROID(R_CAM_CAPTURE_SETUP_MENU_VIDEO_DATA_ID); + } + + iCaptureSetupMenuContainer = + CCamCaptureSetupMenu::NewL( iController, *this, AppUi()->ClientRect(), + resource, iCaptureSetupMenuLastItemIndex ); + + } + +// --------------------------------------------------------------------------- +// CCamPreCaptureViewBase::SwitchToSceneSettingModeL +// Switches the current mode to scene setting and activates a +// specific control. +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::SwitchToSceneSettingModeL() + { + if ( !iSceneSettingContainer ) + { + // Create the scene setting container for video mode. + iSceneSettingContainer = CCamShootingModeContainer::NewL( AppUi()->ApplicationRect(), + *this, + ECamControllerVideo, + iController ); + iSceneSettingContainer->DrawableWindow()->SetOrdinalPosition(-1); + } + + iSettingModeTitleResourceId = R_CAM_VIDEO_SCENE_SETTING_TITLE; + + if ( iEmbedded ) + { + iPreviousMenuResourceId = ROID(R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENUBAR_ID); + } + else + { + iPreviousMenuResourceId = ROID(R_CAM_VIDEO_PRE_CAPTURE_MENUBAR_ID); + } + // Remove the view's main container, and add the capture setup + // control associated with the input command to the container stack. + CCamCaptureSetupViewBase::SwitchToSceneSettingModeL(); + + // only remove the capture setup menu container after + // the switch completes successfully + RemoveCaptureSetupMenuContainers(); + + // Stop the viewfinder as it isn't required for scene settings + StopViewFinder(); + + } + + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::DoActivateL +// Activate this view +// --------------------------------------------------------------------------- +// +void +CCamVideoPreCaptureView::DoActivateL( const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage ) + { + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMVIDEOPRECAPTUREVIEW_DOACTIVATEL, "e_CCamVideoPreCaptureView_DoActivateL 1" ); + PRINT( _L("Camera => CCamVideoPreCaptureView::DoActivateL") ); + PERF_EVENT_START_L2( EPerfEventVideoPreCaptureViewActivation ); + // Ensure the correct menu is used for the current mode. + CCamAppUi* appUi = static_cast( AppUi() ); + + // fixed toolbar is used only with touch devices + if ( iController.IsTouchScreenSupported() ) + { + if ( appUi->IsEmbedded() ) + { + CAknToolbar* toolbar = Toolbar(); + toolbar->SetToolbarVisibility(EFalse); + } + } + else + { + // handled in CamPreCaptureViewBase + } + + // Check if view is activated internally or externally + TUid appUid = aPrevViewId.iAppUid; + if( appUid != appUi->Application()->AppDllUid() ) + { + // set capture mode + appUi->SetCaptureMode( ECamControllerVideo ); + } + + SetMenuBar(); + + CCamPreCaptureViewBase::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage ); + + PERF_EVENT_END_L2( EPerfEventVideoPreCaptureViewActivation ); + PRINT( _L("Camera <= CCamVideoPreCaptureView::DoActivateL") ); + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMVIDEOPRECAPTUREVIEW_DOACTIVATEL, "e_CCamVideoPreCaptureView_DoActivateL 0" ); + } + +// --------------------------------------------------------------------------- +// SetMenuBar <> +// --------------------------------------------------------------------------- +// +void +CCamVideoPreCaptureView::SetMenuBar() + { + PRINT( _L("Camera => CCamVideoPreCaptureView::SetMenuBar") ); + CEikMenuBar* menuBar = MenuBar(); + if ( menuBar ) + { + if ( iStandbyModeActive ) + { + PRINT( _L("Camera <> CCamVideoPreCaptureView::SetMenuBar: setting standby menubar..") ); + menuBar->SetMenuTitleResourceId( R_CAM_STANDBY_MENUBAR ); + } + else if ( iEmbedded ) + { + PRINT( _L("Camera <> CCamVideoPreCaptureView::SetMenuBar: setting menu resource to R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENUBAR_ID") ); + menuBar->SetMenuTitleResourceId( ROID(R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENUBAR_ID)); + } + else + { + PRINT( _L("Camera <> CCamVideoPreCaptureView::SetMenuBar: setting menu resource to R_CAM_VIDEO_PRE_CAPTURE_MENUBAR_ID") ); + menuBar->SetMenuTitleResourceId( ROID(R_CAM_VIDEO_PRE_CAPTURE_MENUBAR_ID) ); + } + } + PRINT( _L("Camera <= CCamVideoPreCaptureView::SetMenuBar") ); + } + + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::GetHelpContext +// Called to identify the help context for this view +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::GetHelpContext( TCoeHelpContext& aContext ) const + { + aContext.iMajor = TUid::Uid( KCameraappUID ); + + // First check to see if the scene settings list is open + if ( iSceneSettingModeActive ) + { + aContext.iContext = KLCAM_HLP_SCENES_VIDEO; + } + // Else check for standby mode + else if ( iStandbyModeActive ) + { + // Also check to see if this is embedded standby + if ( iEmbedded ) + { + aContext.iContext = KLCAM_HLP_STANDYBY_EM; + } + else + { + aContext.iContext = KLCAM_HLP_STANDYBY_EM; + } + } + // Else check for embedded mode + else if ( iEmbedded ) + { + aContext.iContext = KLCAM_HLP_VIEWFINDER_VIDEO_EM; + } + // Else this is the plain photo viewfinder + else + { + aContext.iContext = KLCAM_HLP_VIEWFINDER_VIDEO; + } + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::MuteEmbeddedAudioL +// Mute or unmute audio for embedded video +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::MuteEmbeddedAudioL( TBool aMuteAudio ) + { + if( aMuteAudio ) + { + iController.SetIntegerSettingValueL( ECamSettingItemVideoAudioRec, ECamSettOff ); + } + else + { + iController.SetIntegerSettingValueL( ECamSettingItemVideoAudioRec, ECamSettOn ); + } + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::DynInitToolbarL +// Dynamically initialize toolbar contents +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::DynInitToolbarL( TInt aResourceId, + CAknToolbar* aToolbar ) + { + PRINT2( _L("Camera => CCamVideoPreCaptureView::DynInitToolbarL(%d, 0x%X)" ), aResourceId, aToolbar ) + (void)aResourceId; // remove compiler warning + + CCamAppUi* appUi = static_cast( AppUi() ); + + iController.StartIdleTimer(); + // fixed toolbar is used only with touch devices + if ( iController.IsTouchScreenSupported() ) + { + UpdateToolbarIconsL(); + if( aToolbar ) + { + if ( iEmbedded && appUi->IsSecondCameraEnabled() ) + { + aToolbar->SetItemDimmed(ECamCmdNewPhoto, ETrue, ETrue); + } + CAknToolbarExtension* extension = aToolbar->ToolbarExtension(); + if( extension ) + { + if ( iEmbedded ) + { + extension->HideItemL( ECamCmdNewPhoto, ETrue ); + extension->HideItemL( ECamCmdPhotos, ETrue ); + } + else + { + extension->HideItemL( ECamCmdNewPhoto, EFalse ); + extension->HideItemL( ECamCmdPhotos, EFalse ); + } + if(aResourceId == ECamCmdToolbarExtension) + { + appUi->ZoomPane()->MakeVisible(EFalse,ETrue); + } + } + } + } + + + PRINT2( _L("Camera <= CCamVideoPreCaptureView::DynInitToolbarL(%d, 0x%X)" ), aResourceId, aToolbar ) + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::UpdateToolbarIconsL +// Update fixed toolbar icons according to current settings +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::UpdateToolbarIconsL() + { + // fixed toolbar is used only with touch devices + if (!iController.IsTouchScreenSupported() ) + return; + UpdateVideoFlashIconsL(); + UpdateVideoSceneModeIconsL(); + UpdateVideoColorToneIconsL(); + UpdateVideoWhitebalanceIconsL(); + RedrawToolBar(); + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::OfferToolbarEventL +// Handle commands from toolbar +// --------------------------------------------------------------------------- +// +void CCamVideoPreCaptureView::OfferToolbarEventL( TInt aCommand ) + { + PRINT1( _L("Camera => CCamVideoPreCaptureView::OfferToolbarEventL(%d)" ), aCommand ); + + iController.StartIdleTimer(); + // fixed toolbar is used only with touch devices + if ( iController.IsTouchScreenSupported() ) + { + CCamPreCaptureViewBase::OfferToolbarEventL( aCommand ); + + + // Redraw video light button + CAknToolbar* toolbar = Toolbar(); + if ( aCommand == ECamCmdToggleVideoFlash && + toolbar ) + { + CAknButton* button = static_cast( + toolbar->ControlOrNull( aCommand ) ); + if ( button ) + { + button->DrawDeferred(); + } + } + } + + PRINT1( _L("Camera <= CCamVideoPreCaptureView::OfferToolbarEventL(%d)" ), aCommand ); + } + + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::StartMskCapture() +// Try to start the capture with MSK command. Return true if started. +// --------------------------------------------------------------------------- +// +TBool CCamVideoPreCaptureView::StartMskCaptureL() + { + CCamAppUi* appUi = static_cast( iEikonEnv->AppUi() ); + TCamOrientation orientation = appUi->CamOrientation(); + TBool startedCapture(EFalse); + if( orientation == ECamOrientationCamcorder || + orientation == ECamOrientationCamcorderLeft || + orientation == ECamOrientationPortrait ) + { + if ( appUi && !appUi->IsToolBarVisible() + && iController.UiConfigManagerPtr() + && !iController.UiConfigManagerPtr()->IsOpticalJoyStickSupported() ) + { + // In case of MSK if no AP on screen, it should work as record + // If optical joystic is not available, we will start the + // recording here. Otherwise it is handled + // in CCamVideoPreCaptureContainer + TInt callType( EPSCTsyCallTypeUninitialized ); + RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType, callType ); + if ( callType != EPSCTsyCallTypeH324Multimedia && iController.IsViewFinding() && appUi->CheckMemoryL() ) + { + SetSoftKeysL( R_CAM_SOFTKEYS_BLANK ); + iController.StartVideoRecordingL(); + startedCapture = ETrue; + // fixed toolbar is used only with touch devices + if ( iController.IsTouchScreenSupported() ) + { + CAknToolbar* fixedToolbar = Toolbar(); + if ( fixedToolbar ) + { + fixedToolbar->SetToolbarVisibility( EFalse ); + } + } + } + } + // else let the calling function take care of capturing + } + return startedCapture; + } + + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::UpdateVideoFlashIconsL() +// --------------------------------------------------------------------------- +// + void CCamVideoPreCaptureView::UpdateVideoFlashIconsL() + { + CAknButton* button = ToolbarButtonById(ECamCmdToggleVideoFlash); + if(!button) + return; + MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); + TFileName iconFileName; + CamUtility::ResourceFileName( iconFileName ); + TCamFlashId flash = static_cast< TCamFlashId > + ( iController.IntegerSettingValue( + ECamSettingItemDynamicVideoFlash ) ); + + CAknButtonState* state = button->State(); + if ( state ) + { + switch ( flash ) + { + case ECamFlashOff: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_tb_light_off, + EMbmCameraappQgn_indi_cam4_tb_light_off_mask, + skinInstance, + KAknsIIDQgnIndiCam4TbLightOff ); + HBufC* tooltipText = + StringLoader::LoadLC( R_QTN_LCAM_TT_VIDEOFLASH ); + state->SetHelpTextL( *tooltipText ); + CleanupStack::PopAndDestroy( tooltipText ); + break; + } + case ECamFlashForced: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_tb_light, + EMbmCameraappQgn_indi_cam4_tb_light_mask, + skinInstance, + KAknsIIDQgnIndiCam4TbLight ); + HBufC* tooltipText = + StringLoader::LoadLC( R_QTN_LCAM_TT_FLASHOFF ); + state->SetHelpTextL( *tooltipText ); + CleanupStack::PopAndDestroy( tooltipText ); + break; + } + default: + break; + } + } + } + + // --------------------------------------------------------------------------- + // CCamVideoPreCaptureView::UpdateVideoSceneModeIconsL() + // --------------------------------------------------------------------------- + // + void CCamVideoPreCaptureView::UpdateVideoSceneModeIconsL() + { + CAknButton* button = ToolbarButtonById(ECamCmdCaptureSetupSceneVideo); + if(!button) + { + return; + } + + MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); + TFileName iconFileName; + CamUtility::ResourceFileName( iconFileName ); + TCamSceneId scene = static_cast< TCamSceneId > ( + iController.IntegerSettingValue( ECamSettingItemDynamicVideoScene ) ); + switch ( scene ) + { + case ECamSceneAuto: + case ECamSceneNormal: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_mode_auto, + EMbmCameraappQgn_indi_cam4_mode_auto_mask, + skinInstance, + KAknsIIDQgnIndiCam4ModeAuto ); + break; + } + case ECamSceneNight: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_mode_night, + EMbmCameraappQgn_indi_cam4_mode_night_mask, + skinInstance, + KAknsIIDQgnIndiCam4ModeNight ); + break; + } + case ECamSceneLowLight: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_wb_tungsten, + EMbmCameraappQgn_indi_cam4_wb_tungsten_mask, + skinInstance, + KAknsIIDQgnIndiCam4WbTungsten ); + break; + } + default: + { + //Do Nothing + } + break; + } + } + + // --------------------------------------------------------------------------- + // CCamVideoPreCaptureView::UpdateVideoColorToneIconsL() + // --------------------------------------------------------------------------- + // +void CCamVideoPreCaptureView::UpdateVideoColorToneIconsL() + { + CAknButton* button = ToolbarButtonById(ECamCmdCaptureSetupColourFilterVideo); + if(!button) + return; + if ( !iController.UiConfigManagerPtr()->IsColorToneFeatureSupported() ) + { + HideButton(ECamCmdCaptureSetupColourFilterVideo); + return; + } + MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); + TFileName iconFileName; + CamUtility::ResourceFileName( iconFileName ); + + TCamColourFilterId color = static_cast< TCamColourFilterId > + ( iController.IntegerSettingValue( ECamSettingItemDynamicVideoColourFilter ) ); + + switch ( color ) + { + case ECamColourFilterColour: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_colour_normal, + EMbmCameraappQgn_indi_cam4_colour_normal_mask, + skinInstance, + KAknsIIDQgnIndiCam4ColourNormal ); + break; + } + case ECamColourFilterBlackAndWhite: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_colour_bw, + EMbmCameraappQgn_indi_cam4_colour_bw_mask, + skinInstance, + KAknsIIDQgnIndiCam4ColourBw ); + break; + } + case ECamColourFilterSepia: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_colour_sepia, + EMbmCameraappQgn_indi_cam4_colour_sepia_mask, + skinInstance, + KAknsIIDQgnIndiCam4ColourSepia ); + break; + } + case ECamColourFilterNegative: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_colour_negative, + EMbmCameraappQgn_indi_cam4_colour_negative_mask, + skinInstance, + KAknsIIDQgnIndiCam4ColourNegative ); + break; + } + case ECamColourFilterVivid: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_colour_vivid, + EMbmCameraappQgn_indi_cam4_colour_vivid_mask, + skinInstance, + KAknsIIDQgnIndiCam4ColourVivid ); + break; + } + default: + break; + } + } + +// --------------------------------------------------------------------------- +// CCamVideoPreCaptureView::UpdateVideoWhitebalanceIconsL() +// --------------------------------------------------------------------------- +// + void CCamVideoPreCaptureView::UpdateVideoWhitebalanceIconsL() + { + CAknButton* button = ToolbarButtonById(ECamCmdCaptureSetupWhiteBalanceVideo); + if(!button) + return; + MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); + TFileName iconFileName; + CamUtility::ResourceFileName( iconFileName ); + if ( !iController.UiConfigManagerPtr()->IsWhiteBalanceFeatureSupported() ) + { + HideButton( ECamCmdCaptureSetupWhiteBalanceVideo); + return; + } + TCamWhiteBalanceId wb = static_cast< TCamWhiteBalanceId > + ( iController.IntegerSettingValue( ECamSettingItemDynamicVideoWhiteBalance ) ); + + switch ( wb ) + { + case ECamWhiteBalanceAWB: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_wb_auto, + EMbmCameraappQgn_indi_cam4_wb_auto_mask, + skinInstance, + KAknsIIDQgnIndiCam4WbAuto ); + break; + } + case ECamWhiteBalanceDaylight: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_wb_sunny, + EMbmCameraappQgn_indi_cam4_wb_sunny_mask, + skinInstance, + KAknsIIDQgnIndiCam4WbSunny ); + break; + } + case ECamWhiteBalanceCloudy: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_wb_cloudy, + EMbmCameraappQgn_indi_cam4_wb_cloudy_mask, + skinInstance, + KAknsIIDQgnIndiCam4WbCloudy ); + break; + } + case ECamWhiteBalanceTungsten: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_wb_tungsten, + EMbmCameraappQgn_indi_cam4_wb_tungsten_mask, + skinInstance, + KAknsIIDQgnIndiCam4WbTungsten ); + break; + } + case ECamWhiteBalanceFlourescent: + { + SetIconL( + button, + iconFileName, + EMbmCameraappQgn_indi_cam4_wb_fluorecent, + EMbmCameraappQgn_indi_cam4_wb_fluorecent_mask, + skinInstance, + KAknsIIDQgnIndiCam4WbFluorecent ); + break; + } + default: + break; + } + } + + +// End of File