/*

* 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:  ?Description

*

*/

// INCLUDES

#include "CAknFileSelectionModel.h"

#include <CDirectoryLocalizer.h>

#include <barsread.h>   // TResourceReader

#include <bautils.h>    // BaflUtils for checking if a path exists

#include <coemain.h>

#include <commondialogs.rsg>

#include <apmstd.h> // TDataType

#include <badesca.h>    //CDesC16Array

#include "MAknFileSelectionObserver.h"

#include "MAknFileFilter.h"

#include "AknCFDUtility.h"

#include "CAknDataCagingFilter.h"

// CONSTANTS

const TInt KEntryArrayGranularity( 10 );

const TInt KFilterArrayGranularity( 2 );

_LIT( KCFDMimeTypeImage, "image/*" );

_LIT( KCFDMimeTypeImageGms, "image/x-ota-bitmap" );

_LIT( KCFDMimeTypeRam, "audio/x-pn-realaudio-plugin" ); // = link

_LIT( KCFDMimeTypeAudioVoiceRec, "audio/amr*" );

_LIT( KCFDMimeTypeAudioVoiceRec2, "application/vnd.nokia.ringing-tone" );

_LIT( KCFDMimeTypeAudio, "audio/*" ); // = other sound files

_LIT( KCFDMimeTypePlaylist, "audio/*mpegurl*" );

_LIT( KCFDMimeTypeVideo, "video/*" );

_LIT( KCFDMimeTypeVideoRealMedia, "application/*n-realmedia" );

_LIT( KCFDMimeTypeVideoSdp, "application/sdp" );

_LIT( KCFDMimeTypeGame, "application/*game*" );

_LIT( KCFDMimeTypeNote, "text/*" );

_LIT( KCFDMimeTypeJava, "application/java-archive" );

_LIT( KCFDMimeTypeFlash, "application/x-shockwave-flash" );

_LIT( KCFDFileExtSis, ".sis" );

_LIT( KCFDFileExtSisx, ".sisx");

_LIT( KCFDFileExtMid, ".mid" );

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

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

// CAknFileSelectionModel::CAknFileSelectionModel

//

//

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

//

CAknFileSelectionModel::CAknFileSelectionModel(

    const TCommonDialogType& aDialogType, CCoeEnv& aCoeEnv )

    :   iImageIndexArray( KEntryArrayGranularity ),

        iDirectoryLevel( 0 ),

        iDialogType( aDialogType ),

        iCoeEnv( aCoeEnv )

    {

    }

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

// CAknFileSelectionModel::ConstructL

//

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

//

void CAknFileSelectionModel::ConstructL()

    {

    User::LeaveIfError( iApaSession.Connect() );

    iLocalizer = CDirectoryLocalizer::NewL();

    iEntryArray = new( ELeave ) CArrayPakFlat<TEntry>( KEntryArrayGranularity );

    iFilterArray = new( ELeave ) CArrayPtrSeg<MAknFileFilter>( KFilterArrayGranularity );

    iItemWithImageIndex = HBufC::NewL(KMaxPath);

    User::LeaveIfError( iFs.Connect() );

    iRootFolderText = iCoeEnv.AllocReadResourceL( R_CFD_QTN_FLDR_ROOT_LEVEL );

    AddFilterL( CAknDataCagingFilter::NewLC() );

    CleanupStack::Pop();    //caging filter

    }

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

// CAknFileSelectionModel::NewL

//

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

//

CAknFileSelectionModel* CAknFileSelectionModel::NewL(

    const TCommonDialogType& aType, CCoeEnv& aCoeEnv )

    {

    CAknFileSelectionModel* self =

        new( ELeave ) CAknFileSelectionModel( aType, aCoeEnv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CAknFileSelectionModel::~CAknFileSelectionModel()

    {

    delete iRootFolderText;

    iImageIndexArray.Close();

    iFs.Close();

    delete iItemWithImageIndex;

    if ( iFilterArray )

        {

        iFilterArray->ResetAndDestroy();

        delete iFilterArray;

        }

    if ( iEntryArray )

        {

        iEntryArray->Reset();

        delete iEntryArray;

        }

    delete iLocalizer;

    iApaSession.Close();

    }

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

// CAknFileSelectionModel::SetPathL

//

//

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

//

TInt CAknFileSelectionModel::SetPathL( const TDesC& aPath )

    {

    HBufC * path = HBufC::NewLC( KMaxPath );

    *path = aPath;

    TPtr ptrPath = path->Des();

    TInt errorCode( AknCFDUtility::AddTrailingBackslash( ptrPath ) );

    if ( errorCode != KErrNone )

        {

        CleanupStack::PopAndDestroy();

        return errorCode;

        }

    errorCode = iParse.SetNoWild( ptrPath, NULL, NULL );

    if ( errorCode != KErrNone )

        {

        // Converting path to TParse was unsuccessful

        CleanupStack::PopAndDestroy();

        return errorCode;

        }

    TEntry entry;

    TInt err( iFs.Entry( ptrPath,entry ) );

    if (  err == KErrNotFound || err == KErrPathNotFound )

        {

        // Path doesn't exist

        CleanupStack::PopAndDestroy();

        return KErrPathNotFound;

        }

    // Set as current path

    iCurrentPath = iParse;

    // Reset directory level

    iDirectoryLevel = 0;

    errorCode = UpdateItemListL();

    CleanupStack::PopAndDestroy();

    return errorCode;

    }

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

// CAknFileSelectionModel::AddFolderL

//

//

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

//

TInt CAknFileSelectionModel::AddFolderL( const TDesC& aFolder )

    {

    // Cache the directory level because SetPath resets it

    TInt level( iDirectoryLevel );

    // The engine only supports adding one folder at a time

    if ( AknCFDUtility::DirectoryCount( aFolder ) !=  1 )

        {

        return KErrNotSupported;

        }

    //TPath currentPath( iCurrentPath.DriveAndPath() );

    HBufC * bufCurrentPath = HBufC::NewLC(KMaxPath);

    *bufCurrentPath = iCurrentPath.DriveAndPath();

    TPtr currentPath = bufCurrentPath->Des();

    currentPath.Append( aFolder );

    TInt errorCode( SetPathL( currentPath ) );

    CleanupStack::PopAndDestroy(); //bufCurrentPath

    if ( errorCode < KErrNone )

        {

        return errorCode;

        }

    iDirectoryLevel = ++level;

    return errorCode;

    }

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

// CAknFileSelectionModel::AddFilterL

// Ownership of filter is moved to the engine

//

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

//

void CAknFileSelectionModel::AddFilterL( MAknFileFilter* aFilter )

    {

    iFilterArray->AppendL( aFilter );

    }

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

// CAknFileSelectionModel::GotoSubFolderL

//

//

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

//

TInt CAknFileSelectionModel::GotoSubFolderL( const TDesC& aFolder )

    {

    return AddFolderL( aFolder );

    }

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

// CAknFileSelectionModel::GotoParentFolderL

//

//

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

//

TInt CAknFileSelectionModel::GotoParentFolderL()

    {

    TInt errorCode( KErrNotFound ); // Indicating under root situation

    if ( iDirectoryLevel > 0 )

        {

        errorCode = iCurrentPath.PopDir();

        if ( errorCode == KErrNone )

            {

            iDirectoryLevel--;

            errorCode = UpdateItemListL();

            }

        }

    return errorCode;

    }

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

// CAknFileSelectionModel::UpdateItemListL

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

//

TInt CAknFileSelectionModel::UpdateItemListL()

    {

    iEntryArray->Reset();

    iImageIndexArray.Reset();

    CDir* entryArray = ReadDirectory( iCurrentPath.DriveAndPath() );

    if ( !entryArray )

        {

        return KErrNotFound;

        }

    CleanupStack::PushL( entryArray );

    TInt itemCount( entryArray->Count() );

    if ( itemCount > 0 )

        {

        TInt filterCount( iFilterArray->Count() );

        TInt filterIndex;

        TBool accepted;

        CDesC16Array* desC16FoldersArray = new ( ELeave )

                           CDesC16ArrayFlat( KEntryArrayGranularity );

        CleanupStack::PushL( desC16FoldersArray );

        CDesC16Array* desC16FilesArray = new ( ELeave )

                           CDesC16ArrayFlat( KEntryArrayGranularity );

        CleanupStack::PushL( desC16FilesArray );

        CArrayPakFlat<TEntry>* tmpFoldersArray = new( ELeave ) 

            CArrayPakFlat<TEntry>( KEntryArrayGranularity );

        CleanupStack::PushL( tmpFoldersArray );

        CArrayPakFlat<TEntry>* tmpFilesArray = new( ELeave ) 

            CArrayPakFlat<TEntry>( KEntryArrayGranularity );

        CleanupStack::PushL( tmpFilesArray );

        tmpFoldersArray->Reset();

        desC16FoldersArray->Reset();

        tmpFilesArray->Reset();

        desC16FilesArray->Reset();

        for ( TInt i( 0 ); i < itemCount; i++ ) // Generate filtered list

            {

            accepted = ETrue; // If there are no filters, accept the entry

            TEntry entry = ( *entryArray )[i];

            filterIndex = 0;

            // Go thru the filters while the entry is accepted

            while( ( filterIndex < filterCount ) && ( accepted ) )

                {

                accepted = iFilterArray->At( filterIndex )->Accept(

                    iCurrentPath.DriveAndPath(), entry );

                filterIndex++;

                }

            if ( accepted ) // Directory entry has passed all filters

                {

                 // Add filename to filtered list

                if ( entry.IsDir() )

                    {

                    desC16FoldersArray->AppendL( GetLocalizedName( entry.iName ) );

                    tmpFoldersArray->AppendL( entry, sizeof( TEntry ) );

                    }

                else

                    {

                    desC16FilesArray->AppendL( GetLocalizedName( entry.iName ) );

                    tmpFilesArray->AppendL( entry, sizeof( TEntry ) );

                    }

                }

            }

        TInt entryCount = 0;

        TInt index;

        TKeyArrayPak key( _FOFF( TEntry, iName ), ECmpCollated );

        // Add folder entries

        desC16FoldersArray->Sort( ECmpCollated );

        entryCount = desC16FoldersArray->MdcaCount();

        for( TInt j( 0 ); j < entryCount; j++ )

            {

            for( TInt k( 0 ); k < entryCount; k++ )

                {

                if( ( *desC16FoldersArray )[j] == 

                        GetLocalizedName( ( *tmpFoldersArray )[k].iName ) &&

                    iEntryArray->Find( ( *tmpFoldersArray )[k], key, index ) != 0 )

                    {

                    TEntry tmpEntry = ( *tmpFoldersArray )[k];

                    iEntryArray->AppendL( tmpEntry, sizeof( TEntry ) );

                    // Entry is a directory

                    TFileTypeIcon folderIcon( EFolderIcon );

                    if( !AknCFDUtility::IsRemoteDrive( iCurrentPath.Drive() ) )

                        {

                        if ( ContainsSubfolders( tmpEntry.iName ) )

                            {

                            folderIcon = ESubFolderIcon;

                            }

                        else if ( !ContainsFiles( tmpEntry.iName ) )

                            {

                            folderIcon = EFolderEmptyIcon;

                            }

                        }

                    iImageIndexArray.Append( folderIcon );

                    break;

                    }

                }

            }

        // Add file entries

        desC16FilesArray->Sort( ECmpCollated );

        entryCount = desC16FilesArray->MdcaCount();

        for( TInt j( 0 ); j < entryCount; j++ )

            {

            for( TInt k( 0 ); k < entryCount; k++ )

                {

                if( ( *desC16FilesArray )[j] == 

                        GetLocalizedName( ( *tmpFilesArray )[k].iName ) &&

                    iEntryArray->Find( ( *tmpFilesArray )[k], key, index ) != 0 )

                    {

                    TEntry tmpFile = ( *tmpFilesArray )[k];

                    iEntryArray->AppendL( tmpFile, sizeof( TEntry ) );

                    // Entry is a file

                    AppendIconForFileL( tmpFile.iName );

                    break;

                    }

                }

            }

        CleanupStack::PopAndDestroy( tmpFilesArray );

        CleanupStack::PopAndDestroy( tmpFoldersArray );

        CleanupStack::Pop( desC16FilesArray );

        desC16FilesArray->Reset();

        delete desC16FilesArray;

        CleanupStack::Pop( desC16FoldersArray );

        desC16FoldersArray->Reset();

        delete desC16FoldersArray;

        }

    CleanupStack::PopAndDestroy( entryArray );

    if ( AknCFDUtility::DirectoriesOnly( iDialogType ) )

        {

        // Set the current folder name as first item.

        // Current folder is for example "E:\Images\Holiday\"

        // Remove trailing backslash, we get "E:\Images\Holiday"

        // Parse the path with TParse and ask for NameAndExt().

        // TParse interpretes "Holiday" as file name and returns it.

        HBufC * bufFolder = HBufC::NewLC(KMaxPath);

        * bufFolder = iCurrentPath.DriveAndPath() ;

        TPtr folder = bufFolder->Des();

        AknCFDUtility::RemoveTrailingBackslash( folder ); // ignore error

        TParsePtr parsedFolder(folder);

        folder = parsedFolder.NameAndExt();

        iFolderEntry.iName = folder;

        iEntryArray->InsertL( 0, iFolderEntry, sizeof( TEntry ) );

        iImageIndexArray.Insert( EThisFolderIcon, 0 );

        CleanupStack::PopAndDestroy(); //bufFolder

        }

    return iEntryArray->Count();

    }

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

// CAknFileSelectionModel::Entry

//

//

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

//

const TEntry& CAknFileSelectionModel::Entry( const TInt& aIndex ) const

    {

    return iEntryArray->At( aIndex );

    }

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

// CAknFileSelectionModel::GetCurrentPath

//

//

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

//

void CAknFileSelectionModel::GetCurrentPath( TDes& aPath ) const

    {

    aPath = iCurrentPath.DriveAndPath();

    }

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

// CAknFileSelectionModel::DirectoryLevel

//

//

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

//

TInt CAknFileSelectionModel::DirectoryLevel() const

    {

    return iDirectoryLevel;

    }

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

// CAknFileSelectionModel::FolderIndex

//

//

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

//

TInt CAknFileSelectionModel::FolderIndex( const TDesC& aFolder ) const

    {

    TInt arrayCount( iEntryArray->Count() ); // Number of items in entry array

    TPath folder( aFolder );

    TInt folderLength( folder.Length() );

    if ( folderLength > 0 )

        {

        // If the last character is backslash, delete it

        if ( folder[ folderLength - 1 ] == '\\' )

            {

            folder.Delete( folderLength - 1, 1 );

            }

        // Try to find the folder from list

        for ( TInt index( 0 ); index < arrayCount; index++ )

            {

            if ( folder.CompareF( iEntryArray->At( index ).iName ) == 0 )

                {

                // When found, return its index

                return index;

                }

            }

        }

    // Return not found if not found

    return KErrNotFound;

    }

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

// CAknFileSelectionModel::MdcaCount

//

//

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

//

TInt CAknFileSelectionModel::MdcaCount() const

    {

    return iEntryArray->Count();

    }

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

// CAknFileSelectionModel::MdcaPoint

//

//

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

//

TPtrC CAknFileSelectionModel::MdcaPoint( TInt aIndex ) const

    {

    TEntry entry = iEntryArray->At( aIndex ); // reference

    TParsePtrC parsedEntry( entry.iName );

    TPtrC fileName( parsedEntry.NameAndExt() );

    TInt entryType( iImageIndexArray[ aIndex ] );

    TPtr itemWithImageIndex = iItemWithImageIndex->Des();