/*

* 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:   Definition of CHuiCanvasWsHwGc.

*

*/

#include "huicanvaswshwgc.h"

#include "uiacceltk/HuiCanvasVisual.h"

#include "HuiRenderPlugin.h"

#include "uiacceltk/HuiGc.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiStatic.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiVisual.h"

#include "uiacceltk/HuiTextMesh.h"

#include "uiacceltk/HuiCanvasCmdBufferReader.h"

#include "huicanvasgc.h"

#include "HuiRenderSurface.h"

#include "huicanvastexturecache.h"

#include "huicanvasbackground.h"

#include <graphics/wsgraphicscontext.h>

#include <e32cmn.h>

#include <AknLayoutFont.h>

#include <graphics/lookuptable.h>

//#define HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

CHuiCanvasWsHwGc* CHuiCanvasWsHwGc::NewL()

	{

	CHuiCanvasWsHwGc* self    = new ( ELeave ) CHuiCanvasWsHwGc;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

void CHuiCanvasWsHwGc::AdjustCoordinates(TPoint& aPoint, TBool aUseWsOrigin )

    {

    aPoint +=  iPosDelta;

    if ( aUseWsOrigin ) 

        {

        aPoint += iWsOrigin;

        }

    }

void CHuiCanvasWsHwGc::AdjustCoordinates(TRect& aRect, TBool aUseWsOrigin )

    {

    aRect.Move( iPosDelta );

    if ( aUseWsOrigin )

        {

        aRect.Move( iWsOrigin );

        }

    }

void CHuiCanvasWsHwGc::DrawTextBrush( THuiRealRect& aRect )

    {

    if( iWsBrushStyle == CGraphicsContext::ESolidBrush )

        {

        TRgb oldPenColor = iCanvasGc->PenColor();

        TReal32 oldOpacity = iCanvasGc->Opacity();

        THuiFillMode oldFillMode = iCanvasGc->PolygonDrawMode();

        iCanvasGc->SetPenColor(iWsBrushColor);

        iCanvasGc->SetOpacity(TReal32(iWsBrushColor.Alpha() / 255.f));   

        iCanvasGc->SetPolygonDrawMode(EHuiFillEvenOdd);

        RArray<THuiRealRect> rects;

        rects.Append(aRect);

        iCanvasGc->DrawRects(rects);

        rects.Close();

        iCanvasGc->SetPolygonDrawMode(oldFillMode);

        iCanvasGc->SetOpacity(oldOpacity);

        iCanvasGc->SetPenColor(oldPenColor);

        }

    }

CHuiCanvasWsHwGc::CHuiCanvasWsHwGc()

    {

    }

void CHuiCanvasWsHwGc::ConstructL()

	{

    iCanvasGc = CHuiStatic::Renderer().CreateCanvasGcL();

	// Set delayed clipping mode, this is supposed to reduce unnecessary

	// clipping which may cause bad performance on hw renderers 

	iCanvasGc->SetClippingMode(EHuiCanvasClipModeDelayed);

	WsResetL();

#ifdef __WINS__	

	iPushCount = 0;

#endif

	}

CHuiCanvasWsHwGc::~CHuiCanvasWsHwGc()

    {

    if (iVisual)

        {

        iVisual->Env().CanvasTextureCache().ReleaseCachedRenderBuffer(*iVisual);

        }

    iTempRegion.Close();

    iWsClipRegion.Close();

    delete iCanvasGc;

    iCanvasGc = NULL;

    }

void CHuiCanvasWsHwGc::WsBitBltL(TInt aBitmapHandle, TPoint aPoint)

	{

	THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aPoint );

            THuiRealRect destinationRect = TRect(aPoint, texture->Size());          

            THuiCanvasDrawMode oldDrawMode = iCanvasGc->DrawMode();

            iCanvasGc->SetDrawMode(SelectCanvasDrawMode(iWsDrawMode));        

            // Draw            

            iCanvasGc->DrawImage(*texture, destinationRect, TRect(TPoint(0,0), texture->Size()), CHuiGc::EStretchNone);

            iCanvasGc->SetDrawMode(oldDrawMode);

            }

        }

	}

void CHuiCanvasWsHwGc::WsBitBltRectL(TInt aBitmapHandle, TPoint aPoint, TRect aRect)

	{

	THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aPoint );

            THuiRealRect destinationRect = TRect(aPoint, texture->Size());                

            THuiCanvasDrawMode oldDrawMode = iCanvasGc->DrawMode();

            iCanvasGc->SetDrawMode(SelectCanvasDrawMode(iWsDrawMode));        

            // Draw            

            iCanvasGc->DrawImage(*texture, destinationRect, aRect, CHuiGc::EStretchNone);

            iCanvasGc->SetDrawMode(oldDrawMode);

            }        

        }

	}

void CHuiCanvasWsHwGc::WsBitBltMaskedL(TInt aBitmapHandle, TInt aMaskHandle, TInt aInvertMask, TPoint aPoint, TRect aRect)

	{

	THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iMaskHandle = aMaskHandle;

    cachedImageParams.iInvertedMask = aInvertMask;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aPoint );

            THuiRealRect destinationRect = TRect(aPoint, texture->Size());                

            // Draw            

            iCanvasGc->DrawImage(*texture, destinationRect, aRect, CHuiGc::EStretchNone);

            }

        }

	}

void CHuiCanvasWsHwGc::WsCombinedBitBltMaskedL(TRect aDestinationRect, const RArray<THuiCachedCombinedImageParams>& aBlits )

	{

	THuiCachedCombinedImageParams cachedCombinedImageParams;	    

    THuiCachedGcParams gcParams = CachedGcParams();          

    TSize imageSize = aDestinationRect.Size();

    // Must convert points relative to the image itself

    RArray<THuiCachedCombinedImageParams> convertedBlits;

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

        {

        THuiCachedCombinedImageParams convertedParams;

        convertedParams = aBlits[i];

        convertedParams.iCombinedBitmapPoint -= aDestinationRect.iTl;

        convertedBlits.Append(convertedParams);

        }    

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCombinedCachedImageL(

        convertedBlits, 

        gcParams,

        imageSize, 

        *iVisual);

    convertedBlits.Close();

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();        

        if (texture)

            {

            TPoint point = aDestinationRect.iTl;

            AdjustCoordinates( point );

            THuiRealRect destinationRect = TRect(point, texture->Size());                        

            // Draw            

            iCanvasGc->DrawImage(*texture, destinationRect, TRect(TPoint(0,0), texture->Size()),  CHuiGc::EStretchNone);

            }

        }

	}

void CHuiCanvasWsHwGc::WsBitBltMaskedPointL(TInt aBitmapHandle, TInt aMaskHandle, TPoint aPoint1, TPoint aPoint2, TRect aRect)

	{

	THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iMaskHandle = aMaskHandle;

    cachedImageParams.iMaskOriginPoint = aPoint2;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aPoint1 );

            THuiRealRect destinationRect = TRect(aPoint1, texture->Size());                

            // Draw            

            iCanvasGc->DrawImage(*texture, destinationRect, aRect, CHuiGc::EStretchNone);

            }             

        }

	}

void CHuiCanvasWsHwGc::WsResetClippingRegionL()

	{

    if (IsRenderingEnabled())

        {

        // Reset clip region

        iWsClipRegion.Clear();

        iCanvasGc->CancelClipping();

        }

	}

void CHuiCanvasWsHwGc::WsClearL()

	{		

    if (IsRenderingEnabled())

        {

        THuiRealRect rect(iVisual->DisplayRect());     

        DoWsClearRectL(rect);

        }

	}

void CHuiCanvasWsHwGc::WsClearRectL(TRect& aRect)

	{		

    if (IsRenderingEnabled())

        {

        AdjustCoordinates( aRect );

        DoWsClearRectL(aRect);

        }

	}

void CHuiCanvasWsHwGc::DoWsClearRectL(const THuiRealRect& aRect )

	{

    if (IsRenderingEnabled())

        {

        RArray<THuiRealRect> rects;

        rects.Append(aRect);

        // Store current gc params

        UseWsState();

        CHuiTexture* oldPolygonFillTexture = iCanvasGc->PolygonFillTexture(); 

        // Clear

        iCanvasGc->SetPolygonFillTexture(NULL);

        iCanvasGc->SetPolygonDrawMode(EHuiFillNonZero);

        iCanvasGc->SetPenWidth(1);           	  	        

        iCanvasGc->SetPenColor(iWsBrushColor);            

        iCanvasGc->SetOpacity(TReal32(iWsBrushColor.Alpha() / 255.f));   

        iCanvasGc->SetDrawMode(SelectCanvasDrawMode(iWsDrawMode));        

        iCanvasGc->DrawRects(rects);

        // Restore gc params etc.

        rects.Close();

        UseCanvasState();

        iCanvasGc->SetPolygonFillTexture(oldPolygonFillTexture);

        }

    }

void CHuiCanvasWsHwGc::WsResetBrushPatternL()

	{

	iWsBrushPattern = 0;

	}

void CHuiCanvasWsHwGc::WsResetFontL()

	{

    iWsCurrentFont = 0;

	}

void CHuiCanvasWsHwGc::WsDrawArcL(TPoint aPoint1, TPoint aPoint2, TRect aRect)

	{

	// If penstyle is ENullPen, then nothign is drawn

    if (!iWsPenStyle)

        {

        return;    

        }

    if (IsRenderingEnabled())

        {

        UseWsState();        

        AdjustCoordinates( aRect );

        AdjustCoordinates( aPoint1 );

        AdjustCoordinates( aPoint2 );

        iCanvasGc->DrawArc( THuiRealRect(aRect), THuiRealPoint(aPoint1), THuiRealPoint(aPoint2) );

        UseCanvasState();

        }

    }

void CHuiCanvasWsHwGc::WsDrawPieL(TPoint aPoint1, TPoint aPoint2, TRect aRect)

	{

	// If penstyle is ENullPen, then nothign is drawn

    if (!iWsPenStyle && !iWsBrushStyle)

        {

        return;    

        }

    if (IsRenderingEnabled())

        {    

        UseWsState();

        AdjustCoordinates( aRect );

        AdjustCoordinates( aPoint1 );

        AdjustCoordinates( aPoint2 );

        if (iWsBrushStyle == MWsGraphicsContext::ENullBrush)

            {

            iCanvasGc->SetPolygonDrawMode( EHuiNoFill );

            iCanvasGc->SetPenColor(iWsPenColor);            

            iCanvasGc->SetOpacity(TReal32(iWsPenColor.Alpha() / 255.f));       

            iCanvasGc->DrawPie(THuiRealRect(aRect),THuiRealPoint(aPoint1),THuiRealPoint(aPoint2));  

            }    

        else if (iWsBrushStyle == MWsGraphicsContext::ESolidBrush)

            {

            iCanvasGc->SetPolygonDrawMode( EHuiFillEvenOdd );

            iCanvasGc->SetPenColor(iWsBrushColor);            

            iCanvasGc->SetOpacity(TReal32(iWsBrushColor.Alpha() / 255.f));            

            iCanvasGc->DrawPie(THuiRealRect(aRect),THuiRealPoint(aPoint1),THuiRealPoint(aPoint2));  

            // Border should be drawn if pencolor is different than solid fill

            if (IsDifferent(iWsBrushColor, iWsPenColor, ETrue) && iWsPenStyle && iWsPenSize.iHeight >= 1 && iWsPenSize.iWidth >= 1)

                {

                iCanvasGc->SetPolygonDrawMode( EHuiNoFill );

                iCanvasGc->SetPenColor(iWsPenColor);                    

                iCanvasGc->SetOpacity(TReal32(iWsPenColor.Alpha() / 255.f));       

                iCanvasGc->DrawPie(THuiRealRect(aRect),THuiRealPoint(aPoint1),THuiRealPoint(aPoint2));  

                }            

            }

        else if (iWsBrushStyle == MWsGraphicsContext::EPatternedBrush)

            {

            iCanvasGc->SetPolygonDrawMode( EHuiFillEvenOdd );

            iCanvasGc->SetPenColor(iWsPenColor);                    

            iCanvasGc->SetOpacity(TReal32(iWsPenColor.Alpha() / 255.f));       

            UseBrushPattern();

            iCanvasGc->SetDrawMode(SelectCanvasDrawMode(iWsDrawMode));        

            iCanvasGc->DrawPie(THuiRealRect(aRect),THuiRealPoint(aPoint1),THuiRealPoint(aPoint2));  

            DiscardBrushPattern();

            if (iWsPenStyle && iWsPenSize.iHeight >= 1 && iWsPenSize.iWidth >= 1)

                {

                iCanvasGc->SetPolygonDrawMode( EHuiNoFill );

                iCanvasGc->SetPenColor(iWsPenColor);                    

                iCanvasGc->SetOpacity(TReal32(iWsPenColor.Alpha() / 255.f));       

                iCanvasGc->DrawPie(THuiRealRect(aRect),THuiRealPoint(aPoint1),THuiRealPoint(aPoint2));  

                }

            }

        else

            {

            // We should never get here because fallbackmode should be used in this case !

            RDebug::Print(_L("CHuiCanvasWsHwGc::WsDrawPieL - Unsupported brush mode %i"), iWsBrushStyle);

            }

        UseCanvasState();

        }

	}

void CHuiCanvasWsHwGc::WsDrawBitmap1L(TInt aBitmapHandle, TRect aRect)

	{

	THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aRect );

            THuiRealRect destinationRect = aRect;                

            // Draw            

            // This should stretch !

            iCanvasGc->DrawImage(*texture, destinationRect, TRect(TPoint(0,0), texture->Size()), CHuiGc::EStretchFull); 

            }        	

        }

	}

void CHuiCanvasWsHwGc::WsDrawBitmap2L(TInt aBitmapHandle, TRect aRect1, TRect aRect2)

	{

	THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aRect1 );

            THuiRealRect destinationRect = aRect1;                

            // Draw            

            iCanvasGc->DrawImage(*texture, destinationRect, aRect2, CHuiGc::EStretchFull); 

            }        

        }

	}

void CHuiCanvasWsHwGc::WsDrawBitmap3L(TInt aBitmapHandle, TPoint aPoint)

	{

	 THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aPoint );

            THuiRealRect destinationRect = TRect(aPoint, texture->Size());                

            // Draw

            // TODO: Actually we should check the bitmap size in twips here are decide destinationRect based on that !            

            iCanvasGc->DrawImage(*texture, destinationRect, TRect(TPoint(0,0), texture->Size()), CHuiGc::EStretchNone);

            }        

        }

	}

void CHuiCanvasWsHwGc::WsDrawBitmapMaskedL(TInt aBitmapHandle, TInt aMaskHandle, TInt aInvertMask, TRect& aRect1, TRect& aRect2)

	{

    THuiCachedImageParams cachedImageParams;

    cachedImageParams.iBitmapHandle = aBitmapHandle;

    cachedImageParams.iMaskHandle = aMaskHandle;

    cachedImageParams.iInvertedMask = aInvertMask;

    cachedImageParams.iGcParams = CachedGcParams();

    const CHuiCanvasGraphicImage* cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams,*iVisual);

    if (IsRenderingEnabled())

        {           

        const CHuiTexture* texture = cachedImage->Texture();

        if (texture)

            {

            AdjustCoordinates( aRect1 );

            THuiRealRect destinationRect = aRect1;              

            // Draw            

            iCanvasGc->DrawImage(*texture, destinationRect, aRect2, CHuiGc::EStretchFull);

            }        

        }

	}

void CHuiCanvasWsHwGc::WsDrawRoundRectL(TPoint aPoint, TRect& aRect)

	{

	// If penstyle is ENullPen, then nothign is drawn

    if (!iWsPenStyle && !iWsBrushStyle)

        {

        return;    

        }

    if (IsRenderingEnabled())

        {