/*

* Copyright (c) 2006 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:   Loads textures.

*

*/

#include <e32std.h>

#include <imageconversion.h>

#include <eikenv.h>

#include <eikappui.h>

#include <eikapp.h>

#include "alf/alftexturemanager.h"

#include "alf/alftextureprocessor.h"

#include "alf/alftexture.h"

#include "alf/alfenv.h"

#include "alfclient.h"

#include "alf/alfutil.h"

#include "alf/alfbitmapprovider.h"

#include "alflogger.h"

const TInt KFirstAutoGeneratedTextureId = 0x10000000;

const TInt KAlfDefaultSizeDimension = 4;

/**

 * Flag to indicate to use the provided bitmap directly for the texture, without conversion or copying. The bitmaps

 * should be in the correct format and they shall not be compressed or have duplicated handle.

 * If the direct bitmap cannot be used, this flag is ignored internally.

 *

 * NOTE: This flag is not a public since we cannot guarantee that user does not compress

 * bitmap or otherwise temper with it after providing it to toolkit. 

 * But internally we can use this in some cases to speed up the texture upload.

 *

 */

enum

    {

    EAlfTextureFlagAllowDirectBitmapUsage = 0x20        

    };

struct TTextureEntry 

    {

    public:

    	~TTextureEntry()

        {

        }

    	TTextureEntry()                      

                      : iId(0), iTexture(NULL), iRefCount(-1)

        {                            

        }

    	TTextureEntry(TInt aId,

                      CAlfTexture* aTexture)                      

                      : iId(aId), iTexture(aTexture),iRefCount(-1)

        {

        }

    /** The texture id. Set to zero for no id. */

    TInt iId;

    /** The texture entry. */

    CAlfTexture* iTexture;

    /** Reference count. */

    TInt iRefCount;

    };

struct TLoadQueueEntry

    {

    /** The texture entry that is being loaded. */

    TTextureEntry iLoading;

    /** The image being loaded has an alpha channel. */

    TBool iHasAlpha;

    /** The original, non-downscaled size of the image. */

    TSize iOriginalSize;

    /** Image decoder to load bitmap images. */

    CImageDecoder* iDecoder;

    /** True, if the texture was already unloaded before it finished

        loading. */

    TBool iUnloaded;

    };

// Private structure

struct CAlfTextureManager::TPrivateData

    {

    CAlfEnv* iEnv;              // Not owned.  	

    /**

     * Registry of all textures within this toolkit.

     * Accessed by texture ids (iId). 

     */

    RArray<TTextureEntry> iTextures;

    /** Queue of loading tasks. */

    RArray<TLoadQueueEntry> iLoadQueue;

    /** Queue of loading observers. */

    RPointerArray<MAlfTextureLoadingCompletedObserver> iLoadObserverQueue;

    /** Queue of state observers. */

    RPointerArray<MAlfTextureManagerStateChangedObserver> iStateObserverQueue;

    /** Blank texture */

    CAlfTexture* iBlankTexture;

    /** Path where image files are loaded from. */

    HBufC* iImagePath;

    /** State of the texture manager. */

    TState iState;

    /** Bitmap for loading asynchronously into. */

    CFbsBitmap* iBitmap;

    /** Mask bitmap for loading alpha channels. */

    CFbsBitmap* iMaskBitmap;

    /** Open file server session for image loading. */

    RFs iFs;

    /** Id of this texture manager. */

    TUid iManagerId;

    /** Texture processor */

    CAlfTextureProcessor* iProcessor;

    /** Texture id auto generation */

    TInt iAutoGeneratedTextureId;

    TInt iLowestAutoGeneratedTextureId;

    TInt iHighestAutoGeneratedTextureId;

    RPointerArray<MAlfTextureAutoSizeObserver> iAutoSizeObserverQueue;

    // DEBUG

    TBool iTextureAutoCounterEnabled;

    TInt iTextureAutoRecreateCounter;

    TInt iTextureAutoReloadCounter;

    //...add other member variables...

    CIdle* iDoomBringer;

    };

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

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

// Constructor

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

//

CAlfTextureManager::CAlfTextureManager() : CActive(EPriorityHigh)

	{

	}

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

// Destructor

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

//

CAlfTextureManager::~CAlfTextureManager()

	{

	Cancel();

	if ( iData )

	    {

        delete iData->iImagePath;

	    delete iData->iBlankTexture;

	    RArray<TTextureEntry>& textures = (iData->iTextures);	

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

        while (textures.Count())

            {

            TTextureEntry te = textures[textures.Count()-1];

            delete te.iTexture; 

            te.iTexture = NULL;                

            }

        textures.Close();   

	    iData->iLoadQueue.Close();	    

	    iData->iLoadObserverQueue.Close();	

	    iData->iStateObserverQueue.Close();	

	    iData->iAutoSizeObserverQueue.Close();

        delete iData->iBitmap;

        delete iData->iMaskBitmap;

        iData->iFs.Close();

        delete iData->iProcessor;        

        if (iData->iDoomBringer)

            iData->iDoomBringer->Cancel();

        delete iData->iDoomBringer;

	    }	

	delete iData;

	}

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

// NewL

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

//

CAlfTextureManager* CAlfTextureManager::NewL(CAlfEnv& aEnv, TUid aUid)

	{

	CAlfTextureManager* self = CAlfTextureManager::NewLC(aEnv, aUid);        

    CleanupStack::Pop( self );

    return self;		

	}

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

// NewLC

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

//

CAlfTextureManager* CAlfTextureManager::NewLC(CAlfEnv& aEnv, TUid aUid)

	{

    CAlfTextureManager* self = new( ELeave ) CAlfTextureManager();

    CleanupStack::PushL( self );

    self->ConstructL(aEnv, aUid);

    return self;	

	}

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

// 2nd phase constructor

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

//

void CAlfTextureManager::ConstructL(CAlfEnv& aEnv, TUid aUid)

	{

    iData = new (ELeave) TPrivateData;

    // Zero all data

    iData->iEnv = NULL;  	

    iData->iTextures.Reset();

    iData->iLoadQueue.Reset();

    iData->iLoadObserverQueue.Reset();

    iData->iAutoSizeObserverQueue.Reset();

    iData->iBlankTexture = NULL;

    iData->iImagePath = NULL;

    iData->iState = EIdle;

    iData->iBitmap = NULL;

    iData->iMaskBitmap = NULL;

    iData->iManagerId = TUid::Uid(0);

    iData->iProcessor = NULL;

    // Fill data

    iData->iAutoGeneratedTextureId = KFirstAutoGeneratedTextureId;

    iData->iLowestAutoGeneratedTextureId = KFirstAutoGeneratedTextureId;

    iData->iHighestAutoGeneratedTextureId = KMaxTInt;

    iData->iEnv = &aEnv;    

    iData->iManagerId = aUid;

    iData->iBlankTexture = CAlfTexture::NewL(aEnv, aUid);

    iData->iBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError(iData->iBitmap->Create(

        TSize(KAlfDefaultSizeDimension, KAlfDefaultSizeDimension), EColor64K));

    iData->iMaskBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError(iData->iMaskBitmap->Create(

        TSize(KAlfDefaultSizeDimension, KAlfDefaultSizeDimension), EGray256));	

    iData->iProcessor = CAlfTextureProcessor::NewL(aEnv); 

    User::LeaveIfError(iData->iFs.Connect());

    iData->iDoomBringer = CIdle::NewL(CActive::EPriorityIdle);

    // DEBUG 

    iData->iTextureAutoCounterEnabled = EFalse;

    iData->iTextureAutoRecreateCounter = 0;

    iData->iTextureAutoReloadCounter = 0;

    SetImagePathL(_L(""));

	CActiveScheduler::Add(this);

	}

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

// Returns env

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

//

EXPORT_C CAlfEnv& CAlfTextureManager::Env()

    {

    return *iData->iEnv;

    }

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

// Returns texture with given id

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

//

EXPORT_C const CAlfTexture* CAlfTextureManager::Texture(TInt aId) const

    {

    TInt index = CheckTexture(aId);

    if(index == KErrNotFound)

        {

        return &BlankTexture();

        }

    RArray<TTextureEntry>& textures = (iData->iTextures);	

    CAlfTexture* texture = textures[index].iTexture;

    if(texture)

        {

        return texture;

        }

    else

        {

        return &BlankTexture();

        }    

    }

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

// Returns texture with given id

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

//

EXPORT_C CAlfTexture* CAlfTextureManager::TextureL(TInt aId)

    {

    // try to get the index for the texture id

    TInt index = CheckTexture(aId);

    if(index != KErrNotFound)

        {

        // texture found

        RArray<TTextureEntry>& textures = (iData->iTextures);	

        CAlfTexture* texture = textures[index].iTexture;

        if(texture == NULL)

            {

            User::Leave(KErrNotFound);

            return NULL;                

            }

        return texture;

        }

    User::Leave(KErrNotFound);

    return NULL;

    }

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

// Sets image path

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

//

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

    {

    delete iData->iImagePath;

    iData->iImagePath = NULL;

    TParsePtrC parse(aPath);

    CEikonEnv* coe = CEikonEnv::Static();

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

        {

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

        TPtr ptr = iData->iImagePath->Des();

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

        ptr.Append(aPath);

        }

    else

        {

        iData->iImagePath = aPath.AllocL();        

        }

    }

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

// Gets image path

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

//

EXPORT_C const TDesC& CAlfTextureManager::ImagePath() const

    {

    return *iData->iImagePath;        

    }

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

// Returns blank texture.

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

//

EXPORT_C const CAlfTexture& CAlfTextureManager::BlankTexture() const

    {

    return *iData->iBlankTexture;            

    }

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

// Returns blank texture.

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

//

EXPORT_C CAlfTexture& CAlfTextureManager::BlankTexture()

    {

    return *iData->iBlankTexture;            

    }

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

// DEPRECATED! Load the animated texture based on the Skin name

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

//

EXPORT_C CAlfTexture& CAlfTextureManager::LoadAnimatedTextureL(const TDesC& /*aSkinAnimName*/,

                                       TSize /*aTextureMaxSize*/,

                                       TAlfTextureFlags /*aFlags*/,

                                       TInt /*aId*/)

    {

    __ALFLOGSTRING( "CAlfTextureManager::LoadAnimatedTextureL FUNCTIONALITY REMOVED. REFER TO ANTRIKSH PROJECT" );

    CAlfTexture* tex = NULL;

    return *tex;

    }

// Loads texture.

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

//

EXPORT_C CAlfTexture& CAlfTextureManager::LoadTextureL(const TDesC& aImageName,

                                       TAlfTextureFlags aFlags,

                                       TInt aId)

    {

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

    }

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

// Loads texture.

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

//

EXPORT_C CAlfTexture& CAlfTextureManager::LoadTextureL(const TInt aId,

                                       TSize aTextureMaxSize,

                                       TAlfTextureFlags aFlags)

    {

    return LoadTextureL(_L(""), aTextureMaxSize, aFlags, aId);

    }

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

// Loads texture.

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

//

EXPORT_C CAlfTexture& CAlfTextureManager::LoadTextureL(const TDesC& aImageName,

                                       TSize aTextureMaxSize,

                                       TAlfTextureFlags aFlags,

                                       TInt aId)

    {    

    // Clients are not allowed to let toolkit use bitmaps directly. 

    // We could use it internally if we had separate bitmaps

    // for each entry.

    RemoveFlags(aFlags, EAlfTextureFlagAllowDirectBitmapUsage);

    if (aId == KAlfAutoGeneratedTextureId)

        {

        aId = GenerateTextureId();    

        }    

    CAlfTexture* tex = NULL;

    TFileName fileName;

    // Provide an already created texture if such exists.

    TRAPD(err, tex = TextureL(aId));

    if(err == KErrNone && tex->HasContent())

        {

        return *tex;

        }

    // If shared texture manager, then check the existense of the texture first.

    if (IsShared())

        {

        // AutoSize is not supported (yet) for shared textures

        RemoveFlags(aFlags, EAlfTextureFlagAutoSize);

        TBool sharedTextureAlreadyExists = EFalse;

        iData->iEnv->Client().TextureHasContent(sharedTextureAlreadyExists, 

            aId, 

            iData->iManagerId.iUid);

        // If shared texture already exists, we don't even start to load it.

        if (sharedTextureAlreadyExists)

            {

            TInt bitmapHandle = 0;

            TInt maskHandle = 0;

        	if (iData->iBitmap)

        		{

        		bitmapHandle = iData->iBitmap->Handle();

        		}

        	if (iData->iMaskBitmap)	

        		{

        		maskHandle = iData->iMaskBitmap->Handle();	

        		}

            // Create CAlfTexture instance.

        	tex = CAlfTexture::NewL( Env(), 

        	    iData->iManagerId,

        	    aId, 

        	    bitmapHandle, 

        	    maskHandle, 

        	    aFlags);             

            if(aImageName.Length() > 0)

                {

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

                fileName = aImageName;

                PrependImagePath(fileName);

                tex->SetFileNameL(fileName);

                }

            tex->SetMaxTextureSize(aTextureMaxSize);

            return *tex;    

            }            

        }

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

    // based on id, return a dummy texture.

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

        {

        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);

        }