/*

* Copyright (c) 2006-2008 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:   

*

*/

#include "huicanvastexturecache.h"

#include "uiacceltk/HuiImage.h"

#include "uiacceltk/HuiTexture.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiStatic.h"

#include "huicanvasgc.h"

#include "HuiRenderPlugin.h"

#include "huicanvasrenderbuffer.h"

#include <e32cmn.h>

#include <bitdev.h>

#include <AknLayoutFont.h>

#include <e32property.h>

// Enable this for debugging cache usage

//#define HUI_DEBUG_PRINT_CANVAS_TEXTURE_CACHE

//#define HUI_DEBUG_PRINT_CANVAS_TEXTURE_CACHE_EGL

//#define HUI_DEBUG_PRINT_CANVAS_TEXTURE_CACHE_EXTENDED

// Enable this for debugging performance

//#define HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

/** Magic S60 font constant */

const TInt KHuiFontVerticalShiftInPixels = 1; 

/** Initial touch count value */

const TInt KHuiInitialBitmapTouchCount = -1; 

/** Estimated bits per pixel for all textures */

const TReal32 KHuiTextureEstimatedBpp = 32;

/** Estimated bits per pixel for rasterized canvas texts */

const TReal32 KHuiCanvasTextEstimatedBpp = 8;

/** Estimated bits per pixel for canvas images */

const TReal32 KHuiCanvasImageEstimatedBpp = 32;

/** Estimated bits per pixel for canvas render buffers */

const TReal32 KHuiCanvasRenderBufferEstimatedBpp = 32;

/** Constant to define target how much memory UI textures should use, 

    this is not a hard limit but effects how long unused textures are cached */

const TInt KHuiMaxRecommendedTextureAmountInKBytes = 4096;

/** Constant to define target how much memory UI render buffers should use, 

    this is not a hard limit but effects how long unused render buffers are cached */

const TInt KHuiMaxRecommendedRenderBufferAmountInKBytes = 0;

/** Ratio how cache is divided between canvas texts and images */

const TReal32 KHuiCanvasUnusedTextImageCacheRatio = 0.1f;

/** Max amount of recycled texture objects */

const TInt KHuiMaxRecycledTextureCount = 100;

/** Use color modulation or not for setting text color */

const TBool KHuiCanvasTextUseColorModulation = ETrue;

/** Store bitmap pointers to avoid handle duplication */

const TBool KHuiCanvasKeepBitmapPointer = ETrue;

CHuiCanvasImage::CHuiCanvasImage() :

        iTexture(NULL),

        iCache(NULL)

    {

    }

CHuiCanvasImage::~CHuiCanvasImage()

    {

    if (iCache && iTexture)

        {

        iCache->DeleteRecycledTexture(iTexture);

        }

    else

        {

        delete iTexture;        

        }    

    iActiveUsers.Close();            

    }

void CHuiCanvasImage::RefreshUser(const CHuiCanvasVisual& aUser)

    {

    if (iActiveUsers.FindInAddressOrder(&aUser) == KErrNotFound)

        {

        iActiveUsers.InsertInAddressOrder(&aUser);

        }

    // Update last usage time    

    iLastUsed.UniversalTime();        

    }

void CHuiCanvasImage::RemoveUser(const CHuiCanvasVisual& aUser)

    {

    TInt index = iActiveUsers.FindInAddressOrder(&aUser);

    if (index != KErrNotFound)

        {

        iActiveUsers.Remove(index);

        }    

    }

TBool CHuiCanvasImage::IsUser(const CHuiCanvasVisual& aUser) const

    {

    TInt index = iActiveUsers.FindInAddressOrder(&aUser);

    if (index != KErrNotFound)

        {

        return ETrue;

        }

    return EFalse;

    }

TBool CHuiCanvasImage::IsAnyUser() const

    {

    return iActiveUsers.Count() != 0;

    }

CHuiTexture* CHuiCanvasImage::Texture() const

    {

    return iTexture;

    }

void CHuiCanvasImage::CopyAttributes(CHuiCanvasImage& aSrc)

    {

    iTexture = aSrc.iTexture;

    iGcParams = aSrc.iGcParams;

    iLastUsed = aSrc.iLastUsed;

    iCache = aSrc.iCache;

    iActiveUsers.Reset();        

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

        {

        iActiveUsers.Append(aSrc.iActiveUsers[i]);    

        }               

    }

void CHuiCanvasImage::Reset()

    {

    // Reset does not delete owned items !

    iTexture = NULL;            

    iGcParams = THuiCachedGcParams();       

    iActiveUsers.Reset();

    }

CHuiCanvasGraphicImage::CHuiCanvasGraphicImage() :

    iBitmapHandle(0),

    iMaskHandle(0),

    iBitmap(NULL),

    iMask(NULL),

    iInvertedMask(EFalse),

    iMaskOriginPoint(TPoint(0,0)),

    iBitmapTouchCount(-1),

    iMaskTouchCount(-1),

    iImageSize(TSize(0,0))        

        {

        }

void CHuiCanvasGraphicImage::CopyAttributes(CHuiCanvasGraphicImage& aSrc)

    {

    CHuiCanvasImage::CopyAttributes(aSrc);

    iBitmap = aSrc.iBitmap;

    iMask = aSrc.iMask;        

    iBitmapHandle = aSrc.iBitmapHandle;

    iMaskHandle = aSrc.iMaskHandle;

    iInvertedMask = aSrc.iInvertedMask;

    iMaskOriginPoint = aSrc.iMaskOriginPoint;

    iTexture = aSrc.iTexture;

    iBitmapTouchCount = aSrc.iBitmapTouchCount;

    iMaskTouchCount = aSrc.iMaskTouchCount;

    iImageSize = aSrc.iImageSize;        

    iSubImages.Reset();

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

        {

        iSubImages.Append(aSrc.iSubImages[i]);    

        }               

    }

void CHuiCanvasGraphicImage::Reset()

    {

    // Reset does not delete owned items !        

    CHuiCanvasImage::Reset();                

    iBitmap = NULL;

    iMask = NULL;        

    iSubImages.Reset();        

    iBitmapHandle = 0;

    iMaskHandle = 0;

    iInvertedMask = EFalse;

    iMaskOriginPoint = TPoint(0,0);

    iTexture = NULL;

    iBitmapTouchCount = -1;

    iMaskTouchCount = -1;

    iImageSize = TSize(0,0);        

    };

CHuiCanvasGraphicImage::~CHuiCanvasGraphicImage()

    {

    delete iBitmap;

    delete iMask;

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

        {

        delete iSubImages[i].iBitmap;    

        delete iSubImages[i].iMask;    

        }

    iSubImages.Close();

    }

CHuiCanvasTextImage::CHuiCanvasTextImage() :

    iText(NULL),

    iFindTextPtr(NULL),

    iFontHandle(0),

    iRasterizationOffset(TPoint(0,0)),

    iTextBoxMaxSize(TSize(KMinTInt,KMinTInt)),

    iTextWidth(KMinTInt),

    iBaseLineOffset(KMinTInt),

    iTextAlign(CGraphicsContext::ELeft),

    iMargin(0),

    iAngle(0),

    iUseColorModulation(EFalse),

    iFont(NULL)                

        {

        }

void CHuiCanvasTextImage::CopyAttributes(CHuiCanvasTextImage& aSrc)

    {

    CHuiCanvasImage::CopyAttributes(aSrc);

    iText = aSrc.iText;

    iFindTextPtr = aSrc.iFindTextPtr;

    iFontHandle = aSrc.iFontHandle;

    iRasterizationOffset = aSrc.iRasterizationOffset;

    iTextBoxMaxSize = aSrc.iTextBoxMaxSize;

    iTextWidth = aSrc.iTextWidth;

    iBaseLineOffset = aSrc.iBaseLineOffset;

    iTextAlign = aSrc.iTextAlign;

    iMargin = aSrc.iMargin;

    iAngle = aSrc.iAngle;

    iUseColorModulation = aSrc.iUseColorModulation;            

    iTextParams = aSrc.iTextParams;

    iFont = aSrc.iFont;

    }

void CHuiCanvasTextImage::Reset()

    {

    // Reset does not delete owned items !

    CHuiCanvasImage::Reset();        

    iText = NULL;

    iFindTextPtr = NULL;

    iFontHandle = 0,

    iRasterizationOffset = TPoint(0,0);

    iTextBoxMaxSize = TSize(KMinTInt,KMinTInt);

    iTextWidth = KMinTInt;

    iBaseLineOffset = KMinTInt;

    iTextAlign = CGraphicsContext::ELeft;

    iMargin = 0;

    iAngle = 0;

    iUseColorModulation = EFalse;            

    iFont = NULL;

    }

CHuiCanvasTextImage::~CHuiCanvasTextImage()

    {

    delete iText;

    iText = NULL;

    }

TBool CHuiCanvasTextImage::UseColorModulation() const

    {

    return iUseColorModulation; 

    }

NONSHARABLE_CLASS( CHuiCanvasRenderBufferImage ) : public CHuiCanvasImage

    {

public:

    CHuiCanvasRenderBufferImage();

    ~CHuiCanvasRenderBufferImage();

    virtual void CopyAttributes(CHuiCanvasRenderBufferImage& aSrc);

    virtual void Reset();

public:

    CHuiCanvasRenderBuffer* iCanvasRenderBuffer;

    TAny* iOwner;

    };

CHuiCanvasRenderBufferImage::CHuiCanvasRenderBufferImage() :

    iCanvasRenderBuffer(NULL),

    iOwner(NULL)

        {

        }

void CHuiCanvasRenderBufferImage::CopyAttributes(CHuiCanvasRenderBufferImage& aSrc)

    {

    CHuiCanvasImage::CopyAttributes(aSrc);

    iCanvasRenderBuffer= aSrc.iCanvasRenderBuffer;

    iOwner = aSrc.iOwner;

    }

void CHuiCanvasRenderBufferImage::Reset()

    {

    // Reset does not delete owned items !

    CHuiCanvasImage::Reset();        

    iCanvasRenderBuffer = NULL;

    iOwner = NULL;

    }

CHuiCanvasRenderBufferImage::~CHuiCanvasRenderBufferImage()

    {

    delete iCanvasRenderBuffer;

    }

NONSHARABLE_CLASS( CHuiCanvasImageRasterizer ) : public CBase

    {

public:

    CHuiCanvasImageRasterizer();

    ~CHuiCanvasImageRasterizer();

    void ConstructL(TDisplayMode aPreferredMode = ENone);

    TBool IsSeparateTextMaskUsed();

    static CFbsBitmap* CreateMovedMaskL(CFbsBitmap& aOriginalMask, TPoint aNewTopLeftCorner);

    static CFbsBitmap* CreateInvertedMaskL(CFbsBitmap& aOriginalMask);

protected:

    CFbsBitmap* iTempMask;

    CFbsBitmapDevice* iTempMaskDevice;

    CFbsBitGc*  iTempMaskGc;

    CFbsBitmap* iTempBitmap;

    CFbsBitmapDevice* iTempBitmapDevice;

    CFbsBitGc*  iTempBitmapGc;    

    };

CHuiCanvasImageRasterizer::CHuiCanvasImageRasterizer()

    {    

    }

CHuiCanvasImageRasterizer::~CHuiCanvasImageRasterizer()

    {

    delete iTempMaskGc;

    delete iTempMaskDevice;

    delete iTempMask;

    delete iTempBitmapGc;

    delete iTempBitmapDevice;

    delete iTempBitmap; 

    }

void CHuiCanvasImageRasterizer::ConstructL(TDisplayMode aPreferredMode)

    {

    iTempMask = NULL;

    iTempMaskDevice = NULL;

    iTempMaskGc = NULL;

    iTempBitmap = NULL;

    iTempBitmapDevice = NULL;

    iTempBitmapGc = NULL;

    // Select fastest color mode for uploading rasterized texts, we assume that EColor16MA 

    // should be best for HW accelrated rendereres (requiring least amount of conversions

    // needed before uploading to texture memory) and EColor64K is good for

    // bitgdi because its backbuffer is in that format.

    //

    // NOTE: EHuiRendererGles10 and EHuiRendererGles11 temporarely use EColor64K

    // beacuse it looks as there are some problems with uploading 16MA 

    // mode bitmaps into multisegmented textures.

    //

    TDisplayMode colorMode = EColor16MA;

    if (aPreferredMode == EGray256 && 

        CHuiStatic::Env().Renderer() == EHuiRendererVg10)

        {

        colorMode = EGray256;

        }

    else if (aPreferredMode == EColor64K)

        {

        colorMode = EColor64K;

        }

    else if (CHuiStatic::Env().Renderer() == EHuiRendererBitgdi || 

        CHuiStatic::Env().Renderer() == EHuiRendererGles10 || 

        CHuiStatic::Env().Renderer() == EHuiRendererGles11)

        {

        colorMode = EColor64K;           

        }

    iTempBitmap = new (ELeave) CFbsBitmap;

    iTempBitmap->Create(TSize(4,4), colorMode);       

    iTempBitmapDevice = CFbsBitmapDevice::NewL(iTempBitmap);

    User::LeaveIfError(iTempBitmapDevice->CreateContext(iTempBitmapGc));             

    if (colorMode != EGray256)

        {

        iTempMask = new (ELeave) CFbsBitmap;

        iTempMask->Create(TSize(4,4), EGray256);       

        iTempMaskDevice = CFbsBitmapDevice::NewL(iTempMask);

        User::LeaveIfError(iTempMaskDevice->CreateContext(iTempMaskGc));                 

        }

    }

TBool CHuiCanvasImageRasterizer::IsSeparateTextMaskUsed()

    {

    if (iTempBitmap && 

        iTempBitmap->DisplayMode() != EColor16MA && 

        iTempBitmap->DisplayMode() != EColor16MAP &&

        iTempBitmap->DisplayMode() != EGray256)

        {

        return ETrue;    

        }

    else

        {

        return EFalse;    

        }            

    }

CFbsBitmap* CHuiCanvasImageRasterizer::CreateInvertedMaskL(CFbsBitmap& aOriginalMask)

    {

    TSize size = aOriginalMask.SizeInPixels();

    CFbsBitmap* newMask = new(ELeave)CFbsBitmap;                       

    CleanupStack::PushL(newMask);

    CFbsBitmap* bitmap = new(ELeave)CFbsBitmap;                       

    CleanupStack::PushL(bitmap);

    newMask->Create(size, aOriginalMask.DisplayMode());       

    bitmap->Create(size, aOriginalMask.DisplayMode());       

    CFbsDevice* newMaskdevice = NULL;

    CFbsBitGc* newMaskGc = NULL;

    CFbsDevice* bitmapDevice = NULL;

    CFbsBitGc* bitmapGc = NULL;

    newMaskdevice = CFbsBitmapDevice::NewL(newMask);

    CleanupStack::PushL(newMaskdevice);

    User::LeaveIfError(newMaskdevice->CreateContext(newMaskGc));

    bitmapDevice = CFbsBitmapDevice::NewL(bitmap);

    CleanupStack::PushL(bitmapDevice);

    User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc));

    bitmapGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    bitmapGc->SetPenStyle(CGraphicsContext::ESolidPen);

    bitmapGc->SetPenColor(KRgbBlack);

    bitmapGc->SetBrushColor(KRgbBlack);

    bitmapGc->DrawRect(TRect(TPoint(0,0), size));

    newMaskGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    newMaskGc->SetPenStyle(CGraphicsContext::ESolidPen);

    newMaskGc->SetPenColor(KRgbWhite);

    newMaskGc->SetBrushColor(KRgbWhite);

    newMaskGc->DrawRect(TRect(TPoint(0,0), size));

    newMaskGc->BitBltMasked(TPoint(0,0), bitmap, TRect(TPoint(0,0), size), &aOriginalMask, EFalse);

    delete bitmapGc;

    delete newMaskGc;

    CleanupStack::PopAndDestroy(bitmapDevice);

    CleanupStack::PopAndDestroy(newMaskdevice);

    CleanupStack::PopAndDestroy(bitmap);

    CleanupStack::Pop(newMask);

    return newMask;

    }

CFbsBitmap* CHuiCanvasImageRasterizer::CreateMovedMaskL(CFbsBitmap& aOriginalMask, TPoint aNewTopLeftCorner)

    {

    TSize size = aOriginalMask.SizeInPixels();

    CFbsBitmap* newMask = new(ELeave)CFbsBitmap;                       

    CleanupStack::PushL(newMask);

    newMask->Create(size, aOriginalMask.DisplayMode());       

    CFbsDevice* newMaskdevice = NULL;

    CFbsBitGc* newMaskGc = NULL;

    newMaskdevice = CFbsBitmapDevice::NewL(newMask);

    CleanupStack::PushL(newMaskdevice);

    User::LeaveIfError(newMaskdevice->CreateContext(newMaskGc));

    newMaskGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    newMaskGc->SetPenStyle(CGraphicsContext::ESolidPen);

    newMaskGc->SetPenColor(KRgbWhite);

    newMaskGc->SetBrushColor(KRgbWhite);

    newMaskGc->DrawRect(TRect(TPoint(0,0), size));

    newMaskGc->BitBlt(TPoint(0,0), &aOriginalMask, TRect(aNewTopLeftCorner, size));

    newMaskGc->BitBlt(aNewTopLeftCorner, &aOriginalMask, TRect(TPoint(0,0), size));

    delete newMaskGc;    

    CleanupStack::PopAndDestroy(newMaskdevice);

    CleanupStack::Pop(newMask);