/*

* 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:  Dialog used to selection target memory (drive) which supports

*                multiple drives.

*

*/

#include <aknlists.h>   // Listboxes

#include <eikbtgpc.h>   // CEikButtonGroupContainer

#include <barsread.h>   // TResourceReader

#include <aknmemorycardui.mbg>

#include <avkon.mbg>

#include <commondialogs.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 "CAknMemorySelectionDialogMultiDrive.h"

#include "AknCommonDialogsDynMem.h"

#include "CAknCommonDialogsPopupList.h"

#include "CAknMemorySelectionEventHandler.h"

#include "caknmemoryselectionmodelmultidrive.h"

#include "MAknCommonDialogsEventObserver.h"

#include "AknCFDUtility.h"

const TInt KCFDGranularity = 2;

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

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

// CAknMemorySelectionDialogMultiDrive::CAknMemorySelectionDialogMultiDrive

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

//

CAknMemorySelectionDialogMultiDrive::CAknMemorySelectionDialogMultiDrive(

    TCommonDialogType aDialogType )

    :   iDialogType( aDialogType ),

        iRootPathArray( KCFDGranularity ),

        iDefaultFolderArray( KCFDGranularity )

    {

    }

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

// CAknMemorySelectionDialogMultiDrive::ConstructFromResourceL

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

//

void CAknMemorySelectionDialogMultiDrive::ConstructFromResourceL(

    TInt aResourceId,

    TBool aShowUnavailableDrives )

    {

    ConstructFromResourceL( aResourceId, aShowUnavailableDrives,

        AknCommonDialogsDynMem::EMemoryTypePhone

        | AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage

        | AknCommonDialogsDynMem::EMemoryTypeMMCExternal

        | AknCommonDialogsDynMem::EMemoryTypeRemote );

    }

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

// CAknMemorySelectionDialogMultiDrive::ConstructFromResourceL

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

//

void CAknMemorySelectionDialogMultiDrive::ConstructFromResourceL(

    TInt aResourceId,

    TBool aShowUnavailableDrives,

    TInt aIncludedMedias )

    {

    BaseConstructL();

    iIncludedMedias = aIncludedMedias;

    if( iIncludedMedias & AknCommonDialogsDynMem::EMemoryTypeMMC )

        {

        iIncludedMedias = iIncludedMedias |

            AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage

            | AknCommonDialogsDynMem::EMemoryTypeMMCExternal;

        iIncludedMedias &= ( ~AknCommonDialogsDynMem::EMemoryTypeMMC );

        }

    TInt userDefinedId( 0 );

    if( aResourceId )

        {

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

        userDefinedId = aResourceId;

        ReadFromResourceL( aResourceId );

        }

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

    // by reading all missing settings from default resource.

    SetResourceId( aResourceId, iDialogType );

    ReadFromResourceL( aResourceId );

    MAknMemorySelectionModel::TListBoxLayout layout(

        MAknMemorySelectionModel::ELayoutPopupMenu );

    if( iDialogType == ECFDDialogTypeDefaultSetting )

        {

        layout = MAknMemorySelectionModel::ELayoutSettingPage;

        }

    else if( AknCFDUtility::DirectoriesOnly( iDialogType ) )

        {

        layout = MAknMemorySelectionModel::ELayoutDoublePopup;

        }

    iModel = CAknMemorySelectionModelMultiDrive::NewL(

        iCoeEnv, &iRootPathArray, &iDefaultFolderArray,

        iIncludedMedias, aShowUnavailableDrives, layout );

    GetSystemDrivesL( userDefinedId );

    iEventHandler = CAknMemorySelectionEventHandler::NewL(

            iCoeEnv, iModel, NULL );

#ifdef _DEBUG

    _LOG( "[CAknMemorySelectionDialogMultiDrive] iRootPathArray: " );

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

        {

        TPtrC text = iRootPathArray.MdcaPoint( irp );

        _LOG1( "%S", &text );

        }

    _LOG( "[CAknMemorySelectionDialogMultiDrive] iDefaultFolderArray: " );

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

        {

        TPtrC text = iDefaultFolderArray.MdcaPoint( rpa );

        _LOG1( "%S", &text );

        }

#endif //_DEBUG

    }

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

// CAknMemorySelectionDialogMultiDrive::NewL

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

//

EXPORT_C CAknMemorySelectionDialogMultiDrive*

    CAknMemorySelectionDialogMultiDrive::NewL(

        TCommonDialogType aDialogType,

        TBool aShowUnavailableDrives )

    {

    return NewL( aDialogType, 0, aShowUnavailableDrives );

    }

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

// CAknMemorySelectionDialogMultiDrive::NewL

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

//

EXPORT_C CAknMemorySelectionDialogMultiDrive*

    CAknMemorySelectionDialogMultiDrive::NewL(

        TCommonDialogType aDialogType,

        TInt aResourceId,

        TBool aShowUnavailableDrives )

    {

    if( aDialogType == ECFDDialogTypeDefaultSetting )

        {

    	User::Leave( KErrNotSupported );

        }

    CAknMemorySelectionDialogMultiDrive* self =

        new( ELeave ) CAknMemorySelectionDialogMultiDrive( aDialogType );

    CleanupStack::PushL( self );

    self->ConstructFromResourceL( aResourceId, aShowUnavailableDrives );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CAknMemorySelectionDialogMultiDrive::NewL

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

//

EXPORT_C CAknMemorySelectionDialogMultiDrive*

    CAknMemorySelectionDialogMultiDrive::NewL(

        TCommonDialogType aDialogType,

        TInt aResourceId,

        TBool aShowUnavailableDrives,

        TInt aIncludedMedias )

    {

    if( aDialogType == ECFDDialogTypeDefaultSetting )

        {

    	User::Leave( KErrNotSupported );

        }

    CAknMemorySelectionDialogMultiDrive* self =

        new( ELeave ) CAknMemorySelectionDialogMultiDrive( aDialogType );

    CleanupStack::PushL( self );

    self->ConstructFromResourceL( aResourceId,

                                  aShowUnavailableDrives,

                                  aIncludedMedias );

    CleanupStack::Pop(); // self

    return self;

    }

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

// Destructor

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

//

EXPORT_C

    CAknMemorySelectionDialogMultiDrive::~CAknMemorySelectionDialogMultiDrive()

    {

    delete iEventHandler;

    delete iModel;

    delete iTitle;

    delete iLeftSoftkey;

    delete iRightSoftkey;

    }

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

// CAknMemorySelectionDialogMultiDrive::SetTitleL

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

//

EXPORT_C void CAknMemorySelectionDialogMultiDrive::SetTitleL(

    const TDesC& aText )

    {

    AknCFDUtility::AllocateIfValidL( iTitle, aText );

    }

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

// CAknMemorySelectionDialogMultiDrive::SetLeftSoftkeyL

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

//

EXPORT_C void CAknMemorySelectionDialogMultiDrive::SetLeftSoftkeyL(

    const TDesC& aText )

    {

    AknCFDUtility::AllocateIfValidL( iLeftSoftkey, aText );

    }

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

// CAknMemorySelectionDialogMultiDrive::SetRightSoftkeyL

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

//

EXPORT_C void CAknMemorySelectionDialogMultiDrive::SetRightSoftkeyL(

    const TDesC& aText )

    {

    AknCFDUtility::AllocateIfValidL( iRightSoftkey, aText );

    }

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

// CAknMemorySelectionDialogMultiDrive::GetItem

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

//

EXPORT_C void CAknMemorySelectionDialogMultiDrive::GetItem(

    TInt aIndex, TDes& aItem )

    {

    iModel->GetItem( aIndex, aItem );

    }

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

// CAknMemorySelectionDialogMultiDrive::ExecuteL

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

//

EXPORT_C CAknCommonDialogsBase::TReturnKey

    CAknMemorySelectionDialogMultiDrive::ExecuteL(

        TDriveNumber& aSelectedDrive )

    {

    return ExecuteL( aSelectedDrive, NULL, NULL );

    }

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

// CAknMemorySelectionDialogMultiDrive::ExecuteL

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

//

EXPORT_C CAknCommonDialogsBase::TReturnKey

    CAknMemorySelectionDialogMultiDrive::ExecuteL(

        TDriveNumber& aSelectedDrive, TDes* aRootPath, TDes* aDefaultFolder )

    {

    __ASSERT_DEBUG( iTitle && iLeftSoftkey && iRightSoftkey,

        User::Panic( KCFDPanicText, ECFDPanicTitleOrSoftkeyNotSet ) );

    iModel->UpdateItemsL();

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

    // Set listener for popuplist anytime.

    TBool hasRemoteDrive =

        ( iIncludedMedias & AknCommonDialogsDynMem::EMemoryTypeRemote );

    iEventHandler->StartNotifyDisk( popupList, hasRemoteDrive );

    TInt selectedIndex = FindIndexByDrive( aSelectedDrive );

    if( selectedIndex == KErrNotFound )

        {

        selectedIndex = 0; // The first index

        }

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

    // Update CAB show.

    iEventHandler->HandleEventL(

    		MAknCommonDialogsEventObserver::EFocusChange,

    		selectedIndex,

    		selectedIndex,

    		popupList->ButtonGroupContainer() );

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

    // Execute the popup dialog

    TBool returnValue = EFalse;

    TRAPD( err, returnValue = popupList->ExecuteLD() );

    if ( iEventHandler )

        {        

        iEventHandler->StopNotifyDisk();

        }

    if( returnValue )

        {

        selectedIndex = listBox->CurrentItemIndex();

        GetDrivePaths( selectedIndex, aRootPath, aDefaultFolder );

        aSelectedDrive = FindDriveByIndex( selectedIndex );

        }

    else if ( err )

        {

        User::Leave( err );

        }

    CleanupStack::PopAndDestroy(); // listBox

    return TReturnKey( returnValue );

    }

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

// CAknMemorySelectionDialogMultiDrive::RunDlgLD

// A wrapper for RunL.

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

//

EXPORT_C TBool CAknMemorySelectionDialogMultiDrive::RunDlgLD(

    TDriveNumber& aSelectedDrive )

    {

    return RunL( 0, aSelectedDrive, NULL, NULL, KNullDesC );

    }

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

// CAknMemorySelectionDialogMultiDrive::RunDlgLD

// A wrapper for RunL.

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

//

EXPORT_C TBool CAknMemorySelectionDialogMultiDrive::RunDlgLD(

    TDriveNumber& aSelectedDrive,

    const TDesC& aTitle )

    {

    return RunL( 0, aSelectedDrive, NULL, NULL, aTitle );

    }

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

// CAknMemorySelectionDialogMultiDrive::RunDlgLD

// A wrapper for RunL.

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

//

EXPORT_C TBool CAknMemorySelectionDialogMultiDrive::RunDlgLD(

    TDriveNumber& aSelectedDrive,

    TInt aResourceId,

    TDes* aRootPath,

    TDes* aDefaultFolder )

    {

    return RunL(

        aResourceId, aSelectedDrive, aRootPath, aDefaultFolder, KNullDesC );

    }

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

// CAknMemorySelectionDialogMultiDrive::RunL

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

//

TBool CAknMemorySelectionDialogMultiDrive::RunL(

    TInt aResourceId,

    TDriveNumber& aSelectedDrive,

    TDes* aRootPath,

    TDes* aDefaultFolder,

    const TDesC& aTitle

    )

    {

    CAknMemorySelectionDialogMultiDrive* self =

        CAknMemorySelectionDialogMultiDrive::NewL(

            ECFDDialogTypeNormal, aResourceId, ETrue );

    CleanupStack::PushL( self );

    self->SetTitleL( aTitle );

    TBool returnValue(

        self->ExecuteL( aSelectedDrive, aRootPath, aDefaultFolder ) );

    CleanupStack::PopAndDestroy();

    return returnValue;

    }

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

// CAknMemorySelectionDialogMultiDrive::AddDrivePathsL

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

//

EXPORT_C TInt CAknMemorySelectionDialogMultiDrive::AddDrivePathsL(

    const TDesC& aRootPath,

    const TDesC& aDefaultFolder

    )

    {

    // TODO: Verify paramters if they are valid.

    TInt rootPathCount=iRootPathArray.Count();

    TInt result = KErrNone;

    TPath path;

    for ( TInt i=0;i<rootPathCount;i++ )

        {

        path.Copy( iRootPathArray[i] );

        path.Append( aRootPath );

        AknCFDUtility::AddTrailingBackslash( path );

        iRootPathArray.Delete(i);

        iRootPathArray.Compress();

        iRootPathArray.InsertL( i, path );

        path.Copy( aDefaultFolder );

        AknCFDUtility::AddTrailingBackslash( path );

        iDefaultFolderArray.Delete(i);

        iDefaultFolderArray.Compress();

        iDefaultFolderArray.InsertL( i, path );

        }

    return result;

    }

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

// CAknMemorySelectionDialogMultiDrive::GetDrivePaths

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

//

TInt CAknMemorySelectionDialogMultiDrive::GetDrivePaths(

    TDriveNumber aDrive,

    TDes* aRootPath,

    TDes* aDefaultFolder )

    {

    TInt index = FindIndexByDrive( aDrive );

    if ( index >= 0 )

        return GetDrivePaths( index, aRootPath, aDefaultFolder );

    return KErrNotFound;

    }

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

// CAknMemorySelectionDialogMultiDrive::GetDrivePaths

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

//

TInt CAknMemorySelectionDialogMultiDrive::GetDrivePaths(

    TInt aLbxIndex,

    TDes* aRootPath,

    TDes* aDefaultFolder )

    {

    if ( ( aLbxIndex >= 0 )

        && ( iRootPathArray.Count() > aLbxIndex )

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

        {

        if( aRootPath )

            {

            *aRootPath = iRootPathArray[ aLbxIndex ];

            }

        if( aDefaultFolder )

            {

            *aDefaultFolder = iDefaultFolderArray[ aLbxIndex ];

            }

        return KErrNone;

        }

    else

        return KErrNotFound;

    }

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

// CAknMemorySelectionDialogMultiDrive::LoadIconsL

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

//