/*

* Copyright (c) 2007-2009 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:  Setting page for Image/Video quality.*

*/

#include <AknBidiTextUtils.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <barsread.h>    // resource reader

#include <aknview.h> 

#include <touchfeedback.h> 

#include <StringLoader.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>  

#include "CamShootingModeContainer.h"

#include "CamUtility.h"

#include "CamAppUi.h"

#include "CameraUiConfigManager.h"

#include "CamSceneListBox.h"

#include "CamSceneListBoxModel.h"

#include "CamPanic.h"

#include "camactivepalettehandler.h"

#include <aknlayoutscalable_apps.cdl.h>

#include "akntoolbar.h"

// CONSTANTS

const TInt KInfoTooltipDelay = 0; // time (milliseconds) delay when showing the tooltip

const TInt KInfoTooltipDisplayTime = 5000; // maximum time (milliseconds) the tooltip is displayed

const TInt KExplTxtGranularity = 6;

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

// ---------------------------------------------------------------------------

// CCamShootingModeContainer::NewL

// Symbian OS two-phased constructor

// ---------------------------------------------------------------------------

//

CCamShootingModeContainer* 

CCamShootingModeContainer::NewL( const TRect&             aRect, 

                                       CAknView&          aView,

                                       TCamCameraMode     aMode,

                                       CCamAppController& aController,

                                       TBool              aUserBaseScenes )

  {

  CCamShootingModeContainer* self = 

      new( ELeave ) CCamShootingModeContainer( aMode, 

                                               aController,

                                               aView, 

                                               aUserBaseScenes );

  CleanupStack::PushL( self );

  self->ConstructL( aRect );

  CleanupStack::Pop( self );

  return self;

  }

// ---------------------------------------------------------------------------

// CCamShootingModeContainer::~CCamShootingModeContainer

// Destructor

// ---------------------------------------------------------------------------

//

CCamShootingModeContainer::~CCamShootingModeContainer()

  {

  PRINT( _L( "Camera => ~CCamShootingModeContainer" ) );

  iSummaryBitmapArray.ResetAndDestroy();

  iTitleArray.ResetAndDestroy();

  iDescArray.ResetAndDestroy();

  iExplTxtLinesLayout.Close();  

  if ( iFeedback ) 

    {

    iFeedback->RemoveFeedbackForControl( iListBox );

    }

  if ( iListBox )

	  {

	  delete iListBox;

	  iListBox = NULL;

	  }

    if ( iTooltipController )

        {

        delete iTooltipController;

        iTooltipController = NULL;

        }

  if ( iListboxTitle )

    {

    delete iListboxTitle;

    iListboxTitle = NULL;

    }

  if ( iCurrentDescLineArray ) 

    {

    iCurrentDescLineArray->Reset();

    delete iCurrentDescLineArray;

    }

  PRINT( _L( "Camera <= ~CCamShootingModeContainer" ) );    

  }

// ---------------------------------------------------------

// CCamShootingModeContainer::ConstructL

// Symbian OS 2nd phase constructor

// ---------------------------------------------------------

//

void 

CCamShootingModeContainer::ConstructL( const TRect& aRect )

    {

	PRINT(_L("Camera => CCamShootingModeContainer::ConstructL") )

    CCamContainerBase::BaseConstructL( aRect );

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane,

                                       iLayoutAreaRect );

    // layout area rectangle contains the area, where components need to be 

    // drawn to. the container size is the whole screen, but the layouts are 

    // for the client area. aRect is the container size that might include or

    // might not include statuspane area. calculating area self will

    // go around the problem

    TInt resource = SelectSummaryResourceL();

    if( 0 <= resource )

      {

      ConstructSummaryDetailsFromResourceL( resource );

      }

    TInt scene = 0;

    if ( iUserBaseScenes )

        {

        scene = ECamSettingItemUserSceneBasedOnScene;

        }

    else if ( ECamControllerImage == iMode )

        {

        scene = ECamSettingItemDynamicPhotoScene;

        }

    else

        {

        scene = ECamSettingItemDynamicVideoScene;

        }                      

    // construct the listbox

	iListBox =	new( ELeave ) CCamSceneListBox( iMode, this, iController );                           

	iListBox->ConstructL( iController, this, iTitleArray, iDescArray, 

	                      iUserBaseScenes  );	

	iListBox->InitializeL( iController.IntegerSettingValue( scene ) );

	iListBox->SetContainerWindowL( *this );

	iListBox->CreateScrollBarFrameL( ETrue ); 

    iListBox->DisableSingleClick( ETrue );

	TRect listboxRect;

    if ( CamUtility::IsNhdDevice() ) 

        {

        listboxRect = TouchLayout();

        }

    else

        {

        iCurrentDescLineArray  = 

                     new( ELeave ) CArrayFixFlat<TPtrC>( KExplTxtGranularity );

        listboxRect = NonTouchLayout();

        }

    // Determine the height of the listbox; 

    // Height needs to be based on the number of items, because the layout

    // height (maxListBoxHeight )might be different 

    // than combined height of the max visible listbox items

    CEikScrollBarFrame::TScrollBarVisibility visibility = 

                                                      CEikScrollBarFrame::EOff;

    TInt maxListBoxHeight = listboxRect.Height();

    TInt listBoxHeight = iListBox->CalcHeightBasedOnNumOfItems( 

                                          iListBox->Model()->NumberOfItems() );

    if ( maxListBoxHeight < listBoxHeight )

        {

        // there are more items than would fit to the listbox rectangle

        // the maximum height is the total height of items 

        // that can fit to the maxlistboxheight

        TInt itemHeight = iListBox->ItemHeight();

        TInt itemsVisible = maxListBoxHeight / itemHeight;

        listBoxHeight = itemsVisible * itemHeight;

        // the scrollbar needs to be turned on

        visibility = CEikScrollBarFrame::EOn;        

        }

    // calculate the layout for the listbox with changed height

    const AknLayoutUtils::SAknLayoutControl listboxLayout =

    {   ELayoutEmpty, iListboxLayoutRect.Rect().iTl.iX, listboxRect.iTl.iY,

        ELayoutEmpty, ELayoutEmpty, 

        iListboxLayoutRect.Rect().Width(), listBoxHeight };

    AknLayoutUtils::LayoutControl( iListBox, 

            iLayoutAreaRect, listboxLayout);

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

                                        CEikScrollBarFrame::EOff, visibility );

    iListBox->MakeVisible( ETrue );

    iListBox->SetFocus( EFalse, ENoDrawNow );

    iListBox->UpdateScrollBarsL();

    iListBox->ScrollBarFrame()->DrawScrollBarsNow();

    iListBox->SetListBoxObserver(this);

    CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

    appUi->SetActivePaletteVisibility( EFalse );

    // Prevents the system filling invalidated areas with the background 

    // colour - helps reduce flicker.

    Window().SetBackgroundColor();

    if ( iMode == ECamControllerImage )

        {

        ConstructContainerTitleFromResourceL( R_CAM_STILL_SCENE_SETTING_TITLE ); 

        }

    else 

        {

        ConstructContainerTitleFromResourceL( R_CAM_VIDEO_SCENE_SETTING_TITLE );

        }

    if ( ! iTooltipController )

        {

        iTooltipController = CAknInfoPopupNoteController::NewL();

        }

    iTooltipController->SetTimeDelayBeforeShow( KInfoTooltipDelay );

    iTooltipController->SetTimePopupInView( KInfoTooltipDisplayTime );

    // Position the tooltip

    TPoint position;

    if ( AknsUtils::GetControlPosition( this, position ) != KErrNone )

        {

        position = PositionRelativeToScreen();

        }

    TRect rect( position, Size() );

    TPoint center = rect.Center();

    iTooltipController->SetPositionAndAlignment( 

                             TPoint( center.iX, rect.iTl.iY ), EHLeftVBottom );

    iTooltipController->SetTimeDelayBeforeShow( KInfoTooltipDelay );

    iTooltipController->SetTimePopupInView( KInfoTooltipDisplayTime );

    iFeedback = MTouchFeedback::Instance();  

    if ( iFeedback )  

        {

        iFeedback->SetFeedbackArea( iListBox, 0, iListBox->Rect(), 

                                    ETouchFeedbackBasic, ETouchEventStylusDown );

        }

	PRINT(_L("Camera <= CCamShootingModeContainer::ConstructL") )    

    }

// ---------------------------------------------------------------------------

// SelectSummaryResourceL

// ---------------------------------------------------------------------------

//

TInt 

CCamShootingModeContainer::SelectSummaryResourceL()

  {

  TInt  resourceId = KErrNotSupported;

  TBool secondCameraOn = 

    static_cast<CCamAppUi*>( iEikonEnv->AppUi() )->IsSecondCameraEnabled();

  // -------------------------------------------------------

  // Photo mode  

  if ( ECamControllerImage == iMode )

    {

    if ( secondCameraOn )

      {

      //Product does not currently support shooting modes for secondary camera photo mode

      }

    else

      {

      resourceId = R_CAM_CAPTURE_SETUP_LIST_PHOTO_SHOOTING_MODE_SUMMARY;

      }

    }

  // -------------------------------------------------------

  // Video mode  

  else

    {

    if ( secondCameraOn )

      {

      //Products do not currently support shooting modes for secondary camera video mode           

      }

    else

      {

      resourceId = R_CAM_CAPTURE_SETUP_LIST_VIDEO_SHOOTING_MODE_SUMMARY;

      }

    }

  // -------------------------------------------------------

  return resourceId;

  }

// ---------------------------------------------------------------------------

// CCamShootingModeContainer::CCamShootingModeContainer

// C++ constructor

// ---------------------------------------------------------------------------

//

CCamShootingModeContainer::CCamShootingModeContainer( 

        TCamCameraMode aMode,

        CCamAppController& aController,

        CAknView& aView,

        TBool aUserBaseScenes )

: CCamContainerBase( aController, aView ),

    iListBox( NULL ),

    iMode( aMode ), 

    iUserBaseScenes( aUserBaseScenes ),

    iTooltipController( NULL ),

    iListboxTitle( NULL ),

    iTooltipIndex( -1 ),

    iActivateOnTouchRelease( EFalse )

    {

    }

// ----------------------------------------------------------------

// CCamShootingModeContainer::UserSceneHighlighted

// Returns ETrue if the current selected scene is User

// ----------------------------------------------------------------

//

TBool CCamShootingModeContainer::UserSceneHighlighted()

    {

    return (CurrentSettingItemValue() == ECamSceneUser );

    }

// ----------------------------------------------------------------

// CCamShootingModeContainer::SaveSceneSettingIfChangedL

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

// if it differs from current scene mode

// ----------------------------------------------------------------

//

TBool CCamShootingModeContainer::SaveSceneSettingIfChangedL()

    {

    TInt scene = 0;

    if ( iUserBaseScenes )

      {

      scene = ECamSettingItemUserSceneBasedOnScene;

      }

    else if ( ECamControllerImage == iMode )

      {

      scene = ECamSettingItemDynamicPhotoScene;

      }

    else

      {

      scene = ECamSettingItemDynamicVideoScene;

      }

    TInt currentSceneMode = iController.IntegerSettingValue( scene );

    if ( currentSceneMode != CurrentSettingItemValue() )

        {

        // The scene mode selection has changed, store new mode

        return SaveSceneSettingL();

        }

    else

        {

        // No change, no need to save

        return EFalse;

        }

    }

// ----------------------------------------------------------------

// CCamShootingModeContainer::SaveSceneSetting

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

// ----------------------------------------------------------------

//

TBool CCamShootingModeContainer::SaveSceneSettingL()

  {

  TInt scene = 0;

  if ( iUserBaseScenes )

    {

    scene = ECamSettingItemUserSceneBasedOnScene;

    }

  else if ( ECamControllerImage == iMode )

    {

    scene = ECamSettingItemDynamicPhotoScene;

    }

  else

    {

    scene = ECamSettingItemDynamicVideoScene;

    }

  iController.SetIntegerSettingValueL( scene,

              CurrentSettingItemValue() );

  static_cast<CCamAppUiBase*>( CEikonEnv::Static()->AppUi() )->APHandler()->UpdateActivePaletteL();        

  // If user selected sports scene from list.

  if ( CurrentSettingItemValue() == 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 ( ( CurrentSettingItemValue() 

            == ECamSceneUser ) &&

            ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene )

           != ECamSceneUser ) )

      {

      return EFalse;

      }

  // Remove lint warning.

  else

      {

      }

  // In all other cases, return true.

  return ETrue;

  }

// -----------------------------------------------------------------------------

// CCamShootingModeContainer::CurrentSettingItemValue

// Returns the Current item's setting value ID

// -----------------------------------------------------------------------------

TInt CCamShootingModeContainer::CurrentSettingItemValue() const

    {

    return (static_cast<CCamSceneListBoxModel *>(iListBox->Model())->ItemValue(iListBox->CurrentItemIndex()));

    }

// -----------------------------------------------------------------------------

// CCamShootingModeContainer::IndexForValueId() const

// Returns the index of the item in the array with the specified ValueId

// -----------------------------------------------------------------------------   

TInt CCamShootingModeContainer::IndexForValueId( TInt aValueId ) const

    {

    return static_cast<MCamListboxModel*>( iListBox->Model() )->ValueIndex( aValueId );

    } 

// -----------------------------------------------------------------------------

// CCamShootingModeContainer::HandleSettingValueUpdateL

// Handles a change to the setting value of the slider

// -----------------------------------------------------------------------------

//

void CCamShootingModeContainer::HandleSettingValueUpdateL( TInt /*aNewValue*/ )

    {   

    }

// ---------------------------------------------------------

// CCamShootingModeContainer::CountComponentControls 

// Returns the number of controls owned

// ---------------------------------------------------------

//

TInt CCamShootingModeContainer::CountComponentControls() const

    {

    return 1;

    }

// ---------------------------------------------------------

// CCamShootingModeContainer::ComponentControl

// Returns the requested component control

// ---------------------------------------------------------

//

CCoeControl* CCamShootingModeContainer::ComponentControl( TInt /*aIndex*/ ) const

    {

    return iListBox;

    }

// ---------------------------------------------------------

// CCamShootingModeContainer::Draw

// Draw control

// ---------------------------------------------------------

//

void CCamShootingModeContainer::Draw( const TRect& aRect ) const

    {

	PRINT(_L("Camera => CCamShootingModeContainer::Draw") )

    CWindowGc& gc = SystemGc();

    if ( CamUtility::IsNhdDevice() )

        {

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        AknsDrawUtils::Background( skin, iBgContext, gc, aRect );

        TRgb color;

        AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnTextColors,

                                                EAknsCIQsnTextColorsCG6 );  

        iTitleTextRectLayout.DrawText( gc, *iListboxTitle, ETrue, color ); 

        }

    else

        {  

        TRAP_IGNORE( DrawSummaryTextL( gc ) );

        }

	PRINT(_L("Camera <= CCamShootingModeContainer::Draw") )

    }

// ----------------------------------------------------------------

// CCamShootingModeContainer::OfferKeyEventL

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

// keys to child control(s).

// ----------------------------------------------------------------

//

TKeyResponse CCamShootingModeContainer::OfferKeyEventL( 

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    iController.StartIdleTimer();