diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/src/CamNaviCounterModel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/src/CamNaviCounterModel.cpp Wed Sep 01 12:30:54 2010 +0100 @@ -0,0 +1,2117 @@ +/* +* 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: Control for displaying remaining images/videos in Navi Pane +* +* Copyright © 2007-2008 Nokia. All rights reserved. +* This material, including documentation and any related computer +* programs, is protected by copyright controlled by Nokia. All +* rights are reserved. Copying, including reproducing, storing, +* adapting or translating, any or all of this material requires the +* prior written consent of Nokia. This material also contains +* confidential information which may not be disclosed to others +* without the prior written consent of Nokia. + +* +* +*/ + + +// INCLUDE FILES +#include +#include // For CEikApplication +#include +#include +#include +#include +#include // StringLoader +#include +#include // TResourceReader +#include +#include +#include +#include +#include +#include +#include + +#include "CamNaviCounterModel.h" +#include "CamAppUi.h" +#include "CamUtility.h" +#include "CamSelfTimer.h" + +#include +#include + +#include "CamLogger.h" +#include "CamDecorator.h" +#include "camtextitem.h" +#include "CameraUiConfigManager.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "CamNaviCounterModelTraces.h" +#endif + + +// CONSTANTS +const TInt KMaxRemainingImagesShown = 9999; +const TInt KCamDefaultCapturedImagesTextLen = 30; +_LIT( KNumberFormat, "%04d" ); +_LIT( KTimeLapseImageFormat, "%04d/%04d" ); + +const TAknsItemID KNaviPaneMajorColour = KAknsIIDQsnComponentColors; +const TInt KNaviPaneMinorColour = EAknsCIQsnComponentColorsCG2; + +// Sequence mode related constants that define the amount of pictures taken +// with sequence mode. +const TInt KShortBurstCount = 18; // number of images captured during burst + +// ========================= MEMBER FUNCTIONS ================================ + +// --------------------------------------------------------- +// CCamNaviCounterModel::NewL +// Factory construction function +// --------------------------------------------------------- +// +CCamNaviCounterModel* +CCamNaviCounterModel::NewL( CCamAppController& aController ) + { + CCamNaviCounterModel* self = + new( ELeave ) CCamNaviCounterModel( aController ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// Destructor +CCamNaviCounterModel::~CCamNaviCounterModel() + { + iController.RemoveControllerObserver( this ); + + delete iVideoTextItem; + delete iPhotoTextItem; + + delete iSequenceImageTextItem; + delete iSequenceCapturedTextItem; + delete iTimeLapseCountdownTextItem; + + CCamNaviCounterModel::UnloadResourceData(); + + delete iMpeg4Icon; + delete iMpeg4IconMask; + delete i3GPIcon; + delete i3GPIconMask; + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi()); + if ( appUi ) + { + if ( !iController.IsInShutdownMode() ) + { + appUi->RemoveBurstModeObserver( this ); + } + delete iSequenceIcon; + delete iSequenceMask; + } + + delete iSelfTimerIcon; + delete iSelfTimerMask; + + // If not shutting down, deregister from SelfTimer observers. + // If we try to deregister when shutting down, the object has already been + // deleted + if ( !iController.IsInShutdownMode() && appUi ) + { + // ...Remove self as an observer of the self timer. + CCamSelfTimer* selftimer = appUi->SelfTimer(); + if ( selftimer ) + { + selftimer->RemoveObserver( this ); + } + } + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + delete iGenericIcon; + delete iGenericMask; +#endif // PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + + delete iAudioMuteIcon; + delete iAudioMuteMask; + + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + delete iSubtitlePhotoIcon; + delete iSubtitlePhotoMask; + delete iSubtitleVideoIcon; + delete iSubtitleVideoMask; +#endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + + delete iTimeFormat; + delete iCountDownText; + delete iObserverHandler; + } + +// ----------------------------------------------------------------------------- +// CCamNaviCounterModel::LoadResourceDataL() +// Reads in all information needed from resources +// ----------------------------------------------------------------------------- +// +void CCamNaviCounterModel::LoadResourceDataL() + { +OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMNAVICOUNTERMODEL_LOADRESOURCEDATAL, "e_CCamNaviCounterModel_LoadResourceDataL 1" ); + + PRINT( _L("Camera => CCamNaviCounterModel::LoadResourceDataL") ); + + // Read the time format resource + PRINT( _L("Camera <> construct timeformat..") ); + delete iTimeFormat; + iTimeFormat = NULL; + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + iTimeFormat = CEikonEnv::Static()->AllocReadResourceL( R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO ); + } + else + { + iTimeFormat = CEikonEnv::Static()->AllocReadResourceL( R_QTN_TIME_DURAT_LONG ); + } + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + + delete iPhotoTextItem; + iPhotoTextItem = NULL; + iPhotoTextItem = CCamTextItem::NewL(); + + delete iVideoTextItem; + iVideoTextItem = NULL; + iVideoTextItem = CCamTextItem::NewL(); + + delete iSequenceImageTextItem; + iSequenceImageTextItem = NULL; + iSequenceImageTextItem = CCamTextItem::NewL(); + + delete iTimeLapseCountdownTextItem; + iTimeLapseCountdownTextItem = NULL; + iTimeLapseCountdownTextItem = CCamTextItem::NewL(); + + delete iSequenceCapturedTextItem; + iSequenceCapturedTextItem = NULL; + iSequenceCapturedTextItem = CCamTextItem::NewL(); + + iCamOrientation = appUi->CamOrientation(); + + if ( Layout_Meta_Data::IsLandscapeOrientation() || CamUtility::IsNhdDevice() ) + { + TSize screenSize; + AknLayoutUtils::LayoutMetricsSize( AknLayoutUtils::EScreen, screenSize ); + iExtent = TRect( TPoint(), screenSize ); + } + else + { + TRect screenRect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, screenRect ); + iExtent = screenRect; + } + + if ( CamUtility::IsNhdDevice() ) + { + TouchLayoutL(); + } + else + { + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + NonTouchLayoutSecondaryL(); + } + else + { + NonTouchLayoutL(); + } + } + + iVidPostStorageIconRect = iVidPreStorageIconRect; + + + if ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsLocationSupported() ) + { + iLocationIconVisible = (/*TCamLocationId::ECamLocationOn*/1 == iController.IntegerSettingValue( ECamSettingItemRecLocation )); + // If location setting is on, then the decoration should be wider to fit the location icon + if ( iLocationIconVisible ) + { + iPhotoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER_LOCATION ); + } + else + { + iPhotoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER ); + } + } + else + { + iPhotoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER ); + } + + iVideoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_VIDEO_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER ); + + iPhotoPostcapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_POSTCAP_NAVICOUNTER_DECORATIONS_CAMCORDER ); + iVideoPostcapDecorator = CCamDecorator::NewL( iController, R_CAM_VIDEO_POSTCAP_NAVICOUNTER_DECORATIONS_CAMCORDER ); + + iSequenceInCaptureDecorator = CCamDecorator::NewL( iController, R_CAM_TIMELAPSE_IN_CAPTURE_NAVICOUNTER_DECORATIONS ); + iTimeLapsePostCaptureDecorator = CCamDecorator::NewL( iController, R_CAM_TIMELAPSE_POST_CAPTURE_NAVICOUNTER_DECORATIONS ); + + TFileName resFileName; + CamUtility::ResourceFileName( resFileName ); + TPtrC resname = resFileName; + + // Create component bitmaps + TSize size = iVidPostStorageIconRect.Rect().Size(); + TCamOrientation orientation = appUi->CamOrientation(); + + AknIconUtils::CreateIconL( iPhoneIcon, + iPhoneIconMask, + resname, + EMbmCameraappQgn_indi_cam4_memory_phone, + EMbmCameraappQgn_indi_cam4_memory_phone_mask ); + + AknIconUtils::SetSize( iPhoneIcon, size ); + + AknIconUtils::CreateIconL( iMMCIcon, + iMMCIconMask, + resname, + EMbmCameraappQgn_indi_cam4_memory_mmc, + EMbmCameraappQgn_indi_cam4_memory_mmc_mask ); + + AknIconUtils::SetSize( iMMCIcon, size ); + + if ( orientation != ECamOrientationCamcorder && orientation != ECamOrientationCamcorderLeft ) + { + AknIconUtils::CreateIconL( iMassStorageIcon, + iMassStorageIconMask, + resname, + EMbmCameraappQgn_indi_cam4_memory_mass, + EMbmCameraappQgn_indi_cam4_memory_mass_mask ); + } + else + { + AknIconUtils::CreateIconL( iMassStorageIcon, + iMassStorageIconMask, + resname, + EMbmCameraappQgn_indi_cam4_memory_mass, + EMbmCameraappQgn_indi_cam4_memory_mass_mask ); + } + + AknIconUtils::SetSize( iMassStorageIcon, size ); + PRINT( _L("Camera <= CCamNaviCounterModel::LoadResourceDataL") ); +OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMNAVICOUNTERMODEL_LOADRESOURCEDATAL, "e_CCamNaviCounterModel_LoadResourceDataL 0" ); + + } + +// ----------------------------------------------------------------------------- +// CCamNaviCounterModel::UnloadResourceData() +// Frees all dynamic resources allocated in LoadResourceDataL +// ----------------------------------------------------------------------------- +// +void CCamNaviCounterModel::UnloadResourceData() + { +#ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + delete iSubtitleVideoText; + iSubtitleVideoText = NULL; + delete iSubtitlePhotoText; + iSubtitlePhotoText = NULL; +#endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + + delete iPhotoPrecapDecorator; + iPhotoPrecapDecorator = NULL; + delete iVideoPrecapDecorator; + iVideoPrecapDecorator = NULL; + delete iPhotoPostcapDecorator; + iPhotoPostcapDecorator = NULL; + delete iVideoPostcapDecorator; + iVideoPostcapDecorator = NULL; + delete iSequenceInCaptureDecorator; + iSequenceInCaptureDecorator = NULL; + delete iTimeLapsePostCaptureDecorator; + iTimeLapsePostCaptureDecorator = NULL; + + delete iPhoneIcon; + iPhoneIcon = NULL; + delete iPhoneIconMask; + iPhoneIconMask = NULL; + delete iMMCIcon; + iMMCIcon = NULL; + delete iMMCIconMask; + iMMCIconMask = NULL; + delete iMassStorageIcon; + iMassStorageIcon = NULL; + delete iMassStorageIconMask; + iMassStorageIconMask = NULL; + } + +// ----------------------------------------------------------------------------- +// CCamNaviCounterModel::ReloadResourceDataL() +// Refreshes all resource-based information stored in the class +// ----------------------------------------------------------------------------- +// +void CCamNaviCounterModel::ReloadResourceDataL() + { + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMNAVICOUNTERMODEL_RELOADRESOURCEDATAL, "e_CCamNaviCounterModel_ReloadResourceDataL 1" ); + UnloadResourceData(); + LoadResourceDataL(); + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMNAVICOUNTERMODEL_RELOADRESOURCEDATAL, "e_CCamNaviCounterModel_ReloadResourceDataL 0" ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::UpdateCounter +// Update counter +// --------------------------------------------------------- +// +void CCamNaviCounterModel::UpdateCounter() + { + PRINT( _L("Camera => CCamNaviCounterModel::UpdateCounter") ); + + const TInt imagesLeft = Min( + iController.ImagesRemaining( ECamMediaStorageCurrent, iBurstActive ), + KMaxRemainingImagesShown ); + iCounterText.Format( KNumberFormat, imagesLeft ); + + if ( iPhotoTextItem ) + { + TRAP_IGNORE( iPhotoTextItem->SetTextL( iCounterText ) ); + } + + PRINT( _L("Camera <= CCamNaviCounterModel::UpdateCounter") ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::UpdateTimeLapseCountdownL +// Update the counter for remaining time until the next capture +// --------------------------------------------------------- +// +void CCamNaviCounterModel::UpdateTimeLapseCountdownL() + { + // Get the actual remaining time till next capture + TTime time ( iController.TimeLapseCountdown().Int64() ); + // The format function always rounds down to the next whole number of seconds + // so add on 0.5 secs to force round up if closer to the next higher whole number of seconds + // This gives a countdown from max to 1, to get a countdown from max-1 to 0 remove this + const TTimeIntervalMicroSeconds KHalfSecInMicroSecs = TInt64( 500000 ); + time += KHalfSecInMicroSecs; + + TBuf<15> timebuf; + // use 00:00 format as normal in secondary cam + // but long format for primary cam. 2nd cam uses sharing quality. With primary cam sharing + // we just use the same layout for sharing and other qualities. + HBufC* timeFormat; + if ( ECamActiveCameraSecondary == iController.ActiveCamera() ) + { + timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO ); + } + else + { + timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_LONG ); + } + time.FormatL( timebuf, *timeFormat ); + CleanupStack::PopAndDestroy( timeFormat ); + + delete iCountDownText; + iCountDownText = NULL; + iCountDownText = StringLoader::LoadL( R_CAM_TIMELAPSE_COUNTDOWN_TIME, timebuf ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::UpdateSequenceImageCount +// Update the counter of captured and remaining images for +// timelapse and burst during capture +// --------------------------------------------------------- +// +void CCamNaviCounterModel::UpdateSequenceImageCount() + { + PRINT( _L("Camera => CCamNaviCounterModel::UpdateSequenceImageCount" ) ) + TInt imagesLeft = iController.ImagesRemaining( ECamMediaStorageCurrent, iBurstActive ); + TInt showLeft = Min( imagesLeft, KMaxRemainingImagesShown ); + TInt showCaptured = 0; + + if ( ECamImageCaptureTimeLapse == iImageMode ) + { + // Use the count of captured images + showCaptured = iController.TimeLapseImageCount(); + } + else if ( ECamImageCaptureBurst == iImageMode ) + { + // Use the count of burst capture moments + showCaptured = iController.CurrentCapturedCount(); + // The images have not been saved yet so the remaining count does not account + // for the ones already captured. Reduce the remaining count by the captured count. + // Commented out - The burst images are saved immediately after capturing. + // However, we cannot know if all the previous images have already been saved + // so this number is not 100% accurate. + // showLeft -= showCaptured; + if( ( iOriginalValueForEachBurst > 0 ) && ( iCounterNeedUpdate ) ) + { + iOriginalValueForEachBurst--; + } + if( ( iController.SequenceCaptureInProgress() ) ) + { + if( !iController.IsRemainingImageStored() ) + { + iOriginalValueForEachBurst = showLeft; + iController.SetRemainingImageStored(); + } + iCounterText.Format( KNumberFormat, iOriginalValueForEachBurst ); + } + else + iCounterText.Format( KNumberFormat, iController.ImagesRemaining( ECamMediaStorageCurrent, iBurstActive ) ); + showLeft = iOriginalValueForEachBurst; + } + else + { + // no action + } + + // show only the KShortBurstCount value if there is enough space to take all + // pictures, otherwise display the number of images that can be shown + TInt showSequenceMax = Min( showLeft, KShortBurstCount ); + iSequenceImageText.Format( KTimeLapseImageFormat, showCaptured, showSequenceMax ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::UpdateRecordTimeAvailableL +// Update record time remaining +// --------------------------------------------------------- +// +void CCamNaviCounterModel::UpdateRecordTimeAvailableL() + { + PRINT( _L("Camera => CCamNaviCounterModel::UpdateRecordTimeAvailableL" ) ) + // Get the total remaining record time from the controller + TTime time ( iController.RecordTimeRemaining().Int64() ); + HBufC* timeFormat; + + // Use 00:00 format in secondary cam + if ( ECamActiveCameraSecondary == iController.ActiveCamera() ) + { + timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO ); + } + // Use 0:00:00 format in primary cam + else + { + timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_LONG ); + } + + time.FormatL( iRemainingTimeText, *timeFormat ); + if ( iVideoTextItem ) + { + iVideoTextItem->SetTextL( iRemainingTimeText ); + } + CleanupStack::PopAndDestroy( timeFormat ); + PRINT( _L("Camera <= CCamNaviCounterModel::UpdateRecordTimeAvailableL" ) ) + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::SetCaptureModeL +// Set capture mode (defines which counter to use) +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::SetCaptureModeL( TCamCameraMode aMode, + TCamImageCaptureMode aImageMode ) + { + iMode = aMode; + iImageMode = aImageMode; + + TInt key = ( ECamControllerVideo == iMode ) + ? ECamSettingItemVideoMediaStorage + : ECamSettingItemPhotoMediaStorage; + + // Get the total remaining record time from the controller + iStorageLocation = + static_cast( iController.IntegerSettingValue( key ) ); + + if (ECamMediaStorageMassStorage ==iStorageLocation) + { + iStorageLocation = iController.ExistMassStorage()? + ECamMediaStorageMassStorage: + iController.IntegerSettingValue( ECamSettingItemRemovePhoneMemoryUsage )? + ECamMediaStorageNone: + ECamMediaStoragePhone; + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::HandleSelfTimerEvent +// Handle an event from CCamSelfTimer. +// --------------------------------------------------------- +// +void CCamNaviCounterModel::HandleSelfTimerEvent( TCamSelfTimerEvent aEvent, TInt aCountDown ) + { + switch ( aEvent ) + { + case ECamSelfTimerEventTimerOn: + { + iSelfTimerText.Num( TInt64( aCountDown ) ); + iDrawSelfTimer = ETrue; + } + break; + case ECamSelfTimerEventTimerOff: + { + iDrawSelfTimer = EFalse; + } + break; + default: + break; + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::CCamNaviCounterModel +// C++ constructor +// --------------------------------------------------------- +// +CCamNaviCounterModel::CCamNaviCounterModel( CCamAppController& aController ) + : iController( aController ) + { + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::ConstructL +// Symbian OS 2nd phase constructor +// --------------------------------------------------------- +// +void CCamNaviCounterModel::ConstructL() + { + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMNAVICOUNTERMODEL_CONSTRUCTL, "e_CCamNaviCounterModel_ConstructL 1" ); + PRINT( _L("Camera => CCamNaviCounterModel::ConstructL") ); + iExtent = TRect(0, 0, 0, 0); + + UpdateCounter(); + iController.AddControllerObserverL( this ); + + PRINT( _L("Camera <> Load resource data..") ); + + LoadResourceDataL(); + + TFileName resFileName; + CamUtility::ResourceFileName( resFileName ); + TPtrC resname = resFileName; + +#ifdef PRODUCT_SUPPORTS_POST_CAPTURE_INDICATORS + AknIconUtils::CreateIconL( iMpeg4Icon, + iMpeg4IconMask, + resname, + EMbmCameraappQgn_prop_cam4_codec_mp4, + EMbmCameraappQgn_prop_cam4_codec_mp4_mask ); + + AknIconUtils::CreateIconL( i3GPIcon, + i3GPIconMask, + resname, + EMbmCameraappQgn_prop_cam4_codec_3gp, + EMbmCameraappQgn_prop_cam4_codec_3gp_mask ); +#endif + + // wait for engine to initialise video recorder + iVideoInitialised = EFalse; + + PRINT( _L("Camera <> construct navi self timer..") ); + ConstructNaviSelfTimerL( resname ); + + + PRINT( _L("Camera <> construct navi sequence..") ); + ConstructNaviSequenceL( resname ); + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + PRINT( _L("Camera <> construct generic setup..") ); + ConstructNaviGenericSetupL( resname ); +#endif + + PRINT( _L("Camera <> construct navi audio mute..") ); + ConstructNaviAudioMuteL( resname ); + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + PRINT( _L("Camera <> construct navi subtitle..") ); + ConstructNaviModeSubtitleL( resname ); +#endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + iBurstActive = appUi->IsBurstEnabled(); +#if defined( PRODUCT_SUPPORTS_NAVIPANE_SEQUENCE ) + iDrawSequence = iBurstActive; +#endif // PRODUCT_SUPPORTS_NAVIPANE_SEQUENCE + + PRINT( _L("Camera <> construct observer handler..") ); + iObserverHandler = CCamObserverHandler::NewL(); + + if ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsLocationSupported() ) + { + iLocationIconVisible = (/*TCamLocationId::ECamLocationOn*/1 == iController.IntegerSettingValue( ECamSettingItemRecLocation )); + } + PRINT( _L("Camera <= CCamNaviCounterModel::ConstructL") ); + OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMNAVICOUNTERMODEL_CONSTRUCTL, "e_CCamNaviCounterModel_ConstructL 0" ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::Draw +// Draw the control +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawNaviCtr( CBitmapContext& aGc, + const CCoeControl* aControl ) const + { + DrawCounter( aGc, aControl ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawCounter +// Draw the control +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawCounter( CBitmapContext& aGc, + const CCoeControl* /*aControl*/ ) const + { + PRINT_FRQ( _L("Camera => CCamNaviCounterModel::DrawCounter" )) + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + const TCamViewState& viewState( appUi->CurrentViewState() ); + + + // ------------------------------------------------------- + // Precapture state + if ( ECamViewStatePreCapture == viewState ) + { + TBool inSequence = iController.SequenceCaptureInProgress(); + TBool inTimeLapse = inSequence && (ECamImageCaptureTimeLapse == iImageMode); + TBool inBurst = inSequence && (ECamImageCaptureBurst == iImageMode); + + TBool stillCapturing = ECamImageCaptureSingle == iImageMode + && iController.IsProcessingCapture(); + + + // Audio mute icon should be drawn even though courtesy UI applies. + if ( iMode == ECamControllerVideo ) + { + DrawNaviAudioMute( aGc ); + } + // these are drawn when sequence capture is in progress and + // should be drawn even when courtesy stuff is off + if ( inTimeLapse || inBurst ) + { + iSequenceInCaptureDecorator->Draw( aGc, iExtent ); + } + else + { + // To prevent Lint warning + } + // Draw the navipane sequence icon if current performing a timelapse or burst capture + if ( inTimeLapse || inBurst ) + { + DrawNaviSequence( aGc ); + } + if ( inTimeLapse && iController.TimeLapseSupported() ) + { + // Draw the captured images and captured remaining text + DrawSequenceImageText( skin, aGc ); + // Draw the timelapse countdown counter + DrawTimeLapseCountdown( skin, aGc ); + } + else if ( inBurst ) + { + // Draw the captured images and captured remaining text + DrawSequenceImageText( skin, aGc ); + } + + if ( appUi && ( appUi->DrawPreCaptureCourtesyUI() || + ( !appUi->DrawPreCaptureCourtesyUI() && appUi->IsSecondCameraEnabled() ) ) ) + { + + if ( !inTimeLapse && !inBurst && !iController.IsProcessingCapture() ) + { + // Draw the icon for storage location (Phone/MediaCard) + DrawStorageIcon( aGc ); + } + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_SEQUENCE + if ( iDrawSequence ) + { + DrawNaviSequence( aGc ); + } +#endif // PRODUCT_SUPPORTS_NAVIPANE_SEQUENCE + + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + DrawNaviGenericSetup( aGc ); +#endif // PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + + if ( iMode == ECamControllerVideo ) + { + // only draw remaining time when engine has initialised video + if ( iVideoInitialised && iVideoTextItem && !iController.IsProcessingCapture() ) + { + iVideoTextItem->Draw( aGc ); + } + } + else if ( !stillCapturing && iPhotoTextItem && !inBurst) + { + iPhotoTextItem->Draw( aGc ); + } + else + { + // To prevent Lint warning + } + } + } + + // ------------------------------------------------------- + // Post capture state + else if ( ECamViewStatePostCapture == viewState + || ECamViewStateBurstThumbnail == viewState ) + { + if ( appUi->DrawPostCaptureCourtesyUI() ) + { + + TRAP_IGNORE( DrawCurrentFileSizeL( skin, aGc ) ); + +#ifdef PRODUCT_SUPPORTS_POST_CAPTURE_INDICATORS + // Draw the icon for storage location (Phone/MediaCard) + DrawStorageIcon( aGc ); + + if ( iMode == ECamControllerVideo ) + { + // Draw the video file type indicator + DrawVideoFileTypeIndicator( aGc ); + } +#endif // PRODUCT_SUPPORTS_POST_CAPTURE_INDICATORS + + if ( appUi->CurrentBurstMode() == ECamImageCaptureTimeLapse ) + { + // Draw images captured text background + PRINT( _L("Camera <> Drawing timelapse postcapture decorator.. #######################") ); + iTimeLapsePostCaptureDecorator->Draw( aGc, iExtent ); + // Draw images capture text + TRAP_IGNORE( DrawImagesCapturedTextL( skin, aGc ) ); + } + + } + } + // ------------------------------------------------------- + // otherwise, do nothing + else + { + // empty statement to remove Lint error, MISRA required rule 60 + } + // ------------------------------------------------------- + + DrawNaviSelfTimer( aGc, skin ); + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + DrawNaviModeSubtitle( aGc, skin ); +#endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + + PRINT_FRQ( _L("Camera <= CCamNaviCounterModel::DrawCounter" )) + } + + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawCounter +// Draw the control +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawCounterToBitmaps( CFbsBitGc& aBmpGc, + CFbsBitGc& aBmpMaskGc ) const + { + PRINT( _L("Camera => CCamNaviCounterModel::DrawCounterToBitmaps" )) + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + // Draw bitmaps to use in the real navi pane in the settings views + if ( appUi->CurrentViewState() == ECamViewStateSettings ) + { + DrawStorageIconToBitmap( aBmpGc, aBmpMaskGc ); + const CFont* font = AknLayoutUtils::FontFromId(EAknLogicalFontSecondaryFont); + // TRgb color = layoutText.Color(); + TRgb color = KRgbWhite; + // Color is not updated if it not found from the skin + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + AknsUtils::GetCachedColor( skin, color, KNaviPaneMajorColour, KNaviPaneMinorColour ); + aBmpGc.SetPenColor(color); + aBmpGc.UseFont(font); + if ( iMode == ECamControllerVideo ) + { + + TBufC buf( iRemainingTimeText ); + TPtr pointer = buf.Des(); + AknTextUtils::LanguageSpecificNumberConversion( pointer ); + aBmpGc.DrawText( buf, TPoint( 35, font->HeightInPixels()) ); + } + else + { + TBufC buf( iCounterText ); + TPtr pointer = buf.Des(); + AknTextUtils::LanguageSpecificNumberConversion( pointer ); + aBmpGc.DrawText( buf, TPoint( 35, font->HeightInPixels()) ); + } + aBmpGc.DiscardFont(); + + aBmpMaskGc.SetPenColor(KRgbBlack); + aBmpMaskGc.UseFont(font); + if ( iMode == ECamControllerVideo ) + { + TBufC buf( iRemainingTimeText ); + TPtr pointer = buf.Des(); + AknTextUtils::LanguageSpecificNumberConversion( pointer ); + aBmpMaskGc.DrawText( buf, TPoint( 35,font->HeightInPixels()) ); + + } + else + { + + TBufC buf( iCounterText ); + TPtr pointer = buf.Des(); + AknTextUtils::LanguageSpecificNumberConversion( pointer ); + aBmpMaskGc.DrawText( buf, TPoint( 35,font->HeightInPixels()) ); + + } + aBmpMaskGc.DiscardFont(); + } + PRINT( _L("Camera <= CCamNaviCounterModel::DrawCounterToBitmaps" )) + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawStorageIconToBitmap +// Draw the icon for the media storage location +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawStorageIconToBitmap( CFbsBitGc& aBmpGc, + CFbsBitGc& aBmpMaskGc ) const + { + CFbsBitmap* icon = NULL; + CFbsBitmap* mask = NULL; + switch( iStorageLocation ) + { + case ECamMediaStoragePhone: + { + icon = iPhoneIcon; + mask = iPhoneIconMask; + } + break; + case ECamMediaStorageMassStorage: + { + icon = iMassStorageIcon; + mask = iMassStorageIconMask; + } + break; + case ECamMediaStorageCard: + { + icon = iMMCIcon; + mask = iMMCIconMask; + } + break; + case ECamMediaStorageNone: + default: + { + //TODO: Get icons when none is available + } + break; + } + // Should use layout + aBmpGc.BitBlt(TPoint(0,0), icon); + aBmpMaskGc.BitBlt(TPoint(0,0), mask); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawStorageIcon +// Draw the icon for the media storage location +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawStorageIcon( CBitmapContext& aGc ) const + { + CFbsBitmap* icon = NULL; + CFbsBitmap* mask = NULL; + switch( iStorageLocation ) + { + case ECamMediaStoragePhone: + { + icon = iPhoneIcon; + mask = iPhoneIconMask; + } + break; + case ECamMediaStorageMassStorage: + { + icon = iMassStorageIcon; + mask = iMassStorageIconMask; + } + break; + case ECamMediaStorageCard: + { + icon = iMMCIcon; + mask = iMMCIconMask; + } + break; + case ECamMediaStorageNone: + default: + { + //TODO: Get icons when none is available + } + break; + } + + if( icon == NULL || mask == NULL) + { + return; + } + + if ( iMode == ECamControllerVideo ) + { + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + + // Postcapture state + if ( appUi->CurrentViewState() == ECamViewStatePostCapture ) + { + aGc.BitBltMasked( iVidPostStorageIconRect.Rect().iTl, icon, icon->SizeInPixels(), mask, ETrue ); + } + else + { + aGc.BitBltMasked( iVidPreStorageIconRect.Rect().iTl, icon, icon->SizeInPixels(), mask, ETrue ); + } + } + else + { + aGc.BitBltMasked( iImgStorageIconRect.Rect().iTl, icon, icon->SizeInPixels(), mask, ETrue ); + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawVideoFileTypeIndicator +// Draw the icon for the video file type indicator +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawVideoFileTypeIndicator( CBitmapContext& aGc ) const + { + CFbsBitmap* icon = NULL; + CFbsBitmap* mask = NULL; + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + if ( appUi && appUi->DrawPreCaptureCourtesyUI() ) + { + TCamVideoFileType fileType = static_cast< TCamVideoFileType > + ( iController.IntegerSettingValue( ECamSettingItemVideoFileType ) ); + + if ( fileType == ECamVideoMpeg4 ) + { + icon = iMpeg4Icon; + mask = iMpeg4IconMask; + } + + // Otherwise display the H263 icon. + else + { + icon = i3GPIcon; + mask = i3GPIconMask; + } + + aGc.BitBltMasked( iVideoFileTypeIconRect.Rect().iTl, icon, icon->SizeInPixels(), mask, ETrue ); + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawText +// Draw the counter text (photo mode) +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawText( MAknsSkinInstance* /* aSkin */, + const TDesC& /* aText */, + CBitmapContext& /* aGc */ ) const + { + PRINT( _L("camera <> CCamNaviCounterModel::DrawText() not implemented" ) ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawTimeLapseCountdown +// Draw the timelapse image counter text (captured and remaining images) +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawTimeLapseCountdown( MAknsSkinInstance* /*aSkin*/, + CBitmapContext& aGc ) const + { + PRINT( _L("Camera => CCamNaviCounterModel::DrawTimeLapseCountdown") ); + if( iCountDownText ) + { + TBufC<32> buf( *iCountDownText ); // 00:00:00 as Unicode, 32 should be enough + TPtr pointer = buf.Des(); + AknTextUtils::LanguageSpecificNumberConversion( pointer ); + if ( iTimeLapseCountdownTextItem ) + { + TRAP_IGNORE( iTimeLapseCountdownTextItem->SetTextL( buf ) ); + iTimeLapseCountdownTextItem->Draw( aGc ); + } + } + else + { + PRINT( _L("Camera <> CCamNaviCounterModel::DrawTimeLapseCountdown .. [WARNING] no countdown text!") ); + } + PRINT( _L("Camera <= CCamNaviCounterModel::DrawTimeLapseCountdown") ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawSequenceImageText +// Draw the captured and remaining image count during timelapse capture +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawSequenceImageText( MAknsSkinInstance* /*aSkin*/, + CBitmapContext& aGc ) const + { + PRINT1( _L("CCamNaviCounterModel::DrawSequenceImageText %S" ), &iSequenceImageText ) + + if ( iSequenceImageTextItem ) + { + TRAP_IGNORE( iSequenceImageTextItem->SetTextL( iSequenceImageText ) ); + iSequenceImageTextItem->Draw( aGc ); + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawImagesCapturedTextL +// Draw the count of images captured in timelapse postcapture view +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawImagesCapturedTextL( + MAknsSkinInstance* /*aSkin*/, + CBitmapContext& aGc ) const + { + // Draw count of captured images + const TInt imagesCaptured = iController.TimeLapseImageCount(); + HBufC* capturedImagesText = StringLoader::LoadLC( R_CAM_TIMELAPSE_IMAGES_CAPTURED, imagesCaptured ); + + HBufC* buf = HBufC::NewLC( KCamDefaultCapturedImagesTextLen ); + if ( capturedImagesText->Length() > buf->Length() ) + { + buf->ReAlloc( capturedImagesText->Length() ); + } + + buf = capturedImagesText; + TPtr pointer = buf->Des(); + AknTextUtils::LanguageSpecificNumberConversion( pointer ); + + if ( iSequenceCapturedTextItem ) + { + iSequenceCapturedTextItem->SetTextL( *buf ); + iSequenceCapturedTextItem->Draw( aGc ); + } + + CleanupStack::PopAndDestroy( buf ); + CleanupStack::PopAndDestroy( capturedImagesText ); + } + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_FILENAME +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawCurrentFileName +// Draw the file name +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawCurrentFileName( MAknsSkinInstance* aSkin, + CBitmapContext& aGc ) const + { + TAknLayoutText layoutText; + if ( iMode == ECamControllerVideo ) + { + layoutText = iVideoNameLayout; + } + else + { + layoutText = iPhotoNameLayout; + } + // Draw counter text + TRgb color = layoutText.Color(); + + // Color is not updated if it not found from the skin + AknsUtils::GetCachedColor( aSkin, color, + KNaviPaneMajorColour, KNaviPaneMinorColour ); + + + layoutText.DrawText( aGc, iController.CurrentImageName() , ETrue, KRgbWhite ); + } +#endif // PRODUCT_SUPPORTS_NAVIPANE_FILENAME + + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawCurrentFileSizeL +// Draw the file size +// --------------------------------------------------------- +// + +void +CCamNaviCounterModel::DrawCurrentFileSizeL( MAknsSkinInstance* aSkin, + CBitmapContext& aGc ) const + { + TAknLayoutText layoutText; + if ( iMode == ECamControllerVideo ) + { + layoutText = iVideoSizeLayout; + } + else + { + layoutText = iPhotoSizeLayout; + } + // Draw counter text + TRgb color = layoutText.Color(); + + // Color is not updated if it not found from the skin + AknsUtils::GetCachedColor( aSkin, color, + KNaviPaneMajorColour, KNaviPaneMinorColour ); + + // Show the filename or burst name (if burst mode) + + //START: NOT DISPLAYING FILESIZE + /* + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + TInt size = 0; + + // Get the filesize + if ( appUi->CurrentViewState() == ECamViewStatePostCapture ) + { + TPtrC filename = iController.CurrentFullFileName(); + size = iController.FileSize( filename ); + } + else if ( appUi->CurrentViewState() == ECamViewStateBurstThumbnail ) + { + } + // otherwise, do nothing + else + { + // empty statement to remove Lint error, MISRA required rule 60 + } + */ + //END: NOT DISPLAYING FILESIZE + + if ( iMode == ECamControllerVideo ) + { + // Draw the file size string + TBuf <15> timebuf; + TBuf <30> fullbuf; + + // Generate the string for video length (time) + TTimeIntervalMicroSeconds interval = iController.RecordTimeElapsed(); + TTime time( interval.Int64() ); + time.FormatL( timebuf, *iTimeFormat ); + aGc.SetBrushColor( KRgbWhite ); + TBufC buf( timebuf ); + TPtr pointer = buf.Des(); + AknTextUtils::LanguageSpecificNumberConversion( pointer ); + layoutText.DrawText( aGc, pointer, EFalse, KRgbBlack ); + } + + // START: NOT DISPLAYING FILESIZE + /* + else + { + if ( size > 0 ) + { + // Draw the file size string + HBufC* fileSizeStr = StringLoader::LoadLC( R_QTN_SIZE_KB, size / KKilo ); + layoutText.DrawText( aGc, fileSizeStr->Des() , ETrue, KRgbWhite ); + CleanupStack::PopAndDestroy( fileSizeStr ); + } + } + */ + // END: NOT DISPLAYING FILESIZE + + } + + +// ---------------------------------------------------- +// CCamNaviCounterModel::BurstModeActiveL +// Notification that the burst mode has been activated/deactivated +// ---------------------------------------------------- +// +// burst mode icon is displayed in either the navipane or sidepane +void CCamNaviCounterModel::BurstModeActiveL( TBool aActive, TBool /*aStillModeActive*/ ) + { +#ifdef PRODUCT_SUPPORTS_NAVIPANE_SEQUENCE + // Update internal state, and trigger a redraw + iDrawSequence = aActive; + DrawDeferred(); +#endif // PRODUCT_SUPPORTS_NAVIPANE_SEQUENCE + + // update remaining images + iBurstActive = aActive; + UpdateCounter(); + } + + +// --------------------------------------------------------- +// CCamNaviCounterModel::ForceNaviPaneUpdate +// Force update of navi-pane (i.e after dismissal of MMC removed error note) +// --------------------------------------------------------- +// +void CCamNaviCounterModel::ForceNaviPaneUpdate() + { + PRINT( _L("Camera => CCamNaviCounterModel::ForceNaviPaneUpdate" )) + // update counters + // get current storage location + TInt key = ( ECamControllerVideo == iMode ) + ? ECamSettingItemVideoMediaStorage + : ECamSettingItemPhotoMediaStorage; + + if ( static_cast( CEikonEnv::Static()->AppUi() )->IsMMCRemovedNotePending() ) + { + PRINT( _L("Camera <> CCamNaviCounterModel::ForceNaviPaneUpdate pend") ) + iStorageLocation = + static_cast( + iController.IntegerSettingValueUnfiltered( key ) ); + } + else + { + PRINT( _L("Camera <> CCamNaviCounterModel::ForceNaviPaneUpdate yyy") ) + iStorageLocation = + static_cast( + iController.IntegerSettingValue( key ) ); + } + + if (ECamMediaStorageMassStorage ==iStorageLocation) + { + TCamMediaStorage storage = iController.IntegerSettingValue( ECamSettingItemRemovePhoneMemoryUsage )? + ECamMediaStorageNone: + ECamMediaStoragePhone; + iStorageLocation = iController.ExistMassStorage()?ECamMediaStorageMassStorage:storage; + } + UpdateCounter(); + + TRAP_IGNORE( UpdateRecordTimeAvailableL() ); + PRINT( _L("Camera <= CCamNaviCounterModel::ForceNaviPaneUpdate" )) + } + + +// --------------------------------------------------------- +// CCamNaviCounterModel::HandleControllerEventL +// Handle an event from CCamAppController. +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::HandleControllerEventL( TCamControllerEvent aEvent, + TInt /* aError */ ) + { + PRINT1( _L("Camera => CCamNaviCounterModel::HandleControllerEventL %d" ), aEvent ) + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + iCounterNeedUpdate = EFalse; + + switch( aEvent ) + { + // ----------------------------------------------------- + // If this is a capture complete event, or the image quality or save + // location has changed... +// case ECamEventCaptureComplete: + case ECamEventVideoQualityChanged: + case ECamEventImageQualityChanged: + case ECamEventSaveLocationChanged: + { + if( iMode == ECamControllerVideo ) + { + UpdateRecordTimeAvailableL(); + } + else + { + UpdateCounter(); + } + + if ( ECamEventSaveLocationChanged == aEvent ) + { + TCamSettingItemIds storageId = (ECamControllerVideo == iMode) + ? ECamSettingItemVideoMediaStorage + : ECamSettingItemPhotoMediaStorage; + + // update location + if ( appUi->IsMMCRemovedNotePending() ) + { + iStorageLocation = static_cast< TCamMediaStorage > + ( iController.IntegerSettingValueUnfiltered( storageId ) ); + } + else + { + iStorageLocation = static_cast< TCamMediaStorage > + ( iController.IntegerSettingValue( storageId ) ); + } + //CreateNaviBitmapsL( ETrue ); + + if (ECamMediaStorageMassStorage ==iStorageLocation) + { + TCamMediaStorage storage = iController.IntegerSettingValue( ECamSettingItemRemovePhoneMemoryUsage )? + ECamMediaStorageNone: + ECamMediaStoragePhone; + iStorageLocation = iController.ExistMassStorage()?ECamMediaStorageMassStorage:storage; + } + } + BroadcastEvent( ECamObserverEventNaviModelUpdated ); + break; + } + // ----------------------------------------------------- + case ECamEventLocationSettingChanged: + { + iLocationIconVisible = (/*TCamLocationId::ECamLocationOn*/1 == iController.IntegerSettingValue( ECamSettingItemRecLocation )); + // We reload the resource data so that the control is drawn correctly + ReloadResourceDataL(); + //BroadcastEvent( ECamObserverEventNaviModelUpdated ); + break; + } + // ----------------------------------------------------- + case ECamEventEngineStateChanged: + { + if( ECamControllerVideo == iMode ) + { + // wait until engine has initialised video before updating time remaining + if ( !iVideoInitialised ) + { + // + // if ( iController.EngineState() == ECamEngineVideoCapturePrepared ) + if ( iController.CameraState() == ECamCameraPreparedVideo ) + { + iVideoInitialised = ETrue; + } + } + if ( iVideoInitialised ) + { + UpdateRecordTimeAvailableL(); + if ( iController.IsViewFinding() ) + { + BroadcastEvent( ECamObserverEventNaviModelUpdated ); + } + } + } + else + { + // exited from video mode + iVideoInitialised = EFalse; + } + break; + } + + // ----------------------------------------------------- + case ECamEventSaveComplete: + case ECamEventRecordComplete: + { + if( ECamControllerVideo == iMode ) + { + UpdateRecordTimeAvailableL(); + } + else + { + switch( iImageMode ) + { + case ECamImageCaptureBurst: + case ECamImageCaptureTimeLapse: + // Sequence: captured / remaining + UpdateSequenceImageCount(); + break; + default: + // Remaining images + UpdateCounter(); + break; + } + } + // no broadcast if in burst and all snapshots have not been received + if( !( iMode == ECamControllerImage && + iImageMode == ECamImageCaptureBurst && + !iController.AllSnapshotsReceived()) ) + { + BroadcastEvent( ECamObserverEventNaviModelUpdated ); + } + break; + } + case ECamEventAudioMuteStateChanged: + { + if ( appUi->IsDirectViewfinderActive() ) + { + appUi->HandleCommandL( ECamCmdRedrawScreen ); + } + //Remaining Recording time is updated before drawing + //CreateNaviBitmapsL( ETrue ); + break; + } + // ----------------------------------------------------- + case ECamEventCounterUpdated: + { + if( iController.SequenceCaptureInProgress() + && ( ECamImageCaptureTimeLapse == iImageMode + || ECamImageCaptureBurst == iImageMode ) ) + { + // UpdateCounter; + iCounterNeedUpdate = ETrue; + UpdateSequenceImageCount(); + if ( ECamImageCaptureTimeLapse == iImageMode ) + { + // Update remaining time till next capture + UpdateTimeLapseCountdownL(); + } + if( iController.AllSnapshotsReceived() ) + { + PRINT( _L("CCamNaviCounterModel BroadcastEvent( ECamObserverEventNaviModelUpdated )" ) ) + BroadcastEvent( ECamObserverEventNaviModelUpdated ); + } + } + break; + } + // ----------------------------------------------------- + default: + { + break; + } + // ----------------------------------------------------- + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::ConstructNaviSelfTimerL +// Creating the member variables required for showing the +// self timer state in the navipane +// --------------------------------------------------------- +// +void CCamNaviCounterModel::ConstructNaviSelfTimerL( TPtrC& aResname ) + { + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + + // Setup self timer icon. + // ...Create the icon + TSize size = iSelfTimerIconRect.Rect().Size(); + AknIconUtils::CreateIconL( iSelfTimerIcon, + iSelfTimerMask, + aResname, + EMbmCameraappQgn_indi_cam4_selftimer, + EMbmCameraappQgn_indi_cam4_selftimer_mask ); + AknIconUtils::SetSize( iSelfTimerIcon, size ); + + // ...Add self as an observer of the self timer. + CCamSelfTimer* selftimer = appUi->SelfTimer(); + if ( selftimer ) + { + selftimer->AddObserverL( this ); + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawNaviSelfTimer +// Draw the self timer icon +// --------------------------------------------------------- +// +void +CCamNaviCounterModel::DrawNaviSelfTimer( CBitmapContext& aGc, + MAknsSkinInstance* /*aSkin*/ ) const + { + // Draw self timer icons, if set to on. + if ( iDrawSelfTimer ) + { + if ( CamUtility::IsNhdDevice() ) + { + aGc.SetBrushColor( KRgbWhite ); + aGc.SetBrushStyle( CGraphicsContext::ENullBrush ); + iSelfTimerTextLayout.DrawText( aGc, iSelfTimerText, EFalse, KRgbBlack ); + + aGc.BitBltMasked( iSelfTimerIconRect.Rect().iTl, iSelfTimerIcon, + iSelfTimerIcon->SizeInPixels(), iSelfTimerMask, ETrue ); + } + else + { + aGc.SetBrushColor( KRgbBlack ); + aGc.SetBrushStyle( CGraphicsContext::ENullBrush ); + iSelfTimerTextLayout.DrawText( aGc, iSelfTimerText, EFalse, KRgbWhite ); + + aGc.BitBltMasked( iSelfTimerIconRect.Rect().iTl, iSelfTimerIcon, + iSelfTimerIcon->SizeInPixels(), iSelfTimerMask, ETrue ); + } + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::ConstructNaviSequenceL +// Creating the member variables required for showing the +// sequence capture state in the navipane +// --------------------------------------------------------- +// +void CCamNaviCounterModel::ConstructNaviSequenceL( TPtrC& aResname ) + { + // Setup sequence icon. + // ...Create the icon + TSize size = iSequenceIconRect.Rect().Size(); + AknIconUtils::CreateIconL( iSequenceIcon, + iSequenceMask, + aResname, + EMbmCameraappQgn_indi_cam4_sequence_burst, + EMbmCameraappQgn_indi_cam4_sequence_burst_mask ); + AknIconUtils::SetSize( iSequenceIcon, size ); + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + + // ...Add self as an observer of burst mode + appUi->AddBurstModeObserverL( this ); + } + + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawNaviSequence +// Draw the sequence capture icon +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawNaviSequence( CBitmapContext& aGc ) const + { + aGc.BitBltMasked( iSequenceIconRect.Rect().iTl, iSequenceIcon, + iSequenceIcon->SizeInPixels(), iSequenceMask, ETrue); + } + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR +// --------------------------------------------------------- +// CCamNaviCounterModel::ConstructNaviGenericSetupL +// Creating the member variables required for showing the +// generic setup state in the navipane +// --------------------------------------------------------- +// +void CCamNaviCounterModel::ConstructNaviGenericSetupL( TPtrC& aResname ) + { + // Setup generic setup icon. + // ...Create the icon + TSize size = iGenericIconRect.Rect().Size(); + AknIconUtils::CreateIconL( iGenericIcon, + iGenericMask, + aResname, + EMbmCameraappQgn_indi_lcam_generic, + EMbmCameraappQgn_indi_lcam_generic_mask ); + AknIconUtils::SetSize( iGenericIcon, size ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawNaviGenericSetup +// Draw the generic setup icon +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawNaviGenericSetup( CBitmapContext& aGc ) const + { + if ( ( iMode == ECamControllerVideo && !iController.VideoSceneDefaultsAreSet() ) || + ( iMode != ECamControllerVideo && !iController.PhotoSceneDefaultsAreSet() ) ) + { + aGc.BitBltMasked( iGenericIconRect.Rect().iTl, iGenericIcon, + iGenericIcon->SizeInPixels(), iGenericMask, ETrue); + } + } +#endif // PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + + + + +// --------------------------------------------------------- +// CCamNaviCounterModel::ConstructNaviAudioMuteL +// Creating the member variables required for showing the +// audio mute state in the navipane +// --------------------------------------------------------- +// +void CCamNaviCounterModel::ConstructNaviAudioMuteL( TPtrC& aResname ) + { + // Setup generic setup icon. + + // ...Create the icon + TSize size = iAudioMuteIconRect.Rect().Size(); + AknIconUtils::CreateIconL( iAudioMuteIcon, + iAudioMuteMask, + aResname, + EMbmCameraappQgn_indi_vid4_audio_mute, + EMbmCameraappQgn_indi_vid4_audio_mute_mask ); + AknIconUtils::SetSize( iAudioMuteIcon, size ); + } + + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawNaviAudioMute +// Draw the audio mute icon +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawNaviAudioMute( CBitmapContext& aGc ) const + { + TCamSettingsOnOff audio = static_cast< TCamSettingsOnOff > + ( iController.IntegerSettingValue( ECamSettingItemVideoAudioRec ) ); + + // If the current mode is in video and the audio has been + // muted, display the audio mute indicator. + if ( ( ECamSettOff == audio ) && ( iMode == ECamControllerVideo ) ) + { + // Draw icon + aGc.BitBltMasked( iAudioMuteIconRect.Rect().iTl, iAudioMuteIcon, + iAudioMuteIcon->SizeInPixels(), iAudioMuteMask, ETrue); + } + } + + + + +#ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE +// --------------------------------------------------------- +// CCamNaviCounterModel::ConstructNaviModeSubtitleL +// Creating the member variables required for showing the +// current mode in the navipane +// --------------------------------------------------------- +// +void CCamNaviCounterModel::ConstructNaviModeSubtitleL( TPtrC& aResname ) + { + // Setup generic setup icon. + + // ...Create the icon (photo icon) + TSize size = iSubtitlePhotoRect.Rect().Size(); + AknIconUtils::CreateIconL( iSubtitlePhotoIcon, + iSubtitlePhotoMask, + aResname, + EMbmCameraappQgn_indi_cam_photomode, + EMbmCameraappQgn_indi_cam_photomode_mask ); + AknIconUtils::SetSize( iSubtitlePhotoIcon, size ); + + // ...Create the icon (video icon) + size = iSubtitlePhotoRect.Rect().Size(); + AknIconUtils::CreateIconL( iSubtitleVideoIcon, + iSubtitleVideoMask, + aResname, + EMbmCameraappQgn_indi_cam_videomode, + EMbmCameraappQgn_indi_cam_videomode_mask ); + AknIconUtils::SetSize( iSubtitleVideoIcon, size ); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DrawNaviModeSubtitle +// Draw the subtitle text and icon +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DrawNaviModeSubtitle( CBitmapContext& aGc, MAknsSkinInstance* aSkin ) const + { + CWindowGc& gc = SystemGc(); + // Set drawing colour + TRgb color = iSelfTimerTextLayout.Color(); + // ...Color is not updated if it not found from the skin + AknsUtils::GetCachedColor( aSkin, color, + KNaviPaneMajorColour, KNaviPaneMinorColour ); + + if ( iMode == ECamControllerVideo ) + { + + iSubtitleVideoTextLayout.DrawText( gc, iSubtitleVideoText->Des(), ETrue, KRgbWhite ); + aGc.BitBltMasked( iSubtitleVideoRect.Rect().iTl, iSubtitleVideoIcon, + iSubtitleVideoIcon->SizeInPixels(), iSubtitleVideoMask, ETrue); + } + else + { + + iSubtitlePhotoTextLayout.DrawText( gc, iSubtitlePhotoText->Des(), ETrue, KRgbWhite ); + aGc.BitBltMasked( iSubtitlePhotoRect.Rect().iTl, iSubtitlePhotoIcon, + iSubtitlePhotoIcon->SizeInPixels(), iSubtitlePhotoMask, ETrue); + } + } +#endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + + + +// --------------------------------------------------------- +// CCamNaviCounterModel::SetExtentL +// Sets where the navicounter should be rendered +// --------------------------------------------------------- +// +void CCamNaviCounterModel::SetExtentL( TRect aExtent ) + { + if ( aExtent != iExtent ) + { + iExtent = aExtent; + } + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::RegisterObserverL +// Registers an observer +// --------------------------------------------------------- +// +void CCamNaviCounterModel::RegisterObserverL(MCamObserver* aObserver) + { + iObserverHandler->RegisterObserverL(aObserver); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::DeregisterObserver +// Deregisters an observer +// --------------------------------------------------------- +// +void CCamNaviCounterModel::DeregisterObserver(MCamObserver* aObserver) + { + iObserverHandler->DeregisterObserver(aObserver); + } + +// --------------------------------------------------------- +// CCamNaviCounterModel::BroadcastEvent +// Broadcasts an event code to all observers +// --------------------------------------------------------- +// +void CCamNaviCounterModel::BroadcastEvent(TCamObserverEvent aEvent) + { + iObserverHandler->BroadcastEvent(aEvent); + } + +// --------------------------------------------------------------------------- +// CCamNaviCounterModel::CreateNaviBitmapsL +// Set up the memory icon and counter in the navipane +// --------------------------------------------------------------------------- +// +void CCamNaviCounterModel::CreateNaviBitmapsL( const TBool aDrawIcons ) + { + PRINT( _L("Camera => CCamNaviCounterModel::CreateNaviBitmapsL") ); + CCamAppUi* camAppUi = ( CCamAppUi* )iAvkonAppUiBase; + if ( camAppUi && camAppUi->SettingsLaunchedFromCamera() ) + { + CEikStatusPane* sp = camAppUi->StatusPane(); + + TUid npUid ; + npUid.iUid = EEikStatusPaneUidNavi; + CAknNavigationControlContainer* naviPane = + ( CAknNavigationControlContainer* )sp->ControlL( npUid ); + + // dispose of old decorator and bitmaps + if( iNaviDec ) + { + // do we need to pop it off the navi pane stack first? + delete iNaviDec; + iNaviDec = NULL; + iNaviBitmap = NULL; + iNaviBitmapMask = NULL; + } + + if( iNaviBitmap ) + { + delete iNaviBitmap; + iNaviBitmap = NULL; + } + + iNaviBitmap = new ( ELeave ) CFbsBitmap(); + User::LeaveIfError( iNaviBitmap->Create( TSize(250,20), EColor64K ) ); + CFbsBitmapDevice* bmpDevice = NULL; + bmpDevice = CFbsBitmapDevice::NewL( iNaviBitmap ); + CleanupStack::PushL( bmpDevice ); + CFbsBitGc* bmpGc = NULL; + User::LeaveIfError( bmpDevice->CreateContext( bmpGc ) ); + CleanupStack::PushL( bmpGc ); + + if( iNaviBitmapMask ) + { + delete iNaviBitmapMask; + iNaviBitmapMask = NULL; + } + iNaviBitmapMask = new ( ELeave ) CFbsBitmap(); + User::LeaveIfError( iNaviBitmapMask->Create( TSize(250,20), EColor64K ) ); + CFbsBitmapDevice* bmpMaskDevice = NULL; + bmpMaskDevice = CFbsBitmapDevice::NewL( iNaviBitmapMask ); + CleanupStack::PushL( bmpMaskDevice ); + CFbsBitGc* bmpMaskGc = NULL; + User::LeaveIfError( bmpMaskDevice->CreateContext( bmpMaskGc ) ); + CleanupStack::PushL( bmpMaskGc ); + + if ( aDrawIcons ) + { + if ( iMode == ECamControllerVideo ) + { + UpdateRecordTimeAvailableL(); + } + DrawCounterToBitmaps( *bmpGc, *bmpMaskGc ); + } + // Create the new decorator and push on to navi stack + iNaviDec = naviPane->CreateNavigationImageL( iNaviBitmap, + iNaviBitmapMask ); + CleanupStack::PopAndDestroy( bmpMaskGc ); + CleanupStack::PopAndDestroy( bmpMaskDevice ); + CleanupStack::PopAndDestroy( bmpGc ); + CleanupStack::PopAndDestroy( bmpDevice ); + naviPane->PushL( *iNaviDec ); + } + PRINT( _L("Camera <= CCamNaviCounterModel::CreateNaviBitmapsL") ); + } + +// --------------------------------------------------------------------------- +// CCamNaviCounterModel::NonTouchLayoutL +// --------------------------------------------------------------------------- +void CCamNaviCounterModel::NonTouchLayoutL() + { + TInt variant = 0; + + TInt cba = AknLayoutUtils::CbaLocation() == + AknLayoutUtils::EAknCbaLocationLeft? + AknLayoutUtils::EAknCbaLocationLeft : 0; + + TAknLayoutRect camIndicatorPane; + camIndicatorPane.LayoutRect( iExtent, + AknLayoutScalable_Apps::cam6_indi_pane( variant )); + + iImgStorageIconRect.LayoutRect( camIndicatorPane.Rect(), + AknLayoutScalable_Apps::cam6_indi_pane_g2( cba ) ); + + iPhotoTextItem->SetLayoutL( camIndicatorPane.Rect(), + AknLayoutScalable_Apps::cam6_indi_pane_t1( cba ) ); + + TAknLayoutRect vidIndicatorPane; + vidIndicatorPane.LayoutRect( iExtent, + AknLayoutScalable_Apps::vid6_indi_pane( cba ) ); + + iVidPreStorageIconRect.LayoutRect( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_g3( cba ) ); + + iVideoTextLayout.LayoutText( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t1( cba ) ); + + iVideoTextItem->SetLayoutL( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t1( cba ) ); + + TAknLayoutRect vidProgressPane; + vidProgressPane.LayoutRect( iExtent, + AknLayoutScalable_Apps::vid6_indi_pane( cba ) ); + + iSequenceImageTextItem->SetLayoutL( + vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t4( 2 ) ); + + iTimeLapseCountdownTextItem->SetLayoutL( + vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t4( 2 ) ); + + iSequenceCapturedTextItem->SetLayoutL( + vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t4( 2 ) ); + + + // ...Load layout rect for self timer image. + TAknLayoutRect timerParent; + timerParent.LayoutRect( iExtent, + AknLayoutScalable_Apps::cam6_timer_pane( cba ) ); + iSelfTimerIconRect.LayoutRect( timerParent.Rect(), + AknLayoutScalable_Apps::cam6_timer_pane_g1( cba ) ); + iSelfTimerTextLayout.LayoutText( timerParent.Rect(), + AknLayoutScalable_Apps::cam6_timer_pane_t1( cba ) ); + + iVideoSizeLayout.LayoutText( vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t4( 2 ) ); // Magic: layout Opt2 + iPhotoSizeLayout = iVideoSizeLayout; + + // ...Load layout rect for sequence image. + iSequenceIconRect.LayoutRect( iExtent, + AknLayoutScalable_Apps::cam6_mode_pane_g2( cba ) ); + + iAudioMuteIconRect.LayoutRect( iExtent, + AknLayoutScalable_Apps::cam6_mode_pane_g2( cba ) ); + + } + +// --------------------------------------------------------------------------- +// CCamNaviCounterModel::NonTouchLayoutSecondaryL +// --------------------------------------------------------------------------- +void CCamNaviCounterModel::NonTouchLayoutSecondaryL() + { + // Magic numbers used for layout variation + TAknLayoutRect camIndicatorPane; + camIndicatorPane.LayoutRect( iExtent, + AknLayoutScalable_Apps::cam6_indi_pane( 3 )); + + iImgStorageIconRect.LayoutRect( camIndicatorPane.Rect(), + AknLayoutScalable_Apps::cam6_indi_pane_g2( 2 ) ); + + iPhotoTextItem->SetLayoutL( camIndicatorPane.Rect(), + AknLayoutScalable_Apps::cam6_indi_pane_t1( 4 ) ); + + TAknLayoutRect vidIndicatorPane; + vidIndicatorPane.LayoutRect( iExtent, + AknLayoutScalable_Apps::vid6_indi_pane( 3 ) ); + + iVidPreStorageIconRect.LayoutRect( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_g3( 2 ) ); + + iVideoTextLayout.LayoutText( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t1( 1 ) ); + + iVideoTextItem->SetLayoutL( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t1( 1 ) ); + + iVideoSizeLayout.LayoutText( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid6_indi_pane_t1( 1 ) ); + iPhotoSizeLayout = iVideoSizeLayout; + + iAudioMuteIconRect.LayoutRect( iExtent, + AknLayoutScalable_Apps::cam6_mode_pane_g1( 0 ) ); + + } + +// --------------------------------------------------------------------------- +// CCamNaviCounterModel::TouchLayoutL +// --------------------------------------------------------------------------- +void CCamNaviCounterModel::TouchLayoutL() + { + TInt variant = 0; // portrait + TInt indicatorVariant = 1; + if ( Layout_Meta_Data::IsLandscapeOrientation() ) + { + // Landscape layout variant + variant = 1; // landscape + indicatorVariant = 0; + } + TInt secCamera = ECamActiveCameraSecondary == iController.ActiveCamera(); + + TAknLayoutRect camIndicatorPane; + camIndicatorPane.LayoutRect( iExtent, + AknLayoutScalable_Apps::cam4_indicators_pane( variant ) ); + + iImgStorageIconRect.LayoutRect( camIndicatorPane.Rect(), + AknLayoutScalable_Apps::cam4_indicators_pane_g2( indicatorVariant ) ); + + iPhotoTextItem->SetLayoutL( camIndicatorPane.Rect(), + AknLayoutScalable_Apps::cam4_indicators_pane_t1( secCamera ) ); + + TAknLayoutRect vidIndicatorPane; + vidIndicatorPane.LayoutRect( iExtent, + AknLayoutScalable_Apps::vid4_progress_pane( variant ) );// vid4_indicators_pane should be used + + iVidPreStorageIconRect.LayoutRect( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid4_indicators_pane_g3( indicatorVariant ) ); + + #ifdef PRODUCT_SUPPORTS_POST_CAPTURE_INDICATORS + iVideoFileTypeIconRect.LayoutRect( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid4_indicators_pane_g2( indicatorVariant ) ); + #endif + + iVideoTextLayout.LayoutText( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid4_indicators_pane_t1( indicatorVariant ) ); + + iVideoTextItem->SetLayoutL( vidIndicatorPane.Rect(), + AknLayoutScalable_Apps::vid4_indicators_pane_t1( indicatorVariant ) ); + + + TAknLayoutRect vidProgressPane; + vidProgressPane.LayoutRect( + iExtent, + AknLayoutScalable_Apps::vid4_progress_pane( variant ) ); + + iSequenceImageTextItem->SetLayoutL( + vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid4_progress_pane_t3() ); + + iTimeLapseCountdownTextItem->SetLayoutL( + vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid4_progress_pane_t3() ); + + iSequenceCapturedTextItem->SetLayoutL( + vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid4_progress_pane_t3() ); + + + // ...Load layout rect for self timer image. + iSelfTimerIconRect.LayoutRect( iExtent, + AknLayoutScalable_Apps::main_camera4_pane_g5( variant ) ); + iSelfTimerTextLayout.LayoutText( iExtent, + AknLayoutScalable_Apps::main_camera4_pane_t1( variant ) ); + + #ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + if ( !AknLayoutUtils::LayoutMirrored() ) + { + iSubtitlePhotoTextLayout.LayoutText( iExtent, + ROID(R_CAM_SUBTITLE_PHOTOMODE_TEXT_LAYOUT_ID)); + iSubtitleVideoTextLayout.LayoutText( iExtent, + ROID(R_CAM_SUBTITLE_VIDEOMODE_TEXT_LAYOUT_ID)); + iSubtitlePhotoRect.LayoutRect( iExtent, + ROID(R_CAM_SUBTITLE_PHOTOMODE_ICON_RECT_ID)); + iSubtitleVideoRect.LayoutRect( iExtent, + ROID(R_CAM_SUBTITLE_VIDEOMODE_ICON_RECT_ID)); + } + else + { + iSubtitlePhotoTextLayout.LayoutText( iExtent, + ROID(R_CAM_SUBTITLE_PHOTOMODE_TEXT_LAYOUT_AH_ID)); + iSubtitleVideoTextLayout.LayoutText( iExtent, + ROID(R_CAM_SUBTITLE_VIDEOMODE_TEXT_LAYOUT_AH_ID)); + iSubtitlePhotoRect.LayoutRect( iExtent, + ROID(R_CAM_SUBTITLE_PHOTOMODE_ICON_RECT_AH_ID)); + iSubtitleVideoRect.LayoutRect( iExtent, + ROID(R_CAM_SUBTITLE_VIDEOMODE_ICON_RECT_AH_ID)); + } + + // ...Read the strings from the resource + iSubtitleVideoText = iCoeEnv->AllocReadResourceAsDes16L( + ROID(R_CAM_STILL_PRE_CAPTURE_SUBTITLE_TEXT_VIDEO_ID)); + iSubtitlePhotoText = iCoeEnv->AllocReadResourceAsDes16L( + ROID(R_CAM_STILL_PRE_CAPTURE_SUBTITLE_TEXT_PHOTO_ID)); + #endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE + + #ifdef PRODUCT_SUPPORTS_NAVIPANE_FILENAME + if ( !AknLayoutUtils::LayoutMirrored() ) + { + iPhotoNameLayout.LayoutText( iExtent, + ROID(R_CAM_POST_CAPTURE_IMAGE_NAME_LAYOUT_ID)); + iVideoNameLayout.LayoutText( iExtent, + ROID(R_CAM_POST_CAPTURE_VIDEO_NAME_LAYOUT_ID)); + } + else + { + iPhotoNameLayout.LayoutText( iExtent, + ROID(R_CAM_POST_CAPTURE_IMAGE_NAME_LAYOUT_AH_ID)); + iVideoNameLayout.LayoutText( iExtent, + ROID(R_CAM_POST_CAPTURE_VIDEO_NAME_LAYOUT_AH_ID)); + } + + #endif // PRODUCT_SUPPORTS_NAVIPANE_FILENAME + + + iVideoSizeLayout.LayoutText( vidProgressPane.Rect(), + AknLayoutScalable_Apps::vid4_progress_pane_t3( indicatorVariant )); + + if ( !AknLayoutUtils::LayoutMirrored() ) + { + iPhotoSizeLayout.LayoutText( iExtent, + ROID(R_CAM_POST_CAPTURE_IMAGE_SIZE_LAYOUT_ID)); + } + else + { + iPhotoSizeLayout.LayoutText( iExtent, + ROID(R_CAM_POST_CAPTURE_IMAGE_SIZE_LAYOUT_AH_ID)); + } + + // ...Load layout rect for sequence image. + iSequenceIconRect.LayoutRect( iExtent, + AknLayoutScalable_Apps::main_camera4_pane_g2( variant ) ); + + #ifdef PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + if ( !AknLayoutUtils::LayoutMirrored() ) + { + iGenericIconRect.LayoutRect( iExtent, + ROID(R_CAM_GENERIC_SETUP_ICON_RECT_ID)); + } + else + { + iGenericIconRect.LayoutRect( iExtent, + ROID(R_CAM_GENERIC_SETUP_ICON_RECT_AH_ID)); + } + #endif // PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR + + + CCamAppUi* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() ) + { + TRect mainPaneRect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, + mainPaneRect ); + iAudioMuteIconRect.LayoutRect( + mainPaneRect, + AknLayoutScalable_Apps::main_video4_pane_g2( variant ) ); + } + else + { + iAudioMuteIconRect.LayoutRect( + iExtent, + AknLayoutScalable_Apps::main_video4_pane_g2( variant ) ); + } + } + +// End of File