/*

* 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 CHuiCanvasWsSwGc.

*

*/

#include "huicanvaswsswgc.h"

#include "uiacceltk/HuiCanvasVisual.h"

#include <graphics/wsgraphicscontext.h>

#include <e32cmn.h>

#include <AknLayoutFont.h>

#include <gdi.h>

CHuiCanvasWsSwGc* CHuiCanvasWsSwGc::NewL()

	{

	CHuiCanvasWsSwGc* self    = new ( ELeave ) CHuiCanvasWsSwGc;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CHuiCanvasWsSwGc::CHuiCanvasWsSwGc()

    {

    }

void CHuiCanvasWsSwGc::ConstructL()

	{

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

	// There is no need to do clipping at canvas gc so lets disable it

	iCanvasGc->SetClippingMode(EHuiCanvasClipModeNone);

	}

CHuiCanvasWsSwGc::~CHuiCanvasWsSwGc()

    {

    iTempRegion.Close();

    iWsClipRegion.Close();

    iDefaultClipRegion.Close();

    delete iCanvasGc;

    iCanvasGc = NULL;

    delete iBitBitmap;

    iBitBitmap = NULL;

	delete iBitDevice;

	iBitDevice = NULL;

	delete iBitGc;

	iBitGc = NULL;

    delete iCapturingBitGc;

    iCapturingBitGc = NULL;

    delete iCapturingBitBitmap;

    iCapturingBitBitmap = NULL;

    delete iCapturingBitDevice;

    iCapturingBitDevice = NULL;

    }

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

	{

	iIsReallyDirty = ETrue;

	if (!IsRenderingEnabled())

	    {

	    return;

	    }

    TPoint point = AdjustCoordinates(aPoint);	

    // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

	TInt error = bitmap->Duplicate(aBitmapHandle);

	if ( error == KErrNone  )

	    {

	    iBitGc->BitBlt(point,bitmap);

	    }

	    CleanupStack::PopAndDestroy();

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

	TPoint point = AdjustCoordinates(aPoint);	

    // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

	TInt error = bitmap->Duplicate(aBitmapHandle);

	if ( error == KErrNone  )

        {

        iBitGc->BitBlt(point,bitmap,aRect);

        }

        CleanupStack::PopAndDestroy();

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

	TPoint point = AdjustCoordinates(aPoint);	

    // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    TInt error = bitmap->Duplicate(aBitmapHandle);

	if (error == KErrNone)

	    {

	    CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;

	    CleanupStack::PushL(bitmapMask);

	    error = bitmapMask->Duplicate(aMaskHandle);

	    if (error == KErrNone)

	        {

	        iBitGc->BitBltMasked(point,bitmap,aRect,bitmapMask,aInvertMask);

	        }

	    CleanupStack::PopAndDestroy(2);

	    }

	else

        {

        CleanupStack::PopAndDestroy();

        }

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

	TPoint point1 = AdjustCoordinates(aPoint1);	

     // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    TInt error = bitmap->Duplicate(aBitmapHandle);

    if (error == KErrNone)

        {

        CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;

        CleanupStack::PushL(bitmapMask);

        error = bitmapMask->Duplicate(aMaskHandle);

        if (error == KErrNone)

            {

            if (aPoint2 != TPoint(0,0))

                {

                CFbsBitmap* movedMask = CreateMovedMaskL(*bitmapMask, aPoint2);

                iBitGc->BitBltMasked(point1,bitmap,aRect, movedMask ,ETrue);    

                delete movedMask;    

                }

            else

                {

                iBitGc->BitBltMasked(point1,bitmap,aRect, bitmapMask ,ETrue);            

                }        

            }

        CleanupStack::PopAndDestroy(2);

        }

    else

        {

        CleanupStack::PopAndDestroy();

        }    

	}

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

    {

    if (!IsRenderingEnabled())

        {

        return;

        }

    TRect adjustedDestinationRect(aDestinationRect);

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

        {

      	CFbsBitmap* bitmap = NULL;

    	CFbsBitmap* bitmapMask = NULL;

      	TPoint point = aBlits[i].iCombinedBitmapPoint;

      	TPoint adjustedPoint =AdjustCoordinates(point);

        if (aBlits[i].iBitmapHandle)

            {

        	bitmap = new (ELeave) CFbsBitmap;

            CleanupStack::PushL(bitmap);

            bitmap->Duplicate(aBlits[i].iBitmapHandle);                                        

            }

        if (aBlits[i].iMaskHandle)

            {

    	    bitmapMask = new (ELeave) CFbsBitmap;

            CleanupStack::PushL(bitmapMask);

            bitmapMask->Duplicate(aBlits[i].iMaskHandle);                

            }        

        TRect sourceRect = TRect(TPoint(0,0), bitmap->SizeInPixels());

        if (bitmapMask)

            {

            TBool invertMask = (bitmapMask->DisplayMode() == EGray256);                       

            iBitGc->BitBltMasked(adjustedPoint, bitmap, sourceRect, bitmapMask, invertMask);                       

            }

        else

            {

            iBitGc->BitBlt(adjustedPoint, bitmap);                                           

            }                                                    

        if (bitmapMask)

            {

            CleanupStack::PopAndDestroy(bitmapMask);    

            bitmapMask = NULL;

            }

        if (bitmap)

            {

            CleanupStack::PopAndDestroy(bitmap);                    

            bitmap = NULL;

            }        

        }

    }

void CHuiCanvasWsSwGc::WsResetClippingRegionL()

	{

    if (!IsRenderingEnabled())

        {

        return;

        }

    // Reset clip region in our own region

    iWsClipRegion.Clear();

	// Reset clip region in iBitGc to default one

    if (iDefaultClipRegion.Count())

        {

        iBitGc->SetClippingRegion(iDefaultClipRegion);

        }

    else

        {

        iBitGc->CancelClippingRegion();

        }

	}

void CHuiCanvasWsSwGc::WsClearL()

	{		

	iIsReallyDirty = ETrue;

	if (!IsRenderingEnabled())

        {

        return;

        }

   	iBitGc->Clear();

	}

void CHuiCanvasWsSwGc::WsClearRectL(TRect& aRect)

	{		

	iIsReallyDirty = ETrue;

	if (!IsRenderingEnabled())

        {

        return;

        }

    iBitGc->Clear(AdjustCoordinates(aRect));

	}

void CHuiCanvasWsSwGc::WsResetBrushPatternL()

	{

    if (!IsRenderingEnabled())

        {

        return;

        }

    iBitGc->DiscardBrushPattern();

	}

void CHuiCanvasWsSwGc::WsResetFontL()

	{

    if (!IsRenderingEnabled())

        {

        return;

        }

	iBitGc->DiscardFont();

	}

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

	{

	iIsReallyDirty = ETrue;

	if (!IsRenderingEnabled())

        {

        return;

        }

	TPoint point1 = AdjustCoordinates(aPoint1);

	TPoint point2 = AdjustCoordinates(aPoint2);

	TRect rect = AdjustCoordinates(aRect);

	iBitGc->DrawArc(rect,point1,point2);

	}

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

	{

	iIsReallyDirty = ETrue;

	if (!IsRenderingEnabled())

        {

        return;

        }

	TPoint point1 = AdjustCoordinates(aPoint1);

	TPoint point2 = AdjustCoordinates(aPoint2);

	TRect rect = AdjustCoordinates( aRect );

	iBitGc->DrawPie(rect,point1,point2);

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

    // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

	TInt error = bitmap->Duplicate(aBitmapHandle);

	if ( error == KErrNone )

	    {

	    iBitGc->DrawBitmap(AdjustCoordinates(aRect),bitmap);

	    }

	CleanupStack::PopAndDestroy();

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

     // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

	TInt error = bitmap->Duplicate(aBitmapHandle);

	if ( error == KErrNone )

	    {

	    iBitGc->DrawBitmap(AdjustCoordinates(aRect1),bitmap,aRect2);

	    }

	CleanupStack::PopAndDestroy();   

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

	TPoint point = AdjustCoordinates(aPoint);

    // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

	TInt error = bitmap->Duplicate(aBitmapHandle);

	if ( error == KErrNone )

	    {

	    iBitGc->DrawBitmap(point,bitmap);

	    }

	CleanupStack::PopAndDestroy();

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

    // Draw            

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    TInt error = bitmap->Duplicate(aBitmapHandle);

    if ( error == KErrNone )

        {

        // Draw            

        CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;

        CleanupStack::PushL(bitmapMask);

        error = bitmapMask->Duplicate(aMaskHandle);

        if ( error == KErrNone )

            {

            iBitGc->DrawBitmapMasked(AdjustCoordinates(aRect1),bitmap,aRect2,bitmapMask,aInvertMask);    

            }

        CleanupStack::PopAndDestroy(2);

        }

    else

        {

        CleanupStack::PopAndDestroy();

        }

	}

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

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

    iBitGc->DrawRoundRect(AdjustCoordinates(aRect),TSize(aPoint.iX,aPoint.iY));

	}

void CHuiCanvasWsSwGc::WsDrawPolyLineL(CArrayFix<TPoint>* aPointerArray)

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

	if(aPointerArray)

		{

		for(int i=0; i<aPointerArray->Count();i++)

			{

			aPointerArray->At(i) = AdjustCoordinates(aPointerArray->At(i));

			}

		iBitGc->DrawPolyLine(aPointerArray);

		}

	}

void CHuiCanvasWsSwGc::WsDrawPolyLineNoEndPointL(TPoint* aPointerArray, TInt aCount)

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

	if ( aPointerArray )

        {

        for(int i=0; i<aCount;i++)

			{

			aPointerArray[i] = AdjustCoordinates(aPointerArray[i]);

			}

		iBitGc->DrawPolyLineNoEndPoint(aPointerArray,aCount);

        } 

    }

void CHuiCanvasWsSwGc::WsDrawPolygonL(CArrayFix<TPoint>* aPointerArray, TInt aFillRule)

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }

	if ( aPointerArray )

        {

        for(int i=0; i<aPointerArray->Count();i++)

        	{

        	aPointerArray->At(i) = AdjustCoordinates(aPointerArray->At(i));	

        	}

        iBitGc->DrawPolygon( aPointerArray,(CFbsBitGc ::TFillRule)aFillRule );	

        }

	}	

void CHuiCanvasWsSwGc::WsDrawEllipseL(TRect& aRect)

	{

	iIsReallyDirty = ETrue;

    if (!IsRenderingEnabled())

        {

        return;

        }