/*

* Copyright (c) 2007-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: This file implements class CFsTextureLoader.

*

*/

// INCLUDE FILES

#include "emailtrace.h"

#include <e32std.h>

#include <eikenv.h> 

#include <imageconversion.h>

//<cmail> removed __FS_ALFRED_SUPPORT flag 

//#include <fsconfig.h>

//</cmail> removed __FS_ALFRED_SUPPORT flag 

#include "fstexture.h"

#include "fsbitmapprovider.h"

#include "fstextureloader.h"

// CONSTANTS

const TInt KGranularity = 5;

// ============================= LOCAL FUNCTIONS  =============================

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

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

// CFsTextureLoader::TView::operator= ( const CFsTextureLoader::TView& )

// Operator =

// Status : Draft

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

//

CFsTextureLoader::TView& CFsTextureLoader::TView::operator=( const CFsTextureLoader::TView& aView )

    {

    FUNC_LOG;

    iStart = aView.iStart;

    iLength = aView.iLength;

    return *this;

    }    

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

// CFsTextureLoader::NewL

// Two-phased constructor

// (static, may leave)

// Status : Draft

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

//

CFsTextureLoader* CFsTextureLoader::NewL( CAlfTextureManager& aManager,

                                          MFsTextureObserver& aObserver

                                        )

    {

    FUNC_LOG;

    CFsTextureLoader* loader = new (ELeave) CFsTextureLoader( aManager, 

                                                              aObserver 

                                                            );

    CleanupStack::PushL( loader );

    loader->ConstructL();

    CleanupStack::Pop( loader );

    return loader;

    }

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

// CFsTextureLoader::~CFsTextureLoader

// C++ Destructor

// Status : Draft

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

//

CFsTextureLoader::~CFsTextureLoader()

    {

    FUNC_LOG;

    SetDefaultTimeOut( TTimeIntervalMicroSeconds32( 0 ) );

    iManager.RemoveLoadObserver( this );

    if ( iTextures )

        {

        const TInt count = iTextures->Count();

        for ( TInt i = count - 1; i >= 0; --i )

            {

            delete iTextures->At( i );

            }

        delete iTextures;

        iTextures = NULL;

        }

    return;

    }

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

// CFsTextureLoader::TextureLoadingCompleted

// Loader callback

// Status : Draft

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

//

void CFsTextureLoader::TextureLoadingCompleted( CAlfTexture& aTexture,

                                                TInt /* aTextureId */,

                                                TInt /* aErrorCode */

                                              )

    {

    FUNC_LOG;

    TInt index = 0;

    HBufC* fn = aTexture.FileName();

    TFileName fileName;

    if ( fn )

        {

        fileName.Copy( fn->Des() );

        }

    else

        {

        fileName.Zero();

        }

    CFsTexture* p = SearchByImageName( fileName, &index );

    while ( p )

        {

        iObserver.FsTextureEvent( MFsTextureObserver::EUpdated, *p );

        fn = aTexture.FileName();

        if ( fn )

            {

            fileName.Copy( fn->Des() );

            }

        else

            {

            fileName.Zero();

            }

        p = SearchByImageName( fileName, &index );

        }

    TRAP_IGNORE( UnloadL() )

        {

        TRAP_IGNORE( LoadL() )

        }

    return;

    }                                               

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

// CFsTextureLoader::SetView

// Set current view area

// (may leave)

// Status : Draft

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

//

void CFsTextureLoader::SetViewL( const TInt& aStart, 

                                 const TInt& aLength 

                               )

    {

    FUNC_LOG;

    iView.iStart = aStart;

    iView.iLength = aLength;

    UnloadL();

    LoadL();

    return;

    }

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

// CFsTextureLoader::SetView

// Set current view area

// (may leave)

// Status : Draft

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

//

void CFsTextureLoader::SetViewL( const TView& aView )

    {

    FUNC_LOG;

    SetViewL( aView.iStart, aView.iLength );

    return;

    }

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

// CFsTextureLoader::CFsTextureLoader

// C++ Constructor

// Status : Draft

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

//

CFsTextureLoader::CFsTextureLoader( CAlfTextureManager& aManager,

                                    MFsTextureObserver& aObserver

                                  )

    : iManager( aManager ),

      iFs( CEikonEnv::Static()->FsSession() ),

      iTextures( NULL ),

      iObserver( aObserver ),

      iId( 0 ),

      iDefaultTimeOut( 10000000 ) // 10 sec.

    {

    FUNC_LOG;

    return;

    }  

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

// CFsTextureLoader::ConstructL

// 2nd phase contructor

// (may leave)

// Status : Draft

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

//

void CFsTextureLoader::ConstructL()

    {

    FUNC_LOG;

    iManager.AddLoadObserverL( this );

    iTextures = new ( ELeave ) CArrayPtrFlat<CFsTexture>( KGranularity );

    return;

    }

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

// CFsTextureLoader::TimerExpiredL

// Timer callback passed from texture

// Status : Draft

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

//

void CFsTextureLoader::TimerExpiredL( CFsTexture& aTexture )

    {

    FUNC_LOG;

    Unload( aTexture );

    return;

    }

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

// CFsTextureLoader::TextureCount

// Return number of textures

// Status : Draft

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

//

TInt CFsTextureLoader::TextureCount() const

    {

    FUNC_LOG;

    const TInt count = iTextures ? iTextures->Count() : 0;

    return count;

    }    

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

// CFsTextureLoader::TextureAtIndex

// Return texture

// Status : Draft

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

//

CFsTexture* CFsTextureLoader::TextureAtIndex( const TInt& aIndex )

    {

    FUNC_LOG;

    CFsTexture* texture = NULL;

    if ( iTextures &&

         aIndex >= 0 && 

         aIndex < TextureCount() 

       )

        {

        texture = iTextures->At( aIndex );

        }

    return texture;

    }

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

// CFsTextureLoader::Unload

// Unload texture

// Status : Draft

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

//

void CFsTextureLoader::Unload( CFsTexture& aTexture )

    {

    FUNC_LOG;

    const TInt c = iTextures->Count();

    TInt refCount = 0;

    TInt index = KErrNotFound;

    for ( TInt i = 0; i < c; i++ )

        {

        if ( iTextures->At( i ) == &aTexture )

            {

            index = i;

            }

        if ( &iTextures->At( i )->Texture() == &aTexture.Texture() )

            {

            refCount++;

            }

        }

    if ( refCount == 1 )

        {

        HBufC* p = aTexture.Texture().FileName();

        if ( p )

            {

            iManager.UnloadTexture( p->Des() );

            delete &(aTexture.Texture());

            }

        }

    if ( index != KErrNotFound )

        {

        CFsTexture* p = iTextures->At( index );

        CFsBitmapProvider* provider = p->Provider();

        if ( provider )

            {

            const TInt flags = p->TextFlags();

            if ( !( flags & CFsTexture::EFlagPreserveProvider ) )

                {

                iManager.UnloadTexture( provider->Id() );

                delete &(aTexture.Texture());

                }

            }

        }

    return;

    }    

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

// CFsTextureLoader::SearchByImageName

// Search textures by filename

// Status : Draft

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

//

CFsTexture* CFsTextureLoader::SearchByImageName( const TDesC& aImageFileName,

                                                 TInt* aIndex

                                               )

    {

    FUNC_LOG;

    CFsTexture* r = NULL;

    const TInt c = iTextures->Count();

    TInt i; // Temporaly index

    for ( i = aIndex ? *aIndex : 0; i < c && !r; i++ )

        {

        CFsTexture* tmp = iTextures->At( i );

        CAlfTexture& texture = tmp->Texture();

        HBufC* p = texture.FileName();

        if ( p && !p->Des().Compare( aImageFileName ) )

            {

            r = tmp;

            }

        }

    // Update index

    if ( aIndex )

        {

        *aIndex = i;

        }

    return r;

    }

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

// CFsTextureLoader::SearchByPos

// Search textures by position

// Status : Draft

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

//

CFsTexture* CFsTextureLoader::SearchByPos( const TInt& aPos,

                                           TInt* aIndex )

    {

    FUNC_LOG;

    CFsTexture* r = NULL;

    const TInt c = iTextures->Count();

    TInt i; // Temporaly index

    for ( i = aIndex ? *aIndex : 0; i < c && !r; i++ )

        {

        CFsTexture* tmp = iTextures->At( i );

        const TInt pos = tmp->Pos();

        CAlfTexture& texture = tmp->Texture();

        if ( pos >= 0 && pos == aPos )

            {

            r = tmp;

            }

        }

    // Update index

    if ( aIndex )

        {

        *aIndex = i;

        }

    return r;

    }

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

// CFsTextureLoader::SearchById

// Search textures by id

// Status : Draft

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

//

CFsTexture* CFsTextureLoader::SearchById( TInt aId )

    {

    CFsTexture* r = NULL;

    const TInt c = iTextures->Count();

    TInt i; // Temporaly index

    for ( i = 0 ; i < c && !r ; ++i )

        {

        CFsTexture* tmp = iTextures->At( i );

        if ( tmp->Id() == aId )

            {

            r = tmp;

            }

        }

    return r;

    }

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

// CFsTextureLoader::LoadTextureL

// Create texture from file

// (may leave)

// Status : Draft

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

//

CFsTexture& CFsTextureLoader::LoadTextureL( const TDesC& aImageFileName,

                                            TSize aTextureMaxSize,

                                            TAlfTextureFlags aFlags,

                                            TInt aId,

                                            const TInt& aLoaderFlags

                                          )

    {                                            

    // If id's not given by user, generate unique id

    if ( !aId )

       {

       aId = GetId();

       }

    CAlfTexture& texture = iManager.LoadTextureL( aImageFileName,

                                                  aTextureMaxSize,

                                                  aFlags,

                                                  aId

                                                );

    CFsTexture* holder = CFsTexture::NewL( texture, *this, NULL, aId );

    // Verify if this has been previously loaded or was loaded syncronously

    if ( texture.HasContent() )

        {

        iObserver.FsTextureEvent( MFsTextureObserver::EUpdated, *holder );

        }

    // Pass flagging

    if ( aLoaderFlags & EFlagSetStatic )

        {

        holder->SetTextFlags( holder->TextFlags() | CFsTexture::EFlagStatic );

        }

    CleanupStack::PushL( holder );

    iTextures->AppendL( holder );

    CleanupStack::Pop( holder );

    return *holder;

    }

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

// CFsTextureLoader::AppendBitmapL

// Create texture from bitmap(s) 

// (may leave)

// Status : Draft

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

//

CFsTexture& CFsTextureLoader::AppendBitmapL( CFbsBitmap* aBitmap,

                                             CFbsBitmap* aBitmapMask,

                                             TAlfTextureFlags aFlags,

                                             TInt aId,

                                             const TInt& aLoaderFlags

                                           )

    {                                            

    // If id's not given by user, generate unique id

    if ( !aId )

       {

       aId = GetId();

       }

    CFsBitmapProvider* provider = CFsBitmapProvider::NewL( aBitmap,

                                                           aBitmapMask,

                                                           aId

                                                         );

    CAlfTexture& texture = iManager.CreateTextureL( aId,

                                                    provider,

                                                    aFlags

                                                  );

    CFsTexture* holder  = CFsTexture::NewL( texture, *this, provider, aId );

    // Pass flagging

    if ( aLoaderFlags & EFlagSetStatic )

        {

        holder->SetTextFlags( holder->TextFlags() | CFsTexture::EFlagStatic );

        }

    CleanupStack::PushL( holder );

    iTextures->AppendL( holder );

    CleanupStack::Pop( holder );

    iObserver.FsTextureEvent( MFsTextureObserver::EUpdated, *holder );

    return *holder;

    }    

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

// CFsTextureLoader::LoadL

// Load next picture in queue

// (may leave)