/*
* Copyright (c) 2002-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:  Concrete implementation of MGflmItemGroup interface
*
*/



// INCLUDE FILES
#include "CGflmItemGroupImpl.h"
#include "MGflmItemFilter.h"
#include "CGflmItemLocalizer.h"
#include "CGflmDriveResolver.h"
#include "CGflmFileRecognizer.h"
#include "CGflmDirectoryListingCache.h"
#include "CGflmGlobalActionItem.h"
#include "CGflmFileSystemItem.h"
#include "CGflmDriveItem.h"
#include "GFLMConsts.h"
#include "GFLM.hrh"
#include "GflmUtils.h"
#include <f32file.h>


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


// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::CGflmItemGroupImpl
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CGflmItemGroupImpl::CGflmItemGroupImpl(
        const TInt aId,
        RFs& aFss,
        CGflmDirectoryListingCache& aCache,
        CGflmItemLocalizer& aLocalizer,
        CGflmDriveResolver& aResolver ) :
    iId( aId ),
    iFss( aFss ),
    iListingCache( aCache ),
    iItemLocalizer( aLocalizer ),
    iDriveResolver( aResolver )
    {
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::~CGflmItemGroupImpl
//
// -----------------------------------------------------------------------------
//
CGflmItemGroupImpl::~CGflmItemGroupImpl()
    {
    iVolatileItems.ResetAndDestroy();
    iVolatileItems.Close();

    iStaticItems.ResetAndDestroy();
    iStaticItems.Close();

    iItemReferences.Close();

    delete iDirectory;
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CGflmItemGroupImpl* CGflmItemGroupImpl::NewLC(
        const TInt aId,
        RFs& aFss,
        CGflmDirectoryListingCache& aCache,
        CGflmItemLocalizer& aLocalizer,
        CGflmDriveResolver& aResolver )
    {
    CGflmItemGroupImpl* self = new( ELeave ) CGflmItemGroupImpl(
        aId, aFss, aCache, aLocalizer, aResolver );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::ContructL
// -----------------------------------------------------------------------------
//
void CGflmItemGroupImpl::ConstructL()
    {
    iSortCollationMethod = *Mem::CollationMethodByIndex( 0 );
    iSortCollationMethod.iFlags |=
        TCollationMethod::EIgnoreNone | TCollationMethod::EFoldCase;
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::RefreshL()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CGflmItemGroupImpl::RefreshL(
        MGflmItemFilter* aFilter,
        TGflmSortMethod aSortMethod,
        TGflmRefreshMode aRefreshMode )
    {
    FUNC_LOG

    INFO_LOG2(
        "CGflmItemGroupImpl::RefreshL-aRefreshMode=%d, aSortMethod=%d",
        aRefreshMode, aSortMethod )

    if ( aRefreshMode == ERefreshItems )
        {
        // Reset reference list
        iItemReferences.Reset();

        // Destroy old filesystem items
        iVolatileItems.ResetAndDestroy();

        // Re-read contents of the assigned directories, filter out unwanted
        // items and add rest to the item list
        TIMESTAMP( "GFLM reading and filtering directories started: " )
        PopulateReferenceListL( aFilter );
        TIMESTAMP( "GFLM reading and filtering directories ended: " )
        }

    if ( aRefreshMode == ERefreshItems || aRefreshMode == ERefreshSort )
        {
        if ( !( iInclusion & EDrives ) )
            {
            TIMESTAMP( "GFLM group sorting started: " )
            iItemReferences.Sort( CGflmGroupItem::GetSortL( aSortMethod ) );
            TIMESTAMP( "GFLM group sorting ended: " )
            }
        }
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::PopulateReferenceListL()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CGflmItemGroupImpl::PopulateReferenceListL( MGflmItemFilter* aFilter )
    {
    CGflmGroupItem* item = NULL;
    TInt i( 0 );

    // Add drive items to the reference list
    if ( iInclusion & EDrives )
        {
        if ( iDirectory )
            {
            // Hide drive selection when location inside folder.
            return;
            }

        TInt count( iDriveResolver.DriveCount() );
        for ( i = 0; i < count; i++ )
            {
            // Add directly, items are filtered from drive resolver
            CGflmDriveItem* drvItem = iDriveResolver.DriveAt( i );
            iItemReferences.AppendL( drvItem );
            drvItem->SetGroup( this );
            }
        }

    // Add pointers to the static items (action items) to the
    // reference list
    TInt staticCount( iStaticItems.Count() );

    for ( i = 0; i < staticCount; i++ )
        {
        item = iStaticItems[ i ];
        if ( !aFilter ||
            ( aFilter && aFilter->FilterItemL( item, iId, NULL ) ) )
            {
            iItemReferences.AppendL( item );
            item->SetGroup( this );
            }
        }

    if ( iInclusion & ( EFiles | EDirectories ) )
        {
        if ( iDirectory )
            {
            // Check directory name length validity
            TPtrC directory( iDirectory->Des() );
            TInt dirLen( directory.Length() );
            if ( !dirLen || dirLen > KMaxFileName )
                {
                return;
                }

            // Get the drive where items are located
            CGflmDriveItem* drvItem = iDriveResolver.DriveFromPath(
                directory );

            const CGflmDirectoryListingCache::CEntryArray* dir =
                iListingCache.ListingL( directory );
            TInt entryCount( dir->Count() );

            // Reserve room for all entries at once to avoid overhead
            iVolatileItems.ReserveL( entryCount );
            iItemReferences.ReserveL( iItemReferences.Count() + entryCount );

            // Create buffer for filenames
            HBufC* buffer = HBufC::NewLC( KMaxFileName );
            TPtr filename( buffer->Des() );

            TIMESTAMP( "GFLM files and folders list genaration started: " )

            TInt bsLen( KGFLMBackslash().Length() );

            // For all items in a directory listing
            for( i = 0; i < entryCount; i++ )
                {
                const TEntry& entry( ( *dir )[ i ] );
                TBool isDir( entry.IsDir() );
                TInt extLen( isDir ? bsLen : 0 ); // Handle final backslash
                if ( dirLen + entry.iName.Length() + extLen > KMaxFileName )
                    {
                    continue; // Too long name
                    }
                if ( isDir && !( iInclusion & EDirectories ) )
                    {
                    continue; // No directories allowed
                    }
                if ( !isDir && !( iInclusion & EFiles ) )
                    {
                    continue; // No files allowed
                    }

                // Create a new filesystem item
                CGflmFileSystemItem* fsItem = CGflmFileSystemItem::NewLC(
                    entry, directory );

                // Filter out unwanted items
                if ( !aFilter ||
                    ( aFilter && aFilter->FilterItemL( fsItem, iId, drvItem ) ) )
                    {
                    // Only directory items can be localized
                    if ( isDir )
                        {
                        // Get localized name for the item, if it has one
                        GflmUtils::GetFullPath( directory, entry, filename );
                        TPtrC localizedName(
                            iItemLocalizer.LocalizeFromWorkThread( filename ) );
                        if ( localizedName.Length() )
                            {
                            fsItem->SetLocalizedNameL( localizedName );
                            }
                        }
                    iVolatileItems.AppendL( fsItem );
                    CleanupStack::Pop( fsItem );
                    iItemReferences.AppendL( fsItem );
                    fsItem->SetGroup( this );
                    }
                else
                    {
                    CleanupStack::PopAndDestroy( fsItem );
                    }
                }

            CleanupStack::PopAndDestroy( buffer );

            TIMESTAMP( "GFLM files and folders list genaration ended: " )

            }
        }

    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::ItemCount()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmItemGroupImpl::ItemCount() const
    {
    return iItemReferences.Count();
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::Item()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CGflmGroupItem* CGflmItemGroupImpl::Item( TInt aIndex )
    {
    return iItemReferences[ aIndex ];
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::Id()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmItemGroupImpl::Id() const
    {
    return iId;
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::SetInclusion()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CGflmItemGroupImpl::SetInclusion( TUint aInclusion )
    {
    iInclusion = aInclusion;
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::AddSourceL()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CGflmItemGroupImpl::AddSourceL( const TDesC& aDirectory )
    {
    HBufC* temp = aDirectory.AllocL();
    delete iDirectory;
    iDirectory = temp;
    // Reset reference list to cleanup all references to deleted directory
    iItemReferences.Reset();
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::ResetSources()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CGflmItemGroupImpl::ResetSources()
    {
    delete iDirectory;
    iDirectory = NULL;
    // Reset reference list to cleanup all references to deleted directory
    iItemReferences.Reset();
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::AddActionItemL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CGflmItemGroupImpl::AddActionItemL( TInt aId, const TDesC& aCaption )
    {
    CGflmGlobalActionItem* actionItem =
        CGflmGlobalActionItem::NewLC( aId, aCaption );
    iStaticItems.AppendL( actionItem );
    CleanupStack::Pop( actionItem );
    }

// -----------------------------------------------------------------------------
// CGflmItemGroupImpl::CollationMethod
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
const TCollationMethod* CGflmItemGroupImpl::CollationMethod()
    {
    return &iSortCollationMethod;
    }

//  End of File