/*
* Copyright (c) 2002-2008 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:  Goes through folder tree one item at time
*
*/



// INCLUDE FILES
#include "CFileManagerFileSystemIterator.h"
#include "CFileManagerEngine.h"
#include "CFileManagerCommonDefinitions.h"


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

// -----------------------------------------------------------------------------
// CFileManagerFileSystemIterator::NewL
// 
// -----------------------------------------------------------------------------
// 
CFileManagerFileSystemIterator* CFileManagerFileSystemIterator::NewL(
        RFs& aFs,
        const TDesC& aSrcDir,
        const TDesC& aDstDir,
        CFileManagerEngine& aEngine )
    {
    CFileManagerFileSystemIterator* self =
        new (ELeave) CFileManagerFileSystemIterator( aDstDir, aEngine );
    CleanupStack::PushL( self );
    self->ConstructL( aFs, aSrcDir );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CFileManagerFileSystemIterator::CFileManagerFileSystemIterator
// 
// -----------------------------------------------------------------------------
// 
CFileManagerFileSystemIterator::CFileManagerFileSystemIterator(
        const TDesC& aDstDir, CFileManagerEngine& aEngine ) :
    iCount( KErrNotFound ),
    iDstDir( aDstDir ),
    iEngine( aEngine )
    {
    }

// -----------------------------------------------------------------------------
// CFileManagerFileSystemIterator::~CFileManagerFileSystemIterator
// 
// -----------------------------------------------------------------------------
// 
CFileManagerFileSystemIterator::~CFileManagerFileSystemIterator()
    {
    delete iSrcDir;
    delete iSrc;
    delete iDst;
    delete iDir;
    delete iDirScan;
    }

// -----------------------------------------------------------------------------
// CFileManagerFileSystemIterator::ConstructL
// 
// -----------------------------------------------------------------------------
// 
void CFileManagerFileSystemIterator::ConstructL(
        RFs& aFs, const TDesC& aSrcDir )
    {
    iDirScan = CDirScan::NewL( aFs );
    // Go through the folders first
    iDirScan->SetScanDataL(
        aSrcDir,
        KEntryAttNormal | KEntryAttHidden | KEntryAttSystem |
        KEntryAttDir | KEntryAttMatchExclusive,
        ESortNone );
    iSrc = HBufC::NewL( KMaxFileName );
    // We need double destination size
    // because source and target folder can be
    // KMaxFileName sized and those are append
    // to same buffer.
    iDst = HBufC::NewL( KFmgrDoubleMaxFileName );
    iDst->Des().Copy( iDstDir );
    iDirScan->NextL( iDir );
    iSrcDir = aSrcDir.AllocL();
    iSrc->Des().Copy( aSrcDir );
    }

// -----------------------------------------------------------------------------
// CFileManagerFileSystemIterator::CurrentL
// 
// -----------------------------------------------------------------------------
// 
void CFileManagerFileSystemIterator::CurrentL(
        HBufC** aSrc, HBufC** aDst, TFileManagerTypeOfItem& aItemType )
    {
    *aSrc = NULL;
    *aDst = NULL;

    if( iCount == KErrNotFound )
        {
        // Handle destination root folder first
        aItemType = EFileManagerFolder;
        *aSrc = iSrc; // contains iSrcDir
        *aDst = iDst; // contains iDstDir
        }
    else if( iDir && iCount < iDir->Count() )
        {
        // Handle folder contents
        if( !iFolderScanDone )
            {
            const TEntry& entry( ( *iDir )[ iCount ] );

            TPtr ptrSrc( iSrc->Des() );
            ptrSrc.Copy( iDirScan->FullPath() );
            ptrSrc.Append( entry.iName );
            ptrSrc.Append( KFmgrBackslash );

            TPtr ptrDst( iDst->Des() );
            ptrDst.Copy( iDstDir );
            ptrDst.Append( LocalizedAbbreviatedPath() );

            TPtrC ptr( iEngine.LocalizedName( *iSrc ) );
            if( ptr.Length() )
                {
                ptrDst.Append( ptr );
                }
            else
                {
                ptrDst.Append( entry.iName );
                }
            ptrDst.Append( KFmgrBackslash );

            aItemType = EFileManagerFolder;
            }
        else 
            {
            const TEntry& entry( ( *iDir )[ iCount ] );

            TPtr ptrSrc( iSrc->Des() );
            ptrSrc.Copy( iDirScan->FullPath() );
            ptrSrc.Append( entry.iName );

            TPtr ptrDst( iDst->Des() );
            ptrDst.Copy( iDstDir );
            ptrDst.Append( LocalizedAbbreviatedPath() );
            ptrDst.Append( entry.iName );

            aItemType = EFileManagerFile;
            }
        *aSrc = iSrc;
        *aDst = iDst;
        }
    else
        {
        aItemType = EFileManagerNoType;
        }
    }

// -----------------------------------------------------------------------------
// CFileManagerFileSystemIterator::NextL
// 
// -----------------------------------------------------------------------------
// 
TBool CFileManagerFileSystemIterator::NextL()
    {
    if ( !iDir )
       {
       return EFalse;
       }

    ++iCount;

    // Get next dir
    if( iCount >= iDir->Count() )
        {
        delete iDir;
        iDir = NULL;
        iCount = 0;
        iDirScan->NextL( iDir );
        iLocalizedAbbreviatedPath.Zero();
        }

    // Are we done
    if( iDir )
        {
        return ETrue;
        }
    
    // Folders have been scanned through, now same scanning with files
    if( !iFolderScanDone )
        {
        iDirScan->SetScanDataL( *iSrcDir,
            KEntryAttNormal | KEntryAttHidden | KEntryAttSystem,
            ESortNone );
        iDirScan->NextL( iDir );
        iLocalizedAbbreviatedPath.Zero();
        iCount = 0;
        iFolderScanDone = ETrue;
        return ETrue;
        }

    return EFalse;
    }

// ------------------------------------------------------------------------------
// CFileManagerFileSystemIterator::LocalizedAbbreviatedPath
//
// ------------------------------------------------------------------------------
//
TPtrC CFileManagerFileSystemIterator::LocalizedAbbreviatedPath()
    {
    TPtrC abbrPath( iDirScan->AbbreviatedPath() );

    if( !iLocalizedAbbreviatedPath.Length() && abbrPath.Length() > 1 )
        {
        iLocalizedAbbreviatedPath.Append(
            iEngine.LocalizedName( iDirScan->FullPath() ) );

        if( !iLocalizedAbbreviatedPath.Length() )
            {
            iLocalizedAbbreviatedPath.Append(
                abbrPath.Right( abbrPath.Length() - 1 ) );
            }
        else
            {
            iLocalizedAbbreviatedPath.Append( KFmgrBackslash );
            }
        }
    return iLocalizedAbbreviatedPath;
    }

// End of File