diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/src/CamCaptureSetupViewBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/src/CamCaptureSetupViewBase.cpp Wed Sep 01 12:30:54 2010 +0100 @@ -0,0 +1,1158 @@ +/* +* Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Base class for pre capture views* +*/ + + +// INCLUDE FILES +#include + +#include +#include + +#include "CamCaptureSetupViewBase.h" +#include "CamAppUiBase.h" +#include "CamAppController.h" +#include "CamUtility.h" +#include "CamCaptureSetupControlHandler.h" +#include "CamCaptureSetupContainer.h" +#include "CamShootingModeContainer.h" +#include "CamInfoListBoxContainer.h" +#include "CamPanic.h" +#include "Cam.hrh" +#include "CamZoomPane.h" +#include "CamTimeLapseUtility.h" +#include "camactivepalettehandler.h" +#include "CamAppUi.h" + +#include + +// ========================= MEMBER FUNCTIONS ================================ + + +// --------------------------------------------------------------------------- +// CCamPreCaptureViewBase destructor +// +// --------------------------------------------------------------------------- +// +CCamCaptureSetupViewBase::~CCamCaptureSetupViewBase() + { + PRINT( _L("Camera => ~CCamCaptureSetupViewBase") ); + if( AppUi() ) + { + if ( iCaptureSetupContainer ) + { + AppUi()->RemoveFromStack( iCaptureSetupContainer ); + delete iCaptureSetupContainer; + } + if ( iSceneSettingContainer ) + { + AppUi()->RemoveFromStack( iSceneSettingContainer ); + delete iSceneSettingContainer; + iSceneSettingContainer = NULL; + } + if ( iInfoListBoxContainer ) + { + AppUi()->RemoveFromStack( iInfoListBoxContainer ); + delete iInfoListBoxContainer; + } + } + PRINT( _L("Camera <= ~CCamCaptureSetupViewBase") ); + } + +// ----------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::HandleCommandL +// Handle commands +// ----------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::HandleCommandL( TInt aCommand ) + { + PRINT( _L("Camera => CCamCaptureSetupViewBase::HandleCommandL") ); + TUid view = Id(); + + TBool userSceneActive = ( view.iUid == ECamViewIdPhotoUserSceneSetup ); + + CCamAppUiBase* appUi = static_cast( AppUi() ); + + switch ( aCommand ) + { + case ECamCmdCaptureSetupWhiteBalanceStill: // fallthrough + case ECamCmdCaptureSetupColourFilterStill: + case ECamCmdCaptureSetupExposureStill: + case ECamCmdCaptureSetupWhiteBalanceVideo: + case ECamCmdCaptureSetupColourFilterVideo: + case ECamCmdCaptureSetupBrightnessStill: + case ECamCmdCaptureSetupContrastStill: + case ECamCmdCaptureSetupBrightnessVideo: + case ECamCmdCaptureSetupContrastVideo: + case ECamCmdCaptureSetupImageSharpnessStill: + case ECamCmdCaptureSetupFlashStill: + case ECamCmdCaptureSetupSelfTimer: + { + SwitchToCaptureSetupModeL( aCommand ); + } + break; + case ECamCmdCaptureSetupSceneStill: + case ECamCmdCaptureSetupSceneVideo: + { + SwitchToSceneSettingModeL(); + + + } + break; + case EAknSoftkeyBack: + { + if( appUi && appUi->APHandler()->AccessedViaAP() ) + { + if( !userSceneActive) + { + appUi->APHandler()->APOperationComplete(); + } + + if ( iSceneSettingModeActive ) + { + iSceneSettingContainer->SaveSceneSettingIfChangedL(); + } + + iChangeButtonPressed = EFalse; + ExitAllModesL(); + } + else + { + if( iSceneSettingModeActive ) + { + ExitSceneSettingModeL(); + } + else if ( iInfoListBoxActive ) + { + ExitInfoListBoxL(); + } + } + } + break; + case EAknSoftkeyCancel: + { + if ( iCaptureSetupModeActive && iCaptureSetupControlHandler ) + { + TCamSettingItemIds iSettingItemId = iCaptureSetupControlHandler->SettingType(); + + if ( iSettingItemId == ECamSettingItemDynamicSelfTimer ) //judge if current operation selfTimer + { + iController.SetSlideInSelfTimerPreview(EFalse); + TInt iSelfTimerVal = iController.IntegerSettingValueUnfiltered( ECamSettingItemDynamicSelfTimer ); //get the actual selfTimer value, not the focus one + + iController.IntSettingChangedL(iSettingItemId, iSelfTimerVal); //set the actual status to the actual index + } + + iController.CancelPreviewChangesL(); + // fallthrough to exit CaptureSetup mode + } + else if ( iInfoListBoxActive ) + { + iController.CancelPreviewChangesL(); + ExitAllModesL(); + break; + } + else if ( iSceneSettingModeActive ) + { + iChangeButtonPressed = EFalse; + ExitAllModesL(); + break; + } + else + { + // do nothing, the command is handled by the framework + break; + } + } + //lint -fallthrough + case EAknSoftkeyOk: + { + CaptureSetupModeSelection(); + + } + break; + case ECamMSKCmdAppChange: + case EAknSoftkeySelect: + { + if ( iCaptureSetupModeActive && iCaptureSetupControlHandler ) + { + CaptureSetupModeSelection(); + // fallthrough to exit CaptureSetup mode + } + else if ( iSceneSettingContainer ) + { + + if ( iSceneSettingContainer->UserSceneHighlighted() ) + { + // use context specific ok options menu if user scene is highlighted + CEikMenuBar* menuBar = MenuBar(); + if ( menuBar ) + { + menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_OK_MENUBAR ); + MenuBar()->SetMenuType( CEikMenuBar::EMenuContext ); + menuBar->TryDisplayMenuBarL(); + menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_MENUBAR ); + //Here we again set back the type of menu to "Options" when pressed LSK + menuBar->SetMenuType( CEikMenuBar::EMenuOptions ); + } + break; + } + + } + } + //lint -fallthrough + case ECamCmdSelect: + { + if ( iSceneSettingContainer ) + { + // If successfully saved the scene change to the settings model + // then exit the scene setting mode. + if ( iSceneSettingContainer->SaveSceneSettingL() ) + { + if( appUi && appUi->APHandler()->AccessedViaAP() ) + { + if( !userSceneActive) + { + appUi->APHandler()->APOperationComplete(); + } + + ExitAllModesL(); + } + else + { + ExitSceneSettingModeL(); + } + } + } + else if( iInfoListBoxContainer ) + { + HandleInfoListBoxSelectionL(); + } + } + break; + case ECamCmdEdit: + { + // If 'change' user scene selected from scene list, exit all + // modes in the precapture view and switch view to user scene. + if ( iSceneSettingModeActive ) + { + iChangeButtonPressed = ETrue; + AppUi()->HandleCommandL( ECamCmdUserScene ); + AppUi()->StatusPane()->MakeVisible( ETrue ); + } + + } + break; + case ECamCmdUserSceneSelected: + { + // check as a precaution that there is a container and userscene is highlighted + if ( iSceneSettingContainer && iSceneSettingContainer->UserSceneHighlighted() ) + { + + // use context specific ok options menu if user scene is highlighted + CEikMenuBar* menuBar = MenuBar(); + if ( menuBar ) + { + MenuBar()->SetMenuType( CEikMenuBar::EMenuContext ); + menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_OK_MENUBAR ); + menuBar->TryDisplayMenuBarL(); + menuBar->SetMenuType( CEikMenuBar::EMenuOptions ); + menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_MENUBAR ); + } + } + + break; + } + case ECamCmdInternalExit: + { + if ( appUi ) + { + if ( !appUi->ZoomPane()->IsZoomAtMinimum() ) + { + appUi->ZoomPane()->ResetZoomTo1x(); + } + } + ExitAllModesL(); + CCamViewBase::HandleCommandL( aCommand ); + } + break; + case ECamCmdRedrawScreen: + { + if( iCaptureSetupContainer ) + { + iCaptureSetupContainer->DrawDeferred(); + } + CCamViewBase::HandleCommandL( aCommand ); + } + break; + default: + { + CCamViewBase::HandleCommandL( aCommand ); + break; + } + } + PRINT( _L("Camera <= CCamCaptureSetupViewBase::HandleCommandL") ); + } + +// ----------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::HandleFocusLossL +// Handle focus loss +// ----------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::HandleFocusLossL() + { + // We dont exit any of the modes when we loose focus + // we do it when we gain focus. + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::DoDeactivate +// From CAknView deactivates the view +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::DoDeactivate() + { + if ( iSceneSettingContainer ) + { + AppUi()->RemoveFromStack( iSceneSettingContainer ); + + delete iSceneSettingContainer; + iSceneSettingContainer = NULL; + } + CCamViewBase::DoDeactivate(); + } + + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::CCamCaptureSetupViewBase +// C++ constructor +// --------------------------------------------------------------------------- +// +CCamCaptureSetupViewBase::CCamCaptureSetupViewBase( CCamAppController& aController ) + : CCamViewBase( aController ), + iForceAvkonCBA(EFalse) + { + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::CreateCaptureSetupControlHandlerL +// Create a control handler for the correct capture setup item +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::CreateCaptureSetupControlHandlerL( TInt aSetupCommand ) + { + __ASSERT_DEBUG( !iCaptureSetupControlHandler, CamPanic( ECamPanicInvalidState ) ); + TCamSettingItemIds settingItemId = ECamSettingItemDynamicPhotoWhiteBalance; + switch ( aSetupCommand ) + { + case ECamCmdCaptureSetupWhiteBalanceStill: + { + settingItemId = ECamSettingItemDynamicPhotoWhiteBalance; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + case ECamCmdCaptureSetupColourFilterStill: + { + settingItemId = ECamSettingItemDynamicPhotoColourFilter; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + + case ECamCmdCaptureSetupExposureStill: + { + settingItemId = ECamSettingItemDynamicPhotoExposure; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + + case ECamCmdCaptureSetupFlashStill: + { + settingItemId = ECamSettingItemDynamicPhotoFlash; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + case ECamCmdCaptureSetupSelfTimer: + { + settingItemId = ECamSettingItemDynamicSelfTimer; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + + case ECamCmdCaptureSetupWhiteBalanceVideo: + { + settingItemId = ECamSettingItemDynamicVideoWhiteBalance; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO; + } + break; + case ECamCmdCaptureSetupColourFilterVideo: + { + settingItemId = ECamSettingItemDynamicVideoColourFilter; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO; + } + break; + + // User scene settings pages. + case ECamCmdCaptureSetupWhiteBalanceUser: + { + settingItemId = ECamSettingItemUserSceneWhitebalance; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + case ECamCmdCaptureSetupColourFilterUser: + { + settingItemId = ECamSettingItemUserSceneColourFilter; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + case ECamCmdCaptureSetupExposureUser: + { + settingItemId = ECamSettingItemUserSceneExposure; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + case ECamCmdCaptureSetupFlashUser: + { + settingItemId = ECamSettingItemUserSceneFlash; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + + case ECamCmdCaptureSetupBrightnessStill: + { + settingItemId = ECamSettingItemDynamicPhotoBrightness; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + case ECamCmdCaptureSetupContrastStill: + { + settingItemId = ECamSettingItemDynamicPhotoContrast; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + case ECamCmdCaptureSetupBrightnessVideo: + { + settingItemId = ECamSettingItemDynamicVideoBrightness; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO; + } + break; + case ECamCmdCaptureSetupContrastVideo: + { + settingItemId = ECamSettingItemDynamicVideoContrast; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO; + } + break; + case ECamCmdCaptureSetupBrightnessUser: + { + settingItemId = ECamSettingItemUserSceneBrightness; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + case ECamCmdCaptureSetupContrastUser: + { + settingItemId = ECamSettingItemUserSceneContrast; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + + case ECamCmdCaptureSetupImageSharpnessStill: + { + settingItemId = ECamSettingItemDynamicPhotoImageSharpness; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + case ECamCmdCaptureSetupImageSharpnessUser: + { + settingItemId = ECamSettingItemUserSceneImageSharpness; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + + case ECamCmdCaptureSetupLightSensitivityStill: + { + settingItemId = ECamSettingItemDynamicPhotoLightSensitivity; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL; + } + break; + case ECamCmdCaptureSetupLightSensitivityVideo: + { + settingItemId = ECamSettingItemDynamicVideoLightSensitivity; + iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO; + } + break; + case ECamCmdCaptureSetupLightSensitivityUser: + { + settingItemId = ECamSettingItemUserSceneLightSensitivity; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + case ECamCmdSetUserDefault: + { + settingItemId = ECamSettingItemUserSceneDefault; + iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE; + } + break; + default: + { + User::Leave( KErrNotSupported ); + } + break; + } + + iCaptureSetupControlHandler = new( ELeave ) + CCamCaptureSetupControlHandler( iController, settingItemId ); + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::CleanupCaptureSetupContainer +// Cleanup the capture setup controls if a leave occurs +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::CleanupCaptureSetupContainer( TAny* aAny ) + { + CCamCaptureSetupViewBase* view = static_cast( aAny ); + delete view->iCaptureSetupControlHandler; + view->iCaptureSetupControlHandler = NULL; + + if ( view->iCaptureSetupContainer ) + { + view->AppUi()->RemoveFromStack( view->iCaptureSetupContainer ); + delete view->iCaptureSetupContainer; + view->iCaptureSetupContainer = NULL; + } + // reset the active flag + view->SetCaptureSetupModeActive(EFalse); + + CCamAppUiBase* appUi = static_cast( view->AppUi() ); + appUi->SetPreCaptureMode(ECamPreCapViewfinder); + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::SwitchToCaptureSetupModeL +// Enter capture setup mode +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::SwitchToCaptureSetupModeL( TInt aSetupCommand, TBool aFullScreenVF ) + { + __ASSERT_DEBUG( !iCaptureSetupControlHandler && !iCaptureSetupContainer, CamPanic( ECamPanicResourceLeak ) ); + + CreateCaptureSetupControlHandlerL( aSetupCommand ); + // Cleanup the view correctly if a leave occurs + CleanupStack::PushL( TCleanupItem( CleanupCaptureSetupContainer, this ) ); + CCamAppUiBase* appUi = static_cast( AppUi() ); + + TRect rect = appUi->ApplicationRect(); + if ( !CamUtility::IsNhdDevice() ) + { + // Space for visible statuspane for non-touch device + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect ); + } + iCaptureSetupContainer = CCamCaptureSetupContainer::NewL( iController, + *this, *iCaptureSetupControlHandler, rect, aFullScreenVF ); + appUi->AddToStackL( *this, iCaptureSetupContainer ); + iCaptureSetupContainer->ActivateL(); + iCaptureSetupContainer->DrawNow(); + + // UpdateCbaL need this boolean to be set in order + // to return the correct CBA + SetCaptureSetupModeActive(ETrue); + + iCaptureSetupContainer->DrawableWindow()->SetOrdinalPosition( + KCamPreCaptureWindowOrdinalPos ); + + UpdateCbaL(); + SetTitlePaneTextL(); + appUi->PushDefaultNaviPaneL(); + CleanupStack::Pop(); // CleanupCaptureSetupContainer + // after all leaving functions have completed + // remove the container from the stack + appUi->RemoveFromStack( iContainer ); + iContainer->MakeVisible( EFalse ); + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::ExitCaptureSetupModeL +// Exit capture setup mode +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::ExitCaptureSetupModeL() + { + PRINT( _L("Camera => CCamCaptureSetupViewBase::ExitCaptureSetupModeL()") ); + if ( !iController.InVideocallOrRinging() ) + { + iController.CancelPreviewChangesL(); + } + if ( !iCaptureSetupModeActive ) + { + return; + } + + // Cleanup the view correctly if a leave occurs + CleanupStack::PushL( TCleanupItem( CleanupExit, this ) ); + AppUi()->AddToStackL( *this, iContainer ); + iContainer->MakeVisible( ETrue ); + //Draw already here to prevent the activepalette showing briefly before it is updated + if ( !iController.IsTouchScreenSupported() ) + { + iContainer->DrawNow(); + } + SetCaptureSetupModeActive(EFalse); + + UpdateCbaL(); + + if ( Cba() ) + { + Cba()->DrawNow(); + } + + SetTitlePaneTextL(); + CleanupStack::Pop(); // CleanupExit + + // delete the capture setup controls when all + // leaving functions have completed + AppUi()->RemoveFromStack( iCaptureSetupContainer ); + delete iCaptureSetupContainer; + iCaptureSetupContainer = NULL; + delete iCaptureSetupControlHandler; + iCaptureSetupControlHandler = NULL; + PRINT( _L("Camera <= CCamCaptureSetupViewBase::ExitCaptureSetupModeL()") ); + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::CleanupSceneSettingContainer +// Cleanup the capture setup controls if a leave occurs +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::CleanupSceneSettingContainer( TAny* aAny ) + { + CCamCaptureSetupViewBase* view = static_cast( aAny ); + if ( view->iSceneSettingContainer ) + { + view->AppUi()->RemoveFromStack( view->iSceneSettingContainer ); + delete view->iSceneSettingContainer; + view->iSceneSettingContainer = NULL; + } + // reset the active mode + view->SetSceneSettingMode(EFalse); + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::CleanupInfoListBox +// Cleanup the InfoListBox controls if a leave occurs +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::CleanupInfoListBox( TAny* aAny ) + { + CCamCaptureSetupViewBase* view = static_cast( aAny ); + if ( view->iInfoListBoxContainer ) + { + view->AppUi()->RemoveFromStack( view->iInfoListBoxContainer ); + delete view->iInfoListBoxContainer; + view->iInfoListBoxContainer = NULL; + } + // reset the active mode + view->SetInfoListBoxMode(EFalse); + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::SwitchToSceneSettingModeL +// Enter scene setup mode +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::SwitchToSceneSettingModeL() + { + // Cleanup the view correctly if a leave occurs + CleanupStack::PushL( TCleanupItem( CleanupSceneSettingContainer, this ) ); + CCamAppUi* appUi = static_cast( AppUi() ); + iSceneSettingContainer->SetMopParent( this ); + appUi->AddToStackL( *this, iSceneSettingContainer ); + iSceneSettingContainer->ActivateL(); + + if ( iChangeButtonPressed && iSceneSettingContainer ) + { + iSceneSettingContainer->SelectItem( iSceneSettingContainer->IndexForValueId( ECamSceneUser ) ); + // iChangeButtonPressed is set to EFalse in SetSceneSettingMode method + } + + // UpdateCbaL need this boolean to be set in + // order to return the correct CBA + SetSceneSettingMode(ETrue); + + appUi->SetToolbarVisibility(); + + iForceAvkonCBA = ETrue; + UpdateCbaL(); + SetTitlePaneTextL(); + appUi->PushDefaultNaviPaneL(); + CleanupStack::Pop(); // CleanupSceneSettingContainer + // after all leaving functions have completed + // remove the container from the stack and + // set the capture setup mode active + appUi->RemoveFromStack( iContainer ); + iContainer->MakeVisible( EFalse ); + + CEikMenuBar* menuBar = MenuBar(); + // if menuBar exists + if ( menuBar ) + { + menuBar->SetMenuTitleResourceId( ROID(R_CAM_SCENE_SETTING_MENUBAR_ID)); + } + + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::SwitchToInfoListBoxL +// Show InfoListBox +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::SwitchToInfoListBoxL( TCamInfoListBoxMode aMode, TBool aFullySkinned ) + { + // Cleanup the view correctly if a leave occurs + CleanupStack::PushL( TCleanupItem( CleanupInfoListBox, this ) ); + CCamAppUiBase* appUi = static_cast( AppUi() ); + iInfoListBoxContainer->SetMopParent( this ); + appUi->AddToStackL( *this, iInfoListBoxContainer ); + iInfoListBoxContainer->ActivateL(); + // UpdateCbaL need this boolean to be set in + // order to return the correct CBA + SetInfoListBoxMode(ETrue, aFullySkinned); + UpdateCbaL(); + SetTitlePaneTextL(); + appUi->PushDefaultNaviPaneL(); + CleanupStack::Pop(); // CleanupSceneSettingContainer + + // after all leaving functions have completed + // remove the container from the stack and + // set the capture setup mode active + appUi->RemoveFromStack( iContainer ); + iContainer->MakeVisible( EFalse ); + + CEikMenuBar* menuBar = MenuBar(); + // if menuBar exists + if ( menuBar ) + { + // Use same menu resource as scene setting + menuBar->SetMenuTitleResourceId( R_CAM_INFOLISTBOX_MENUBAR ); + } + } + + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::HandleInfoListBoxSelectionL() +// Handle selection events from InfoListBox +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::HandleInfoListBoxSelectionL() + { + CCamAppUiBase* appUi = static_cast( AppUi() ); + + TUid view = Id(); + TBool userSceneActive = ( view.iUid == ECamViewIdPhotoUserSceneSetup ); + + if( iInfoListBoxContainer->SettingValueChanged() ) + { + // Store the selected setting + switch( iInfoListBoxMode ) + { + case EInfoListBoxModeTimeLapse: + { + TCamTimeLapse settingValue = static_cast( iInfoListBoxContainer->CurrentSettingItemValue() ); + TInt command = CamTimeLapseUtility::EnumToCommand( settingValue ); + TTimeIntervalMicroSeconds interval = CamTimeLapseUtility::EnumToInterval( settingValue ); + + // Update the current mode (single/burst/timelapse) + if( appUi ) + { + TRAP_IGNORE( appUi->HandleCommandL( command ) ); + } + + // Update timelapse interval + iController.SetTimeLapseInterval( interval ); + } + break; + + case EInfoListBoxModeISO: + { + TInt settingValue = iInfoListBoxContainer->CurrentSettingItemValue(); + + // For the light sensitivity setting, PreviewSettingChangeL and CommitPreviewChanges + // must be used, instead of UpdateEngineWithSettingL, in order to actually change + // the setting value. + iController.PreviewSettingChangeL( ECamSettingItemDynamicPhotoLightSensitivity, settingValue ); + iController.CommitPreviewChanges(); + } + break; + + default: + break; + } + } + + + if( appUi && appUi->APHandler()->AccessedViaAP() ) + { + if( !userSceneActive) + { + // If user scene is active, we aren't yet done + appUi->APHandler()->APOperationComplete(); + } + + ExitAllModesL(); + } + else + { + ExitInfoListBoxL(); + } + + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::CleanupExit +// Stop the scene setting mode from exiting if a leave occurs +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::CleanupExit( TAny* aAny ) + { + CCamCaptureSetupViewBase* view = static_cast( aAny ); + view->AppUi()->RemoveFromStack( view->iContainer ); + view->iContainer->MakeVisible( EFalse ); + if ( view->iSceneSettingContainer ) + { + // reset the active mode + view->SetSceneSettingMode(ETrue); + } + if ( view->iCaptureSetupContainer ) + { + // reset the active mode + view->SetCaptureSetupModeActive(ETrue); + } + if ( view->iInfoListBoxContainer ) + { + // reset the active mode + view->SetInfoListBoxMode(ETrue); + } + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::ExitSceneSettingModeL +// Exit scene setup mode +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::ExitSceneSettingModeL() + { + PRINT( _L( "Camera => CCamCaptureSetupViewBase::ExitSceneSettingModeL" ) ); + iForceAvkonCBA = EFalse; + if ( !iSceneSettingModeActive ) + { + AppUi()->RemoveFromStack( iSceneSettingContainer ); + + if ( iSceneSettingContainer ) + { + delete iSceneSettingContainer; + iSceneSettingContainer = NULL; + } + return; + } + + // Cleanup the view correctly if a leave occurs + CleanupStack::PushL( TCleanupItem( CleanupExit, this ) ); + AppUi()->AddToStackL( *this, iContainer ); + + if ( iChangeButtonPressed == EFalse ) + { + AppUi()->RemoveFromStack( iSceneSettingContainer ); + if ( iSceneSettingContainer ) + { + delete iSceneSettingContainer; + iSceneSettingContainer = NULL; + } + iContainer->MakeVisible( ETrue ); + //Draw already here to prevent the activepalette showing briefly before it is updated + if ( !iController.IsTouchScreenSupported() ) + { + iContainer->DrawNow(); + } + SetSceneSettingMode(EFalse); + UpdateCbaL(); + + if ( Cba() ) + { + Cba()->DrawNow(); + } + + SetTitlePaneTextL(); + CleanupStack::Pop(); // CleanupExit + + + + } + else // iChangeButtonPressed == ETrue + { + iContainer->MakeVisible( EFalse ); + SetSceneSettingMode(EFalse); + SetTitlePaneTextL(); + CleanupStack::Pop(); // CleanupExit + } + + + CEikMenuBar* menuBar = MenuBar(); + // if menuBar exists + if ( menuBar ) + { + menuBar->SetMenuTitleResourceId( iPreviousMenuResourceId ); + } + PRINT( _L( "Camera <= CCamCaptureSetupViewBase::ExitSceneSettingModeL" ) ); + } + + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::ExitInfoListBoxL +// Exit scene setup mode +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::ExitInfoListBoxL() + { + PRINT( _L( "Camera => CCamCaptureSetupViewBase::ExitInfoListBoxL" ) ); + + if ( !iInfoListBoxActive ) + { + return; + } + + // Cleanup the view correctly if a leave occurs + CleanupStack::PushL( TCleanupItem( CleanupExit, this ) ); + AppUi()->AddToStackL( *this, iContainer ); + iController.SetViewfinderWindowHandle( &iContainer->Window() ); + PRINT( _L( "Camera => CCamCaptureSetupViewBase::ExitInfoListBoxL removing iInfoListBoxContainer" ) ); + AppUi()->RemoveFromStack( iInfoListBoxContainer ); + delete iInfoListBoxContainer; + iInfoListBoxContainer = NULL; + PRINT( _L( "Camera => CCamCaptureSetupViewBase::ExitInfoListBoxL removed iInfoListBoxContainer" ) ); + + iContainer->MakeVisible( ETrue ); + //Draw already here to prevent the activepalette showing briefly before it is updated + if ( !iController.IsTouchScreenSupported() ) + { + iContainer->DrawNow(); + } + SetInfoListBoxMode(EFalse); + UpdateCbaL(); + + if ( Cba() ) + { + Cba()->DrawNow(); + } + + SetTitlePaneTextL(); + CleanupStack::Pop(); // CleanupExit + + CEikMenuBar* menuBar = MenuBar(); + // if menuBar exists + if ( menuBar ) + { + menuBar->SetMenuTitleResourceId( iPreviousMenuResourceId ); + } + + iInfoListBoxActive = EFalse; + + // StartViewFinderL(); + PRINT( _L( "Camera <= CCamCaptureSetupViewBase::ExitInfoListBoxL" ) ); + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::SetupModeTitlePaneResourceId +// Return the resource id for the title pane text while in setup mode +// --------------------------------------------------------------------------- +// +TInt CCamCaptureSetupViewBase::SetupModeTitlePaneResourceId() + { + return iSettingModeTitleResourceId; + } + + +void CCamCaptureSetupViewBase::CaptureSetupModeSelection() + { + + TUid view = Id(); + + TBool userSceneActive = ( view.iUid == ECamViewIdPhotoUserSceneSetup ); + + CCamAppUiBase* appUi = static_cast( AppUi() ); + + if ( iCaptureSetupModeActive && iCaptureSetupControlHandler ) + { + TCamSettingItemIds iSettingItemId = iCaptureSetupControlHandler->SettingType(); + if ( iSettingItemId == ECamSettingItemDynamicSelfTimer ) + { + iController.SetSlideInSelfTimerPreview(EFalse); + } + + iController.CommitPreviewChanges(); + // fallthrough to exit CaptureSetup mode + } + if( appUi && appUi->APHandler()->AccessedViaAP() ) + { + if( !userSceneActive) + { + appUi->APHandler()->APOperationComplete(); + } + ExitAllModesL(); + } + + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::DynInitMenuPaneL +// Dynamically initialise the options menu +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane ) + { + PRINT( _L("Camera => CCamCaptureSetupViewBase::DynInitMenuPaneL")) + iController.StartIdleTimer(); + if( iSceneSettingModeActive && aResourceId == ROID(R_CAM_SCENE_SETTING_MENU_ID)) + { + if ( iSceneSettingContainer && !iSceneSettingContainer->UserSceneHighlighted() ) + { + aMenuPane->SetItemDimmed( ECamCmdEdit, ETrue ); + } + else + { + // do nothing + } + } + else + { + // do nothing + } + PRINT( _L("Camera <= CCamCaptureSetupViewBase::DynInitMenuPaneL")) + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::ExitAllModesL +// Revert to normal mode +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::ExitAllModesL() + { + // intentionally doing nothing + PRINT( _L("Camera =><= CCamCaptureSetupViewBase::ExitAllModesL empty impl.")) + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::SetSceneSettingMode +// Sets the iSceneSettingModeActive flag +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::SetSceneSettingMode(TBool aActive) + { + TUid view = Id(); + TBool userSceneActive = ( view.iUid == ECamViewIdPhotoUserSceneSetup ); + // This should be the only place iSceneSettingModeActive is set! + // We need to inform the AppUi + iSceneSettingModeActive = aActive; + + CCamAppUi* appUi = static_cast(AppUi()); //static_cast( AppUi() ); + + if ( appUi ) + { + if ( aActive ) + { + appUi->SetPreCaptureMode(ECamPreCapSceneSetting); + iChangeButtonPressed = EFalse; + } // userSceneActive to avoit toolbar flicker after back from scene setting + else if ( iChangeButtonPressed || userSceneActive ) + { + // transfering to user scene setup view + appUi->SetPreCaptureMode(ECamPreCapSceneSetting); + } + else + { + appUi->SetPreCaptureMode(ECamPreCapViewfinder); + } + } + + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::SetInfoListBoxMode +// Sets the iInfoListBoxActive flag +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::SetInfoListBoxMode( TBool aActive, TBool aFullySkinned ) + { + // We need to inform the AppUi + iInfoListBoxActive = aActive; + + CCamAppUi* appUi = static_cast( AppUi() ); + + if ( appUi) + { + if ( aActive ) + { + iPrevCaptureMode = appUi->PreCaptureMode(); + appUi->SetPreCaptureMode(ECamPreCapGenericSetting); + } + else + { + appUi->SetPreCaptureMode( iPrevCaptureMode ); + } + } + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::SetCaptureSetupModeActive +// Sets the iSceneSettingModeActive flag +// --------------------------------------------------------------------------- +// +void CCamCaptureSetupViewBase::SetCaptureSetupModeActive(TBool aActive) + { + // This should be the only place iCaptureSetupModeActive is set! + // We need to inform the AppUi + iCaptureSetupModeActive = aActive; + PRINT1( _L("Camera <> CCamCaptureSetupViewBase::SetCaptureSetupModeActive iCaptureSetupModeActive=%d"),iCaptureSetupModeActive); + CCamAppUiBase* appUi = static_cast( AppUi() ); + + if ( appUi) + { + if ( aActive ) + { + appUi->SetPreCaptureMode(ECamPreCapCaptureSetup); + } + else + { + appUi->SetPreCaptureMode(ECamPreCapViewfinder); + } + } + } +// --------------------------------------------------------------------------- +// CCamCaptureSetupViewBase::HandleForegroundEventL +// Called to notify of change of app fore/background state +// --------------------------------------------------------------------------- +// + void CCamCaptureSetupViewBase::HandleForegroundEventL( TBool aForeground ) + { + + PRINT1( _L("Camera => CCamCaptureSetupViewBase::HandleForegroundEventL foreground:%d"), aForeground ); + + if( aForeground ) + { + + if ( iCaptureSetupModeActive && iCaptureSetupContainer ) + { + iCaptureSetupContainer->HandleForegroundEventL( aForeground ); + } + } + } +// End of File