/*

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

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

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

// CAknFileSelectionModel::CAknFileSelectionModel

//

//

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

//

CAknFileSelectionModel::CAknFileSelectionModel(

    const TCommonDialogType& aDialogType, CCoeEnv& aCoeEnv )

        iDialogType( aDialogType ),

        iCoeEnv( aCoeEnv )

    {

    }

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

// CAknFileSelectionModel::ConstructL

//

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

//

void CAknFileSelectionModel::ConstructL()

    {

    iLocalizer = CDirectoryLocalizer::NewL();

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

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

    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;

    iFs.Close();

    if ( iFilterArray )

        {

        iFilterArray->ResetAndDestroy();

        delete iFilterArray;

        }

    if ( iEntryArray )

        {

        iEntryArray->Reset();

        delete iEntryArray;

        }

    delete iLocalizer;

    }

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

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

    errorCode = UpdateItemListL();

    CleanupStack::PopAndDestroy();

    return errorCode;

    }

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

// CAknFileSelectionModel::AddFolderL

//

//

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

//

TInt CAknFileSelectionModel::AddFolderL( const TDesC& aFolder )

    {

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

        }

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

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

    if ( !entryArray )

        {

        return KErrNotFound;

        }

    CleanupStack::PushL( entryArray );

    TInt itemCount( entryArray->Count() );

        {

            {

                {

                    {

                        {

                        }

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy( entryArray );

    if ( AknCFDUtility::DirectoriesOnly( iDialogType ) )

        {

        // Set the current folder name as first item.

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

        }

    }

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

// CAknFileSelectionModel::Entry

//

//

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

//

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

    {

    }

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

// 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

    {