/*

* 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:  Holds item information

*

*/

// INCLUDES

#include <e32base.h>

#include <f32file.h>

#include <tz.h>

#include "CFileManagerItemProperties.h"

#include "CFileManagerUtils.h"

#include "CFilemanagerMimeIconArray.h"

#include "Cfilemanagerfolderarray.h"

#include "Cfilemanageractivesize.h"

#include "CFilemanagerActiveCount.h"

#include "CFileManagerEngine.h" 

#include "CGflmGroupItem.h"

#include "CGflmFileSystemItem.h"

#include "CGflmDriveItem.h"

#include "CGflmGlobalActionItem.h"

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

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

// CFileManagerItemProperties::CFileManagerItemProperties

// 

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

// 

CFileManagerItemProperties::CFileManagerItemProperties( 

        CFileManagerUtils& aUtils,

        CFileManagerEngine& aEngine ) :

            iSize( KErrNotFound ),

            iFilesContained( KErrNotFound ),

            iFoldersContained( KErrNotFound ),

            iOpenFiles( KErrNotFound ),

            iUtils( aUtils ),

            iEngine( aEngine )

    {

    }

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

// CFileManagerItemProperties::NewL

// 

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

// 

CFileManagerItemProperties* CFileManagerItemProperties::NewL( 

        const TDesC& aFullPath,

        CFileManagerUtils& aUtils,

        CFileManagerEngine& aEngine )

    {

    CFileManagerItemProperties* self =

        new (ELeave) CFileManagerItemProperties( aUtils, aEngine );

    CleanupStack::PushL( self );

    self->ConstructL( aFullPath );

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileManagerItemProperties::NewL

// 

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

// 

CFileManagerItemProperties* CFileManagerItemProperties::NewL(

        const CGflmGroupItem& aItem,

        CFileManagerUtils& aUtils,

        CFileManagerEngine& aEngine )

    {

    CFileManagerItemProperties* self =

        new (ELeave) CFileManagerItemProperties( aUtils, aEngine );

    CleanupStack::PushL( self );

    self->ConstructL( aItem );

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileManagerItemProperties::ConstructL

// 

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

// 

void CFileManagerItemProperties::ConstructL( const TDesC& aFullPath )

    {

    iFullPath = aFullPath.AllocL();

    // Setup the rest of entry data when needed first time

    if ( CFileManagerUtils::HasFinalBackslash( aFullPath ) )

        {

        iState |= EItemDirectory;

        }

    else

        {

        iState |= EItemFile;

        }

    }

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

// CFileManagerItemProperties::ConstructL

// 

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

// 

void CFileManagerItemProperties::ConstructL(

        const TDesC& aFullPath, const TEntry& aEntry )

    {

    iFullPath = aFullPath.AllocL();

    // Setup all entry data now

    SetEntryData( aEntry );

    }

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

// CFileManagerItemProperties::ConstructL

// 

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

// 

void CFileManagerItemProperties::ConstructL( const CGflmGroupItem& aItem )

    {

    switch ( aItem.Type() )

        {

        case CGflmGroupItem::EFile:

        case CGflmGroupItem::EDirectory:

            {

            const CGflmFileSystemItem& fsItem =

                static_cast< const CGflmFileSystemItem& >( aItem );

            HBufC* fullPath = fsItem.FullPathLC();

            ConstructL( *fullPath, fsItem.Entry() );

            if ( iUtils.IsRemoteDrive( *fullPath ) )

                {

                iState |= EItemRemoteDrive;

                }

            CleanupStack::PopAndDestroy( fullPath );

            break;

            }

        case CGflmGroupItem::EDrive:

            {

            const CGflmDriveItem& drvItem =

                static_cast< const CGflmDriveItem& >( aItem );

            iFullPath = drvItem.RootDirectory().AllocL();

#ifdef RD_MULTIPLE_DRIVE

            iName = iUtils.GetDriveNameL(

                drvItem.Drive(),

                CFileManagerUtils::EMainLayout );

#else // RD_MULTIPLE_DRIVE

            iName = drvItem.Name().AllocL();

#endif // RD_MULTIPLE_DRIVE

            iState |= EItemDrive;

            if ( iUtils.IsRemoteDrive( *iFullPath ) )

                {

                iState |= EItemRemoteDrive;

                }

            break;

            }

        case CGflmGroupItem::EGlobalActionItem:

            {

            const CGflmGlobalActionItem& actItem = 

                static_cast< const CGflmGlobalActionItem& >( aItem );

            if ( actItem.Id() == EFileManagerBackupAction )

                {

                // Ignore error

                iEngine.LatestBackupTime( iModified );

                }

            iName = aItem.Name().AllocL();

            // Action items do not have entry data, so mark it as fetched

            iState |= EItemAction | EItemEntryDataFetched;

            break;

            }

        default:

            {

            User::Leave( KErrNotFound );

            break;

            }

        }

    }

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

// CFileManagerItemProperties::~CFileManagerItemProperties

// 

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

// 

CFileManagerItemProperties::~CFileManagerItemProperties()

    {

    delete iFullPath;

    delete iActiveSize;

    delete iActiveCount;

    delete iName;

    }

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

// CFileManagerItemProperties::Name() const

//

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

//

EXPORT_C TPtrC CFileManagerItemProperties::Name() const

    {

    if ( iState & EItemNotFileOrDir )

        {

        return iName->Des();

        }

    TParsePtrC parse( CFileManagerUtils::StripFinalBackslash( *iFullPath ) );

    return parse.Name();

    }

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

// CFileManagerItemProperties::ModifiedDate() const

//

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

//

EXPORT_C TTime CFileManagerItemProperties::ModifiedDate() const

    {

    EnsureEntryDataFetched();

    return iModified;

    }

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

// CFileManagerItemProperties::SizeL()

//

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

//

EXPORT_C TInt64 CFileManagerItemProperties::SizeL()

    {

    if ( iState & EItemNotFileOrDir )

        {

        return 0;

        }

    if( iSize == KErrNotFound )

        {

        if ( iState & EItemFile )

            {

            EnsureEntryDataFetched();

            }

        else

            {

            iSize = FolderSizeL( *iFullPath );

            }

        }

    return iSize;

    }

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

// CFileManagerItemProperties::FilesContainedL()

//

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

//

EXPORT_C TInt CFileManagerItemProperties::FilesContainedL()

    {

    if( iFilesContained == KErrNotFound )

        {

        CountItemsL( CFileManagerItemProperties::EFile );

        }

    return iFilesContained;

    }

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

// CFileManagerItemProperties::FoldersContainedL()

//

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

//

EXPORT_C TInt CFileManagerItemProperties::FoldersContainedL()

    {

    if( iFoldersContained == KErrNotFound )

        {

        CountItemsL( CFileManagerItemProperties::EFolder );

        }

    return iFoldersContained;

    }

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

// CFileManagerItemProperties::OpenFilesL()

//

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

//

EXPORT_C TInt CFileManagerItemProperties::OpenFilesL()

    {

    if( iOpenFiles == KErrNotFound )

        {

        CountItemsL( CFileManagerItemProperties::EOpen );

        }

    return iOpenFiles;

    }

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

// CFileManagerItemProperties::TypeL()

//

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

//

EXPORT_C TUint32 CFileManagerItemProperties::TypeL()

    {

    if( iType == CFileManagerItemProperties::ENotDefined )

        {

        iType = iUtils.FileTypeL( *iFullPath );

        }

    return iType;

    }

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

// CFileManagerItemProperties::Ext() const

//

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

//

EXPORT_C TPtrC CFileManagerItemProperties::Ext() const

    {

    if ( iState & EItemNotFileOrDir )

        {

        return TPtrC( KNullDesC );

        }

    TParsePtrC parse( *iFullPath );

    TPtrC ext( parse.Ext() );

    return ext;

    }

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

// CFileManagerItemProperties::CountItemsL

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

//

TInt CFileManagerItemProperties::CountItemsL(

        const TFileManagerFileType& aType )

    {

    if ( !( iState & ( EItemDirectory | EItemDrive ) ) )

        {

        // It's not a folder

        return KErrNotFound;

        }

    delete iActiveCount;

    iActiveCount = NULL;

    iActiveCount = CFileManagerActiveCount::NewL(

        iEngine.Fs(), *iFullPath, aType );

    if ( !iActiveCount->IsProcessDone() )

        {

        iEngine.ShowWaitDialogL( *iActiveCount );

        }

    if ( iFilesContained == KErrNotFound )

        {

        iFilesContained = iActiveCount->FileCount();

        }

    if ( iFoldersContained == KErrNotFound )

        {

        iFoldersContained = iActiveCount->FolderCount();

        }

    if ( iOpenFiles == KErrNotFound )

        {

        iOpenFiles = iActiveCount->OpenFiles();

        }

    return KErrNone;

    }

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

// CFileManagerItemProperties::FolderSizeL

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

//

TInt64 CFileManagerItemProperties::FolderSizeL( const TDesC& aFullPath )

    {

    if ( !( iState & EItemDirectory ) )

        {

        // It's not a folder

        return KErrNotFound;

        }

    delete iActiveSize;

    iActiveSize = NULL;

    iActiveSize = CFileManagerActiveSize::NewL( iEngine.Fs(), aFullPath );

    iEngine.ShowWaitDialogL( *iActiveSize );

    return iActiveSize->GetFolderSize();

    }

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

// CFileManagerItemProperties::FullPath() const

//

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

//

EXPORT_C TPtrC CFileManagerItemProperties::FullPath() const

    {

    if ( iFullPath )

        {

        return iFullPath->Des();

        }

    return TPtrC( KNullDesC );

    }

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

// CFileManagerItemProperties::NameAndExt() const

//

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

//

EXPORT_C TPtrC CFileManagerItemProperties::NameAndExt() const

    {

    if ( iState & EItemNotFileOrDir )

        {

        return iName->Des();

        }

    TParsePtrC parse( CFileManagerUtils::StripFinalBackslash( *iFullPath ) );

    return parse.NameAndExt();

    }

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

// CFileManagerItemProperties::LocalizedName() const

//

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

//

EXPORT_C TPtrC CFileManagerItemProperties::LocalizedName() const

    {

    if (iState & EItemDirectory )

        {

        TPtrC ptr( iUtils.LocalizedName( *iFullPath ) );

        if ( ptr.Length() )

            {

            return ptr;

            }

        }

    return NameAndExt();

    }

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

// CFileManagerItemProperties::ModifiedLocalDate() const

//

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

//

EXPORT_C TInt CFileManagerItemProperties::ModifiedLocalDate(

        TTime& aTime ) const

    {

    aTime = ModifiedDate(); // convert from universal time

    RTz tz;

    TInt err( tz.Connect() );

    if ( err == KErrNone )

        {

        err = tz.ConvertToLocalTime( aTime );

        if ( err != KErrNone )

            {

            aTime = ModifiedDate(); // use universal time

            }

        tz.Close();

        }

    return err;

    }

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

// CFileManagerItemProperties::ContainsAnyFilesOrFolders()

//

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

//

EXPORT_C TInt CFileManagerItemProperties::ContainsAnyFilesOrFolders()

    {

    if ( !( iState & EItemDirectory ) ||

         ( iState & EItemHasNoFilesOrFolders ) )

        {

        return EFalse;

        }

    if ( iState & EItemHasFilesOrFolders )

        {

        return ETrue;

        }

    TBool ret( CFileManagerUtils::HasAny(

        iEngine.Fs(),

        *iFullPath,

        KEntryAttNormal | KEntryAttDir | KEntryAttHidden | KEntryAttSystem ) );

    if ( ret )

        {

        iState |= EItemHasFilesOrFolders;

        }

    else

        {

        iState |= EItemHasNoFilesOrFolders;

        }

    return ret;

    }

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

// CFileManagerItemProperties::MimeTypeL()

//

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

// 

EXPORT_C TPtrC CFileManagerItemProperties::MimeTypeL()

    {

    if ( iState & EItemNotFileOrDir )

        {

        return TPtrC( KNullDesC );

        }

    return iUtils.MimeTypeL( *iFullPath );

    }

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

// CFileManagerItemProperties::IsDrive()

//

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

// 

EXPORT_C TBool CFileManagerItemProperties::IsDrive() const

    {

    if ( iState & EItemDrive )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CFileManagerItemProperties::DriveName()

//

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

// 

EXPORT_C TPtrC CFileManagerItemProperties::DriveName() const

    {

    if ( iState & EItemDrive )

        {

        return Name();

        }

    return iEngine.CurrentDriveName();

    }

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