/*

* 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 )