--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/src/CamSceneSettingContainer.cpp Wed Sep 01 12:30:54 2010 +0100
@@ -0,0 +1,1639 @@
+/*
+* Copyright (c) 2007 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: Container class for scene settings view*
+*/
+
+// INCLUDE FILES
+#include "CamSceneSettingContainer.h"
+#include "CamUtility.h"
+#include "CamPanic.h"
+
+#include <eikenv.h>
+#include <eikappui.h> // For CCoeAppUiBase
+#include <eikapp.h> // For CEikApplication
+#include <stringloader.h>
+#include <AknBidiTextUtils.h>
+#include <AknsUtils.h>
+#include <AknsDrawUtils.h>
+#include <cameraapp.mbg>
+#include <BitmapTransforms.h>
+#include <AknUtils.h>
+#include <AknLayoutFont.h>
+#include <barsRead.h> // resource reader
+
+#include <cameraapp.rsg>
+#include <vgacamsettings.rsg>
+
+
+// CONSTANTS
+
+const TInt KStepSize = 4; // Pixels the animation moves each timer event
+
+const TInt KCornerSize = 3;
+const TInt KBorderSize = 1;
+
+const TReal KNumIconStages = 7;
+
+#define KRgbGray4 TRgb(0xEEEEEE)
+#define KRgbGray3 TRgb(0xDDDDDD)
+#define KRgbGray2 TRgb(0xCCCCCC)
+#define KRgbGray1 TRgb(0xBBBBBB)
+
+
+#ifdef __WINS__
+static const TInt KTimerPeriod = 10000;
+#else
+static const TInt KTimerPeriod = 150000;
+#endif
+
+// ================= MEMBER FUNCTIONS =======================
+
+// -----------------------------------------------------------------------------
+// TCamAnimationData::Initialise
+// Sets up the animation data
+// -----------------------------------------------------------------------------
+//
+void TCamAnimationData::Initialise( const TRect& aRect )
+ {
+ iDeltaY = KStepSize;
+ // scrolling needs to be faster (2 times?) than the fade in/out
+ iScrollingY = iDeltaY * 2;
+
+ iCurrentRect = aRect;
+ iPreviousRect = iCurrentRect;
+ iCurrentRectOld = iCurrentRect;
+ iPreviousRectOld = iCurrentRect;
+
+ iStep = 0;
+ iPenFadeOut = KRgbBlack;
+ iPenFadeIn = KRgbWhite;
+ iScrolling = EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::NewL
+// Symbian OS two-phased constructor
+// ---------------------------------------------------------------------------
+//
+CCamSceneSettingItem* CCamSceneSettingItem::NewL( TCamSceneId aSceneId,
+ const TSize& aLargeBmpSize,
+ const TSize& aSmallBmpSize )
+ {
+ CCamSceneSettingItem* self = new( ELeave ) CCamSceneSettingItem( aSceneId );
+ CleanupStack::PushL( self );
+ self->ConstructL( aLargeBmpSize, aSmallBmpSize );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::~CCamSceneSettingItem
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CCamSceneSettingItem::~CCamSceneSettingItem()
+ {
+ PRINT( _L("Camera => ~CCamSceneSettingItem") );
+ delete iBitmapSmall;
+ delete iBitmap1;
+ delete iBitmap2;
+ delete iBitmap3;
+ delete iBitmap4;
+ delete iBitmap5;
+ delete iBitmap6;
+ delete iBitmapLarge;
+ delete iTitle;
+ delete iDescription;
+ PRINT( _L("Camera <= ~CCamSceneSettingItem") );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::SceneId
+// Returns the sceneId
+// ---------------------------------------------------------------------------
+//
+TCamSceneId CCamSceneSettingItem::SceneId() const
+ {
+ return iSceneId;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::Icon
+// Returns the bitmap specified by aSize
+// ---------------------------------------------------------------------------
+//
+const CFbsBitmap* CCamSceneSettingItem::Icon( TCamIconSize aSize ) const
+ {
+ if ( aSize == ECamIconSizeLarge )
+ {
+ return iBitmapLarge;
+ }
+ else if ( aSize == ECamIconSizeSmall )
+ {
+ return iBitmapSmall;
+ }
+ else if ( aSize == ECamIconSizeOne )
+ {
+ return iBitmap1;
+ }
+ else if ( aSize == ECamIconSizeTwo )
+ {
+ return iBitmap2;
+ }
+ else if ( aSize == ECamIconSizeThree )
+ {
+ return iBitmap3;
+ }
+ else if ( aSize == ECamIconSizeFour )
+ {
+ return iBitmap4;
+ }
+ else if ( aSize == ECamIconSizeFive )
+ {
+ return iBitmap5;
+ }
+ else if ( aSize == ECamIconSizeSix )
+ {
+ return iBitmap6;
+ }
+ else
+ {
+ return iBitmapLarge;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::Title
+// returns the title text
+// ---------------------------------------------------------------------------
+//
+const HBufC* CCamSceneSettingItem::Title() const
+ {
+ return iTitle;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::Description
+// returns the title text
+// ---------------------------------------------------------------------------
+//
+const HBufC* CCamSceneSettingItem::Description() const
+ {
+ return iDescription;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::ConstructL
+// Symbian OS second phase constructor
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingItem::ConstructL( const TSize& aLargeBmpSize,
+ const TSize& aSmallBmpSize )
+ {
+ TInt bmpLarge = 0;
+ TInt bmpSmall = 0;
+ TInt title = 0;
+ TInt description = 0;
+ switch ( iSceneId )
+ {
+ case ECamSceneNight:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_night_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_night_l;
+ title = R_CAM_SCENE_TITLE_NIGHT;
+ description = R_CAM_SCENE_DESCRIPTION_NIGHT;
+ }
+ break;
+ case ECamSceneMacro:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_macro_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_macro_l;
+ title = R_CAM_SCENE_TITLE_MACRO;
+ description = R_CAM_SCENE_DESCRIPTION_MACRO;
+ }
+ break;
+ case ECamScenePortrait:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_port_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_port_l;
+ title = R_CAM_SCENE_TITLE_PORTRAIT;
+ description = R_CAM_SCENE_DESCRIPTION_PORTRAIT;
+ }
+ break;
+ case ECamSceneAuto:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_auto_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_auto_l;
+ title = R_CAM_SCENE_TITLE_AUTO;
+ description = R_CAM_SCENE_DESCRIPTION_AUTO;
+ }
+ break;
+ case ECamSceneScenery:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_land_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_land_l;
+ title = R_CAM_SCENE_TITLE_LANDSCAPE;
+ description = R_CAM_SCENE_DESCRIPTION_LANDSCAPE;
+ }
+ break;
+ case ECamSceneSports:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_sport_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_sport_l;
+ title = R_CAM_SCENE_TITLE_SPORTS;
+ description = R_CAM_SCENE_DESCRIPTION_SPORTS;
+ }
+ break;
+ case ECamSceneUser:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_user_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_user_l;
+ title = R_CAM_SCENE_TITLE_USER;
+ description = R_CAM_SCENE_DESCRIPTION_USER;
+ }
+ break;
+ case ECamSceneNormal:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_auto_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_auto_l;
+ title = R_CAM_SCENE_TITLE_NORMAL;
+ description = R_CAM_SCENE_DESCRIPTION_NORMAL;
+ }
+ break;
+ case ECamSceneNightScenery:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_nightland_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_nightland_l;
+ title = R_CAM_SCENE_TITLE_NIGHT_LANDSCAPE;
+ description = R_CAM_SCENE_DESCRIPTION_NIGHT_LANDSCAPE;
+ }
+ break;
+ case ECamSceneNightPortrait:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_nightport_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_nightport_l;
+ title = R_CAM_SCENE_TITLE_NIGHT_PORTRAIT;
+ description = R_CAM_SCENE_DESCRIPTION_NIGHT_PORTRAIT;
+ }
+ break;
+ case ECamSceneCandlelight:
+ {
+ bmpSmall = EMbmCameraappQgn_ico_lcam_sce_candle_s;
+ bmpLarge = EMbmCameraappQgn_ico_lcam_sce_candle_l;
+ title = R_CAM_SCENE_TITLE_CANDLELIGHT;
+ description = R_CAM_SCENE_DESCRIPTION_CANDLELIGHT;
+ }
+ break;
+ default:
+ User::Leave( KErrGeneral );
+ break;
+ }
+
+ // Find the name and path of the MBM file for bitmaps
+ TFileName mbmFileName;
+ CamUtility::ResourceFileName( mbmFileName );
+
+ iBitmapSmall = AknIconUtils::CreateIconL( mbmFileName, bmpSmall );
+ AknIconUtils::SetSize( iBitmapSmall, aSmallBmpSize, EAspectRatioNotPreserved );
+
+ TReal xInc = TReal( aLargeBmpSize.iWidth - aSmallBmpSize.iWidth ) / KNumIconStages;
+ TReal yInc = TReal( aLargeBmpSize.iHeight - aSmallBmpSize.iHeight ) / KNumIconStages;
+
+ TSize size;
+ TReal width = aSmallBmpSize.iWidth;
+ TReal height = aSmallBmpSize.iHeight;
+
+ width += xInc;
+ height += yInc;
+ size.SetSize( ( TInt ) width, ( TInt ) height );
+
+ iBitmap1 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );
+ AknIconUtils::SetSize( iBitmap1, size, EAspectRatioNotPreserved);
+
+ width += xInc;
+ height += yInc;
+ size.SetSize( ( TInt ) width, ( TInt ) height );
+
+ iBitmap2 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );
+ AknIconUtils::SetSize( iBitmap2, size, EAspectRatioNotPreserved );
+
+ width += xInc;
+ height += yInc;
+ size.SetSize( ( TInt ) width, ( TInt ) height );
+
+ iBitmap3 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );
+ AknIconUtils::SetSize( iBitmap3, size, EAspectRatioNotPreserved );
+
+ width += xInc;
+ height += yInc;
+ size.SetSize( ( TInt ) width, ( TInt ) height );
+
+ iBitmap4 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );
+ AknIconUtils::SetSize( iBitmap4, size, EAspectRatioNotPreserved );
+
+ width += xInc;
+ height += yInc;
+ size.SetSize( ( TInt ) width, ( TInt ) height );
+
+ iBitmap5 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );
+ AknIconUtils::SetSize( iBitmap5, size, EAspectRatioNotPreserved );
+
+ width += xInc;
+ height += yInc;
+ size.SetSize( ( TInt ) width, ( TInt ) height );
+
+ iBitmap6 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );
+ AknIconUtils::SetSize( iBitmap6, size, EAspectRatioNotPreserved );
+
+ iBitmapLarge = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );
+ AknIconUtils::SetSize( iBitmapLarge, aLargeBmpSize, EAspectRatioNotPreserved );
+
+ iTitle = StringLoader::LoadL( title );
+ iDescription = StringLoader::LoadL( description );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingItem::CCamSceneSettingContainer
+// C++ constructor
+// ---------------------------------------------------------------------------
+//
+CCamSceneSettingItem::CCamSceneSettingItem( TCamSceneId aSceneId ) :
+ iSceneId( aSceneId )
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::NewL
+// Symbian OS two-phased constructor
+// ---------------------------------------------------------------------------
+//
+CCamSceneSettingContainer*
+CCamSceneSettingContainer::NewL( const TRect& aRect,
+ CAknView& aView,
+ TCamCameraMode aMode,
+ CCamAppController& aController,
+ TBool aUserBaseScenes )
+ {
+ CCamSceneSettingContainer* self =
+ new( ELeave ) CCamSceneSettingContainer( aMode,
+ aController,
+ aView,
+ aUserBaseScenes );
+ CleanupStack::PushL( self );
+ self->ConstructL( aRect );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::~CCamSceneSettingContainer
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CCamSceneSettingContainer::~CCamSceneSettingContainer()
+ {
+ PRINT( _L( "Camera => ~CCamSceneSettingContainer" ) );
+
+ iSettingItemArray.ResetAndDestroy();
+ iSettingItemArray.Close();
+
+ iHighlightIcons.Close();
+ iNormalIcons.Close();
+ iDisplacedIcons.Close();
+
+ iHighlightArray.Close();
+ iHighlightTitles.Close();
+ iHighlightDescriptions.Close();
+
+ iNormalTitles.Close();
+ iDisplacedTitles.Close();
+
+ if (iAnimTimer)
+ {
+ iAnimTimer->Cancel();
+ }
+ delete iAnimTimer;
+ delete iScrollFrame;
+ delete iAnimData.iOffScreenBitmap;
+
+ PRINT( _L( "Camera <= ~CCamSceneSettingContainer" ) );
+ }
+
+// ---------------------------------------------------------
+// CCamSceneSettingContainer::ConstructL
+// Symbian OS 2nd phase constructor
+// ---------------------------------------------------------
+//
+void CCamSceneSettingContainer::ConstructL( const TRect& aRect )
+ {
+ PRINT(_L("Camera => CCamSceneSettingContainer::ConstructL") )
+
+ CCamContainerBase::BaseConstructL( aRect );
+
+ TBool secondCameraOn =
+ static_cast<CCamAppUiBase*>( iEikonEnv->AppUi() )->IsSecondCameraEnabled();
+
+ if( !AknLayoutUtils::LayoutMirrored() )
+ {
+ // get the icon positions from the resource
+ ReadLayoutL( ROID(R_CAM_SCENE_ICON_HIGHLIGHT_ARRAY_ID), iHighlightIcons );
+ ReadLayoutL( ROID(R_CAM_SCENE_ICON_DISPLACED_ARRAY_ID), iDisplacedIcons );
+ ReadLayoutL( ROID(R_CAM_SCENE_ICON_NORMAL_ARRAY_ID), iNormalIcons );
+
+ // get the highlight rects
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_LAYOUT_ARRAY_ID), iHighlightArray );
+
+ // Check if we require APAC layouts
+ if( AknLayoutUtils::Variant() == EApacVariant )
+ {
+ // get the layout texts
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_TITLE_ARRAY_APAC_ID), iHighlightTitles );
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_DESCRIPTION_ARRAY_APAC_ID), iHighlightDescriptions );
+
+ ReadLayoutL( ROID(R_CAM_SCENE_TITLE_NORMAL_ARRAY_APAC_ID), iNormalTitles );
+ ReadLayoutL( ROID(R_CAM_SCENE_TITLE_DISPLACED_ARRAY_APAC_ID), iDisplacedTitles );
+ }
+ else
+ {
+ // get the layout texts
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_TITLE_ARRAY_ID), iHighlightTitles );
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_DESCRIPTION_ARRAY_ID), iHighlightDescriptions );
+
+ ReadLayoutL( ROID(R_CAM_SCENE_TITLE_NORMAL_ARRAY_ID), iNormalTitles );
+ ReadLayoutL( ROID(R_CAM_SCENE_TITLE_DISPLACED_ARRAY_ID), iDisplacedTitles );
+ }
+ }
+ else
+ {
+ // get the icon positions from the resource
+ ReadLayoutL( ROID(R_CAM_SCENE_ICON_HIGHLIGHT_ARRAY_AH_ID), iHighlightIcons );
+ ReadLayoutL( ROID(R_CAM_SCENE_ICON_DISPLACED_ARRAY_AH_ID), iDisplacedIcons );
+ ReadLayoutL( ROID(R_CAM_SCENE_ICON_NORMAL_ARRAY_AH_ID), iNormalIcons );
+
+ // get the highlight rects
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_LAYOUT_ARRAY_AH_ID), iHighlightArray );
+
+ // get the layout texts
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_TITLE_ARRAY_AH_ID), iHighlightTitles );
+ ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_DESCRIPTION_ARRAY_AH_ID), iHighlightDescriptions );
+
+ ReadLayoutL( ROID(R_CAM_SCENE_TITLE_NORMAL_ARRAY_AH_ID), iNormalTitles );
+ ReadLayoutL( ROID(R_CAM_SCENE_TITLE_DISPLACED_ARRAY_AH_ID), iDisplacedTitles );
+ }
+
+ TResourceReader reader;
+ iEikonEnv->CreateResourceReaderLC( reader, ROID(R_CAM_SCENE_MAX_ITEMS_TO_DISPLAY_ID));
+ iNumberOfIconsToDisplay = reader.ReadInt16();
+ CleanupStack::PopAndDestroy(); // reader
+
+ if ( iUserBaseScenes )
+ {
+ CreateSceneArrayL( R_CAM_SCENE_LIST_USER );
+ TCamSceneId currentScene = static_cast<TCamSceneId>(
+ iController.IntegerSettingValue(
+ ECamSettingItemUserSceneBasedOnScene ) );
+ SetCurrentPositionToScene( currentScene );
+ SetupScrollbarL();
+ }
+ else if ( ECamControllerImage == iMode )
+ {
+ if ( secondCameraOn )
+ {
+ CreateSceneArrayL( R_CAM_SCENE_LIST_PHOTO_CAM2 );
+ }
+ else
+ {
+ CreateSceneArrayL( R_CAM_SCENE_LIST_PHOTO);
+ SetupScrollbarL();
+ }
+
+ TCamSceneId currentScene = static_cast<TCamSceneId>(
+ iController.IntegerSettingValue(
+ ECamSettingItemDynamicPhotoScene ) );
+ SetCurrentPositionToScene( currentScene );
+ }
+ else
+ {
+ if ( secondCameraOn )
+ {
+ CreateSceneArrayL( R_CAM_SCENE_LIST_VIDEO_CAM2);
+ }
+ else
+ {
+ CreateSceneArrayL( R_CAM_SCENE_LIST_VIDEO );
+ }
+
+ TCamSceneId currentScene = static_cast<TCamSceneId>(
+ iController.IntegerSettingValue(
+ ECamSettingItemDynamicVideoScene ) );
+ SetCurrentPositionToScene( currentScene );
+ }
+
+ TInt index = iCurrentArrayPosition - iTopDisplayPosition;
+ iAnimData.Initialise( iHighlightArray[index].Rect() );
+
+ // create a bitmap to be used off-screen
+ iAnimData.iOffScreenBitmap = new ( ELeave ) CFbsBitmap();
+ User::LeaveIfError( iAnimData.iOffScreenBitmap->Create( aRect.Size(), EColor256 ) );
+
+ TInt leftMarginDiff = iNormalIcons[0].Rect().iTl.iX -
+ iHighlightIcons[0].Rect().iTl.iX;
+ iAnimData.iIconLeftInc = TReal( leftMarginDiff / KNumIconStages );
+
+
+ // Create the timeout timer
+ iAnimTimer = CPeriodic::NewL( EPriorityHigh );
+
+ PRINT(_L("Camera <= CCamSceneSettingContainer::ConstructL") )
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::ReadLayoutL
+// Read the TAknLayoutRect info from the resource file
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::ReadLayoutL( TInt aResourceId,
+ RArray<TAknLayoutRect>& aArray) const
+ {
+ TResourceReader reader;
+ iEikonEnv->CreateResourceReaderLC( reader, aResourceId );
+ const TInt count = reader.ReadInt16();
+
+ TInt i;
+ // Read all of the layout entries from the resource file
+ for ( i = 0; i < count; i++ )
+ {
+ TAknLayoutRect layoutRect;
+ layoutRect.LayoutRect( Rect(), reader );
+ User::LeaveIfError( aArray.Append( layoutRect ) );
+ }
+ CleanupStack::PopAndDestroy(); // reader
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::ReadLayoutL
+// Read the TAknLayoutText info from the resource file
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::ReadLayoutL( TInt aResourceId,
+ RArray<TAknLayoutText>& aArray) const
+ {
+ TResourceReader reader;
+ iEikonEnv->CreateResourceReaderLC( reader, aResourceId );
+ const TInt count = reader.ReadInt16();
+
+ TInt i;
+ // Read all of the layout entries from the resource file
+ for ( i = 0; i < count; i++ )
+ {
+ TAknLayoutText layoutText;
+ layoutText.LayoutText( Rect(), reader );
+ User::LeaveIfError( aArray.Append( layoutText ) );
+ }
+ CleanupStack::PopAndDestroy(); // reader
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::CCamSceneSettingContainer
+// C++ constructor
+// ---------------------------------------------------------------------------
+//
+CCamSceneSettingContainer::CCamSceneSettingContainer(
+ TCamCameraMode aMode,
+ CCamAppController& aController,
+ CAknView& aView,
+ TBool aUserBaseScenes )
+ : CCamContainerBase( aController, aView ),
+ iMode( aMode ),
+ iUserBaseScenes( aUserBaseScenes )
+ {
+ }
+
+// ----------------------------------------------------------------
+// CCamSceneSettingContainer::UserSceneHighlighted
+// Returns ETrue if the current selected scene is User
+// ----------------------------------------------------------------
+//
+TBool CCamSceneSettingContainer::UserSceneHighlighted()
+ {
+ return ( iSettingItemArray[iCurrentArrayPosition]->SceneId() ==
+ ECamSceneUser );
+ }
+
+// ----------------------------------------------------------------
+// CCamSceneSettingContainer::SaveSceneSetting
+// Stores the currently selected scene in the dynamic settings model
+// ----------------------------------------------------------------
+//
+TBool CCamSceneSettingContainer::SaveSceneSettingL()
+ {
+ TInt scene = 0;
+ if ( iUserBaseScenes )
+ {
+ scene = ECamSettingItemUserSceneBasedOnScene;
+ }
+ else if ( ECamControllerImage == iMode )
+ {
+ scene = ECamSettingItemDynamicPhotoScene;
+ }
+ else
+ {
+ scene = ECamSettingItemDynamicVideoScene;
+ }
+
+ iController.SetIntegerSettingValueL( scene,
+ iSettingItemArray[iCurrentArrayPosition]->SceneId() );
+
+ // If user selected sports scene from list.
+ if ( iSettingItemArray[iCurrentArrayPosition]->SceneId() == ECamSceneSports )
+ {
+ // if the selection was for user scene base scene, and user
+ // scene is active, but request was cancelled, return false.
+ if ( ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene )
+ == ECamSceneUser ) &&
+ ( iController.IntegerSettingValue( ECamSettingItemUserSceneBasedOnScene )
+ != ECamSceneSports ) )
+ {
+ return EFalse;
+ }
+ // if the selection was for the photo/video scene, but request was
+ // cancelled, return false.
+ if ( ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene )
+ != ECamSceneUser ) &&
+ ( iController.IntegerSettingValue( scene ) != ECamSceneSports ) )
+ {
+ return EFalse;
+ }
+ }
+ // Otherwise, if the user selected user scene from the list, but request
+ // was cancelled, return false.
+ else if ( ( iSettingItemArray[iCurrentArrayPosition]->SceneId()
+ == ECamSceneUser ) &&
+ ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene )
+ != ECamSceneUser ) )
+ {
+ return EFalse;
+ }
+
+ // Remove lint warning.
+ else
+ {
+ }
+
+ // In all other cases, return true.
+ return ETrue;
+ }
+
+
+// ---------------------------------------------------------
+// CCamSceneSettingContainer::CountComponentControls
+// Returns the number of controls owned
+// ---------------------------------------------------------
+//
+TInt CCamSceneSettingContainer::CountComponentControls() const
+ {
+ TInt count = CCamContainerBase::CountComponentControls(); // Return the number of controls inside this container
+ if ( iScrollFrame )
+ {
+ count += iScrollFrame->CountComponentControls();
+ }
+ return count;
+ }
+
+// ---------------------------------------------------------
+// CCamSceneSettingContainer::ComponentControl
+// Returns the requested component control
+// ---------------------------------------------------------
+//
+CCoeControl* CCamSceneSettingContainer::ComponentControl( TInt aIndex ) const
+ {
+ CCoeControl* control = NULL;
+ if( aIndex == 0 )
+ control = CCamContainerBase::ComponentControl( aIndex );
+ else
+ {
+ if ( iScrollFrame )
+ {
+ return iScrollFrame->ComponentControl( aIndex - 1 );
+ }
+ }
+ return control;
+ }
+
+// ---------------------------------------------------------
+// CCamSceneSettingContainer::Draw
+// Draw control
+// ---------------------------------------------------------
+//
+void CCamSceneSettingContainer::Draw( const TRect& /*aRect*/ ) const
+ {
+ PRINT(_L("Camera => CCamSceneSettingContainer::Draw") )
+
+ CWindowGc& gc = SystemGc();
+ // Draw the background
+ gc.SetBrushColor( KRgbWhite );
+ gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
+ gc.SetPenStyle( CGraphicsContext::ENullPen );
+ gc.DrawRect( Rect() );
+ gc.SetPenStyle( CGraphicsContext::ESolidPen );
+
+ TBool drawnHighlight = EFalse;
+ TInt index = 0;
+
+ TInt i;
+ for ( i = 0; i < iNumberOfIconsToDisplay; i++ )
+ {
+ TInt position = iTopDisplayPosition + i;
+ CCamSceneSettingItem* item = iSettingItemArray[position];
+ const HBufC* title = item->Title();
+ const HBufC* description = item->Description();
+
+ // Drawing currently selected icon and text
+ if ( position == iCurrentArrayPosition )
+ {
+ // Draw the highlight
+ gc.DrawRoundRect( iHighlightArray[i].Rect(),
+ TSize( KCornerSize, KCornerSize ) );
+
+ // Draw the enlarged icon
+ iHighlightIcons[i].DrawImage( gc,
+ const_cast<CFbsBitmap*>( item->Icon( ECamIconSizeLarge ) ), NULL );
+
+ // Draw the enlarged header text
+ iHighlightTitles[i].DrawText( gc, *title );
+
+ // Draw the description text
+ iHighlightDescriptions[i].DrawText( gc, *description );
+
+#if 0 // debug drawing code
+ gc.SetPenColor(KRgbRed);
+ gc.DrawRect( iHighlightTitles[i].TextRect() );
+ gc.DrawRect( iHighlightDescriptions[i].TextRect() );
+#endif
+ drawnHighlight = ETrue;
+ }
+ else // Drawing normal items
+ {
+ // Draw the highlight box
+ TAknLayoutRect layoutRect;
+ TAknLayoutText layoutText;
+ if ( drawnHighlight )
+ {
+ layoutRect = iNormalIcons[index];
+ layoutText = iNormalTitles[index];
+ }
+ else
+ {
+ layoutRect = iDisplacedIcons[index];
+ layoutText = iDisplacedTitles[index];
+ }
+
+ // Draw the standard icon
+ layoutRect.DrawImage( gc,
+ const_cast<CFbsBitmap*>( item->Icon( ECamIconSizeSmall ) ), NULL );
+ // Draw the header text
+ layoutText.DrawText( gc, *title );
+
+#if 0 // debug drawing code
+ gc.SetPenColor(KRgbRed);
+ gc.DrawRect( layoutText.TextRect() );
+#endif
+ index++;
+ }
+ }
+ PRINT(_L("Camera <= CCamSceneSettingContainer::Draw") )
+ }
+
+// ----------------------------------------------------------------
+// CCamSceneSettingContainer::OfferKeyEventL
+// Handles this application view's command keys. Forwards other
+// keys to child control(s).
+// ----------------------------------------------------------------
+//
+TKeyResponse CCamSceneSettingContainer::OfferKeyEventL(
+ const TKeyEvent& aKeyEvent,
+ TEventCode aType )
+ {
+ PRINT( _L( "Camera => CCamSceneSettingContainer::OfferKeyEventL" ) );
+
+ if ( iAnimTimer->IsActive() )
+ {
+ return EKeyWasNotConsumed;
+ }
+
+ // Moving down the list
+ if ( aKeyEvent.iScanCode == EStdKeyDownArrow && aType == EEventKey )
+ {
+ // at the bottom of the list and pressing down key
+ if ( iCurrentArrayPosition == iSettingItemArray.Count() - 1 )
+ {
+ // wrap to the top of the list and redraw
+ iCurrentArrayPosition = 0;
+ iPreviousArrayPosition = 0;
+ iTopDisplayPosition = 0;
+
+ iAnimData.iCurrentRect = iHighlightArray[0].Rect();
+ iAnimData.iPreviousRect = iAnimData.iCurrentRect;
+
+ if ( iScrollFrame )
+ {
+ iScrollFrame->MoveVertThumbTo( 0 );
+ }
+
+ DrawDeferred();
+ return EKeyWasConsumed;
+ }
+
+ iAnimData.iMovingDown = ETrue;
+ iPreviousArrayPosition = iCurrentArrayPosition;
+ iCurrentArrayPosition++;
+
+ // need to scroll the list
+ if( iCurrentArrayPosition > iNumberOfIconsToDisplay - 1 )
+ {
+ iAnimData.iScrolling = ETrue;
+ iScrollFrame->MoveThumbsBy( 0, 1 );
+ iTopDisplayPosition++;
+ DrawListL();
+
+ // blit the bitmap at above the 2nd displaced icon
+ TInt yPos = iDisplacedIcons[1].Rect().iTl.iY;
+ // less the difference between the top of the first icon on
+ // the off-screen bitmap and the top of the off-screen bitmap
+ yPos -= iDisplacedIcons[0].Rect().iTl.iY;
+ // less the scrolling value
+ yPos -= iAnimData.iScrollingY;
+ iAnimData.iOffScreenPos.SetXY( 0, yPos );
+
+ TInt curIndex = iCurrentArrayPosition - iTopDisplayPosition;
+ TInt defaultIndex = curIndex - 1;
+ iAnimData.iTitleFadeIn = iNormalTitles[defaultIndex].TextRect();
+
+ iAnimData.iCurrentRect = iHighlightArray[curIndex].Rect();
+ TRect rect = iNormalIcons[defaultIndex].Rect();
+ iAnimData.iCurrentRect.iTl.iY = rect.iTl.iY;
+ iAnimData.iCurrentRect.iBr.iY = iAnimData.iCurrentRect.iTl.iY + rect.Height();
+
+ // clear the top item from the list
+ ActivateGc();
+ SystemGc().Clear( iHighlightArray[0].Rect() );
+ DeactivateGc();
+ }
+ else // just move to the next position
+ {
+ MoveHighlight();
+ }
+
+ StartAnimation();
+ return EKeyWasConsumed;
+ }
+ else if ( aKeyEvent.iScanCode == EStdKeyUpArrow && aType == EEventKey )
+ {
+ // At the top of list and pressing the up key
+ if ( iCurrentArrayPosition == 0 )
+ {
+ // wrap to the bottom of the list and redraw
+ TInt lastItem = iSettingItemArray.Count() - 1;
+ iCurrentArrayPosition = lastItem;
+ iPreviousArrayPosition = lastItem;
+ iTopDisplayPosition = iSettingItemArray.Count() - iNumberOfIconsToDisplay;
+
+ TInt pos = iCurrentArrayPosition - iTopDisplayPosition;
+ iAnimData.iCurrentRect = iHighlightArray[pos].Rect();
+ iAnimData.iPreviousRect = iAnimData.iCurrentRect;
+
+ if ( iScrollFrame )
+ {
+ iScrollFrame->MoveThumbsBy( 0, iTopDisplayPosition );
+ }
+
+ DrawDeferred();
+ iController.StartIdleTimer();
+ return EKeyWasConsumed;
+ }
+
+ iAnimData.iMovingDown = EFalse;
+ iPreviousArrayPosition = iCurrentArrayPosition;
+ iCurrentArrayPosition--;
+
+ // need to scroll the list
+ if ( iPreviousArrayPosition > iNumberOfIconsToDisplay - 1 )
+ {
+ iAnimData.iScrolling = ETrue;
+ iScrollFrame->MoveThumbsBy( 0, -1 );
+ // draw the list before decrementing top display pos
+ DrawListL();
+ iTopDisplayPosition--;
+
+ iAnimData.iOffScreenPos.SetXY( 0, iAnimData.iScrollingY );
+
+ TInt curIndex = iCurrentArrayPosition - iTopDisplayPosition;
+ TInt defaultIndex = curIndex - 1;
+ iAnimData.iTitleFadeIn = iNormalTitles[defaultIndex].TextRect();
+
+ iAnimData.iCurrentRect = iHighlightArray[curIndex].Rect();
+ TRect rect = iNormalIcons[defaultIndex].Rect();
+ iAnimData.iCurrentRect.iTl.iY = rect.iTl.iY;
+ iAnimData.iCurrentRect.iBr.iY = iAnimData.iCurrentRect.iTl.iY + rect.Height();
+ }
+ else // just move to the next position
+ {
+ MoveHighlight();
+ }
+
+ StartAnimation();
+ iController.StartIdleTimer();
+ return EKeyWasConsumed;
+ }
+ else
+ {
+ return CCamContainerBase::OfferKeyEventL( aKeyEvent, aType );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::HandleScrollEventL
+// Called when a scroll event is detected
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::HandleScrollEventL( CEikScrollBar* /*aScrollBar*/,
+ TEikScrollEvent /*aEventType*/ )
+ {
+ }
+
+// ----------------------------------------------------------------
+// CCamBurstThumbnailGrid::SetupScrollbarL
+// Sets up the scrollbar for the list
+// ----------------------------------------------------------------
+//
+void CCamSceneSettingContainer::SetupScrollbarL()
+ {
+ if ( !AknLayoutUtils::LayoutMirrored() )
+ {
+ iScrollLayout.LayoutRect( Rect(), ROID(R_CAM_SCENE_SCROLLBAR_POSITION_ID));
+ }
+ else
+ {
+ iScrollLayout.LayoutRect( Rect(), ROID(R_CAM_SCENE_SCROLLBAR_POSITION_AH_ID));
+ }
+
+ // Create scrollbar frame
+ iScrollFrame = new (ELeave) CEikScrollBarFrame( this, this, ETrue );
+
+ // Set up the model accordingly
+ ivModel.SetScrollSpan( iSettingItemArray.Count() );
+ ivModel.SetFocusPosition( 0 );
+ ivModel.SetWindowSize( iNumberOfIconsToDisplay );
+
+ iScrollFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
+ CEikScrollBarFrame::EOn );
+ iScrollFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );
+
+ TRect rect = iScrollLayout.Rect();
+ iScrollFrame->Tile( &ivModel, rect );
+ iScrollFrame->MoveVertThumbTo( iTopDisplayPosition );
+ }
+
+// ----------------------------------------------------------------
+// CCamSceneSettingContainer::CreateSceneArrayL
+// Populates the scene array with scenes using a resource
+// ----------------------------------------------------------------
+//
+void CCamSceneSettingContainer::CreateSceneArrayL( TInt aResourceId )
+ {
+ // Create a resource reader for the scene array resource id.
+ TResourceReader reader;
+ iEikonEnv->CreateResourceReaderLC( reader, aResourceId );
+
+ // Create all scene list items from the resource reader.
+ TInt sceneCount = reader.ReadInt16();
+
+ TInt i;
+ for ( i = 0; i < sceneCount; ++i )
+ {
+ TCamSceneId sceneId = static_cast<TCamSceneId> ( reader.ReadInt16() );
+ if ( iController.IsSceneSupported( sceneId ) )
+ {
+ TSize large = iHighlightIcons[0].Rect().Size();
+ TSize small = iNormalIcons[0].Rect().Size();
+ CCamSceneSettingItem* settingItem = CCamSceneSettingItem::NewL(
+ sceneId, large, small );
+ CleanupStack::PushL( settingItem );
+ iSettingItemArray.AppendL( settingItem );
+ CleanupStack::Pop( settingItem );
+ }
+
+ }
+
+ CleanupStack::PopAndDestroy(); // reader
+
+ // If total number of scenes is less than the current number
+ // of icons to display on screen then reset the current number of
+ // icons to display on screen.
+ if ( sceneCount < iNumberOfIconsToDisplay )
+ {
+ iNumberOfIconsToDisplay = sceneCount;
+ }
+ }
+
+// ----------------------------------------------------------------
+// CCamSceneSettingContainer::SetCurrentPositionToScene
+// Sets the current position of the scene array to the element
+// associated with a particular scene id.
+// ----------------------------------------------------------------
+//
+void CCamSceneSettingContainer::SetCurrentPositionToScene
+( TCamSceneId aSceneId )
+ {
+ // Find scene in scene array.
+ TInt count = iSettingItemArray.Count();
+ TInt j;
+ for ( j = 0; j < count; j++ )
+ {
+ if ( aSceneId == iSettingItemArray[j]->SceneId() )
+ {
+ iCurrentArrayPosition = j;
+ j = count; // stop loop
+ }
+ }
+
+ // If scene array position is offscreen, move top display position.
+ if ( iCurrentArrayPosition >= iNumberOfIconsToDisplay )
+ {
+ iTopDisplayPosition = ( iCurrentArrayPosition -
+ iNumberOfIconsToDisplay ) + 1;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::StartAnimation
+// Called to start the animation
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::StartAnimation()
+ {
+#ifndef _ANIMATION_OFF
+ iAnimTimer->Start( KTimerPeriod, KTimerPeriod, TCallBack( TimerExpired, this ) );
+#else
+ DrawDeferred();
+#endif
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::TimerExpired
+// Called when the timer expires
+// ---------------------------------------------------------------------------
+//
+TInt CCamSceneSettingContainer::TimerExpired( TAny* aAny )
+ {
+ CCamSceneSettingContainer* container =
+ static_cast<CCamSceneSettingContainer*>( aAny );
+ __ASSERT_DEBUG( container != NULL, CamPanic( ECamPanicNullPointer ) );
+ container->Animate();
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::Animate
+// Called every time the timer expires to update the animation
+// The animation works by changing a single line non-highlighted item
+// into a double line highlighted item.
+// When a highlighted item comes into focus, the title text remains the same
+// size, but its position is moved up to indicate moving from a single to
+// double line.
+// The description text fades in underneath the title text - the title text
+// moves up to make way for the description text.
+// When a highlighted item looses the focus, the title text remains the same
+// size, but its position moves down to indicate moving from a double line
+// to a single line.
+// The description text fades out and the title text moves down into the
+// position occupied by the description text.
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::Animate()
+ {
+ iAnimData.iStep++;
+
+ // update the pen/bitmaps
+ UpdateAnimationData();
+
+ // font is the same for all titles
+ const CAknLayoutFont* layoutFont = CAknLayoutFont::AsCAknLayoutFontOrNull(
+ iHighlightTitles[0].Font() );
+ __ASSERT_DEBUG( layoutFont != NULL, CamPanic( ECamPanicNullPointer ) );
+ TInt baseline = layoutFont->TextPaneTopToBaseline();
+
+ const CCamSceneSettingItem* previousItem = iSettingItemArray[iPreviousArrayPosition];
+ const CCamSceneSettingItem* currentItem = iSettingItemArray[iCurrentArrayPosition];
+
+ TInt currentPosition = iCurrentArrayPosition - iTopDisplayPosition;
+ TInt previousPosition = iPreviousArrayPosition - iTopDisplayPosition;
+
+ CWindowGc& gc = SystemGc();
+ ActivateGc();
+
+ TBool animScrolled = ETrue;
+ TBool animCompleted = ETrue;
+ if ( iAnimData.iScrolling )
+ {
+ animScrolled = ScrollList();
+
+ // update the highlight rects
+ animCompleted = UpdateHighlight();
+
+ DrawIcon( EFalse );
+
+ if ( iAnimData.iMovingDown )
+ {
+ // Save the current position, so we can rub it out later
+ iAnimData.iTitleFadeInOld = iAnimData.iTitleFadeIn;
+
+ TRect rectLimit = iHighlightTitles[currentPosition].TextRect();
+ iAnimData.iTitleFadeIn.Move( 0, -iAnimData.iDeltaY );
+ if ( iAnimData.iTitleFadeIn.iTl.iY <= rectLimit.iTl.iY )
+ {
+ // finish
+ iAnimData.iTitleFadeIn.iTl.iY = rectLimit.iTl.iY;
+ iAnimData.iTitleFadeIn.iBr.iY = rectLimit.iBr.iY;
+ }
+ DrawText( *currentItem->Title(), layoutFont, baseline, EFalse );
+ }
+
+ // draw the description text
+ iHighlightDescriptions[currentPosition].DrawText( gc,
+ *currentItem->Description(), ETrue, iAnimData.iPenFadeIn );
+
+ // draw the highlighted border
+ DrawHighlight();
+ }
+ else
+ {
+ // update the highlight rects
+ animCompleted = UpdateHighlight();
+
+ // draw the highlighted border
+ DrawHighlight();
+
+/**** PREVIOUS ITEM - FADE OUT ****/
+ DrawIcon( ETrue );
+
+ // fade description text out
+ iHighlightDescriptions[previousPosition].DrawText( gc,
+ *previousItem->Description(), ETrue, iAnimData.iPenFadeOut );
+
+ // Save the current position, so we can rub it out later
+ iAnimData.iTitleFadeOutOld = iAnimData.iTitleFadeOut;
+
+ // Draw the title text if moving down the list
+ TRect rectLimit;
+ if ( iAnimData.iMovingDown )
+ {
+ rectLimit = iDisplacedTitles[previousPosition].TextRect();
+ }
+ else // Draw the title text if moving up the list
+ {
+ rectLimit = iNormalTitles[previousPosition-1].TextRect();
+ }
+
+ iAnimData.iTitleFadeOut.Move( 0, iAnimData.iDeltaY );
+ if ( iAnimData.iTitleFadeOut.iTl.iY >= rectLimit.iTl.iY )
+ {
+ // finish
+ iAnimData.iTitleFadeOut.iTl.iY = rectLimit.iTl.iY;
+ iAnimData.iTitleFadeOut.iBr.iY = rectLimit.iBr.iY;
+ }
+
+ DrawText( *previousItem->Title(), layoutFont, baseline, ETrue );
+
+/**** NEXT ITEM - FADE IN ****/
+ DrawIcon( EFalse );
+
+ if ( iAnimData.iMovingDown )
+ {
+ iHighlightDescriptions[currentPosition].DrawText( gc,
+ *currentItem->Description(), ETrue, iAnimData.iPenFadeIn );
+ }
+ else
+ {
+ // don't fade in straight away otherwise looks messy
+ if ( iAnimData.iStep > 3 )
+ {
+ iHighlightDescriptions[currentPosition].DrawText( gc,
+ *currentItem->Description(), ETrue, iAnimData.iPenFadeIn );
+ }
+ }
+
+ // Save the current position, so we can rub it out later
+ iAnimData.iTitleFadeInOld = iAnimData.iTitleFadeIn;
+
+ rectLimit = iHighlightTitles[currentPosition].TextRect();
+ iAnimData.iTitleFadeIn.Move( 0, -iAnimData.iDeltaY );
+ if ( iAnimData.iTitleFadeIn.iTl.iY <= rectLimit.iTl.iY )
+ {
+ // finish
+ iAnimData.iTitleFadeIn.iTl.iY = rectLimit.iTl.iY;
+ iAnimData.iTitleFadeIn.iBr.iY = rectLimit.iBr.iY;
+ }
+ DrawText( *currentItem->Title(), layoutFont, baseline, EFalse );
+ }
+
+ DeactivateGc();
+
+ if ( animScrolled && animCompleted )
+ {
+ iAnimTimer->Cancel();
+ iAnimData.iScrolling = EFalse;
+ iAnimData.iPenFadeOut = KRgbBlack;
+ iAnimData.iPenFadeIn = KRgbWhite;
+ iAnimData.iStep = 0;
+ iAnimData.iIconLeftOffset = 0;
+ DrawNow();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::UpdateHighlight
+// Updates the highlight rect each time Animate() is called
+// ---------------------------------------------------------------------------
+//
+TBool CCamSceneSettingContainer::UpdateHighlight()
+ {
+ TInt currentPosition = iCurrentArrayPosition - iTopDisplayPosition;
+ TInt previousPosition = iPreviousArrayPosition - iTopDisplayPosition;
+
+ // Save the current position, so we can rub it out later
+ iAnimData.iCurrentRectOld = iAnimData.iCurrentRect;
+ iAnimData.iPreviousRectOld = iAnimData.iPreviousRect;
+
+ TBool completedCurrentTop = EFalse;
+ TBool completedCurrentBottom = EFalse;
+ TBool completedPreviousTop = EFalse;
+ TBool completedPreviousBottom = EFalse;
+
+ TInt currentRectTopLimit = iHighlightArray[currentPosition].Rect().iTl.iY;
+ TInt currentRectBottomLimit = iHighlightArray[currentPosition].Rect().iBr.iY;
+
+ iAnimData.iCurrentRect.iTl.iY -= iAnimData.iDeltaY;
+ if ( iAnimData.iCurrentRect.iTl.iY <= currentRectTopLimit )
+ {
+ iAnimData.iCurrentRect.iTl.iY = currentRectTopLimit;
+ completedCurrentTop = ETrue;
+ }
+ iAnimData.iCurrentRect.iBr.iY += iAnimData.iDeltaY;
+ if ( iAnimData.iCurrentRect.iBr.iY >= currentRectBottomLimit )
+ {
+ iAnimData.iCurrentRect.iBr.iY = currentRectBottomLimit;
+ completedCurrentBottom = ETrue;
+ }
+
+ // not scrolling so fade the previous highlight
+ if ( !iAnimData.iScrolling )
+ {
+ TInt previousRectTopLimit;
+ TInt previousRectBottomLimit;
+ if ( iAnimData.iMovingDown )
+ {
+ previousRectTopLimit = iDisplacedIcons[previousPosition].Rect().iTl.iY;
+ previousRectBottomLimit = iDisplacedIcons[previousPosition].Rect().iBr.iY;
+ }
+ else // moving up
+ {
+ previousRectTopLimit = iNormalIcons[previousPosition-1].Rect().iTl.iY;
+ previousRectBottomLimit = iNormalIcons[previousPosition-1].Rect().iBr.iY;
+ }
+
+ iAnimData.iPreviousRect.iTl.iY += iAnimData.iDeltaY;
+ if ( iAnimData.iPreviousRect.iTl.iY >= previousRectTopLimit )
+ {
+ iAnimData.iPreviousRect.iTl.iY = previousRectTopLimit;
+ completedPreviousTop = ETrue;
+ }
+
+ iAnimData.iPreviousRect.iBr.iY -= iAnimData.iDeltaY;
+ if ( iAnimData.iPreviousRect.iBr.iY <= previousRectBottomLimit )
+ {
+ iAnimData.iPreviousRect.iBr.iY = previousRectBottomLimit;
+ completedPreviousBottom = ETrue;
+ }
+ }
+ else // scrolling - don't draw the previous rect
+ {
+ completedPreviousTop = ETrue;
+ completedPreviousBottom = ETrue;
+ }
+
+ return ( completedCurrentTop && completedCurrentBottom &&
+ completedPreviousTop && completedPreviousBottom );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::UpdateAnimationData
+// Updates the pen/icons each time Animate() is called
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::UpdateAnimationData()
+ {
+ const CCamSceneSettingItem* previousItem = iSettingItemArray[iPreviousArrayPosition];
+ const CCamSceneSettingItem* currentItem = iSettingItemArray[iCurrentArrayPosition];
+
+ if ( iAnimData.iStep == 1 )
+ {
+ iAnimData.iPenFadeOut = KRgbDarkGray;
+ iAnimData.iPenFadeIn = KRgbGray4;
+ iAnimData.iIconFadeOut = previousItem->Icon( ECamIconSizeSix );
+ iAnimData.iIconFadeIn = currentItem->Icon( ECamIconSizeOne );
+ }
+ else if ( iAnimData.iStep == 2 )
+ {
+ iAnimData.iPenFadeOut = KRgbGray;
+ iAnimData.iPenFadeIn = KRgbGray3;
+ iAnimData.iIconFadeOut = previousItem->Icon( ECamIconSizeFive );
+ iAnimData.iIconFadeIn = currentItem->Icon( ECamIconSizeTwo );
+ }
+ else if ( iAnimData.iStep == 3 )
+ {
+ iAnimData.iPenFadeOut = KRgbGray1;
+ iAnimData.iPenFadeIn = KRgbGray2;
+ iAnimData.iIconFadeOut = previousItem->Icon( ECamIconSizeFour );
+ iAnimData.iIconFadeIn = currentItem->Icon( ECamIconSizeThree );
+ }
+ else if ( iAnimData.iStep == 4 )
+ {
+ iAnimData.iPenFadeOut = KRgbGray2;
+ iAnimData.iPenFadeIn = KRgbGray1;
+ iAnimData.iIconFadeOut = previousItem->Icon( ECamIconSizeThree );
+ iAnimData.iIconFadeIn = currentItem->Icon( ECamIconSizeFour );
+ }
+ else if ( iAnimData.iStep == 5 )
+ {
+ iAnimData.iPenFadeOut = KRgbGray3;
+ iAnimData.iPenFadeIn = KRgbGray;
+ iAnimData.iIconFadeOut = previousItem->Icon( ECamIconSizeTwo );
+ iAnimData.iIconFadeIn = currentItem->Icon( ECamIconSizeFive );
+ }
+ else if ( iAnimData.iStep == 6 )
+ {
+ iAnimData.iPenFadeOut = KRgbGray4;
+ iAnimData.iPenFadeIn = KRgbDarkGray;
+
+ iAnimData.iIconFadeOut = previousItem->Icon( ECamIconSizeOne );
+ iAnimData.iIconFadeIn = currentItem->Icon( ECamIconSizeSix );
+ }
+ else if ( iAnimData.iStep == 7 )
+ {
+ iAnimData.iPenFadeOut = KRgbWhite;
+ iAnimData.iPenFadeIn = KRgbBlack;
+ iAnimData.iIconFadeOut = previousItem->Icon( ECamIconSizeSmall );
+ iAnimData.iIconFadeIn = currentItem->Icon( ECamIconSizeLarge );
+ }
+ else
+ {
+
+ }
+ iAnimData.iIconLeftOffset += iAnimData.iIconLeftInc;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::DrawText
+// Draws the title text each time Animate() is called
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::DrawText( const TDesC& aText,
+ const CAknLayoutFont* aFont,
+ TInt aBaseline,
+ TBool aFadeOut ) const
+ {
+ CWindowGc& gc = SystemGc();
+
+ TRect oldRect;
+ TRect rect;
+ if ( aFadeOut )
+ {
+ rect = iAnimData.iTitleFadeOut;
+ oldRect = iAnimData.iTitleFadeOutOld;
+ }
+ else
+ {
+ rect = iAnimData.iTitleFadeIn;
+ oldRect = iAnimData.iTitleFadeInOld;
+ }
+ gc.UseFont( aFont );
+ TLogicalRgb backgroundColour( TLogicalRgb::ESystemBackgroundColor );
+ gc.SetPenColor( backgroundColour );
+ // draw test aligned left or right depending on layout
+ if( !AknLayoutUtils::LayoutMirrored() )
+ {
+ gc.DrawText( aText, oldRect, aBaseline, CGraphicsContext::ELeft );
+ gc.SetPenColor( KRgbBlack );
+ gc.DrawText( aText, rect, aBaseline, CGraphicsContext::ELeft );
+ }
+ else
+ {
+ gc.DrawText( aText, oldRect, aBaseline, CGraphicsContext::ERight );
+ gc.SetPenColor( KRgbBlack );
+ gc.DrawText( aText, rect, aBaseline, CGraphicsContext::ERight );
+ }
+
+ gc.DiscardFont();
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::DrawIcon
+// Draws the icon each time Animate() is called
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::DrawIcon( TBool aFadeOut )
+ {
+ TRect oldRect;
+ TRect bmpRect;
+ const CFbsBitmap* bitmap = NULL;
+
+ TRect largeIcon = iHighlightIcons[0].Rect();
+ TRect smallIcon = iNormalIcons[0].Rect();
+
+ if ( aFadeOut )
+ {
+ bitmap = iAnimData.iIconFadeOut;
+ TSize bmpSize = bitmap->SizeInPixels();
+
+ TInt iconYPos = ( iAnimData.iPreviousRect.Height() - bmpSize.iHeight ) / 2;
+
+ TPoint iconPos( ( largeIcon.iTl.iX + (TInt)iAnimData.iIconLeftOffset ),
+ ( iAnimData.iPreviousRect.iTl.iY + iconYPos ) );
+
+ iAnimData.iIconRectFadeOutOld = iAnimData.iIconRectFadeOut;
+ iAnimData.iIconRectFadeOut.SetRect( iconPos, bmpSize );
+
+ oldRect = iAnimData.iIconRectFadeOutOld;
+ bmpRect = iAnimData.iIconRectFadeOut;
+ }
+ else
+ {
+ bitmap = iAnimData.iIconFadeIn;
+ TSize bmpSize = bitmap->SizeInPixels();
+
+ TInt iconYPos = ( iAnimData.iCurrentRect.Height() - bmpSize.iHeight ) / 2;
+
+ TPoint iconPos( ( smallIcon.iTl.iX - (TInt)iAnimData.iIconLeftOffset ),
+ ( iAnimData.iCurrentRect.iTl.iY + iconYPos ) );
+
+ iAnimData.iIconRectFadeInOld = iAnimData.iIconRectFadeIn;
+ iAnimData.iIconRectFadeIn.SetRect( iconPos, bmpSize );
+
+ oldRect = iAnimData.iIconRectFadeInOld;
+ bmpRect = iAnimData.iIconRectFadeIn;
+ }
+
+ CWindowGc& gc = SystemGc();
+ gc.Clear( oldRect );
+ gc.BitBlt( bmpRect.iTl, bitmap );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::DrawHighlight
+// Draws the highlight rect each time Animate() is called
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::DrawHighlight() const
+ {
+ if( Flags() & CListItemDrawer::ESingleClickDisabledHighlight )
+ {
+ return;
+ }
+
+ CWindowGc& gc = SystemGc();
+
+ TSize corner( KCornerSize,KCornerSize );
+ // Clear the old highlight
+ gc.SetPenSize( TSize( KBorderSize, KBorderSize ) );
+ TLogicalRgb backgroundColour( TLogicalRgb::ESystemBackgroundColor );
+ gc.SetPenColor( backgroundColour );
+ gc.DrawRoundRect( iAnimData.iCurrentRectOld, corner );
+ if ( !iAnimData.iScrolling )
+ {
+ gc.DrawRoundRect( iAnimData.iPreviousRectOld, corner );
+ }
+ // Draw the new highlight
+ gc.SetPenSize( TSize( KBorderSize, KBorderSize ) );
+ gc.SetPenColor( iAnimData.iPenFadeIn );
+ gc.DrawRoundRect( iAnimData.iCurrentRect, corner );
+ if ( !iAnimData.iScrolling )
+ {
+ gc.SetPenColor( iAnimData.iPenFadeOut );
+ gc.DrawRoundRect( iAnimData.iPreviousRect, corner );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::DrawListL
+// Draws the list to an off-screen bitmap
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::DrawListL()
+ {
+ // create an off-screen device and context
+ CFbsBitGc* bitmapGc = NULL;
+ CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( iAnimData.iOffScreenBitmap );
+ CleanupStack::PushL( bitmapDevice );
+ User::LeaveIfError( bitmapDevice->CreateContext( bitmapGc ) );
+ CleanupStack::PushL( bitmapGc );
+
+ bitmapGc->SetPenStyle( CGraphicsContext::ENullPen );
+ bitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
+ bitmapGc->DrawRect( TRect( iAnimData.iOffScreenBitmap->SizeInPixels() ) );
+
+ TInt i;
+ // only draw top 4 items in the list
+ for ( i = 0; i < iNumberOfIconsToDisplay-1; i++ )
+ {
+ TInt position = iTopDisplayPosition + i;
+ CCamSceneSettingItem* item = iSettingItemArray[position];
+
+ // Draw the standard icon
+ iDisplacedIcons[i].DrawImage( *bitmapGc,
+ const_cast<CFbsBitmap*>( item->Icon( ECamIconSizeSmall ) ), NULL );
+ // Draw the header text
+ iDisplacedTitles[i].DrawText( *bitmapGc, *item->Title() );
+ }
+
+ CleanupStack::PopAndDestroy( bitmapGc );
+ CleanupStack::PopAndDestroy( bitmapDevice );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::ScrollList
+// Scrolls the list
+// ---------------------------------------------------------------------------
+//
+TBool CCamSceneSettingContainer::ScrollList()
+ {
+ SystemGc().BitBlt( iAnimData.iOffScreenPos, iAnimData.iOffScreenBitmap );
+ if ( iAnimData.iMovingDown )
+ {
+ iAnimData.iOffScreenPos.iY -= iAnimData.iScrollingY;
+ if ( iAnimData.iOffScreenPos.iY <= 0 )
+ {
+ return ETrue;
+ }
+ }
+ else
+ {
+ iAnimData.iOffScreenPos.iY += iAnimData.iScrollingY;
+ if ( iAnimData.iOffScreenPos.iY >= iDisplacedIcons[1].Rect().iTl.iY )
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamSceneSettingContainer::MoveHighlight
+// Moves the highlight to its new position, ready to be animated
+// ---------------------------------------------------------------------------
+//
+void CCamSceneSettingContainer::MoveHighlight()
+ {
+ iAnimData.iPreviousRect = iAnimData.iCurrentRect;
+
+ TInt curIndex = iCurrentArrayPosition - iTopDisplayPosition;
+ TInt prevIndex = iPreviousArrayPosition - iTopDisplayPosition;
+
+ TRect iconRect;
+ TRect titleRect;
+
+ if ( iAnimData.iMovingDown )
+ {
+ TInt defaultIndex = curIndex - 1;
+ iconRect = iNormalIcons[defaultIndex].Rect();
+ titleRect = iNormalTitles[defaultIndex].TextRect();
+ }
+ else
+ {
+ iconRect = iDisplacedIcons[curIndex].Rect();
+ titleRect = iDisplacedTitles[curIndex].TextRect();
+ }
+
+ iAnimData.iCurrentRect = iHighlightArray[curIndex].Rect();
+ iAnimData.iCurrentRect.iTl.iY = iconRect.iTl.iY;
+ iAnimData.iCurrentRect.iBr.iY = iAnimData.iCurrentRect.iTl.iY + iconRect.Height();
+
+ iAnimData.iTitleFadeOut = iHighlightTitles[prevIndex].TextRect();
+ iAnimData.iTitleFadeIn = titleRect;
+
+ iAnimData.iIconRectFadeOut = iHighlightIcons[prevIndex].Rect();
+ iAnimData.iIconRectFadeIn = iconRect;
+ }
+
+// End of File