/*
* 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:  Setting item to support multiple drives.
*
*/


#include <driveinfo.h>

#include "CAknMemorySelectionSettingItemMultiDrive.h"
#include "CAknMemorySelectionDialogMultiDrive.h"
#include "maknmemoryselectionmodel.h"
#include "AknCFDUtility.h"
#include "CAknCFDFileSystemEvent.h"
#include "MAknCFDFileSystemObserver.h"


NONSHARABLE_CLASS(CAknMemorySelectionSettingItemExtension)
    : public CBase,
      public MAknCFDFileSystemObserver
    {

public:
    CAknMemorySelectionSettingItemExtension(
        CAknMemorySelectionSettingItemMultiDrive* aSettingItem );
    ~CAknMemorySelectionSettingItemExtension();

    /**
     * second phase construct
     *
     * @param aIncludedMedias bit flag definition of which medias are
     *        included in the dialog. See AknCommonDialogsDynMem::TMemoryTypes.
     */
    void ConstructL( TInt aIncludedMedias );
    
    /**
     * Static constructor.
     *
     * @since S60 5.0
     * @param aSettingItem defines a pointer to the setting item. 
     * @param aIncludedMedias bit flag definition of which medias are
     *        included in the dialog. See AknCommonDialogsDynMem::TMemoryTypes.
     *        if not set, use dialog default value.
     * @return Returns a pointer to an instance of itself.
     */
    static CAknMemorySelectionSettingItemExtension* NewL(
        CAknMemorySelectionSettingItemMultiDrive* aSettingItem,
        TInt aIncludedMedias = -1 );
    
    /**
     * Construct memory selection dialog
     *
     * @param aIncludedMedias bit flag definition of which medias are
     *        included in the dialog. See AknCommonDialogsDynMem::TMemoryTypes.
     */
    void ConstructDialogL( TInt aIncludedMedias );
    
    // Functions from base interface MAknCFDFileSystemObserver
    /**
     * From MAknCFDFileSystemObserver
     */
    void NotifyFileSystemChangedL();
    
    // Own: memory selection dialog
    CAknMemorySelectionDialogMultiDrive* iDialog;
    
    // Ref: The external data
    CAknMemorySelectionSettingItemMultiDrive* iSettingItem;
    
    // Own: The extension of setting item
    CAknCFDFileSystemEvent* iFSEvent;
    
    // Own: Indicate which media types of drives could be visible.
    TInt iIncludedMedias;
    };

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

// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItem::CAknMemorySelectionSettingItem
// ---------------------------------------------------------------------------
//
EXPORT_C CAknMemorySelectionSettingItemMultiDrive
    ::CAknMemorySelectionSettingItemMultiDrive(
        TInt aIdentifier,
        TDriveNumber& aSelectedDrive )
        :   CAknSettingItem( aIdentifier ),
            iExternalData( aSelectedDrive )
    {
    
    }

// Destructor
EXPORT_C CAknMemorySelectionSettingItemMultiDrive::
    ~CAknMemorySelectionSettingItemMultiDrive()
    {
    delete iSettingText;
    delete iExtension, iExtension = NULL;
    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemMultiDrive::CompleteConstructionL
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknMemorySelectionSettingItemMultiDrive::CompleteConstructionL()
    {
    if ( !iExtension )
        {
        iExtension = CAknMemorySelectionSettingItemExtension::NewL( this );
        }
    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemMultiDrive::EditItemL
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknMemorySelectionSettingItemMultiDrive::EditItemL(
    TBool aCalledFromMenu )
    {
    if( !iExtension )
        {
        // This in case application hasn't called CompleteConstructionL()
        CompleteConstructionL();
        }

    if( aCalledFromMenu )
        {
        // Changed with Options/Change
        iExtension->iDialog->ExecuteL( iInternalData, NULL, NULL );
        }
    else
        {
        // Changed with selection key
        if( ( iExtension->iDialog->NumberOfItems() == 2 ) )
            {
            // Two items in list, function as binary pop-up setting page
            TInt selectedIndex =
                iExtension->iDialog->FindIndexByDrive( iInternalData );
	          if ( selectedIndex == KErrNotFound )
	              {
	              selectedIndex = 0;
	              }
	          else
	              {
                  TDriveNumber driveNum =
                      iExtension->iDialog->FindDriveByIndex( 1 - selectedIndex );
                  if ( AknCFDUtility::DriveStatusL( driveNum ) == EDriveOK )
                      {
                      selectedIndex = 1 - selectedIndex; // switch to another one.
                      }
	              }
            iInternalData =
                iExtension->iDialog->FindDriveByIndex( selectedIndex );
            }
        else
            {
            iExtension->iDialog->ExecuteL( iInternalData, NULL, NULL );
            }
        }

    UpdateListBoxTextL();

    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemMultiDrive::LoadL
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknMemorySelectionSettingItemMultiDrive::LoadL()
    {
    iInternalData = iExternalData;
    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemMultiDrive::StoreL
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknMemorySelectionSettingItemMultiDrive::StoreL()
    {
    iExternalData = iInternalData;
    
    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemMultiDrive::SettingTextL
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC& CAknMemorySelectionSettingItemMultiDrive::SettingTextL()
    {
    if( !iExtension )
        {
        // This in case application hasn't called CompleteConstructionL()
        CompleteConstructionL();
        }

    TInt memoryIndex = iExtension->iDialog->FindIndexByDrive( iInternalData );
    if ( AknCFDUtility::DriveStatusL( iInternalData ) != EDriveOK )
        {
        // Find the first proper drive in the dialog list.
        memoryIndex = 0;
        while ( memoryIndex < iExtension->iDialog->NumberOfItems() )
            {
            iInternalData = iExtension->iDialog->FindDriveByIndex( memoryIndex );
            if ( AknCFDUtility::DriveStatusL( iInternalData ) == EDriveOK )
                {
                break;
                }
            memoryIndex++;
            }
        // Not find the proper drive.
        if ( memoryIndex == iExtension->iDialog->NumberOfItems() )
            {
            iInternalData = EDriveC;
            memoryIndex = KErrNotFound;
            }
        }

    if ( memoryIndex == KErrNotFound )
        {
        return KNullDesC;
        }

    if( !iSettingText )
        iSettingText = HBufC::NewL( KMaxName );
    TPtr ptrSettingText( iSettingText->Des() );
    iExtension->iDialog->GetItem( memoryIndex, ptrSettingText );

    return *iSettingText;
    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemMultiDrive::UpdateSettingItemContentL
// ---------------------------------------------------------------------------
//
void CAknMemorySelectionSettingItemMultiDrive::UpdateSettingItemContentL()
    {
    if ( iExtension->iDialog != NULL )
        {
        // Update model.
        iExtension->iDialog->UpdateModelL();

        // Update setting item value.
        TInt selectedIndex = iExtension->iDialog->
            FindIndexByDrive( iInternalData );

        if ( selectedIndex == KErrNotFound )
            {
            // If the selected index is not found, set it to the first one
            selectedIndex = 0;
            }
        iInternalData = iExtension->iDialog->FindDriveByIndex( selectedIndex );

        UpdateListBoxTextL();
        }
    }

// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemMultiDrive::SetIncludedMediasL
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknMemorySelectionSettingItemMultiDrive::SetIncludedMediasL(
    TInt aIncludedMedias )
    {
    if ( !iExtension )
        {
        iExtension = CAknMemorySelectionSettingItemExtension::NewL(
            this, aIncludedMedias );
        }
    else if ( iExtension->iIncludedMedias != aIncludedMedias )
        {
        iExtension->ConstructDialogL( aIncludedMedias );
        }
    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemExtension
// Constructor
// ---------------------------------------------------------------------------
//
CAknMemorySelectionSettingItemExtension::
    CAknMemorySelectionSettingItemExtension(
        CAknMemorySelectionSettingItemMultiDrive* aSettingItem )
        : iSettingItem( aSettingItem )
    {
    }


// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemExtension
// Constructor
// ---------------------------------------------------------------------------
//
CAknMemorySelectionSettingItemExtension::
    ~CAknMemorySelectionSettingItemExtension()
    {
    delete iDialog;
    iDialog = NULL;
    
    if ( iFSEvent )
        {
        iFSEvent->Cancel();
        delete iFSEvent;
        iFSEvent = NULL;
        }
        
    }

// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemExtension
// NotifyFileSystemChangedL
// ---------------------------------------------------------------------------
//
void CAknMemorySelectionSettingItemExtension::NotifyFileSystemChangedL()
    {
    iSettingItem->UpdateSettingItemContentL();
    
    if (iFSEvent != NULL)
        {
        iFSEvent->Setup();
        }
    }

// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemExtension
// ConstructDialogL
// ---------------------------------------------------------------------------
//
void CAknMemorySelectionSettingItemExtension::ConstructDialogL(
    TInt aIncludedMedias )
    {
    if ( iDialog )
        {
        delete iDialog;
        iDialog = NULL;
        }
    
    iIncludedMedias = aIncludedMedias;
    
    if ( aIncludedMedias == -1 )
        {
        iDialog = CAknMemorySelectionDialogMultiDrive::NewL(
            ECFDDialogTypeNormal, ETrue );
        }
    else
        {
        iDialog = CAknMemorySelectionDialogMultiDrive::NewL( 
            ECFDDialogTypeNormal, 0, ETrue, aIncludedMedias );
        }
    }

// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemExtension
// ConstructL
// ---------------------------------------------------------------------------
//
void CAknMemorySelectionSettingItemExtension::ConstructL( TInt aIncludedMedias )
    {
    ConstructDialogL( aIncludedMedias );
    
    iFSEvent = CAknCFDFileSystemEvent::NewL(
        CCoeEnv::Static()->FsSession(), *this, ENotifyDisk );
    }

// ---------------------------------------------------------------------------
// CAknMemorySelectionSettingItemExtension
// NewL
// ---------------------------------------------------------------------------
//
CAknMemorySelectionSettingItemExtension*
    CAknMemorySelectionSettingItemExtension::NewL(
        CAknMemorySelectionSettingItemMultiDrive* aSettingItem,
        TInt aIncludedMedias )
    {
    CAknMemorySelectionSettingItemExtension* self =
        new( ELeave ) CAknMemorySelectionSettingItemExtension( aSettingItem );

    CleanupStack::PushL( self );
    self->ConstructL( aIncludedMedias );
    CleanupStack::Pop( self );

    return self;
    }