/*

* 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:  Model used in listbox of memory selection dialog which support

*                multiple drives. It is used to replace

*                CAknMemorySelectionModel

*

*/

#include <coemain.h>

#include <StringLoader.h>

#include <commondialogs.rsg>

#include <pathinfo.h> //PathInfo

#include <barsread.h>   // TResourceReader

#include <driveinfo.h> //DriveInfo

#include "caknmemoryselectionmodelmultidrive.h"

#include "CAknCommonDialogsBase.h"

#include "AknCFDUtility.h"

const TInt KListBoxEntryMaxLength( KMaxFileName + 32 );

const TInt KNoIndex = -1;

const TInt KIndexFirst = 0;

const TInt KIndexSecond = 1;

_LIT( KImageHeader, "%d" );

_LIT( KTabChar, "\t" );

_LIT( KSpaceChar, " " );

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

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

// CAknMemorySelectionModelMultiDrive::CAknMemorySelectionModelMultiDrive

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

//

CAknMemorySelectionModelMultiDrive::CAknMemorySelectionModelMultiDrive(

    CCoeEnv* aCoeEnv,

    MDesCArray* aDriveArray,

    MDesCArray* aDefaultFolderArray,

    TInt aIncludedMedias,

    TBool aShowUnavailable,

    TListBoxLayout aLayout )

    :   iCoeEnv( aCoeEnv ),

        iDriveArray( aDriveArray ),

        iDefaultFolderArray( aDefaultFolderArray ),

        iIncludedMedias( aIncludedMedias ),

        iShowUnavailable( aShowUnavailable ),

        iLayout( aLayout )

    {

    }

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

// CAknMemorySelectionModelMultiDrive::ConstructL

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

//

void CAknMemorySelectionModelMultiDrive::ConstructL()

    {

    ReadResourcesL();

    }

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

// CAknMemorySelectionModelMultiDrive::NewL

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

//

CAknMemorySelectionModelMultiDrive* CAknMemorySelectionModelMultiDrive::NewL(

    CCoeEnv* aCoeEnv,

    MDesCArray* aDriveArray,

    MDesCArray* aDefaultFolderArray,

    TInt aIncludedMedias,

    TBool aShowUnavailable,

    TListBoxLayout aLayout )

    {

    CAknMemorySelectionModelMultiDrive* self =

        new( ELeave ) CAknMemorySelectionModelMultiDrive(

            aCoeEnv, aDriveArray, aDefaultFolderArray,

            aIncludedMedias, aShowUnavailable, aLayout );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CAknMemorySelectionModelMultiDrive::~CAknMemorySelectionModelMultiDrive()

    {

    iListBoxArray.ResetAndDestroy();

    iListBoxArray.Close();

    iLocStringArray.ResetAndDestroy();

    iLocStringArray.Close();

    delete iDefDriveArray;

    iDefDriveArray = NULL;

    delete iDefDefaultFolderArray;

    iDefDefaultFolderArray = NULL;

    }

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

// CAknMemorySelectionModelMultiDrive::GetItem

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

//

void CAknMemorySelectionModelMultiDrive::GetItem( TInt aIndex, TDes& aItem )

    {

    aItem = iListBoxArray[ aIndex ]->Des();

    if( iLayout == ELayoutPopupMenu || iLayout == ELayoutDoublePopup )

        {

        // On layout with graphic, delete image index.

        _LIT( KTab, "\t" );

        TInt tabIndex( aItem.Find( KTab ) );

        if( tabIndex >= 0 )

            {

            aItem.Delete( 0, tabIndex + 1 );

            }

        if( iLayout == ELayoutDoublePopup )

            {

            tabIndex = aItem.Find( KTab );

            if( tabIndex >= 0 )

                {

                aItem = aItem.Left( tabIndex );

                }

            }

        }

    }

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

// CAknMemorySelectionModelMultiDrive::UpdateItemsL

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

//

void CAknMemorySelectionModelMultiDrive::UpdateItemsL()

    {

    TInt drive;

    TCFDDriveInfo driveInfo;

    // If array has items - reset it before updating

    iListBoxArray.ResetAndDestroy();

    _LOG( "[CAknMemorySelectionModelMultiDrive] iDriveArray: " );

    // Go through all drives

    for( TInt index( 0 ); index < iDriveArray->MdcaCount(); index++ )

        { 

        TPtrC text(iDriveArray->MdcaPoint( index ));

        _LOG1( "%S", &text );

        drive = AknCFDUtility::DriveNumber( iDriveArray->MdcaPoint( index ) );

        User::LeaveIfError( drive ); // Leaves if < 0

        AknCFDUtility::DriveInfoL( TDriveNumber( drive ), driveInfo );

        _LOG7( "\n[CAknMemorySelectionModelMultiDrive] TCFDDriveInfo \n DriveNum:%d \n Path:%S \n Media:%d \n Status:%d \n Label:%S \n Space:%d \n ConnectionState:%d",

               driveInfo.iDriveNumber,

               &text,

               driveInfo.iMediaType,

               driveInfo.iDriveStatus,

               &(driveInfo.iVolumeLabel),

               driveInfo.iDiskSpace,

               driveInfo.iConnectionState );

        AddItemToLbxL( driveInfo );

        } // for

    }

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

// CAknMemorySelectionModelMultiDrive::MdcaCount

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

//

TInt CAknMemorySelectionModelMultiDrive::MdcaCount() const

    {

    return iListBoxArray.Count();

    }

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

// CAknMemorySelectionModelMultiDrive::MdcaPoint

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

//

TPtrC CAknMemorySelectionModelMultiDrive::MdcaPoint( TInt aIndex ) const

    {

    return *iListBoxArray[ aIndex ];

    }

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

// CAknMemorySelectionModelMultiDrive::ReadResourcesL

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

//

void CAknMemorySelectionModelMultiDrive::ReadResourcesL()

    {

    HBufC* buffer;

    TInt resource;

    for( TInt locStrIndex( 0 ); locStrIndex < ETextCount; locStrIndex++ )

        {

        resource = 0;

        // Resource depends on the layout type (TListBoxLayout):

        switch( iLayout )

            {

            case ELayoutPopupMenu:

                {

                resource = ResourceIDForLayoutPopupMenuItem( locStrIndex );

                break;

                }

            case ELayoutSettingPage:

                {

                resource = ResourceIDForLayoutSettingPageItem( locStrIndex );

                break;

                }

            case ELayoutDoublePopup:

                {

                resource = ResourceIDForLayoutDoublePopupItem( locStrIndex );

                break;

                }

            default:

                {

                User::Panic( KCFDPanicText, ECFDPanicOutOfBounds );

                }

            }//iLayout

        if( resource )

            {

            buffer = NULL;

            buffer = iCoeEnv->AllocReadResourceLC( resource );

            User::LeaveIfError( iLocStringArray.Append( buffer ) );

            CleanupStack::Pop();

            }

        }//For loop

#ifdef _DEBUG

        _LOG( "[CAknMemorySelectionModelMultiDrive] iLocStringArray: " );

        for( TInt lsa = 0; lsa < iLocStringArray.Count(); lsa++ )

            {

            _LOG1( "%S",iLocStringArray[ lsa ] );

            }

#endif // _DEBUG

    }

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

// CAknMemorySelectionModelMultiDrive::ResourceIDForLayoutPopupMenuItem

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

//

TInt CAknMemorySelectionModelMultiDrive::ResourceIDForLayoutPopupMenuItem(

    TInt aLocStrIndex )

    {

    TInt resource = 0;

    switch( aLocStrIndex )

        {

        case ETextDeviceMemory:

            {

            // qtn.mem.device.memory

            resource = R_CFD_QTN_MEM_DEVICE_MEMORY;

            break;

            }

        case ETextInternalMassStorage:

            {

            // qtn.mem.mass.storage

            resource = R_CFD_QTN_MEM_MASS_STORAGE;

            break;

            }

        case ETextInternalMassStorageUnavailable:

            {

            // qtn.mem.mass.storage.unavailable

            resource = R_CFD_QTN_MEM_MASS_STORAGE_UNAVAILABLE;

            break;

            }

        case ETextMMCDefaultName:

            {

            // If MMC's name is empty.

            // qtn.mem.memory.card.default

            resource = R_CFD_QTN_MEM_MEMORY_CARD_DEFAULT;

            break;

            }

        case ETextMMCNamed:

            {

            // If MMC's name is given.

            // qtn.mem.named.memory.card

            resource = R_CFD_QTN_MEM_NAMED_MEMORY_CARD;

            break;

            }

        case ETextMMCLocked:

            {

            // qtn.mem.memory.card.locked

            resource = R_CFD_QTN_MEM_MEMORY_CARD_LOCKED;

            break;

            }

        case ETextMMCUnavailable:

            {

            // qtn.mem.memory.card.unavailable

            resource = R_CFD_QTN_MEM_MEMORY_CARD_UNAVAILABLE;

            break;

            }

        case ETextRemoteDrive:

            {

            // qtn.memc.remote.drive

            resource = R_CFD_QTN_MEMC_REMOTE_DRIVE;

            break;

            }

        }

    return resource;

    }

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

// CAknMemorySelectionModelMultiDrive::ResourceIDForLayoutSettingPageItem

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

//

TInt CAknMemorySelectionModelMultiDrive::ResourceIDForLayoutSettingPageItem(

    TInt aLocStrIndex )

    {

    TInt resource = 0;

    switch( aLocStrIndex )

        {

        case ETextDeviceMemory:

            {

            // qtn.mem.device.memory.setting.list

            resource = R_CFD_QTN_MEM_DEVICE_MEMEORY_SETTING_LIST;

            break;

            }

        case ETextInternalMassStorage:

        case ETextInternalMassStorageUnavailable:

            {

            // qtn.mem.mass.storage.setting.list

            resource = R_CFD_QTN_MEM_MASS_STORAGE_SETTING_LIST;

            break;

            }

        case ETextMMCDefaultName:

        case ETextMMCLocked:

        case ETextMMCUnavailable:

            {

            // If MMC's name is empty.

            // qtn.mem.memory.card.defaul.setting.list

            resource = R_CFD_QTN_MEM_MEMORY_CARD_DEFAULT_SETTING_LIST;

            break;

            }

        case ETextMMCNamed:

            {

            // If MMC's name is given.

            // qtn.mem.named.memory.card.setting.list

            resource = R_CFD_QTN_MEM_NAMED_MEMORY_CARD_SETTING_LIST;

            break;

            }

        case ETextRemoteDrive:

            {

            // TODO: To get real value from UI spec

            resource = R_CFD_QTN_MEMC_REMOTE_DRIVE;

            break;

            }

        }

    return resource;

    }

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

// CAknMemorySelectionModelMultiDrive::ResourceIDForLayoutDoublePopupItem

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

//

TInt CAknMemorySelectionModelMultiDrive::ResourceIDForLayoutDoublePopupItem(

    TInt aLocStrIndex )

    {

    TInt resource = 0;

     switch( aLocStrIndex )

        {

        case ETextDeviceMemory:

            {

            // qtn.mem.device.memory.double.list

            resource = R_CFD_QTN_MEM_DEVICE_MEMORY_DOUBLE_LIST;

            break;

            }

        case ETextInternalMassStorage:

            {

            // qtn.mem.mass.storage.double.list

            resource = R_CFD_QTN_MEM_MASS_STORAGE_DOUBLE_LIST;

            break;

            }

        case ETextMMCNamed:

            {

            // If MMC's name is given.

            // qtn.mem.named.memory.card.double

            resource = R_CFD_QTN_MEM_NAMED_MEMORY_CARD_DOUBLE;

            break;

            }

        case ETextMMCDefaultName:

            {

            // If MMC's name is empty.

            // qtn.mem.memory.card.default.double

            resource = R_CFD_QTN_MEM_MEMORY_CARD_DEFAULT_DOUBLE;

            break;

            }

        case ETextMMCLocked:

            {

            // qtn.memc.mmc.locked.double

            resource = R_CFD_QTN_MEMC_MMC_LOCKED_DOUBLE;

            break;

            }

        case ETextRemoteDrive:

            {

            // TODO: To be checked because of missing data in UI spec.

            resource = R_CFD_QTN_MEMC_REMOTE_DRIVE_DOUBLE_LIST;

            break;

            }

        }

    return resource;

    }

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

// CAknMemorySelectionModelMultiDrive::AddItemToLbxL

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

//

void CAknMemorySelectionModelMultiDrive::AddItemToLbxL(

        const TCFDDriveInfo& aDriveInfo )

    {

    // Listbox items are differend depending on the media type.

    if ( aDriveInfo.iStatus & DriveInfo::EDriveInternal )

        {

        // Internal drives including device memory and internal mass storage

        if ( aDriveInfo.iStatus & DriveInfo::EDriveExternallyMountable )

            {

            // Internal mass storage drive

            AddInternalStorageItemToLbxL( aDriveInfo );

            }

        else

            {

            // Device memory drive

            AddDeviceMemoryItemToLbxL( aDriveInfo );

            }

        }

    else if( aDriveInfo.iStatus & DriveInfo::EDriveRemovable  )

        {

        // External mass storage drive, like external MMC

        }

    else if ( ( aDriveInfo.iStatus & DriveInfo::EDriveRemote )

        && ( aDriveInfo.iMediaType == EMediaRemote ) )

        // 2 conditions used here just for sure

        {

        // Remote drive

        AddRemoteItemToLbxL( aDriveInfo );

        }

    else

        {

        // Default

        // No actual use case for this yet.

        AddDefaultItemToLbxL( aDriveInfo );

        }

    }      

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

// CAknMemorySelectionModelMultiDrive::AddDeviceMemoryItemToLbxL

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

void CAknMemorySelectionModelMultiDrive::AddDeviceMemoryItemToLbxL(

    const TCFDDriveInfo& aDriveInfo )

    {

    HBufC* lbxItemBuf = HBufC::NewLC( KListBoxEntryMaxLength );

    TPtr itemString( lbxItemBuf->Des() );

    HBufC* textItemBuf = HBufC::NewLC( KListBoxEntryMaxLength );

    TPtr textString( textItemBuf->Des() );

    TDriveUnit driveUnit( aDriveInfo.iDriveNumber );

    // Item text is affected by layout

    switch( iLayout )

        {

            case ELayoutPopupMenu:

                {

                // A-column icon:

                itemString.Format( KImageHeader, EIconDeviceMemory );

                itemString.Append( KTabChar );

                // 1st row text:

                // Drive letter needs to be added

                StringLoader::Format( textString,

                                      *iLocStringArray[ ETextDeviceMemory ],

                                      KNoIndex,

                                      driveUnit.Name() );

                itemString.Append( textString );

                break;

                }

            case ELayoutSettingPage:

                {

                // 1st row text:

                // Drive letter needs to be added

                StringLoader::Format( itemString,

                                      *iLocStringArray[ ETextDeviceMemory ],

                                      KNoIndex,

                                      driveUnit.Name() );

                break;

                }

            case ELayoutDoublePopup:

                {

                // A-column icon:

                itemString.Format( KImageHeader, EIconDeviceMemory );

                itemString.Append( KTabChar );

                // 1st row text:

                StringLoader::Format( textString,

                                      *iLocStringArray[ ETextDeviceMemory ],

                                      KNoIndex,

                                      driveUnit.Name() );

                itemString.Append( textString );

                itemString.Append( KTabChar );

                // 2nd row text:

                HBufC* buffer;

                TInt64 freeSpace = aDriveInfo.iDiskSpace;