/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 item list class for Video settings list view.*

*/

// Version : %version: 16 %

// INCLUDE FILES

#include <eikappui.h>

#include <MediaSettings.rsg>

#include <StringLoader.h>

#include <swi/sisregistrysession.h>

#include <swi/sisregistryentry.h>

#include <AknCommonDialogsDynMem.h>

#include <CAknMemorySelectionDialogMultiDrive.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmapplicationsettingsui.h>

#include "MediaPlayerVariant.hrh" 

#include "MediaPlayerPrivateCRKeys.h"

#include "mediasettings.hrh"

#include "MPSettingsVideoSettingItemList.h"

#include "MPSettingsSliderSettingItem.h"

#include "MPSettingsModelForROP.h"

#include "MPSettingsAppUi.h" 

#include "videoplayersettingsengine.h"

#include "videoplayercenrepkeys.h"

#include "mpxlog.h"

const TInt KParentControlAdult( 18 );

const TInt KParentControlMinAge( 4 );

const TInt KParentControlIndexShift( 3 );

const TInt KParentControlMaxIndex( 15 );

const TInt KParentControlSelections( 16 );

const TInt KParentControlOff( 0 );

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

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

// CMPSettingsVideoSettingItemList::CMPSettingsVideoSettingItemList

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPSettingsVideoSettingItemList::CMPSettingsVideoSettingItemList(

        CMPSettingsModelForROP* aModel, CVcxNsSettingsEngine& aVideoSettingsEngine) :

    iModel(aModel), iVideoSettingsEngine(aVideoSettingsEngine), iRockerKeysSupported(EFalse)

    {

    CMPSettingsAppUi* AppUi =

            static_cast<CMPSettingsAppUi*> (CCoeEnv::Static()->AppUi());

    iLandscapeSupportedByDevice = AppUi->OrientationCanBeChanged();

    TBool rockerSupported = EFalse;

    TRAP_IGNORE( rockerSupported = iModel->IsRockerKeysSupportedL() );

    if ( rockerSupported )

        {

        iRockerKeysSupported = ETrue;

        }

    MPX_DEBUG3(_L("#MS# CMPSettingsVideoSettingItemList::CMPSettingsVideoSettingItemList() iLandscapeSupportedByDevice(%d) iRockerKeysSupported(%d) "),iLandscapeSupportedByDevice,iRockerKeysSupported );

    }

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

// CMPSettingsVideoSettingItemList::~CMPSettingsVideoSettingItemList

// Destructor

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

//

CMPSettingsVideoSettingItemList::~CMPSettingsVideoSettingItemList()

    {   

    MPX_DEBUG1(_L("#MS# CMPSettingsVideoSettingItemList::~CMPSettingsVideoSettingItemList()"));

    delete iDriveMonitor;

    }

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

// CMPSettingsVideoSettingItemList::EditItemL

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

//

void CMPSettingsVideoSettingItemList::EditItemL(TInt aIndex, TBool aCalledFromMenu)

    {

    MPX_DEBUG3(_L("#MS# CMPSettingsVideoSettingItemList::EditItemL(%d,%d)"),aIndex,aCalledFromMenu);

    TInt itemIndex = aIndex;

    TBool storeModifiedSetting( ETrue );

    CAknSettingItem* settingItem = SettingItemArray()->At( itemIndex );

    TInt identifier = settingItem->Identifier();

    // Load current value from shared data

    switch ( identifier )

         {

         case EMPSettVideoContrastSettingId:

            {

            CAknSettingItemList::EditItemL( itemIndex, aCalledFromMenu );

            break;

            }

         case EVcSettingsViewParentControlItem:     

            {

            EditParentControlItemL( itemIndex, aCalledFromMenu );

            break;

            }

         case EVcSettingsViewMemoryItem:

            {

            EditPreferredMemoryItemL( itemIndex, aCalledFromMenu );

            break;    

            }

         case EVcSettingsViewThumbnails:    

            {

            EditThumbnailItemL( itemIndex, aCalledFromMenu );

            break;

            }

         case EVcSettingsviewIadUpdateItem:     

            {

            // Not editable

            storeModifiedSetting = EFalse;

            }

            break;

         default:

            break;

         }

    if ( storeModifiedSetting )

        {

         // Store the modified setting

        switch ( itemIndex )

            {

            case EVcSettingsViewParentControlIndex:

            case EVcSettingsViewMemoryItemIndex:

            case EVcSettingsViewThumbnailsIndex:

                break;

            default:

                {

                // Store setting value to settings model

                settingItem->StoreL();

                StoreSettingL( identifier );

                }

                break;

            }

        }

    }

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

// CMPSettingsVideoSettingItemList::EditThumbnailItemL

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

//

void CMPSettingsVideoSettingItemList::EditThumbnailItemL( TInt itemIndex, TBool aCalledFromMenu )

    {

    if ( aCalledFromMenu )

        {

        CAknSettingItemList::EditItemL( itemIndex, aCalledFromMenu);

        (*SettingItemArray())[itemIndex]->StoreL();

        }

    else

        {

        if (iSettingThumbnails)

            {

            iSettingThumbnails = 0;

            }

        else

            {

            iSettingThumbnails = 1;

            }

        (*SettingItemArray())[itemIndex]->LoadL();

        (*SettingItemArray())[itemIndex]->UpdateListBoxTextL();

        }

        iVideoSettingsEngine.SetVideoOnDemandThumbnails(

                        iSettingThumbnails);

        DrawDeferred();

    }

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

// CMPSettingsVideoSettingItemList::EditParentControlItemL

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

//

void CMPSettingsVideoSettingItemList::EditParentControlItemL( 

    TInt itemIndex, 

    TBool aCalledFromMenu )

    {

    if (!iLockCodeAccepted)

        {

        iLockCodeAccepted = iVideoSettingsEngine.CheckLockCodeL();

        }

    if (iLockCodeAccepted)

        {

        // can edit setting

        iParentControlIndex = GetCurrentParentControl();

        CAknSettingItemList::EditItemL( itemIndex, aCalledFromMenu );

        (*SettingItemArray())[itemIndex]->StoreL();

        }

    SetCurrentParentControl( iParentControlIndex );

    iParentControlIndex = GetCurrentParentControl();

    }

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

// CMPSettingsVideoSettingItemList::EditPreferredMemoryItemL

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

//

void CMPSettingsVideoSettingItemList::EditPreferredMemoryItemL( 

        TInt itemIndex, 

        TBool 

#ifndef RD_MULTIPLE_DRIVE_ENABLERS

        aCalledFromMenu 

#endif 

        )

    {

    TInt drive;

    iVideoSettingsEngine.GetUsedMemoryL(drive);

    iSettingMemory = iDriveMonitor->ArrayPos(drive);

    if (iSettingMemory == KErrNotFound)

        {

        iSettingMemory = 0;

        }

#ifndef RD_MULTIPLE_DRIVE_ENABLERS

    const TInt KThree( 3 );

    if ( iDriveMonitor->iAvailableDrives.Count() < KThree && !aCalledFromMenu )

        {

        if ( iSettingMemory == 1 )

            {

            iSettingMemory = 0;

            }

        else

            {

            iSettingMemory = 1;

            }

        }

    else

        {

        CAknSettingItemList::EditItemL( aIndex, aCalledFromMenu );

        ( *SettingItemArray() )[aIndex]->StoreL();

        }

#else

    TBool driveSelected(EFalse);

    TDriveNumber selectedMem;

    TInt includedMedias = 0;

    if (iDriveMonitor->PhoneMemoryDrive() != KErrNotFound)

        {

        includedMedias = AknCommonDialogsDynMem::EMemoryTypePhone;

        }

    includedMedias |= AknCommonDialogsDynMem::EMemoryTypeMMCExternal

            | AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage;

    CAknMemorySelectionDialogMultiDrive* dlg =

            CAknMemorySelectionDialogMultiDrive::NewL(

                    ECFDDialogTypeSelect,

                    R_MTV_MEMORY_SELECTION_DIALOG, EFalse,

                    includedMedias);

    CleanupStack::PushL(dlg);

    driveSelected = dlg->ExecuteL(selectedMem);

    CleanupStack::PopAndDestroy(dlg);

    if (driveSelected)

        {

        iSettingMemory = iDriveMonitor->ArrayPos(selectedMem);

        }

#endif

    (*SettingItemArray())[itemIndex]->LoadL();

    (*SettingItemArray())[itemIndex]->UpdateListBoxTextL();

    iVideoSettingsEngine.SetUsedMemory( 

                  iDriveMonitor->iAvailableDrives[iSettingMemory].iDrive );

    DrawDeferred();

    }

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

// CMPSettingsVideoSettingItemList::HandleListBoxEventL()

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

//

void CMPSettingsVideoSettingItemList::HandleListBoxEventL(

    CEikListBox* aListBox,

    TListBoxEvent aListBoxEvent )

    {

    if ( aListBoxEvent == EEventEnterKeyPressed   ||

         aListBoxEvent == EEventItemSingleClicked ||

         aListBoxEvent == EEventItemDoubleClicked )

        {

        TInt itemIndex = SettingItemArray()->ItemIndexFromVisibleIndex(

            aListBox->CurrentItemIndex() );

        CAknSettingItemList::HandleListBoxEventL( aListBox, aListBoxEvent );

        }

    }

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

// CMPSettingsVideoSettingItemList::EditCurrentItemL()

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

//

void CMPSettingsVideoSettingItemList::EditCurrentItemL( TBool aCalledFromMenu )

    {

    TInt itemIndex = SettingItemArray()->ItemIndexFromVisibleIndex(

            ListBox()->CurrentItemIndex() );

    EditItemL( itemIndex, aCalledFromMenu );

    }

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

// CMPSettingsVideoSettingItemList::IsCurrentItem()

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

//

TBool CMPSettingsVideoSettingItemList::IsCurrentItem( TInt aIndex )

    {

    TBool retValue( EFalse ); 

    TInt currentIndex = SettingItemArray()->ItemIndexFromVisibleIndex(

            ListBox()->CurrentItemIndex() );

    CAknSettingItem* settingItem = SettingItemArray()->At( currentIndex );

    TInt identifier = settingItem->Identifier();

    if ( aIndex == identifier )

        {

        retValue = ETrue;

        }

    return retValue;

    }

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

// CMPSettingsVideoSettingItemList::LoadSettingsL

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

//

void CMPSettingsVideoSettingItemList::LoadSettingsL()

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsVideoSettingItemList::LoadSettingsL()"));

    // Get setting values from settings model

    LoadAllL();

    CAknSettingItemList::LoadSettingsL();

    FinishConstructionL();

    }

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

// CMPSettingsVideoSettingItemList::CreateSettingItemL

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

//

CAknSettingItem* CMPSettingsVideoSettingItemList::CreateSettingItemL(TInt aSettingId)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsVideoSettingItemList::CreateSettingItemL(%d)"),aSettingId);

    CAknSettingItem* settingItem = NULL;

    switch (aSettingId)

        {

        case EMPSettVideoContrastSettingId:

            {

            settingItem = new (ELeave) CMPSettingsSliderSettingItem(

                aSettingId, iVideoContrast,

                R_MPSETT_CONTRAST_SLIDER_LIST_VALUE, EFalse);

            if ( ! VideoContrastIsSupportedL() )

			    {

                settingItem->SetHidden( ETrue );

				}

            break;

            }

        case EVcSettingsViewParentControlItem:

            {

            iParentControlIndex = GetCurrentParentControl();

            iSettingParentControlItem

                    = new (ELeave) CAknEnumeratedTextPopupSettingItem(

                            aSettingId, iParentControlIndex);

            return iSettingParentControlItem;

            }

        case EVcSettingsViewMemoryItem:

            {

            if (!iDriveMonitor)

                {

                iDriveMonitor = CVideoSettingsDriveMonitor::NewL();

                iDriveMonitor->RegisterObserverL(this);

                }

            TInt drive;

            iVideoSettingsEngine.GetUsedMemoryL(drive);

            iSettingMemory = iDriveMonitor->ArrayPos(drive);

            if (iSettingMemory == KErrNotFound)

                {

                iSettingMemory = 0;

                }

            iSettingMemoryItem

                    = new (ELeave) CAknEnumeratedTextPopupSettingItem(

                            aSettingId, iSettingMemory);

            return iSettingMemoryItem;

            }

        case EVcSettingsviewIadUpdateItem:

            {

            // Set text value to empty. The version number is displayed by

            // changing the string of empty item in UpdateVersionNumberTextL().

            iSettingVersionText = KNullDesC();

            iSettingIadUpdateItem = new (ELeave) CAknTextSettingItem(

                    aSettingId, iSettingVersionText);

            return iSettingIadUpdateItem;

            }

        case EVcSettingsViewThumbnails:

            {

            iVideoSettingsEngine.GetVideoOnDemandThumbnails(iSettingThumbnails);

            iSettingThumbnailsItem

                    = new (ELeave) CAknEnumeratedTextPopupSettingItem(

                            aSettingId, iSettingThumbnails);

            return iSettingThumbnailsItem;

            }   

        default:

            break;

        }

    return settingItem;   

    }

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

// CMPSettingsVideoSettingItemList::LoadSettingL

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

//

void CMPSettingsVideoSettingItemList::LoadSettingL(TInt aSettingId)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsVideoSettingItemList::LoadSettingL(%d)"),aSettingId);

    switch (aSettingId)

        {

        case EMPSettVideoContrastSettingId:

            iModel->GetVideoContrast(iVideoContrast);

            break;

        default:

            break;

        }

    }

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

// CMPSettingsVideoSettingItemList::StoreSettingL

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

//

void CMPSettingsVideoSettingItemList::StoreSettingL(TInt aSettingId)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsVideoSettingItemList::StoreSettingL(%d)"),aSettingId);

    switch (aSettingId)

        {

        case EMPSettVideoContrastSettingId:

            iModel->SetVideoContrast(iVideoContrast);

            break;

        default:

            break;

        }

    iModel->StoreSettingsL();

    }

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

// CMPSettingsVideoSettingItemList::LoadAllL

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

//

void CMPSettingsVideoSettingItemList::LoadAllL()

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsVideoSettingItemList::LoadAllL()"));

    iModel->LoadSettingsL(EConfigUser);

    LoadSettingL(EMPSettVideoContrastSettingId);

    }

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

// CMPSettingsVideoSettingItemList::FinishConstructionL()

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

//

void CMPSettingsVideoSettingItemList::FinishConstructionL()

    {

    UpdateMemoryItemTextL();

    UpdateVersionNumberTextL();

    UpdateParentControlTextL();

    }

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

// CMPSettingsVideoSettingItemList::UpdateVersionNumberTextL()

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

//

void CMPSettingsVideoSettingItemList::UpdateVersionNumberTextL()

    {

    Swi::RSisRegistrySession sisRegistrySession;

    if ( sisRegistrySession.Connect() == KErrNone )

        {

        CleanupClosePushL( sisRegistrySession );

        if ( sisRegistrySession.IsInstalledL( KSisUid ) )

            {

            Swi::RSisRegistryEntry sisRegistryEntry;

            TInt error = sisRegistryEntry.Open( sisRegistrySession, KSisUid );

            if ( error == KErrNone )

                {

                CleanupClosePushL( sisRegistryEntry );

                TVersion vcVersion( sisRegistryEntry.VersionL() );

                CleanupStack::PopAndDestroy( &sisRegistryEntry );

                HBufC* versionString = HBufC::NewLC( KMaxVersionNumberLength );

                TPtr versionPtr( versionString->Des() );

                versionPtr.Format(

                        KVersionNumberFormat,

                        vcVersion.iMajor,