/*

* Copyright (c) 2002-2006 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.

*

*/

// INCLUDES

#include "CAknMemorySelectionModel.h"

#include "CAknCommonDialogsBase.h"

#include "AknCFDUtility.h"

#include <coemain.h>

#include <StringLoader.h>

#include <commondialogs.rsg>

#include <rsfwmountman.h>

#include <pathinfo.h> //PathInfo

#include <driveinfo.h> //DriveInfo

// CONSTANTS

const TInt KListBoxEntryMaxLength( KMaxFileName + 32 );

_LIT( KImageHeader, "%d" );

_LIT( KTabChar, "\t" );

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

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

// CAknMemorySelectionModel::CAknMemorySelectionModel

//

//

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

//

CAknMemorySelectionModel::CAknMemorySelectionModel(

	CCoeEnv* aCoeEnv,

	MDesCArray* aDriveArray,

	TBool aShowUnavailable,

	TListBoxLayout aLayout )

	:	iCoeEnv( aCoeEnv ),

		iDriveArray( aDriveArray ),

		iShowUnavailable( aShowUnavailable ),

		iLayout( aLayout )

	{

	}

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

// CAknMemorySelectionModel::ConstructL

//

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

//

void CAknMemorySelectionModel::ConstructL()

	{

	ReadResourcesL();

	UpdateItemsL();

	}

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

// CAknMemorySelectionModel::NewL

//

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

//

CAknMemorySelectionModel* CAknMemorySelectionModel::NewL(

	CCoeEnv* aCoeEnv,

	MDesCArray* aDriveArray,

	TBool aShowUnavailable,

	TListBoxLayout aLayout )

	{

	CAknMemorySelectionModel* self = new( ELeave ) CAknMemorySelectionModel(

		aCoeEnv, aDriveArray, aShowUnavailable, aLayout );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

// Destructor

CAknMemorySelectionModel::~CAknMemorySelectionModel()

	{

	iListBoxArray.ResetAndDestroy();

	iListBoxArray.Close();

	iLocStringArray.ResetAndDestroy();

	iLocStringArray.Close();

	}

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

// CAknMemorySelectionModel::GetItem

//

//

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

//

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

	{

    TInt err = 0;

	TRAP( err, UpdateItemsL() );

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

				}

			}

		}

	}

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

// CAknMemorySelectionModel::UpdateItemsL

//

//

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

//

void CAknMemorySelectionModel::UpdateItemsL()

	{

	TInt drive;

	TCFDDriveInfo driveInfo;

	// If array has items - reset it before updating

	iListBoxArray.ResetAndDestroy();

	_LOG( "[CAknMemorySelectionModel] 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[CAknMemorySelectionModel] 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

	}

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

// CAknMemorySelectionModel::MdcaCount

//

//

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

//

TInt CAknMemorySelectionModel::MdcaCount() const

	{

	return iListBoxArray.Count();

	}

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

// CAknMemorySelectionModel::MdcaPoint

//

//

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

//

TPtrC CAknMemorySelectionModel::MdcaPoint( TInt aIndex ) const

	{

	return *iListBoxArray[ aIndex ];

	}

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

// CAknMemorySelectionModel::ReadResourcesL

//

//

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

//

void CAknMemorySelectionModel::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();// Buffer???

		    }

		}//For loop

#ifdef _DEBUG

        _LOG( "[CAknMemorySelectionModel] iLocStringArray: " );

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

    	    {

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

    	    }

#endif // _DEBUG

	}

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

// CAknMemorySelectionModel::ResourceIDForLayoutPopupMenuItem

//

//

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

//

TInt CAknMemorySelectionModel::ResourceIDForLayoutPopupMenuItem(

    TInt aLocStrIndex )

    {

    TInt resource = 0;

    switch( aLocStrIndex )

        {

    	case ETextPhoneMemory:

			{

			resource = R_CFD_QTN_MEMC_PHONE;

			break;

			}

		case ETextMMC:

			{

			resource = R_CFD_QTN_MEMC_MMC;

			break;

			}

		case ETextMMCLocked:

			{

			resource = R_CFD_QTN_MEMC_MMC_LOCKED;

			break;

			}

		case ETextMMCUnavailable:

			{

			resource = R_CFD_QTN_MEMC_MMC_UNAVAILABLE;

			break;

			}

		case ETextRemoteDrive:

			{

			resource = R_CFD_QTN_MEMC_REMOTE_DRIVE;

			break;

			}

        }

    return resource;

    }

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

// CAknMemorySelectionModel::ResourceIDForLayoutSettingPageItem

//

//

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

//

TInt CAknMemorySelectionModel::ResourceIDForLayoutSettingPageItem(

    TInt aLocStrIndex )

    {

    TInt resource = 0;

    switch( aLocStrIndex )

        {

		case ETextPhoneMemory:

			{

			resource = R_CFD_QTN_DATABASE_PHONE;

			break;

			}

		case ETextMMC:

			{

			resource = R_CFD_QTN_MEMC_MCE_DEFAULT;

			break;

			}

		case ETextMMCLocked:

			{

			resource = R_CFD_QTN_DATABASE_LOCKED;

			break;

			}

		case ETextMMCUnavailable:

			{

			resource = R_CFD_QTN_DATABASE_UNAVAILABLE;

			break;

			}

	    case ETextRemoteDrive:

			{

			resource = R_CFD_QTN_MEMC_REMOTE_DRIVE;

			break;

			}

        }

    return resource;

    }

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

// CAknMemorySelectionModel::ResourceIDForLayoutDoublePopupItem

//

//

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

//

TInt CAknMemorySelectionModel::ResourceIDForLayoutDoublePopupItem(

    TInt aLocStrIndex )

    {

    TInt resource = 0;

     switch( aLocStrIndex )

        {

		case ETextPhoneMemory:

			{

			resource = R_CFD_QTN_MEMC_PHONE_DOUBLE_LIST;

			break;

			}

		case ETextMMC:

			{

			resource = R_CFD_QTN_MEMC_MMC_DOUBLE_LIST;

			break;

			}

		case ETextMMCLocked:

			{

			resource = R_CFD_QTN_MEMC_MMC_LOCKED_DOUBLE;

			break;

			}

		case ETextMMCUnavailable:

			{

			resource = R_CFD_QTN_MEMC_MMC_UNAVAILABLE_DOUBLE;

			break;

			}

		case ETextRemoteDrive:

			{

			resource = R_CFD_QTN_MEMC_REMOTE_DRIVE_DOUBLE_LIST;

			break;

			}

        }

    return resource;

    }

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

// CAknMemorySelectionModel::AddItemToLbxL

//

//

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

//

void CAknMemorySelectionModel::AddItemToLbxL( const TCFDDriveInfo& aDriveInfo )

    {

	// Drives C and E are special cases and these point to phone memory and MMC

	// memory regardless the media type. Listbox items are differend depending

	// on the media type.

    TDriveNumber phoneDrive, mmcDrive;

    phoneDrive = ( TDriveNumber )AknCFDUtility::DriveNumber(

                        PathInfo::PhoneMemoryRootPath() );

    User::LeaveIfError(

        DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage,

                                    ( TInt& )mmcDrive ) );

	if( aDriveInfo.iDriveNumber == phoneDrive /*Phone memory*/ )

	    {

	    AddPhoneItemToLbxL( aDriveInfo );

	    }

    else if( aDriveInfo.iDriveNumber == mmcDrive  /*MMC memory*/ )

	    {

	    AddMMCItemToLbxL( aDriveInfo );

	    }

	else

	    {

        switch( aDriveInfo.iMediaType )

			{

			// Different media type cases can be added here in the future

			case EMediaRemote:

				{

				AddRemoteItemToLbxL( aDriveInfo );

                break;

				}

			default:

				{

				// No actual use case for this yet (only remote drives should

				// exist).

				AddDefaultItemToLbxL( aDriveInfo );

                break;

				}

			}

	    }

    }

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

// CAknMemorySelectionModel::AddPhoneItemToLbxL

//

//

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

//

void CAknMemorySelectionModel::AddPhoneItemToLbxL( const TCFDDriveInfo& aDriveInfo )

    {

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

	TPtr itemString( lbxItemBuf->Des() );

	// Item text is affected by layout

	switch( iLayout )

	    {

	        case ELayoutPopupMenu:

	            {

                // A-column icon:

            	itemString.Format( KImageHeader, EIconPhoneMemory );

            	itemString.Append( KTabChar );

        		// 1st row text:

            	if( aDriveInfo.iVolumeLabel.Length() > 0 )

            	    {

            	    // Append drive name if it has one

            	    itemString.Append( aDriveInfo.iVolumeLabel );

            	    }

            	else

            	    {

            	    // Use default drive description

            	    itemString.Append( *iLocStringArray[ ETextPhoneMemory ] );

            	    }

   	            break;

	            }

	        case ELayoutSettingPage:

	            {

	            // 1st row text:

            	if( aDriveInfo.iVolumeLabel.Length() > 0 )

            	    {

            	    // Append drive name if it has one

            	    itemString.Append( aDriveInfo.iVolumeLabel );

            	    }

            	else

            	    {

            	    // Use default drive description

            	    itemString.Append( *iLocStringArray[ ETextPhoneMemory ] );

            	    }

	            break;

	            }

	        case ELayoutDoublePopup:

	            {

	            // A-column icon:

            	itemString.Format( KImageHeader, EIconPhoneMemory );

            	itemString.Append( KTabChar );

            	// 1st row text:

            	if( aDriveInfo.iVolumeLabel.Length() > 0 )

            	    {

            	    // Append drive name if it has one

            	    itemString.Append( aDriveInfo.iVolumeLabel );

            	    itemString.Append( KTabChar );

            	    }

            	else

            	    {

            	    // Use default drive description

            	    itemString.Append( *iLocStringArray[ ETextPhoneMemory ] );

            	    itemString.Append( KTabChar );

            	    }

            	// 2nd row text:

            	HBufC* buffer;

            	TInt64 freeSpace = aDriveInfo.iDiskSpace;

                if ( freeSpace >= 0 )

                    {

                    buffer = HBufC::NewLC( KListBoxEntryMaxLength );  

                    TPtr unitStr( buffer->Des() );

                    AknCFDUtility::SetSecondRowTextL( freeSpace, unitStr );	

                    }

                else

        	        {

        			// Disk space is unavailable

        			buffer = StringLoader::LoadLC(

        			            R_CFD_QTN_MEMC_SPACE_NOT_AVAILABLE,

        			            iCoeEnv);

        			}

            	itemString.Append( *buffer );//Free mem text

            	CleanupStack::PopAndDestroy( buffer );

	            break;

	            }

	        }

	// Finally!: append the formatted string to listbox

    User::LeaveIfError( iListBoxArray.Append( lbxItemBuf ) );

	CleanupStack::Pop( lbxItemBuf );

    _LOG1( "[CAknMemorySelectionModel] Item string added to lbx array: %S", &itemString );

    _LOG1( "itemString length=%d", itemString.Length() );

    }

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

// CAknMemorySelectionModel::AddMMCItemToLbxL

//

//

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

//

void CAknMemorySelectionModel::AddMMCItemToLbxL( const TCFDDriveInfo& aDriveInfo )

    {

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

	TPtr itemString( lbxItemBuf->Des() );