/*

* Copyright (c) 2006-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:   Implementation of CHuiTextureManager, texture objects loading 

*                and management.

*

*/

#include <eikenv.h>

#include <eikappui.h>

#include <eikapp.h>

#include "uiacceltk/HuiTextureManager.h"  // Class definition

#include "uiacceltk/HuiTextureProcessor.h"

#include "HuiRenderPlugin.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiTexture.h"

#include "uiacceltk/HuiFont.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiDisplay.h"

#include "huitextureanimationstate.h"

/**

 * Granularity of CHuiTextureManager::iAnimations and 

 * CHuiTextureManager::iAnimatedTextureGroupItems arrays.

 */

const TInt KHuiAnimationsGranularity = 4;

EXPORT_C MHuiBitmapProvider::~MHuiBitmapProvider()

    {

    }

EXPORT_C CHuiTextureManager::CHuiTextureManager(CHuiEnv& aEnv)

        : CActive(EPriorityHigh),

        iEnv(aEnv), iState(EIdle), iReleaseState(ENormal), iFS(CHuiStatic::FsSession()),

        iAnimatedTextureGroupItems( KHuiAnimationsGranularity ),

        iAnimations( KHuiAnimationsGranularity ),

        iEnableTexMemCalculation( EFalse )  //Texture memory calculation is disabled by default

    {}

EXPORT_C void CHuiTextureManager::BaseConstructL()

    {

    iEnv.SetTextureManager(*this);

    SetImagePathL(_L(""));

    // Create a small initial bitmaps for decoder output.

    iBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError( iBitmap->Create(TSize(4, 4), EColor64K) );

    iMaskBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError( iMaskBitmap->Create(TSize(4, 4), EGray256) );

    // Create blank texture

    iBlankTexture = CHuiStatic::Renderer().CreateTextureL();

    iBlankTexture->SetImageFileNameL(_L("blank"));

    CActiveScheduler::Add(this);

    // Enabling logging will cause diagnostics and debugging messages to be

    // printed to a file.

    CHuiStatic::EnableLogging(EFalse);

    }

EXPORT_C CHuiTextureManager::~CHuiTextureManager()

    {

    Cancel();

    delete iAnimationWithoutGroup;

    iAnimatedTextureGroupItems.Close();

    iAnimations.ResetAndDestroy();

    iAnimations.Close();

    // Delete the texture processor.

    delete iProcessor;

    // Clear any remaining entries in the load queue.

    for(TInt i = 0; i < iLoadQueue.Count(); ++i)

        {

        delete iLoadQueue[i].iDecoder;

        iLoadQueue[i].iDecoder = 0;

        }

    iLoadQueue.Reset();

    delete iBlankTexture;

    // Remove all texture entries (from last to first -order)

    /*while (iTextures.Count()>0)*/

    for(TInt i = iTextures.Count()-1; i >= 0; --i)

        {

        CTextureEntry * te = iTextures[i];

        if (te->iTexture)

            {

            delete te->iTexture;

            }

        else

            {

            // This texture was defined but never loaded.

            HUI_DEBUG2(_L("CHuiTextureManager::~CHuiTextureManager() - Notice, texture id %i (\"%S\") was never loaded!"), te->iId, te->iFileName);

            }

        }

    iTextures.ResetAndDestroy();

    iStateObservers.Close();

    iLoadObservers.Close();

    iAnimatedTextures.Close();

    iTextureAutoSizeObservers.Close();

    delete iBitmap;

    delete iMaskBitmap;

    delete iImagePath;

    }

EXPORT_C CHuiEnv& CHuiTextureManager::Env()

    {

    return iEnv;

    }

EXPORT_C CHuiTexture* CHuiTextureManager::Texture(TInt aId)

    {

    TInt index = CheckTexture(aId);

    if(index == -1)

        {

        HUI_DEBUG1(_L("CHuiTextureManager::Texture() - Texture id %i not found! Returning blank."), aId);

        // NOTE: there is a danger of editing the blank texture

        // instead of the real texture..

        return &BlankTexture();

        }

    CHuiTexture * texture = iTextures[index]->iTexture;

    if(texture)

        {

        return texture;

        }

    else

        {

        HUI_ASSERT(EFalse); // texture exists but is not loaded! (defined but not loaded)

        return &BlankTexture();

        }

    }

EXPORT_C const CHuiTexture* CHuiTextureManager::Texture(TInt aId) const

    {

    TInt id = CheckTexture(aId);

    if(id == -1)

        {

        return &BlankTexture();

        }

    const CHuiTexture * texture = iTextures[id]->iTexture;

    if(texture)

        {

        return texture;

        }

    else

        {

        HUI_ASSERT(EFalse); // texture exists but is not loaded! (defined but not loaded)

        return &BlankTexture();

        }

    }

EXPORT_C CHuiTexture* CHuiTextureManager::TextureL(TInt aId)

    {

    // try to get the index for the texture id

    TInt index = CheckTexture(aId);

    if(index != -1)

        {

        // If the texture has content and a filename, we can do a load-on-demand.       

        if(!iTextures[index]->iTexture->HasContent() && iTextures[index]->iFileName)

            {

            // we don't want to return textures without content

            // so load-on-demand      

            // texture has an entry but the

            // actual texture object has not been loaded yet

            // we can load the texture if there's a filename

            // available for this id

            return &LoadTextureL(aId);

            }

        // texture found  

        return iTextures[index]->iTexture;

        }

    User::Leave(KErrNotFound);

    return NULL; // never

    }

EXPORT_C void CHuiTextureManager::SetImagePathL(const TDesC& aPath)

    {

    delete iImagePath;

    iImagePath = NULL;

    TParsePtrC parse(aPath);

    CEikonEnv* coe = CEikonEnv::Static();

    if (aPath.Length() && !parse.DrivePresent() && coe && coe->EikAppUi() && coe->EikAppUi()->Application())

        {

        iImagePath = HBufC::NewL(aPath.Size()+2); // two extra characters for drive

        TPtr ptr = iImagePath->Des();

        ptr.Append(coe->EikAppUi()->Application()->AppFullName().Left(2));

        ptr.Append(aPath);

        }

    else

        {

        iImagePath = aPath.AllocL();        

        }

    }

EXPORT_C const TDesC& CHuiTextureManager::ImagePath() const

    {

    return *iImagePath;

    }

EXPORT_C const CHuiTexture& CHuiTextureManager::BlankTexture() const

    {

    HUI_ASSERT(iBlankTexture!=NULL); // this MUST have a valid pointer otherwise access violation will follow..

    return *iBlankTexture;

    }

EXPORT_C CHuiTexture& CHuiTextureManager::BlankTexture()

    {

    HUI_ASSERT(iBlankTexture!=NULL); // this MUST have a valid pointer otherwise access violation will follow..

    return *iBlankTexture;

    }

EXPORT_C TBool CHuiTextureManager::SetTextureId(CHuiTexture* aTexture, TInt aId)

    {

    if(!aTexture)

        {

        // Cannot set texture ID for null texture.

        return EFalse;

        }

    // Iterate through all the managed textures to find the one we

    // are interested in, and then set its texture ID.

    for(TInt i = 0; i < iTextures.Count(); ++i)

        {

        if(iTextures[i]->iTexture == aTexture)

            {

            // Texture was found in the list, so set the new identifier.

            iTextures[i]->iId = aId;

            return ETrue;

            }

        }

    // Texture was not found in the manager's list.

    return EFalse;

    }

EXPORT_C TBool CHuiTextureManager::IsLoaded(const CHuiTexture * texture) const

    {

    if(texture != NULL && texture->HasContent() && !IsInLoadQueue(texture))

        {

        return ETrue;

        }

    return EFalse;

    }

EXPORT_C TBool CHuiTextureManager::IsLoaded(const TDesC& aImageName, const TInt aFrameNumber) const

    {

    TFileName fileName = *iImagePath;

    fileName.Append(aImageName);

    TInt index = CheckTexture(fileName, aFrameNumber);

    if(index < 0)

        {

        HUI_DEBUG1(_L("CHuiTextureManager::IsLoaded() - Texture \"%S\" was not found. Assuming not loaded."), &aImageName);

        return EFalse;

        }

    return IsLoaded(iTextures[index]->iTexture);

    }

EXPORT_C TBool CHuiTextureManager::IsLoaded(TInt aId) const

    {

    HUI_ASSERT(aId!=0);

    TInt index = CheckTexture(aId);

    if(index < 0)

        {

        HUI_DEBUG1(_L("CHuiTextureManager::IsLoaded() - Texture having id %i was not found. Assuming not loaded."), aId);

        return EFalse;

        }

    return IsLoaded(iTextures[index]->iTexture);

    }

EXPORT_C void CHuiTextureManager::AppendTextureL(CHuiTexture* aTexture, TInt aId)

    {

    // Panic if the manager is currently restoring or releasing textures.

    if(iReleaseState == EReleasing)

        {

        THuiPanic::Panic(THuiPanic::ETextureManagerTextureDestroyedDuringRelease);

        }

    else if(iReleaseState == ERestoring)

        {

        THuiPanic::Panic(THuiPanic::ETextureManagerTextureConstructedDuringRestore);

        }

    else

        {

        // for PC lint

        }

    HUI_ASSERT(aTexture != NULL);

#ifdef _DEBUG

    // Look for an existing entry for this.

    // There must not be any duplicates present!

    for(TInt i = 0; i < iTextures.Count(); ++i)

        {

        if(iTextures[i]->iTexture == aTexture)

            {

            User::Leave(KErrAlreadyExists);

            }

        }

#endif

    // Create a new texture entry

    CTextureEntry * te = new (ELeave) CTextureEntry(aId, aTexture);

    CleanupStack::PushL(te);

    // Add the new entry to the list of new textures

    User::LeaveIfError( iTextures.Append(te) );

    CleanupStack::Pop(); // pop the texture entry

    HUI_DEBUG1(_L("CHuiTextureManager::AppendTextureL() - Registered texture 0x%x."), aTexture);

    }

EXPORT_C void CHuiTextureManager::RemoveTexture(CHuiTexture& aTexture)

    {

    // Panic if the manager is currently restoring or releasing textures.

    if(iReleaseState == EReleasing)

        {

        THuiPanic::Panic(THuiPanic::ETextureManagerTextureDestroyedDuringRelease);

        }

    else if(iReleaseState == ERestoring)

        {

        THuiPanic::Panic(THuiPanic::ETextureManagerTextureDestroyedDuringRestore);

        }

    else

        {

        // for PC lint

        }

    // Cancel loading of the texture to be removed.

    CancelLoadingOfTexture(aTexture);

    // Manual sequential search.

    for(TInt index = iTextures.Count() - 1; index >= 0; --index)

        {

        if(iTextures[index]->iTexture == &aTexture)

            {

            CTextureEntry * entry = iTextures[index];

            if ( entry->iFileName )

                {

                HUI_DEBUG4(_L("CHuiTextureManager::RemoveTexture() - Removing texture 0x%x  (Name: \"%S\", Id: %i). Number of textures after deleting: %i."),

                              &aTexture, &(aTexture.ImageFileName()), entry->iId, iTextures.Count()-1);                     

                }

            else

                {

                HUI_DEBUG3(_L("CHuiTextureManager::RemoveTexture() - Removing unnamed texture 0x%x  ( Id: %i). Number of textures after deleting: %i."),

                              &aTexture, entry->iId, iTextures.Count()-1);                     

                }

            iTextures.Remove(index);

            delete entry;

            return;

            }

        }

    HUI_DEBUG2(_L("CHuiTextureManager::RemoveTexture() - Error! Failed to remove texture 0x%x \"%S\". Texture not found."), &aTexture, &aTexture.ImageFileName());

    // this is a programming error.. texturemanager is aware of all textures in the toolkit!!

    #ifdef _DEBUG

    HUI_PANIC(THuiPanic::ETextureNotValid)

    #endif

    }

EXPORT_C CHuiTexture& CHuiTextureManager::LoadTextureL(

    const TDesC& aImageName,

    THuiTextureUploadFlags aFlags,

    TInt aId,

    TInt aFrameNumber)

    {

    return LoadTextureL(aImageName, TSize(0, 0), aFlags, aId, aFrameNumber);

    }

EXPORT_C CHuiTexture& CHuiTextureManager::LoadTextureL(const TInt aId,

                                       const TSize& aTextureMaxSize,

                                       THuiTextureUploadFlags aFlags)

    {

    return LoadTextureL(KNullDesC(), aTextureMaxSize, aFlags, aId);

    }

EXPORT_C CHuiTexture& CHuiTextureManager::LoadTextureL(const TDesC& aImageName,

        const TSize& aTextureMaxSize,

        THuiTextureUploadFlags aFlags,

        TInt aId,

        TInt aFrameNumber)

    {

    // Ignore EHuiTextureFlagAllowDirectBitmapUsage flag

   	aFlags = (THuiTextureUploadFlags)(aFlags & ~EHuiTextureFlagAllowDirectBitmapUsage);		

    TFileName fileName;

    CTextureEntry * entry = NULL;  

    // If the name is invalid, and there was no filename available

    // based on id, return a dummy texture.

    if((aImageName.Length() == 0) && (aId == 0))

        {

        HUI_DEBUG(_L("CHuiTextureManager::LoadTextureL() - No filename or id provided for texture. Returning blank."));

        return BlankTexture();

        }

    // add path to filename if filename has been passed

    if(aImageName.Length() > 0)

        {

        // assume relative pathname and prepend the image path to get full filename

        fileName = aImageName;

        PrependImagePath(fileName);

        }

    // if no name has been passed as a parameter but

    // a nonzero id has been passed, we

    // can assume that there's a predefined name available

    if((aImageName.Length() == 0) && (aId != 0))

       {

        // search for a texture filename based on the id.

        TInt index = CheckTexture(aId);

        if(index >=0)

            {

            entry = iTextures[index];

            HUI_ASSERT(entry->iFileName);

            fileName = *(entry->iFileName);

            }

        else

            {

            HUI_DEBUG1(_L("CHuiTextureManager::LoadTextureL() - Unable to load texture without filename or pre-defined id (filename definition for id %i not found)."), aId);

            User::Leave(KErrNotFound);

            }

       }

    // a guarantee that there's a filename available

    HUI_ASSERT(	fileName.Length()>0 );

    // Reuse pre-existing entries:

    // try first finding an entry based on id

    if(entry == NULL && aId != 0)

        {

        TInt previouslyLoadedIndex = CheckTexture(aId);

        if (previouslyLoadedIndex >= 0)

            {

            entry = iTextures[previouslyLoadedIndex];

            }

        }

    // We are not allowed to change required texture id so we can't 

    // try again with the filename unless user does not care about id

    if(aId == 0 && entry == NULL)

        {

        TInt previouslyLoadedIndex = CheckTexture(fileName, aFrameNumber);

        if (previouslyLoadedIndex >= 0)

            {

            entry = iTextures[previouslyLoadedIndex];

            }

        }

    // create new texture entry if there's not one

    // available at this point

    if(entry == NULL)

        {

        HUI_DEBUG(_L("CHuiTextureManager::LoadTextureL() - Creating new texture."));

        // in the case that a previously loaded slot was not found,

        // create a new texture, which automatically registers a new

        // texture entry in the iTextures list.

        CHuiTexture::NewL();

        // we assume that the newest entry was added the last

        entry = iTextures[iTextures.Count()-1];

        entry->iId = aId;

        }

    else

        {

        // We have a valid texture name and ID.

        HUI_ASSERT(entry->iTexture);

        // we have a pre-existing texture,

        // but check that the texture is loaded ok, we can also

        // return unloaded textures that are in the load queue

        if (entry->iTexture->HasContent() || IsInLoadQueue(entry->iTexture))

            {

            // a previous texture exists!

            HUI_ASSERT(entry->iTexture!=NULL);            

            HUI_DEBUG3(_L("CHuiTextureManager::LoadTextureL() - Reusing texture 0x%x (\"%S\", id: %i) No need to load."),

                      entry->iTexture, &entry->iTexture->ImageFileName(), entry->iId);

            return *(entry->iTexture);

            }

        }

    HUI_ASSERT(entry!=NULL);