/*

* Copyright (c) 2002-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:  Dialog used to selection target memory

*

*/

#include <aknlists.h>   // Listboxes

#include <eikbtgpc.h>   // CEikButtonGroupContainer

#include <barsread.h>   // TResourceReader

#include <aknmemorycardui.mbg>

#include <avkon.mbg>

#include <AknIconArray.h>

#include <aknconsts.h> // KAvkonBitmapFile

#include <AknsConstants.h> // KAknsIIDQgnPropPhoneMemcLarge etc.

#include <AknsUtils.h>

#include <commondialogs.rsg> // Common dialogs resource IDs

#include <pathinfo.h> //PathInfo

#include <driveinfo.h> //DriveInfo

#include "CAknMemorySelectionDialog.h"

#include "AknCommonDialogsDynMem.h"

#include "CAknCommonDialogsPopupList.h"

#include "CAknMemorySelectionEventHandler.h"

#include "CAknMemorySelectionModel.h"

#include "MAknCommonDialogsEventObserver.h"

#include "AknCFDUtility.h"

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

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

// CAknMemorySelectionDialog::CAknMemorySelectionDialog

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

//

CAknMemorySelectionDialog::CAknMemorySelectionDialog(

    TCommonDialogType aDialogType )

    :   iDialogType( aDialogType ),

        iRootPathArray( EMemoryCount ),

        iDefaultFolderArray( EMemoryCount )

    {

    }

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

// CAknMemorySelectionDialog::ConstructFromResourceL

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

//

void CAknMemorySelectionDialog::ConstructFromResourceL(

    TInt aResourceId,

    TBool aShowUnavailableDrives )

    {

    // EMemoryTypePhone|EMemoryTypeMMC are the drives used in legacy code.

    ConstructFromResourceL( aResourceId, aShowUnavailableDrives,

        AknCommonDialogsDynMem::EMemoryTypePhone

        | AknCommonDialogsDynMem::EMemoryTypeMMC );

    }

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

// CAknMemorySelectionDialog::ConstructFromResourceL

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

//

void CAknMemorySelectionDialog::ConstructFromResourceL(

    TInt aResourceId,

    TBool aShowUnavailableDrives,

    TInt aIncludedMedias )

    {

    BaseConstructL();

    iIncludedMedias = aIncludedMedias;

    if( iIncludedMedias & AknCommonDialogsDynMem::EMemoryTypeMMC )

        {

        iIncludedMedias = iIncludedMedias |

            AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage

            | AknCommonDialogsDynMem::EMemoryTypeMMCExternal;

        iIncludedMedias &= ( ~AknCommonDialogsDynMem::EMemoryTypeMMC );

        }

    if( aResourceId )

        {

        // If a resource id is given, read settings from it.

        ReadFromResourceL( aResourceId, ETrue );

        }

    // After user resource is read, "patch" the missing values with defaults

    // by reading all missing settings from default resource.

    SetResourceId( aResourceId, iDialogType );

    ReadFromResourceL( aResourceId, EFalse );

    if( !iRootPathArray.Count() )

        {

        GetSystemPathsL();

        }

    MAknMemorySelectionModel::TListBoxLayout layout(

        MAknMemorySelectionModel::ELayoutPopupMenu );

    if( iDialogType == ECFDDialogTypeDefaultSetting )

        {

        layout = MAknMemorySelectionModel::ELayoutSettingPage;

        }

    else if( AknCFDUtility::DirectoriesOnly( iDialogType ) )

        {

        layout = MAknMemorySelectionModel::ELayoutDoublePopup;

        }

    // Add dynamic drives to iRootPathArray if they're required:

    if( aIncludedMedias & AknCommonDialogsDynMem::EMemoryTypeRemote )

        {

        // Enable dynamic drives, this means iRootPathArray items are dynamic.

        iDynamicDrivesEnabled = ETrue;

        AknCFDUtility::ReadDynamicDrivesL( iRootPathArray, aIncludedMedias );

        }

    // Create model of listbox listing the drives in iRootPathArray:

    iModel = CAknMemorySelectionModel::NewL(

        iCoeEnv, &iRootPathArray, aShowUnavailableDrives, layout );

    iEventHandler = CAknMemorySelectionEventHandler::NewL(

            iCoeEnv, iModel, iObserver );

#ifdef _DEBUG

    _LOG( "[CAknMemorySelectionDialog] iRootPathArray: " );

    for( TInt irp = 0; irp < iRootPathArray.MdcaCount(); irp++ )

        {

        TPtrC text = iRootPathArray.MdcaPoint( irp );

        _LOG1( "%S", &text );

        }

    _LOG( "[CAknMemorySelectionDialog] iDefaultFolderArray: " );

    for( TInt rpa = 0; rpa < iDefaultFolderArray.MdcaCount(); rpa++ )

        {

        TPtrC text = iDefaultFolderArray.MdcaPoint( rpa );

        _LOG1( "%S", &text );

        }

#endif //_DEBUG

    }

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

// CAknMemorySelectionDialog::NewL

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

//

EXPORT_C CAknMemorySelectionDialog* CAknMemorySelectionDialog::NewL(

    TCommonDialogType aDialogType,

    TBool aShowUnavailableDrives )

    {

    return NewL( aDialogType, 0, aShowUnavailableDrives );

    }

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

// CAknMemorySelectionDialog::NewL

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

//

EXPORT_C CAknMemorySelectionDialog* CAknMemorySelectionDialog::NewL(

    TCommonDialogType aDialogType,

    TInt aResourceId,

    TBool aShowUnavailableDrives )

    {

    if( aDialogType == ECFDDialogTypeDefaultSetting )

        {

    	User::Leave( KErrNotSupported );

        }

    CAknMemorySelectionDialog* self =

        new( ELeave ) CAknMemorySelectionDialog( aDialogType );

    CleanupStack::PushL( self );

    self->ConstructFromResourceL( aResourceId, aShowUnavailableDrives );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CAknMemorySelectionDialog::NewL

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

//

EXPORT_C CAknMemorySelectionDialog* CAknMemorySelectionDialog::NewL(

    TCommonDialogType aDialogType,

    TInt aResourceId,

    TBool aShowUnavailableDrives,

    TInt aIncludedMedias )

    {

    if( aDialogType == ECFDDialogTypeDefaultSetting )

        {

    	User::Leave( KErrNotSupported );

        }

    CAknMemorySelectionDialog* self =

        new( ELeave ) CAknMemorySelectionDialog( aDialogType );

    CleanupStack::PushL( self );

    self->ConstructFromResourceL( aResourceId,

                                  aShowUnavailableDrives,

                                  aIncludedMedias );

    CleanupStack::Pop(); // self

    return self;

    }

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

// Destructor

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

//

EXPORT_C CAknMemorySelectionDialog::~CAknMemorySelectionDialog()

    {

    delete iEventHandler;

    delete iModel;

    delete iTitle;

    delete iLeftSoftkey;

    delete iRightSoftkey;

    }

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

// CAknMemorySelectionDialog::SetObserver

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

//

EXPORT_C void CAknMemorySelectionDialog::SetObserver(

    MAknMemorySelectionObserver* aObserver )

    {

    // The observer could not be called, so the following code is useless

    iObserver = aObserver;

    }

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

// CAknMemorySelectionDialog::SetTitleL

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

//

EXPORT_C void CAknMemorySelectionDialog::SetTitleL( const TDesC& aText )

    {

    AknCFDUtility::AllocateIfValidL( iTitle, aText );

    }

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

// CAknMemorySelectionDialog::SetLeftSoftkeyL

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

//

EXPORT_C void CAknMemorySelectionDialog::SetLeftSoftkeyL( const TDesC& aText )

    {

    AknCFDUtility::AllocateIfValidL( iLeftSoftkey, aText );

    }

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

// CAknMemorySelectionDialog::SetRightSoftkeyL

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

//

EXPORT_C void CAknMemorySelectionDialog::SetRightSoftkeyL( const TDesC& aText )

    {

    AknCFDUtility::AllocateIfValidL( iRightSoftkey, aText );

    }

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

// CAknMemorySelectionDialog::GetItem

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

//

EXPORT_C void CAknMemorySelectionDialog::GetItem( TInt aIndex, TDes& aItem )

    {

    iModel->GetItem( aIndex, aItem );

    }

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

// CAknMemorySelectionDialog::GetMemories

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

//

EXPORT_C void CAknMemorySelectionDialog::GetMemories(

    TMemory aSelectedMemory,

    TDes* aRootPath,

    TDes* aDefaultFolder )

    {

    if( iDynamicDrivesEnabled )

        {

        // When dynamic drives are enabled, parameter aSelectedMemory is not

        // of type TMemory but TInt indexing the selected listbox item.

        // GetDrivePaths handles this logic.

        GetDrivePaths( aSelectedMemory, aRootPath, aDefaultFolder );

        }

    else

        {

        // aSelectedMemory is fixed enum pointing either Phone or MMC memory.

        // This is needed for CommonDialogs legacy implementation.

        if( aRootPath )

            {

            __ASSERT_DEBUG( ( aSelectedMemory >= 0 )

                && ( aSelectedMemory < iRootPathArray.Count() ),

                User::Panic( KCFDPanicText, ECFDPanicOutOfBounds ) );

            *aRootPath = iRootPathArray[ aSelectedMemory ];

            }

        if( aDefaultFolder )

            {

            __ASSERT_DEBUG( ( aSelectedMemory >= 0 ) &&

                            ( aSelectedMemory < iDefaultFolderArray.Count() ),

                User::Panic( KCFDPanicText, ECFDPanicOutOfBounds ) );

            *aDefaultFolder = iDefaultFolderArray[ aSelectedMemory ];

            }

        }

    }

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

// CAknMemorySelectionDialog::ExecuteL

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

//

EXPORT_C CAknCommonDialogsBase::TReturnKey CAknMemorySelectionDialog::ExecuteL(

    TMemory& aSelectedMemory )

    {

    return ExecuteL( aSelectedMemory, NULL, NULL );

    }

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

// CAknMemorySelectionDialog::ExecuteL

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

//

EXPORT_C CAknCommonDialogsBase::TReturnKey CAknMemorySelectionDialog::ExecuteL(

    TMemory& aSelectedMemory,

    TDes* aRootPath,

    TDes* aDefaultFolder )

    {

    __ASSERT_DEBUG( iTitle && iLeftSoftkey && iRightSoftkey,

        User::Panic( KCFDPanicText, ECFDPanicTitleOrSoftkeyNotSet ) );

    TBool doubleStyle( AknCFDUtility::DirectoriesOnly( iDialogType ) );

    CEikFormattedCellListBox* listBox = NULL;

    if( doubleStyle )

        {

        listBox = new( ELeave ) CAknDoubleLargeGraphicPopupMenuStyleListBox();

        }

    else

        {

        listBox = new( ELeave ) CAknSingleGraphicPopupMenuStyleListBox();

        }

    CleanupStack::PushL( listBox );

    AknPopupLayouts::TAknPopupLayouts layout( doubleStyle ?

        AknPopupLayouts::EMenuDoubleLargeGraphicWindow :

        AknPopupLayouts::EMenuGraphicWindow );

    TBool isEndKeyPress = EFalse;

    CAknCommonDialogsPopupList* popupList =

        CAknCommonDialogsPopupList::NewL(

            *iEventHandler, listBox, layout, isEndKeyPress );

    CleanupStack::PushL( popupList );

    listBox->ConstructL( popupList, 0 );

    listBox->CreateScrollBarFrameL( ETrue ); // Create scroll indicator

    listBox->ScrollBarFrame()->SetScrollBarVisibilityL(

        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    listBox->Model()->SetItemTextArray( iModel );

    // Set model ownership type

    listBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    // Icons:

    // Granularity, 5 icons

    CAknIconArray* iconArray = new( ELeave ) CAknIconArray( 5 );

    CleanupStack::PushL( iconArray );

    LoadIconsL( iconArray, doubleStyle );

    listBox->ItemDrawer()->FormattedCellData()->SetIconArrayL( iconArray );

    CleanupStack::Pop(); // iconArray

    popupList->SetTitleL( *iTitle ); // Set title

    CEikButtonGroupContainer* cba = popupList->ButtonGroupContainer();

    MEikButtonGroup* buttonGroup = cba->ButtonGroup();

    cba->SetCommandL( buttonGroup->CommandId( 0 ), *iLeftSoftkey );

    cba->SetCommandL( buttonGroup->CommandId( 2 ), *iRightSoftkey );

    listBox->View()->SetCurrentItemIndex( aSelectedMemory );

    CleanupStack::Pop(); // popupList (deleted in ExecuteLD)

    // Execute the popup dialog

    TBool returnValue( popupList->ExecuteLD() );

    if( returnValue )

        {

        aSelectedMemory = TMemory( listBox->CurrentItemIndex() );

        GetMemories( aSelectedMemory, aRootPath, aDefaultFolder );

        }

    CleanupStack::PopAndDestroy(); // listBox

    return TReturnKey( returnValue );

    }

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

// CAknMemorySelectionDialog::RunDlgLD

// A wrapper for RunL.

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

//

EXPORT_C TBool CAknMemorySelectionDialog::RunDlgLD(

    TMemory& aSelectedMemory,

    MAknMemorySelectionObserver* aObserver )

    {

    return RunL( 0, aSelectedMemory,

        NULL, NULL, KNullDesC, aObserver );

    }

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

// CAknMemorySelectionDialog::RunDlgLD

// A wrapper for RunL.

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

//

EXPORT_C TBool CAknMemorySelectionDialog::RunDlgLD(

    TMemory& aSelectedMemory,

    const TDesC& aTitle,

    MAknMemorySelectionObserver* aObserver )

    {

    return RunL( 0, aSelectedMemory,

        NULL, NULL, aTitle, aObserver );

    }

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

// CAknMemorySelectionDialog::RunDlgLD

// A wrapper for RunL.

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

//

EXPORT_C TBool CAknMemorySelectionDialog::RunDlgLD(

    TMemory& aSelectedMemory,

    TInt aResourceId,

    TDes* aRootPath, TDes* aDefaultFolder,

    MAknMemorySelectionObserver* aObserver )

    {

    return RunL( aResourceId, aSelectedMemory,

        aRootPath, aDefaultFolder, KNullDesC, aObserver );

    }

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

// CAknMemorySelectionDialog::GetDrivePaths

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

//

TInt CAknMemorySelectionDialog::GetDrivePaths(

    TInt aLbxIndex,

    TDes* aRootPath,

    TDes* aDefaultFolder )

    {

    if ( aLbxIndex >= 0 )

        {

        if( aRootPath && ( iRootPathArray.Count() > aLbxIndex ))

            {

            // aRootPath is required.

            *aRootPath = iRootPathArray[ aLbxIndex ];

            }

        if( aDefaultFolder && ( iDefaultFolderArray.Count() > aLbxIndex ))

            {

            // aDefaultFolder is required.

            *aDefaultFolder = iDefaultFolderArray[ aLbxIndex ];

            }

        return KErrNone;

        }

    else

        return KErrNotFound;

    }

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

// CAknMemorySelectionDialog::LoadIconsL

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

//

void CAknMemorySelectionDialog::LoadIconsL( CAknIconArray* aIconArray,

                                            TBool aDoubleStyle )

    {

    CEikonEnv* eikEnv = CEikonEnv::Static();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if( aDoubleStyle )

        {

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropPhoneMemcLarge, KAvkonBitmapFile,

            EMbmAvkonQgn_prop_phone_memc_large,

            EMbmAvkonQgn_prop_phone_memc_large_mask );

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropMmcMemcLarge, KAvkonBitmapFile,

            EMbmAvkonQgn_prop_mmc_memc_large,

            EMbmAvkonQgn_prop_mmc_memc_large_mask );

        /**

        * !!! NOTE !!!

        * Inserting NULL pointers so the aIconArray count is always same

        * regardless the if(doubleStyle) clause. In doubleStyle the icons

        * are actually replaced by localized strings.

        */

        aIconArray->AppendL( NULL );// Uses mmc_locked string instead.

        aIconArray->AppendL( NULL );// Uses mmc_non string insterad.

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropRemoteDriveMemcLarge, KAvkonBitmapFile,

            EMbmAvkonQgn_prop_remote_drive_memc_large,

            EMbmAvkonQgn_prop_remote_drive_memc_large_mask );

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnIndiConnectionOnAdd, KAvkonBitmapFile,

            EMbmAvkonQgn_indi_connection_on_add,

            EMbmAvkonQgn_indi_connection_on_add_mask );

        }

    else

        {

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropPhoneMemc, KMemoryCardUiBitmapFile,

            EMbmAknmemorycarduiQgn_prop_phone_memc,

            EMbmAknmemorycarduiQgn_prop_phone_memc_mask );

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropMmcMemc, KMemoryCardUiBitmapFile,

            EMbmAknmemorycarduiQgn_prop_mmc_memc,

            EMbmAknmemorycarduiQgn_prop_mmc_memc_mask );

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropMmcLocked, KMemoryCardUiBitmapFile,

            EMbmAknmemorycarduiQgn_prop_mmc_locked,

            EMbmAknmemorycarduiQgn_prop_mmc_locked_mask );

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropMmcNon, KMemoryCardUiBitmapFile,

            EMbmAknmemorycarduiQgn_prop_mmc_non,

            EMbmAknmemorycarduiQgn_prop_mmc_non_mask );

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,

            skin, KAknsIIDQgnPropRemoteDriveMemc, KMemoryCardUiBitmapFile,

            EMbmAvkonQgn_prop_remote_drive_memc,

            EMbmAvkonQgn_prop_remote_drive_memc_mask );

        AknCFDUtility::AppendSkinnedImageToArrayL( *eikEnv, *aIconArray,