/*

* Copyright (c) 2008-2009 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:    Texture Manager

*

*/

// INCLUDE FILES

#include "glxtexturemanagerimpl.h"

#include <AknIconUtils.h>

#include <AknsUtils.h>

#include <aknconsts.h>

#include <alf/alftexturemanager.h>

#include <alf/alfutil.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediageneraldefs.h>

#include <glxdrmutility.h>

#include <glxmedia.h>

#include <glxmediageneraldefs.h>

#include <glxthumbnailattributeinfo.h>

#include <glxthumbnailutility.h>

#include <mglxcache.h>

#include <glxresolutionutility.h>

#include <glxlog.h>

#include <glxtracer.h>

#include <glxuiutility.h>

#include "mglxtextureobserver.h"

namespace

    {

    const TInt KGlxFirstAlfThumbnailTextureId = 0x10000001;

    const TInt KGlxLastAlfThumbnailTextureId = 0x20000000;

    const TInt KGlxFirstThumbnailTextureId = 0x20000001;

    /** Bitmap size for flat (solid colour) textures */

    const TInt KGlxFlatTextureSize = 64; 

    }

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

// Constructor

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

//  

CGlxTextureManagerImpl::CGlxTextureManagerImpl

       (CAlfTextureManager& aAlfTextureManager) :

    iAlfTextureManager(aAlfTextureManager),

      iNextTextureId( KGlxFirstThumbnailTextureId )

    {

    }

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

// Destructor

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

//  

CGlxTextureManagerImpl::~CGlxTextureManagerImpl()

    {

    TRACER("CGlxTextureManagerImpl::~CGlxTextureManagerImpl");

    // delete other icon textures

    // iIconLIst should deleted only once in destructor as

    // they are using in full applicaiton

    TInt count = iIconList.Count();

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

        {

        delete iIconList[i].iTexture;

        }

    iIconList.Close();

    iThumbnailList.Close();

    iAnimatedTnmList.Close();

    // delete DRM GIF textures

    count = iDRMGifAnimatedTnmList.Count();

    GLX_LOG_INFO1("CGlxTextureManagerImpl iDRMGifAnimatedTnmList.Count=%d",count);

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

        {

        GLX_LOG_INFO1("CGlxTextureManagerImpl DRM Gif Texture deleted i=%d",i);

        for(TInt texCnt = KGlxMaxFrameCount - 1; texCnt >= 0; texCnt--)

            {

            delete iDRMGifAnimatedTnmList[i].iTexture[texCnt];

            }

        }

    iDRMGifAnimatedTnmList.Close();

    // delete zoom textures

    count = iZoomedList.Count();

    GLX_LOG_INFO1("CGlxTextureManagerImpl iZoomedList.Count=%d",count);

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

        {

        GLX_LOG_INFO1("CGlxTextureManagerImpldeleted i=%d",i);

        delete iZoomedList[i].iTexture;

        }

    iZoomedList.Close();

    delete iMifFilenames;

    if ( iDrmUtility )

        {

        iDrmUtility->Close();

        }

    if ( iCache )

        {

	    iCache->RemoveObserver(this);

        iCache->Close();

        }

    if ( iResUtil )

        {

        iResUtil->RemoveObserver(*this);

        iResUtil->Close();

        }

    if(iZoomDecoder)

        {

        delete iZoomDecoder;

        }

    }

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

// NewL

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

//

CGlxTextureManagerImpl* CGlxTextureManagerImpl::NewL(

                                        CAlfTextureManager& aAlfTextureManager)

    {

    TRACER("CGlxTextureManagerImpl::NewL");

    CGlxTextureManagerImpl* self = CGlxTextureManagerImpl::NewLC(aAlfTextureManager);

    CleanupStack::Pop(self);

    return self;

    }

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

// NewLC

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

//

CGlxTextureManagerImpl* CGlxTextureManagerImpl::NewLC(

                                        CAlfTextureManager& aAlfTextureManager)

    {

    TRACER("CGlxTextureManagerImpl::NewLC");

    CGlxTextureManagerImpl* self = 

                        new (ELeave) CGlxTextureManagerImpl(aAlfTextureManager);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// ConstructL

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

//  

void CGlxTextureManagerImpl::ConstructL()

    {

    TRACER("CGlxTextureManagerImpl::ConstructL");

    iMifFilenames = new (ELeave) CDesCArrayFlat(2);

    // get handle to DRM utility

    iDrmUtility = CGlxDRMUtility::InstanceL();

    // get handle to the media cache

    iCache = MGlxCache::InstanceL();

    iCache->AddObserverL(this);

    // Get instance of Resolution utility and register for notification of 

    // resolution changes

    /// @todo implement CGlxResolutionUtility this later        

    iResUtil = CGlxResolutionUtility::InstanceL();

    iResUtil->AddObserverL(*this);

    // Set the TextureId range. Now we can set our own ID outside this Range

    iAlfTextureManager.SetAutomaticTextureIdRange(

                            KGlxFirstAlfThumbnailTextureId, 

                            KGlxLastAlfThumbnailTextureId);

    }

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

// TextureNeedsUpdating

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

//  

TBool CGlxTextureManagerImpl::TextureNeedsUpdating( TGlxMedia aMedia,

    TGlxIdSpaceId aIdSpaceId, const TSize& aRequiredSize )

    {

    TRACER("CGlxTextureManagerImpl::TextureNeedsUpdating");

    TInt thumbnailIndex = KErrNotFound;

    TMPXAttribute thumbNailAttribute( 0, 0 );

    TBool updateTexture = ETrue;

    TRAPD( err, updateTexture = GetThumbnailAttributeAndIndexL( aRequiredSize,

        aMedia, aIdSpaceId, thumbnailIndex, thumbNailAttribute ) );

    // don't update the texture if there's an error

    return ( err == KErrNone ? updateTexture : EFalse );

    }

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

// CreateIconTextureL 

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

//

CAlfTexture& CGlxTextureManagerImpl::CreateIconTextureL(

                                               const TAknsItemID& aSkinID,

                                               TInt aIconResourceId, 

                                               const TDesC& aFilename,

                                               TBool aSetColor,

                                               TRgb aDefaultColor,

                                               const TAknsItemID& aSkinColorId,

                                               TInt aSkinColorIndex,

                                               TSize aRequestedSize)

    {

    TRACER("CGlxTextureManagerImpl::CreateIconTextureL");

    // Convert size to POSS

    TReal32 heightInPoss = 

                  iResUtil->PixelsToPoss(TReal32(aRequestedSize.iHeight));

    TReal32 widthInPoss = 

                  iResUtil->PixelsToPoss(TReal32(aRequestedSize.iWidth));

    CAlfTexture* texture = NULL;

    //search array for existing item

    TInt i = iIconList.Count();

    while(i > 0 && !texture)

        {

        i--;

        TGlxIcon icon = iIconList[i];

        if( icon.iAvkonSkinId == aSkinID && 

            icon.iBitmapId == aIconResourceId &&

            icon.iSetColor == aSetColor &&

            icon.iDefaultColor == aDefaultColor &&

            icon.iSkinColorId == aSkinColorId &&

            icon.iSkinColorIndex == aSkinColorIndex &&

            icon.iHeightInPoss == heightInPoss &&

            icon.iWidthInPoss == widthInPoss )

            {

            // also compare file names

            TFileName filename(KNullDesC);

            if(icon.iFilenameIndex >= 0)

                {

                filename = iMifFilenames->MdcaPoint(icon.iFilenameIndex);

                }

            if(0 == filename.CompareF(aFilename) )

                {

                // match found - use existing texture

                texture = icon.iTexture;

                }

            }

        }

    if(!texture)

        {

        // existing texture not found - prepare to create new one

        TInt filenameIndex = -1;

        if(aFilename.Length() > 0)

            {

            // is filename already in filename list

            if(iMifFilenames->MdcaCount())

                {

                iMifFilenames->Find(aFilename, filenameIndex);

                if(filenameIndex == iMifFilenames->MdcaCount())

                    {

                    filenameIndex = -1;

                    }

                }

            if(filenameIndex < 0)

                {

                // name not in list. Add it

                iMifFilenames->AppendL(aFilename);

                filenameIndex = iMifFilenames->MdcaCount() - 1;

                }

            }

        // Create new icon entry

        TGlxIcon icon;

        icon.iTextureId = NextTextureId();

        icon.iTexture = NULL;

        icon.iAvkonSkinId = aSkinID;

        icon.iBitmapId = aIconResourceId;

        icon.iFilenameIndex = filenameIndex;

        icon.iSetColor = aSetColor;

        icon.iDefaultColor = aDefaultColor;

        icon.iSkinColorId  = aSkinColorId;

        icon.iSkinColorIndex = aSkinColorIndex;

        icon.iHeightInPoss = heightInPoss;

        icon.iWidthInPoss = widthInPoss;

        // add to list so ProvideBitmapL can use it

        iIconList.AppendL(icon);

        // trap create texture

       TRAPD(err, texture = &iAlfTextureManager.CreateTextureL(

                                               icon.iTextureId, 

                                               this, 

                                               EAlfTextureFlagDefault));

        if(err)

            {

            // if error delete entry and leave

            iIconList.Remove(iIconList.Count() - 1);

            User::Leave(err);    

            }

        else

            {

            // if no error add texture to entry

            iIconList[iIconList.Count() - 1].iTexture = texture;

            }

        }

    if (NULL == texture)

        {

        User::Leave(KErrNotFound);

        }

    return *texture;

    }

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

// CreateNewTextureForMediaL

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

//

CAlfTexture& CGlxTextureManagerImpl::CreateNewTextureForMediaL(

                                            TSize aSize, 

                                            const TGlxMedia& aMedia, 

                                            const TGlxIdSpaceId& aIdSpaceId, 

                                            MGlxTextureObserver* aObserver,

                                            TBool aScaleGridTnm)

    {

    TRACER("CGlxTextureManagerImpl::CreateNewTextureForMediaL");

    TInt thumbnailIndex = KErrNotFound;

    TMPXAttribute thumbNailAttribute(0,0);

    TGlxThumbnailIcon thumbData;

    // If the current thumbnail matches what is required then return the current texture otherwise

    // create a new one.

    if (!GetThumbnailAttributeAndIndexL(aSize, aMedia, aIdSpaceId, thumbnailIndex, thumbNailAttribute))

        {

        // only texture is missing. 

        if ( (NULL != iThumbnailList[thumbnailIndex].iBitmap) && (NULL == iThumbnailList[thumbnailIndex].iTexture)) 

            {

            CAlfTexture* newTexture = &iAlfTextureManager.CreateTextureL(

                                                                    iThumbnailList[thumbnailIndex].iTextureId, 

                                                                    this, 

                                                                    EAlfTextureFlagDefault);

            iThumbnailList[thumbnailIndex].iTexture = newTexture ;

            }

        return *iThumbnailList[thumbnailIndex].iTexture;

        }

    // We have 2 scenarios here.

    // 1) We do not have a thumbnail

    // 2) The thumbnail we have is not good enough   

    iThumbnailList.ReserveL( iThumbnailList.Count() + 1 );

    CAlfTexture& texture = CreateNewTextureL(aSize, aMedia, aIdSpaceId, 

                            aObserver, thumbNailAttribute, thumbData,ETrue,aScaleGridTnm);   

    if ( thumbnailIndex != KErrNotFound )

        {

        // A new texture was created so remove the old one and 

        // update the thumbnail list.

        iAlfTextureManager.UnloadTexture(iThumbnailList[thumbnailIndex].iTextureId);

        iThumbnailList.Remove(thumbnailIndex);

        GLX_LOG_INFO("CGlxTextureManagerImpl CreateNewTextureForMediaL UnloadTexture ");

        }

    return texture;

    }

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

// CreateFlatColourTextureL

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

//  

CAlfTexture& CGlxTextureManagerImpl::CreateFlatColourTextureL( TRgb aColour )

    {

    TRACER("CGlxTextureManagerImpl::CreateFlatColourTextureL");

    // Create a picture with the colour

	CFbsBitmap* picture = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(picture);

	User::LeaveIfError(picture->Create(TSize(KGlxFlatTextureSize,

	                                        KGlxFlatTextureSize), EColor16M ) );

	CFbsBitmapDevice* drawBufDevice = CFbsBitmapDevice::NewL(picture);

	CleanupStack::PushL(drawBufDevice);

	CFbsBitGc* drawBufContext;

	User::LeaveIfError(drawBufDevice->CreateContext(drawBufContext));

	CleanupStack::PushL(drawBufContext);

    // draw the color

	drawBufContext->Activate(drawBufDevice);

    drawBufContext->SetBrushColor(aColour);

    drawBufContext->Clear();

    TInt alpha = aColour.Alpha();

    CleanupStack::PopAndDestroy(drawBufContext); 

    CleanupStack::PopAndDestroy(drawBufDevice); 

	CFbsBitmap* mask = NULL;

	if( alpha != 0 )

	    {

	    mask = new (ELeave) CFbsBitmap();

    	CleanupStack::PushL( mask );

    	User::LeaveIfError( mask->Create(TSize( KGlxFlatTextureSize,

    	                                        KGlxFlatTextureSize ), EGray256 ));

        CFbsBitmapDevice* maskBufDevice = CFbsBitmapDevice::NewL( mask );

    	CleanupStack::PushL( maskBufDevice );

    	CFbsBitGc* maskBufContext = NULL;

    	User::LeaveIfError( maskBufDevice->CreateContext( maskBufContext ) );

    	CleanupStack::PushL( maskBufContext );

        // draw the mask    	

    	maskBufContext->Activate(maskBufDevice);

        maskBufContext->SetBrushColor( TRgb::Color256( alpha ) );

        maskBufContext->Clear();

        CleanupStack::PopAndDestroy( maskBufContext ); 

        CleanupStack::PopAndDestroy( maskBufDevice ); 

        }

    // Manage the texture ids ourself. Get the next id and store the

    // associated bitmap and mask to ensure that we supply the correct bitmaps

    // when alf calls back to ProvideBitmap 

    TInt nextTextureId = NextTextureId();

    iProvideBitmapHolder.iTextureId = nextTextureId;

    iProvideBitmapHolder.iBitmap = picture;

    iProvideBitmapHolder.iMaskBitmap = mask;

    CAlfTexture& newTexture = iAlfTextureManager.CreateTextureL(

                                                           nextTextureId, 

                                                           this, 

                                                           EAlfTextureFlagDefault );

    // don't want alf to delete this texture

    newTexture.SetPriority( EAlfTexturePriorityHighest );

    // if we had alpha, release the mask

	if( alpha != 0 )

	    {

	    CleanupStack::Pop( mask );

	    }

    CleanupStack::Pop( picture ); 

    return newTexture;

    }

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

// RemoveTexture

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

//

void CGlxTextureManagerImpl::RemoveTexture( const CAlfTexture& aTexture )

    {

    TRACER("CGlxTextureManagerImpl::RemoveTexture");

    // Find the texture in the iThumbnailList

    TInt index = iThumbnailList.Find( aTexture, &TGlxThumbnailIcon::MatchTexture );

    if ( index != KErrNotFound )

        {

        iThumbnailList.Remove( index );

        iAlfTextureManager.UnloadTexture( aTexture.Id() );

        }

    else

        {

        // Find the texture in the zoomed list

        index = iZoomedList.Find( aTexture, &TGlxThumbnailIcon::MatchTexture );

        GLX_LOG_INFO1("CGlxTextureManagerImpl RemoveTexture index=%d",index);

        if ( index != KErrNotFound )

            {

            GLX_LOG_INFO("CGlxTextureManagerImpl RemoveTexture index != KErrNotFound");

            iAlfTextureManager.UnloadTexture( aTexture.Id() );

            if(iZoomedList[index].iBitmap)

                {

                GLX_LOG_INFO("CGlxTextureManagerImpl RemoveTexture iZoomedList[index].iBitmap delete");

                delete iZoomedList[index].iBitmap;

                iZoomedList[index].iBitmap=NULL;

                iZoomedList.Remove( index );

                }

            }

            // iIconLIst should deleted only once in destructor as

            // they are using in full applicaiton

        }

    index = iAnimatedTnmList.Find( aTexture, &TGlxThumbnailIcon::MatchTexture );

    GLX_LOG_INFO1("CGlxTextureManagerImpl RemoveTexture iAnimatedTnmList index=%d",index);

    if ( index != KErrNotFound )

        {

        if(iAnimatedTnmList[index].iTexture)

            {

            GLX_LOG_INFO("RemoveTexture iAnimatedTnmList Stop animation");

            (iAnimatedTnmList[index].iTexture)->StopAnimation();

            }

        iAnimatedTnmList.Remove( index );        

        iAlfTextureManager.UnloadTexture( aTexture.Id() );

        }

    }

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

// RemoveZoomList

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

//

void CGlxTextureManagerImpl::RemoveZoomList()

    {

    TRACER("CGlxTextureManagerImpl::RemoveZoomList");

    TInt count = iZoomedList.Count();

    GLX_LOG_INFO1("CGlxTextureManagerImpl RemoveZoomList  Count()=%d",count);

	if(iZoomDecoder)

      {

      }

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

        {

        iAlfTextureManager.UnloadTexture( iZoomedList[i].iTextureId );

        if( iZoomedList[i].iBitmap)

            {

            GLX_LOG_INFO("CGlxTextureManagerImpl RemoveZoomList delete iZoomedList[i]");