1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Container class for scene settings view*

    15 */

    16 

    17 // INCLUDE FILES

    18 #include "CamSceneSettingContainer.h"

    19 #include "CamUtility.h"

    20 #include "CamPanic.h"

    21 

    22 #include <eikenv.h>

    23 #include <eikappui.h> // For CCoeAppUiBase

    24 #include <eikapp.h>   // For CEikApplication

    25 #include <stringloader.h>

    26 #include <AknBidiTextUtils.h>

    27 #include <AknsUtils.h>

    28 #include <AknsDrawUtils.h>

    29 #include <cameraapp.mbg>

    30 #include <BitmapTransforms.h>

    31 #include <AknUtils.h>

    32 #include <AknLayoutFont.h>

    33 #include <barsRead.h>    // resource reader

    34 

    35 #include <cameraapp.rsg>

    36 #include <vgacamsettings.rsg>

    37 

    38 

    39 // CONSTANTS

    40 

    41 const TInt KStepSize = 4;  // Pixels the animation moves each timer event 

    42 

    43 const TInt KCornerSize = 3;

    44 const TInt KBorderSize = 1;

    45 

    46 const TReal KNumIconStages = 7;

    47 

    48 #define KRgbGray4 TRgb(0xEEEEEE)

    49 #define KRgbGray3 TRgb(0xDDDDDD)

    50 #define KRgbGray2 TRgb(0xCCCCCC)

    51 #define KRgbGray1 TRgb(0xBBBBBB)

    52 

    53 

    54 #ifdef __WINS__

    55 static const TInt KTimerPeriod = 10000;

    56 #else

    57 static const TInt KTimerPeriod = 150000;

    58 #endif

    59 

    60 // ================= MEMBER FUNCTIONS =======================

    61 

    62 // -----------------------------------------------------------------------------

    63 // TCamAnimationData::Initialise

    64 // Sets up the animation data

    65 // -----------------------------------------------------------------------------

    66 //

    67 void TCamAnimationData::Initialise( const TRect& aRect )

    68     {

    69     iDeltaY = KStepSize;

    70     // scrolling needs to be faster (2 times?) than the fade in/out

    71     iScrollingY = iDeltaY * 2;

    72 

    73     iCurrentRect = aRect;

    74     iPreviousRect = iCurrentRect;

    75     iCurrentRectOld = iCurrentRect;

    76     iPreviousRectOld = iCurrentRect;

    77 

    78     iStep = 0;

    79     iPenFadeOut = KRgbBlack;

    80     iPenFadeIn = KRgbWhite;

    81     iScrolling = EFalse;

    82     }

    83 

    84 // ---------------------------------------------------------------------------

    85 // CCamSceneSettingItem::NewL

    86 // Symbian OS two-phased constructor

    87 // ---------------------------------------------------------------------------

    88 //

    89 CCamSceneSettingItem* CCamSceneSettingItem::NewL( TCamSceneId aSceneId,

    90                                                   const TSize& aLargeBmpSize,

    91                                                   const TSize& aSmallBmpSize )

    92     {

    93     CCamSceneSettingItem* self =  new( ELeave ) CCamSceneSettingItem( aSceneId );

    94     CleanupStack::PushL( self );

    95     self->ConstructL( aLargeBmpSize, aSmallBmpSize );

    96     CleanupStack::Pop( self );

    97     return self;

    98     }

    99 

   100 // ---------------------------------------------------------------------------

   101 // CCamSceneSettingItem::~CCamSceneSettingItem

   102 // Destructor

   103 // ---------------------------------------------------------------------------

   104 //

   105 CCamSceneSettingItem::~CCamSceneSettingItem()

   106   {

   107   PRINT( _L("Camera => ~CCamSceneSettingItem") );

   108   delete iBitmapSmall;

   109   delete iBitmap1;

   110   delete iBitmap2;

   111   delete iBitmap3;

   112   delete iBitmap4;

   113   delete iBitmap5;

   114   delete iBitmap6;

   115   delete iBitmapLarge;

   116   delete iTitle;

   117   delete iDescription;

   118   PRINT( _L("Camera <= ~CCamSceneSettingItem") );

   119   }

   120 

   121 // ---------------------------------------------------------------------------

   122 // CCamSceneSettingItem::SceneId

   123 // Returns the sceneId

   124 // ---------------------------------------------------------------------------

   125 //

   126 TCamSceneId CCamSceneSettingItem::SceneId() const

   127     {

   128     return iSceneId;

   129     }

   130 

   131 // ---------------------------------------------------------------------------

   132 // CCamSceneSettingItem::Icon

   133 // Returns the bitmap specified by aSize

   134 // ---------------------------------------------------------------------------

   135 //

   136 const CFbsBitmap* CCamSceneSettingItem::Icon( TCamIconSize aSize ) const

   137     {

   138     if ( aSize == ECamIconSizeLarge )

   139         {

   140         return iBitmapLarge;

   141         }

   142     else if ( aSize == ECamIconSizeSmall )

   143         {

   144         return iBitmapSmall;

   145         }

   146     else if ( aSize == ECamIconSizeOne )

   147         {

   148         return iBitmap1;

   149         }

   150     else if ( aSize == ECamIconSizeTwo )

   151         {

   152         return iBitmap2;

   153         }

   154     else if ( aSize == ECamIconSizeThree )

   155         {

   156         return iBitmap3;

   157         }

   158     else if ( aSize == ECamIconSizeFour )

   159         {

   160         return iBitmap4;

   161         }

   162     else if ( aSize == ECamIconSizeFive )

   163         {

   164         return iBitmap5;

   165         }

   166     else if ( aSize == ECamIconSizeSix )

   167         {

   168         return iBitmap6;

   169         }

   170     else

   171         {

   172         return iBitmapLarge;

   173         }

   174     }

   175 

   176 // ---------------------------------------------------------------------------

   177 // CCamSceneSettingItem::Title

   178 // returns the title text

   179 // ---------------------------------------------------------------------------

   180 //

   181 const HBufC* CCamSceneSettingItem::Title() const

   182     {

   183     return iTitle;

   184     }

   185 

   186 // ---------------------------------------------------------------------------

   187 // CCamSceneSettingItem::Description

   188 // returns the title text

   189 // ---------------------------------------------------------------------------

   190 //

   191 const HBufC* CCamSceneSettingItem::Description() const

   192     {

   193     return iDescription;

   194     }

   195 

   196 // ---------------------------------------------------------------------------

   197 // CCamSceneSettingItem::ConstructL

   198 // Symbian OS second phase constructor

   199 // ---------------------------------------------------------------------------

   200 //

   201 void CCamSceneSettingItem::ConstructL( const TSize& aLargeBmpSize, 

   202                                        const TSize& aSmallBmpSize )

   203     {

   204     TInt bmpLarge = 0;

   205     TInt bmpSmall = 0;

   206     TInt title = 0;

   207     TInt description = 0;

   208     switch ( iSceneId )

   209         {

   210         case ECamSceneNight:

   211             {

   212             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_night_s;

   213             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_night_l;

   214             title = R_CAM_SCENE_TITLE_NIGHT;

   215             description = R_CAM_SCENE_DESCRIPTION_NIGHT;

   216             }

   217             break;

   218         case ECamSceneMacro:

   219             {

   220             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_macro_s;

   221             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_macro_l;    

   222             title = R_CAM_SCENE_TITLE_MACRO;

   223             description = R_CAM_SCENE_DESCRIPTION_MACRO;

   224             }

   225             break;

   226         case ECamScenePortrait:

   227             {

   228             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_port_s;

   229             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_port_l;          

   230             title = R_CAM_SCENE_TITLE_PORTRAIT;

   231             description = R_CAM_SCENE_DESCRIPTION_PORTRAIT;

   232             }

   233             break;

   234         case ECamSceneAuto:

   235             {

   236             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_auto_s;

   237             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_auto_l;

   238             title = R_CAM_SCENE_TITLE_AUTO;

   239             description = R_CAM_SCENE_DESCRIPTION_AUTO;

   240             }

   241             break;

   242         case ECamSceneScenery:

   243             {

   244             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_land_s;

   245             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_land_l;           

   246             title = R_CAM_SCENE_TITLE_LANDSCAPE;

   247             description = R_CAM_SCENE_DESCRIPTION_LANDSCAPE;

   248             }

   249             break;

   250         case ECamSceneSports:

   251             {

   252             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_sport_s;

   253             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_sport_l;           

   254             title = R_CAM_SCENE_TITLE_SPORTS;

   255             description = R_CAM_SCENE_DESCRIPTION_SPORTS;

   256             }

   257             break;

   258         case ECamSceneUser:

   259             {

   260             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_user_s;

   261             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_user_l;           

   262             title = R_CAM_SCENE_TITLE_USER;

   263             description = R_CAM_SCENE_DESCRIPTION_USER;

   264             }

   265             break;

   266         case ECamSceneNormal:

   267             {

   268             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_auto_s;

   269             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_auto_l;           

   270             title = R_CAM_SCENE_TITLE_NORMAL;

   271             description = R_CAM_SCENE_DESCRIPTION_NORMAL;

   272             }

   273             break;

   274         case ECamSceneNightScenery:

   275             {

   276             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_nightland_s;

   277             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_nightland_l;

   278             title = R_CAM_SCENE_TITLE_NIGHT_LANDSCAPE;

   279             description = R_CAM_SCENE_DESCRIPTION_NIGHT_LANDSCAPE;

   280             }

   281             break;

   282         case ECamSceneNightPortrait:

   283             {

   284             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_nightport_s;

   285             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_nightport_l;

   286             title = R_CAM_SCENE_TITLE_NIGHT_PORTRAIT;

   287             description = R_CAM_SCENE_DESCRIPTION_NIGHT_PORTRAIT;

   288             }

   289             break;

   290         case ECamSceneCandlelight:

   291             {

   292             bmpSmall = EMbmCameraappQgn_ico_lcam_sce_candle_s;

   293             bmpLarge = EMbmCameraappQgn_ico_lcam_sce_candle_l;           

   294             title = R_CAM_SCENE_TITLE_CANDLELIGHT;

   295             description = R_CAM_SCENE_DESCRIPTION_CANDLELIGHT;

   296             }

   297             break;

   298         default:

   299             User::Leave( KErrGeneral );

   300             break;

   301         }

   302 

   303     // Find the name and path of the MBM file for bitmaps

   304     TFileName mbmFileName;

   305     CamUtility::ResourceFileName( mbmFileName );

   306 

   307     iBitmapSmall = AknIconUtils::CreateIconL( mbmFileName, bmpSmall );

   308     AknIconUtils::SetSize( iBitmapSmall, aSmallBmpSize, EAspectRatioNotPreserved );

   309 

   310     TReal xInc = TReal( aLargeBmpSize.iWidth - aSmallBmpSize.iWidth ) / KNumIconStages;

   311     TReal yInc = TReal( aLargeBmpSize.iHeight - aSmallBmpSize.iHeight ) / KNumIconStages;

   312 

   313     TSize size;

   314     TReal width = aSmallBmpSize.iWidth;

   315     TReal height = aSmallBmpSize.iHeight;

   316     

   317     width += xInc;

   318     height += yInc;

   319     size.SetSize( ( TInt ) width, ( TInt ) height );

   320 

   321     iBitmap1 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );

   322     AknIconUtils::SetSize( iBitmap1, size, EAspectRatioNotPreserved);

   323 

   324     width += xInc;

   325     height += yInc;

   326     size.SetSize( ( TInt ) width, ( TInt ) height );

   327 

   328     iBitmap2 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );

   329     AknIconUtils::SetSize( iBitmap2, size, EAspectRatioNotPreserved );

   330 

   331     width += xInc;

   332     height += yInc;

   333     size.SetSize( ( TInt ) width, ( TInt ) height );

   334 

   335     iBitmap3 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );

   336     AknIconUtils::SetSize( iBitmap3, size, EAspectRatioNotPreserved );

   337 

   338     width += xInc;

   339     height += yInc;

   340     size.SetSize( ( TInt ) width, ( TInt ) height );

   341 

   342     iBitmap4 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );

   343     AknIconUtils::SetSize( iBitmap4, size, EAspectRatioNotPreserved );

   344 

   345     width += xInc;

   346     height += yInc;

   347     size.SetSize( ( TInt ) width, ( TInt ) height );

   348 

   349     iBitmap5 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );

   350     AknIconUtils::SetSize( iBitmap5, size, EAspectRatioNotPreserved );

   351 

   352     width += xInc;

   353     height += yInc;

   354     size.SetSize( ( TInt ) width, ( TInt ) height );

   355 

   356     iBitmap6 = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );

   357     AknIconUtils::SetSize( iBitmap6, size, EAspectRatioNotPreserved );

   358 

   359     iBitmapLarge = AknIconUtils::CreateIconL( mbmFileName, bmpLarge );

   360     AknIconUtils::SetSize( iBitmapLarge, aLargeBmpSize, EAspectRatioNotPreserved );

   361     

   362     iTitle = StringLoader::LoadL( title );

   363     iDescription = StringLoader::LoadL( description );

   364     }

   365 

   366 // ---------------------------------------------------------------------------

   367 // CCamSceneSettingItem::CCamSceneSettingContainer

   368 // C++ constructor

   369 // ---------------------------------------------------------------------------

   370 //

   371 CCamSceneSettingItem::CCamSceneSettingItem( TCamSceneId aSceneId ) :

   372     iSceneId( aSceneId )

   373     {

   374     }  

   375 

   376 // ---------------------------------------------------------------------------

   377 // CCamSceneSettingContainer::NewL

   378 // Symbian OS two-phased constructor

   379 // ---------------------------------------------------------------------------

   380 //

   381 CCamSceneSettingContainer* 

   382 CCamSceneSettingContainer::NewL( const TRect& aRect, 

   383                                  CAknView& aView,

   384                                  TCamCameraMode aMode,

   385                                  CCamAppController& aController,

   386                                  TBool aUserBaseScenes )

   387   {

   388   CCamSceneSettingContainer* self = 

   389       new( ELeave ) CCamSceneSettingContainer( aMode,

   390                                                aController,

   391                                                aView, 

   392                                                aUserBaseScenes );

   393   CleanupStack::PushL( self );

   394   self->ConstructL( aRect );

   395   CleanupStack::Pop( self );

   396   return self;

   397   }

   398 

   399 // ---------------------------------------------------------------------------

   400 // CCamSceneSettingContainer::~CCamSceneSettingContainer

   401 // Destructor

   402 // ---------------------------------------------------------------------------

   403 //

   404 CCamSceneSettingContainer::~CCamSceneSettingContainer()

   405   {

   406   PRINT( _L( "Camera => ~CCamSceneSettingContainer" ) );

   407   

   408   iSettingItemArray.ResetAndDestroy();

   409   iSettingItemArray.Close();

   410   

   411   iHighlightIcons.Close();

   412   iNormalIcons.Close();

   413   iDisplacedIcons.Close();

   414   

   415   iHighlightArray.Close();

   416   iHighlightTitles.Close();

   417   iHighlightDescriptions.Close();

   418   

   419   iNormalTitles.Close();

   420   iDisplacedTitles.Close();

   421   

   422   if (iAnimTimer)

   423     {

   424     iAnimTimer->Cancel();

   425     }

   426   delete iAnimTimer;

   427   delete iScrollFrame;

   428   delete iAnimData.iOffScreenBitmap;

   429   

   430   PRINT( _L( "Camera <= ~CCamSceneSettingContainer" ) );    

   431   }

   432   

   433 // ---------------------------------------------------------

   434 // CCamSceneSettingContainer::ConstructL

   435 // Symbian OS 2nd phase constructor

   436 // ---------------------------------------------------------

   437 //

   438 void CCamSceneSettingContainer::ConstructL( const TRect& aRect )

   439   {

   440   PRINT(_L("Camera => CCamSceneSettingContainer::ConstructL") )

   441   

   442   CCamContainerBase::BaseConstructL( aRect );

   443 

   444   TBool secondCameraOn = 

   445       static_cast<CCamAppUiBase*>( iEikonEnv->AppUi() )->IsSecondCameraEnabled();

   446 

   447   if( !AknLayoutUtils::LayoutMirrored() )

   448     {

   449     // get the icon positions from the resource

   450     ReadLayoutL( ROID(R_CAM_SCENE_ICON_HIGHLIGHT_ARRAY_ID), iHighlightIcons );

   451     ReadLayoutL( ROID(R_CAM_SCENE_ICON_DISPLACED_ARRAY_ID), iDisplacedIcons );

   452     ReadLayoutL( ROID(R_CAM_SCENE_ICON_NORMAL_ARRAY_ID), iNormalIcons );

   453 

   454     // get the highlight rects

   455     ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_LAYOUT_ARRAY_ID), iHighlightArray );

   456 

   457     // Check if we require APAC layouts

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

   459       {

   460       // get the layout texts

   461       ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_TITLE_ARRAY_APAC_ID), iHighlightTitles );

   462       ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_DESCRIPTION_ARRAY_APAC_ID), iHighlightDescriptions );

   463 

   464       ReadLayoutL( ROID(R_CAM_SCENE_TITLE_NORMAL_ARRAY_APAC_ID), iNormalTitles );

   465       ReadLayoutL( ROID(R_CAM_SCENE_TITLE_DISPLACED_ARRAY_APAC_ID), iDisplacedTitles );

   466       }

   467     else

   468       {

   469       // get the layout texts

   470       ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_TITLE_ARRAY_ID), iHighlightTitles );

   471       ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_DESCRIPTION_ARRAY_ID), iHighlightDescriptions );

   472       

   473       ReadLayoutL( ROID(R_CAM_SCENE_TITLE_NORMAL_ARRAY_ID), iNormalTitles );

   474       ReadLayoutL( ROID(R_CAM_SCENE_TITLE_DISPLACED_ARRAY_ID), iDisplacedTitles );

   475       }

   476     }

   477   else

   478     {

   479     // get the icon positions from the resource

   480     ReadLayoutL( ROID(R_CAM_SCENE_ICON_HIGHLIGHT_ARRAY_AH_ID), iHighlightIcons );

   481     ReadLayoutL( ROID(R_CAM_SCENE_ICON_DISPLACED_ARRAY_AH_ID), iDisplacedIcons );

   482     ReadLayoutL( ROID(R_CAM_SCENE_ICON_NORMAL_ARRAY_AH_ID), iNormalIcons );

   483 

   484     // get the highlight rects

   485     ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_LAYOUT_ARRAY_AH_ID), iHighlightArray );

   486 

   487     // get the layout texts

   488     ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_TITLE_ARRAY_AH_ID), iHighlightTitles );

   489     ReadLayoutL( ROID(R_CAM_SCENE_HIGHLIGHT_DESCRIPTION_ARRAY_AH_ID), iHighlightDescriptions );

   490 

   491     ReadLayoutL( ROID(R_CAM_SCENE_TITLE_NORMAL_ARRAY_AH_ID), iNormalTitles );

   492     ReadLayoutL( ROID(R_CAM_SCENE_TITLE_DISPLACED_ARRAY_AH_ID), iDisplacedTitles );

   493     }

   494 

   495   TResourceReader reader;                                                                                     

   496   iEikonEnv->CreateResourceReaderLC( reader, ROID(R_CAM_SCENE_MAX_ITEMS_TO_DISPLAY_ID));    

   497   iNumberOfIconsToDisplay = reader.ReadInt16();

   498   CleanupStack::PopAndDestroy(); // reader

   499 

   500   if ( iUserBaseScenes )

   501     {

   502     CreateSceneArrayL( R_CAM_SCENE_LIST_USER );

   503     TCamSceneId currentScene = static_cast<TCamSceneId>( 

   504         iController.IntegerSettingValue( 

   505             ECamSettingItemUserSceneBasedOnScene ) );

   506     SetCurrentPositionToScene( currentScene );      

   507     SetupScrollbarL();

   508     }

   509   else if ( ECamControllerImage == iMode )

   510     {

   511     if ( secondCameraOn )

   512       {

   513       CreateSceneArrayL( R_CAM_SCENE_LIST_PHOTO_CAM2 );

   514       }

   515     else

   516       {

   517       CreateSceneArrayL( R_CAM_SCENE_LIST_PHOTO);         

   518       SetupScrollbarL();

   519       }

   520 

   521     TCamSceneId currentScene = static_cast<TCamSceneId>( 

   522             iController.IntegerSettingValue( 

   523                 ECamSettingItemDynamicPhotoScene ) );

   524     SetCurrentPositionToScene( currentScene );      

   525     }

   526   else

   527     {

   528     if ( secondCameraOn )

   529       {

   530       CreateSceneArrayL( R_CAM_SCENE_LIST_VIDEO_CAM2);

   531       }

   532     else

   533       {

   534       CreateSceneArrayL( R_CAM_SCENE_LIST_VIDEO );

   535       }

   536     

   537     TCamSceneId currentScene = static_cast<TCamSceneId>( 

   538             iController.IntegerSettingValue( 

   539                 ECamSettingItemDynamicVideoScene ) );

   540     SetCurrentPositionToScene( currentScene );      

   541     }

   542 

   543   TInt index = iCurrentArrayPosition - iTopDisplayPosition;

   544   iAnimData.Initialise( iHighlightArray[index].Rect() );

   545 

   546   // create a bitmap to be used off-screen

   547   iAnimData.iOffScreenBitmap = new ( ELeave ) CFbsBitmap();

   548   User::LeaveIfError( iAnimData.iOffScreenBitmap->Create( aRect.Size(), EColor256 ) );

   549 

   550   TInt leftMarginDiff = iNormalIcons[0].Rect().iTl.iX - 

   551                         iHighlightIcons[0].Rect().iTl.iX;

   552   iAnimData.iIconLeftInc = TReal( leftMarginDiff / KNumIconStages );

   553 

   554 

   555   // Create the timeout timer

   556   iAnimTimer = CPeriodic::NewL( EPriorityHigh );

   557   

   558   PRINT(_L("Camera <= CCamSceneSettingContainer::ConstructL") )    

   559   }

   560 

   561 // ---------------------------------------------------------------------------

   562 // CCamSceneSettingContainer::ReadLayoutL

   563 // Read the TAknLayoutRect info from the resource file

   564 // ---------------------------------------------------------------------------

   565 //

   566 void CCamSceneSettingContainer::ReadLayoutL( TInt aResourceId, 

   567                                              RArray<TAknLayoutRect>& aArray) const

   568   {

   569   TResourceReader reader;                                                                                     

   570   iEikonEnv->CreateResourceReaderLC( reader, aResourceId );    

   571   const TInt count = reader.ReadInt16();

   572   

   573   TInt i;

   574   // Read all of the layout entries from the resource file

   575   for ( i = 0; i < count; i++ )

   576     {

   577     TAknLayoutRect layoutRect;

   578     layoutRect.LayoutRect( Rect(), reader );

   579     User::LeaveIfError( aArray.Append( layoutRect ) );

   580     }

   581   CleanupStack::PopAndDestroy(); // reader

   582   }

   583 

   584 // ---------------------------------------------------------------------------

   585 // CCamSceneSettingContainer::ReadLayoutL

   586 // Read the TAknLayoutText info from the resource file

   587 // ---------------------------------------------------------------------------

   588 //

   589 void CCamSceneSettingContainer::ReadLayoutL( TInt aResourceId, 

   590                                              RArray<TAknLayoutText>& aArray) const

   591   {

   592   TResourceReader reader;                                                                                     

   593   iEikonEnv->CreateResourceReaderLC( reader, aResourceId );    

   594   const TInt count = reader.ReadInt16();

   595   

   596   TInt i;

   597   // Read all of the layout entries from the resource file

   598   for ( i = 0; i < count; i++ )

   599     {

   600     TAknLayoutText layoutText;

   601     layoutText.LayoutText( Rect(), reader );

   602     User::LeaveIfError( aArray.Append( layoutText ) );

   603     }

   604   CleanupStack::PopAndDestroy(); // reader

   605   }

   606     

   607 // ---------------------------------------------------------------------------

   608 // CCamSceneSettingContainer::CCamSceneSettingContainer

   609 // C++ constructor

   610 // ---------------------------------------------------------------------------

   611 //

   612 CCamSceneSettingContainer::CCamSceneSettingContainer( 

   613     TCamCameraMode aMode,

   614     CCamAppController& aController,

   615     CAknView& aView,

   616     TBool aUserBaseScenes )

   617   : CCamContainerBase( aController, aView ), 

   618     iMode( aMode ), 

   619     iUserBaseScenes( aUserBaseScenes )

   620   {

   621   }

   622 

   623 // ----------------------------------------------------------------

   624 // CCamSceneSettingContainer::UserSceneHighlighted

   625 // Returns ETrue if the current selected scene is User

   626 // ----------------------------------------------------------------

   627 //

   628 TBool CCamSceneSettingContainer::UserSceneHighlighted()

   629   {

   630   return ( iSettingItemArray[iCurrentArrayPosition]->SceneId() == 

   631            ECamSceneUser );

   632   }

   633 

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

   635 // CCamSceneSettingContainer::SaveSceneSetting

   636 // Stores the currently selected scene in the dynamic settings model

   637 // ----------------------------------------------------------------

   638 //

   639 TBool CCamSceneSettingContainer::SaveSceneSettingL()

   640   {

   641   TInt scene = 0;

   642   if ( iUserBaseScenes )

   643     {

   644     scene = ECamSettingItemUserSceneBasedOnScene;

   645     }

   646   else if ( ECamControllerImage == iMode )

   647     {

   648     scene = ECamSettingItemDynamicPhotoScene;

   649     }

   650   else

   651     {

   652     scene = ECamSettingItemDynamicVideoScene;

   653     }

   654 

   655   iController.SetIntegerSettingValueL( scene,

   656               iSettingItemArray[iCurrentArrayPosition]->SceneId() );

   657 

   658   // If user selected sports scene from list.

   659   if ( iSettingItemArray[iCurrentArrayPosition]->SceneId() == ECamSceneSports )

   660     {

   661     // if the selection was for user scene base scene, and user 

   662     // scene is active, but request was cancelled, return false.

   663     if ( ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene )

   664              == ECamSceneUser ) &&

   665          ( iController.IntegerSettingValue( ECamSettingItemUserSceneBasedOnScene )

   666              != ECamSceneSports ) )

   667       {

   668       return EFalse;

   669       }

   670     // if the selection was for the photo/video scene, but request was 

   671     // cancelled, return false.

   672     if ( ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene )

   673          != ECamSceneUser )  && 

   674          ( iController.IntegerSettingValue( scene ) != ECamSceneSports ) )

   675       {

   676       return EFalse;

   677       }

   678     }

   679   // Otherwise, if the user selected user scene from the list, but request

   680   // was cancelled, return false.

   681   else if ( ( iSettingItemArray[iCurrentArrayPosition]->SceneId() 

   682             == ECamSceneUser ) &&

   683             ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene )

   684            != ECamSceneUser ) )

   685     {

   686     return EFalse;

   687     }

   688 

   689   // Remove lint warning.

   690   else

   691     {

   692     }

   693 

   694   // In all other cases, return true.

   695   return ETrue;

   696   }

   697 

   698 

   699 // ---------------------------------------------------------

   700 // CCamSceneSettingContainer::CountComponentControls 

   701 // Returns the number of controls owned

   702 // ---------------------------------------------------------

   703 //

   704 TInt CCamSceneSettingContainer::CountComponentControls() const

   705   {

   706   TInt count = 0; // Return the number of controls inside this container    

   707   if ( iScrollFrame )

   708     {

   709     count = iScrollFrame->CountComponentControls();

   710     }

   711   return count;

   712   }

   713 

   714 // ---------------------------------------------------------

   715 // CCamSceneSettingContainer::ComponentControl

   716 // Returns the requested component control

   717 // ---------------------------------------------------------

   718 //

   719 CCoeControl* CCamSceneSettingContainer::ComponentControl( TInt aIndex ) const

   720   {

   721   if ( iScrollFrame )

   722     {

   723     return iScrollFrame->ComponentControl( aIndex );

   724     }

   725   else

   726     {

   727     return NULL;

   728     }    

   729   }

   730 

   731 // ---------------------------------------------------------

   732 // CCamSceneSettingContainer::Draw

   733 // Draw control

   734 // ---------------------------------------------------------

   735 //

   736 void CCamSceneSettingContainer::Draw( const TRect& /*aRect*/ ) const

   737   {

   738   PRINT(_L("Camera => CCamSceneSettingContainer::Draw") )

   739   

   740   CWindowGc& gc = SystemGc();

   741   // Draw the background

   742   gc.SetBrushColor( KRgbWhite );

   743   gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

   744   gc.SetPenStyle( CGraphicsContext::ENullPen );

   745   gc.DrawRect( Rect() );

   746   gc.SetPenStyle( CGraphicsContext::ESolidPen );

   747   

   748   TBool drawnHighlight = EFalse;

   749   TInt index = 0;

   750   

   751   TInt i;

   752   for ( i = 0; i < iNumberOfIconsToDisplay; i++ )

   753     {

   754     TInt position = iTopDisplayPosition + i;

   755     CCamSceneSettingItem* item = iSettingItemArray[position];

   756     const HBufC* title = item->Title();

   757     const HBufC* description = item->Description();

   758 

   759     // Drawing currently selected icon and text

   760     if ( position == iCurrentArrayPosition )

   761       {

   762       // Draw the highlight

   763       gc.DrawRoundRect( iHighlightArray[i].Rect(), 

   764                         TSize( KCornerSize, KCornerSize ) );

   765       

   766       // Draw the enlarged icon

   767       iHighlightIcons[i].DrawImage( gc, 

   768           const_cast<CFbsBitmap*>( item->Icon( ECamIconSizeLarge ) ), NULL );

   769       

   770       // Draw the enlarged header text

   771       iHighlightTitles[i].DrawText( gc, *title );

   772       

   773       // Draw the description text

   774       iHighlightDescriptions[i].DrawText( gc, *description );

   775       

   776 #if 0       // debug drawing code

   777       gc.SetPenColor(KRgbRed);

   778       gc.DrawRect( iHighlightTitles[i].TextRect() );

   779       gc.DrawRect( iHighlightDescriptions[i].TextRect() );

   780 #endif

   781       drawnHighlight = ETrue;

   782       }

   783     else    // Drawing normal items

   784       {

   785       // Draw the highlight box

   786       TAknLayoutRect layoutRect;

   787       TAknLayoutText layoutText;

   788       if ( drawnHighlight )

   789         {

   790         layoutRect = iNormalIcons[index];

   791         layoutText = iNormalTitles[index];

   792         }

   793       else

   794         {

   795         layoutRect = iDisplacedIcons[index];

   796         layoutText = iDisplacedTitles[index];

   797         }

   798 

   799       // Draw the standard icon

   800       layoutRect.DrawImage( gc, 

   801           const_cast<CFbsBitmap*>( item->Icon( ECamIconSizeSmall ) ), NULL );

   802       // Draw the header text

   803       layoutText.DrawText( gc, *title );

   804             

   805 #if 0       // debug drawing code

   806       gc.SetPenColor(KRgbRed);

   807       gc.DrawRect( layoutText.TextRect() );

   808 #endif

   809       index++;

   810       }

   811     }

   812   PRINT(_L("Camera <= CCamSceneSettingContainer::Draw") )

   813   }

   814 

   815 // ----------------------------------------------------------------

   816 // CCamSceneSettingContainer::OfferKeyEventL

   817 // Handles this application view's command keys. Forwards other

   818 // keys to child control(s).

   819 // ----------------------------------------------------------------

   820 //

   821 TKeyResponse CCamSceneSettingContainer::OfferKeyEventL( 

   822     const TKeyEvent& aKeyEvent,

   823     TEventCode aType )

   824     {

   825     PRINT( _L( "Camera => CCamSceneSettingContainer::OfferKeyEventL" ) );

   826 

   827     if ( iAnimTimer->IsActive() )

   828         {

   829         return EKeyWasNotConsumed;

   830         }

   831 

   832     // Moving down the list

   833     if ( aKeyEvent.iScanCode == EStdKeyDownArrow && aType == EEventKey )

   834         {

   835         // at the bottom of the list and pressing down key

   836         if ( iCurrentArrayPosition == iSettingItemArray.Count() - 1 )

   837             {

   838             // wrap to the top of the list and redraw

   839             iCurrentArrayPosition = 0;

   840             iPreviousArrayPosition = 0;

   841             iTopDisplayPosition = 0;

   842 

   843             iAnimData.iCurrentRect = iHighlightArray[0].Rect();

   844             iAnimData.iPreviousRect = iAnimData.iCurrentRect;

   845 

   846             if ( iScrollFrame )

   847                 {

   848                 iScrollFrame->MoveVertThumbTo( 0 );

   849                 }

   850 

   851             DrawDeferred();

   852             return EKeyWasConsumed;

   853             }

   854 

   855         iAnimData.iMovingDown = ETrue;

   856         iPreviousArrayPosition = iCurrentArrayPosition;

   857         iCurrentArrayPosition++;

   858 

   859         // need to scroll the list

   860         if( iCurrentArrayPosition > iNumberOfIconsToDisplay - 1 )

   861             {

   862             iAnimData.iScrolling = ETrue;

   863             iScrollFrame->MoveThumbsBy( 0, 1 );

   864             iTopDisplayPosition++;

   865             DrawListL();

   866 

   867             // blit the bitmap at above the 2nd displaced icon

   868             TInt yPos = iDisplacedIcons[1].Rect().iTl.iY;

   869             // less the difference between the top of the first icon on 

   870             // the off-screen bitmap and the top of the off-screen bitmap

   871             yPos -= iDisplacedIcons[0].Rect().iTl.iY;

   872             // less the scrolling value

   873             yPos -= iAnimData.iScrollingY;

   874             iAnimData.iOffScreenPos.SetXY( 0, yPos );

   875 

   876             TInt curIndex = iCurrentArrayPosition - iTopDisplayPosition;

   877             TInt defaultIndex = curIndex - 1;

   878             iAnimData.iTitleFadeIn = iNormalTitles[defaultIndex].TextRect();

   879 

   880             iAnimData.iCurrentRect = iHighlightArray[curIndex].Rect();

   881             TRect rect = iNormalIcons[defaultIndex].Rect();

   882             iAnimData.iCurrentRect.iTl.iY = rect.iTl.iY;

   883             iAnimData.iCurrentRect.iBr.iY = iAnimData.iCurrentRect.iTl.iY + rect.Height();

   884 

   885             // clear the top item from the list

   886             ActivateGc();

   887             SystemGc().Clear( iHighlightArray[0].Rect() );

   888             DeactivateGc();

   889             }

   890         else // just move to the next position

   891             {

   892             MoveHighlight();

   893             }

   894 

   895         StartAnimation();

   896         return EKeyWasConsumed;

   897         }

   898     else if ( aKeyEvent.iScanCode == EStdKeyUpArrow && aType == EEventKey )

   899         {

   900         // At the top of list and pressing the up key

   901         if ( iCurrentArrayPosition == 0 )

   902             {

   903             // wrap to the bottom of the list and redraw

   904             TInt lastItem = iSettingItemArray.Count() - 1;

   905             iCurrentArrayPosition = lastItem;

   906             iPreviousArrayPosition = lastItem;

   907             iTopDisplayPosition = iSettingItemArray.Count() - iNumberOfIconsToDisplay;

   908             

   909             TInt pos = iCurrentArrayPosition - iTopDisplayPosition;

   910             iAnimData.iCurrentRect = iHighlightArray[pos].Rect();

   911             iAnimData.iPreviousRect = iAnimData.iCurrentRect;

   912 

   913             if ( iScrollFrame )

   914                 {

   915                 iScrollFrame->MoveThumbsBy( 0, iTopDisplayPosition );

   916                 }

   917 

   918             DrawDeferred();

   919             iController.StartIdleTimer();

   920             return EKeyWasConsumed;

   921             }

   922 

   923         iAnimData.iMovingDown = EFalse;

   924         iPreviousArrayPosition = iCurrentArrayPosition;

   925         iCurrentArrayPosition--;

   926 

   927         // need to scroll the list

   928         if ( iPreviousArrayPosition > iNumberOfIconsToDisplay - 1 )

   929             {

   930             iAnimData.iScrolling = ETrue;

   931             iScrollFrame->MoveThumbsBy( 0, -1 );

   932             // draw the list before decrementing top display pos

   933             DrawListL();

   934             iTopDisplayPosition--;

   935 

   936             iAnimData.iOffScreenPos.SetXY( 0, iAnimData.iScrollingY );

   937 

   938             TInt curIndex = iCurrentArrayPosition - iTopDisplayPosition;

   939             TInt defaultIndex = curIndex - 1;

   940             iAnimData.iTitleFadeIn = iNormalTitles[defaultIndex].TextRect();

   941 

   942             iAnimData.iCurrentRect = iHighlightArray[curIndex].Rect();

   943             TRect rect = iNormalIcons[defaultIndex].Rect();

   944             iAnimData.iCurrentRect.iTl.iY = rect.iTl.iY;

   945             iAnimData.iCurrentRect.iBr.iY = iAnimData.iCurrentRect.iTl.iY + rect.Height();

   946             }

   947         else // just move to the next position

   948             {

   949             MoveHighlight();

   950             }

   951 

   952         StartAnimation();

   953         iController.StartIdleTimer();

   954         return EKeyWasConsumed;

   955         }

   956     else

   957         {

   958         return CCamContainerBase::OfferKeyEventL( aKeyEvent, aType );

   959         }

   960     }

   961 

   962 // ---------------------------------------------------------------------------

   963 // CCamSceneSettingContainer::HandleScrollEventL

   964 // Called when a scroll event is detected

   965 // ---------------------------------------------------------------------------

   966 //

   967 void CCamSceneSettingContainer::HandleScrollEventL( CEikScrollBar* /*aScrollBar*/, 

   968                                                     TEikScrollEvent /*aEventType*/ )

   969     {

   970     }

   971 

   972 // ----------------------------------------------------------------

   973 // CCamBurstThumbnailGrid::SetupScrollbarL

   974 // Sets up the scrollbar for the list

   975 // ----------------------------------------------------------------

   976 //

   977 void CCamSceneSettingContainer::SetupScrollbarL()

   978     {

   979     if ( !AknLayoutUtils::LayoutMirrored() )

   980         {

   981         iScrollLayout.LayoutRect( Rect(), ROID(R_CAM_SCENE_SCROLLBAR_POSITION_ID));

   982         }

   983     else

   984         {

   985         iScrollLayout.LayoutRect( Rect(), ROID(R_CAM_SCENE_SCROLLBAR_POSITION_AH_ID));

   986         }

   987 

   988     // Create scrollbar frame

   989     iScrollFrame = new (ELeave) CEikScrollBarFrame( this, this, ETrue );

   990 

   991     // Set up the model accordingly

   992     ivModel.SetScrollSpan( iSettingItemArray.Count() );

   993     ivModel.SetFocusPosition( 0 );

   994     ivModel.SetWindowSize( iNumberOfIconsToDisplay );

   995             

   996     iScrollFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, 

   997                                            CEikScrollBarFrame::EOn );

   998     iScrollFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse );

   999     

  1000     TRect rect = iScrollLayout.Rect();

  1001     iScrollFrame->Tile( &ivModel, rect );

  1002     iScrollFrame->MoveVertThumbTo( iTopDisplayPosition );

  1003     }

  1004 

  1005 // ----------------------------------------------------------------

  1006 // CCamSceneSettingContainer::CreateSceneArrayL

  1007 // Populates the scene array with scenes using a resource

  1008 // ----------------------------------------------------------------

  1009 //

  1010 void CCamSceneSettingContainer::CreateSceneArrayL( TInt aResourceId )

  1011     {

  1012     // Create a resource reader for the scene array resource id.

  1013     TResourceReader reader;                                                                                     

  1014     iEikonEnv->CreateResourceReaderLC( reader, aResourceId );    

  1015 

  1016     // Create all scene list items from the resource reader.

  1017     TInt sceneCount = reader.ReadInt16();

  1018 

  1019     TInt i;

  1020     for ( i = 0; i < sceneCount; ++i )

  1021         {

  1022         TCamSceneId sceneId = static_cast<TCamSceneId> ( reader.ReadInt16() );

  1023         if ( iController.IsSceneSupported( sceneId ) )

  1024             {

  1025             TSize large = iHighlightIcons[0].Rect().Size();

  1026             TSize small = iNormalIcons[0].Rect().Size();

  1027             CCamSceneSettingItem* settingItem = CCamSceneSettingItem::NewL( 

  1028                                                 sceneId, large, small );

  1029             CleanupStack::PushL( settingItem );

  1030             iSettingItemArray.AppendL( settingItem );

  1031             CleanupStack::Pop( settingItem );            

  1032             }

  1033 

  1034         }

  1035 

  1036     CleanupStack::PopAndDestroy(); // reader

  1037 

  1038     // If total number of scenes is less than the current number 

  1039     // of icons to display on screen then reset the current number of

  1040     // icons to display on screen.

  1041     if ( sceneCount < iNumberOfIconsToDisplay )

  1042         {

  1043         iNumberOfIconsToDisplay = sceneCount;

  1044         }    

  1045     }

  1046 

  1047 // ----------------------------------------------------------------

  1048 // CCamSceneSettingContainer::SetCurrentPositionToScene

  1049 // Sets the current position of the scene array to the element

  1050 // associated with a particular scene id.

  1051 // ----------------------------------------------------------------

  1052 //

  1053 void CCamSceneSettingContainer::SetCurrentPositionToScene

  1054 ( TCamSceneId aSceneId )

  1055     {

  1056     // Find scene in scene array.

  1057     TInt count = iSettingItemArray.Count();

  1058     TInt j;

  1059     for ( j = 0; j < count; j++ )

  1060         {

  1061         if ( aSceneId == iSettingItemArray[j]->SceneId() )

  1062             {  

  1063             iCurrentArrayPosition = j;

  1064             j = count; // stop loop

  1065             }

  1066         }

  1067 

  1068     // If scene array position is offscreen, move top display position.

  1069     if ( iCurrentArrayPosition >= iNumberOfIconsToDisplay )

  1070         {

  1071         iTopDisplayPosition = ( iCurrentArrayPosition - 

  1072                                 iNumberOfIconsToDisplay ) + 1;

  1073         }

  1074     }

  1075 

  1076 // ---------------------------------------------------------------------------

  1077 // CCamSceneSettingContainer::StartAnimation

  1078 // Called to start the animation

  1079 // ---------------------------------------------------------------------------

  1080 //

  1081 void CCamSceneSettingContainer::StartAnimation()

  1082     {

  1083 #ifndef _ANIMATION_OFF

  1084     iAnimTimer->Start( KTimerPeriod, KTimerPeriod, TCallBack( TimerExpired, this ) );

  1085 #else

  1086     DrawDeferred();

  1087 #endif

  1088     }

  1089 

  1090 // ---------------------------------------------------------------------------

  1091 // CCamSceneSettingContainer::TimerExpired

  1092 // Called when the timer expires

  1093 // ---------------------------------------------------------------------------

  1094 //

  1095 TInt CCamSceneSettingContainer::TimerExpired( TAny* aAny )

  1096     {

  1097     CCamSceneSettingContainer* container = 

  1098                     static_cast<CCamSceneSettingContainer*>( aAny );

  1099     __ASSERT_DEBUG( container != NULL, CamPanic( ECamPanicNullPointer ) );

  1100     container->Animate();

  1101     return KErrNone;

  1102     }

  1103 

  1104 // ---------------------------------------------------------------------------

  1105 // CCamSceneSettingContainer::Animate

  1106 // Called every time the timer expires to update the animation

  1107 // The animation works by changing a single line non-highlighted item

  1108 // into a double line highlighted item.

  1109 // When a highlighted item comes into focus, the title text remains the same

  1110 // size, but its position is moved up to indicate moving from a single to

  1111 // double line.

  1112 // The description text fades in underneath the title text - the title text

  1113 // moves up to make way for the description text.

  1114 // When a highlighted item looses the focus, the title text remains the same

  1115 // size, but its position moves down to indicate moving from a double line

  1116 // to a single line.

  1117 // The description text fades out and the title text moves down into the 

  1118 // position occupied by the description text.

  1119 // ---------------------------------------------------------------------------

  1120 //

  1121 void CCamSceneSettingContainer::Animate()

  1122     {

  1123     iAnimData.iStep++;

  1124 

  1125     // update the pen/bitmaps

  1126     UpdateAnimationData();

  1127 

  1128     // font is the same for all titles

  1129     const CAknLayoutFont* layoutFont = CAknLayoutFont::AsCAknLayoutFontOrNull( 

  1130                                        iHighlightTitles[0].Font() );

  1131     __ASSERT_DEBUG( layoutFont != NULL, CamPanic( ECamPanicNullPointer ) );

  1132     TInt baseline = layoutFont->TextPaneTopToBaseline();

  1133 

  1134     const CCamSceneSettingItem* previousItem = iSettingItemArray[iPreviousArrayPosition];