/*

* Copyright (c) 2007 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:   Graphics context

*

*/

#include <alf/alfgc.h>

#include <alf/alfenv.h>

#include <alf/alftexture.h>

#include <alf/alftimedvalue.h>

#include <alf/alftextstyle.h>

#include <alf/alfrealline.h>

#include "alflogger.h"

//#include <uiacceltk/huicanvasconstants.h>

enum TAlfCanvasCommands

    {

    EAlfCanvasDrawImage,

    EAlfCanvasDrawText,

    EAlfCanvasDrawLines,

	EAlfCanvasDrawEllipse,

	EAlfCanvasDrawPoints,

	EAlfCanvasDrawPolygon,

	EAlfCanvasDrawRects,

	// Setters

    EAlfCanvasSetTextStyle,

	EAlfCanvasSetPenColor,

	EAlfCanvasSetPenWidth,

	EAlfCanvasSetOpacity,

	EAlfCanvasSetPolygonDrawMode,

	EAlfCanvasSetTextAlign,

    // Transformations

	EAlfCanvasLoadIdentity,

	EAlfCanvasTranslate,

	EAlfCanvasScale,

	EAlfCanvasRotate,

	EAlfCanvasPrepareDrawText

    };

NONSHARABLE_STRUCT( TAlfCanvasEndDrawParams )

    {

    TInt    iDummy1;

    TInt    iDummy2;

    TInt    iDummy3;

    TInt    iDummy4;

    };

NONSHARABLE_STRUCT( TAlfCanvasDrawImageParams )

    {

    TInt    iTexture;

    TReal32 iDestinationRectTopLeftX;

    TReal32 iDestinationRectTopLeftY;

    TReal32 iDestinationRectBottomRightX;

    TReal32 iDestinationRectBottomRightY;

    };

NONSHARABLE_STRUCT( TAlfCanvasDrawTextParams )

    {

    TReal32 iDestinationRectTopLeftX;

    TReal32 iDestinationRectTopLeftY;

    TReal32 iDestinationRectBottomRightX;

    TReal32 iDestinationRectBottomRightY;

    };

NONSHARABLE_STRUCT( TAlfCanvasDrawLinesParams )

    {

    TInt iLineCount;

	RArray<TReal32> iPointCords;

	};    

NONSHARABLE_STRUCT( TAlfCanvasDrawEllipseParams )

	{

    TReal32 iDestinationRectTopLeftX;

    TReal32 iDestinationRectTopLeftY;

    TReal32 iDestinationRectBottomRightX;

    TReal32 iDestinationRectBottomRightY;

    };

	// Setters

NONSHARABLE_STRUCT( TAlfCanvasSetTextStyleParams )

    {

    TInt  iTextstyleId;

    };

NONSHARABLE_STRUCT( TAlfCanvasSetPenColorParams )

	{

    TRgb  iPenColor;

    };

NONSHARABLE_STRUCT( TAlfCanvasSetPenWidthParams )

	{

    TReal32  iPenWidth;

    };

NONSHARABLE_STRUCT( TAlfCanvasSetOpacityParams )

	{

    TReal32  iOpacity;

    };

NONSHARABLE_STRUCT( TAlfCanvasSetPolygonDrawModeParams )

	{

    TInt  iPolygonDrawMode;

    };

NONSHARABLE_STRUCT( TAlfCanvasSetTextAlignParams )

	{

    TInt  iTextAlignHorizontal;

    TInt  iTextAlignVertical;

    };

   // Transformations

NONSHARABLE_STRUCT( TAlfCanvasLoadIdentityParams )

	{

	TInt iDummy;

	};

NONSHARABLE_STRUCT( TAlfCanvasTranslateParams )

	{

	TReal32 iX; 

	TReal32 iY; 

	TReal32 iZ;

	};

NONSHARABLE_STRUCT( TAlfCanvasScaleParams )

	{

	TReal32 iX; 

	TReal32 iY; 

	TReal32 iZ;

	};

NONSHARABLE_STRUCT( TAlfCanvasRotateParams )

	{

	TReal32 iAngle;

	TReal32 iX; 

	TReal32 iY; 

	TReal32 iZ;

	};

template <class T>

HBufC8* AlfGcExternalizeL( const RArray<T>& aArray )

    {

    const TInt itemCount = aArray.Count();

    if ( !itemCount)

        {

        return HBufC8::NewL(0);

        }

    const T* firstItem = &aArray[0];    

    TPtrC8 arrayPtr( (TUint8*)firstItem, itemCount*sizeof(T) );            

    HBufC8* buffer = HBufC8::NewL( sizeof(TInt) + arrayPtr.Length() );

    TPtr8 ptr = buffer->Des();     

    ptr.Append( (const TUint8*)&itemCount, sizeof(TInt) );

    ptr.Append( arrayPtr );    

    return buffer;

    }

const TInt KAlfGcBufferGranularity = 1024;

struct CAlfGc::TAlfGcData

    {

    TAlfGcData() : iBuffer(NULL) {}

    HBufC8* iBuffer;

    };

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

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

// 

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

//

CAlfGc* CAlfGc::NewL()

    {

    CAlfGc* self = new (ELeave) CAlfGc;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAlfGc::CAlfGc()

    {

    }

void CAlfGc::ConstructL()

    {

    iData = new (ELeave) TAlfGcData;

    }

CAlfGc::~CAlfGc()

    {

    if ( iData )

        {

        delete iData->iBuffer;

        iData->iBuffer = NULL;

        }

    delete iData;

    iData = NULL;

    }

void CAlfGc::ActivateL()

    {    

    Deactivate(); // Just in case...

    iData->iBuffer = HBufC8::NewL( KAlfGcBufferGranularity );

    }

HBufC8* CAlfGc::CommandBuffer()

    {

    return iData->iBuffer;      

    }

void CAlfGc::Deactivate()

    {        

    delete iData->iBuffer;

    iData->iBuffer = NULL;

    }

void CAlfGc::AppendCommand( TInt aCommand, const TDesC8& aParams )

    {

    TRAP_IGNORE(AppendCommandL(aCommand,aParams));

    }

void CAlfGc::AppendCommandL( TInt aCommand, const TDesC8& aParams )

    {

    if (!iData->iBuffer)

        {

        return;    

        }

    __ALFLOGSTRING1( "CAlfGc::AppendCommand - start, buffer length: %d", iData->iBuffer->Length() )

    // create a bigger buffer if needed

    const TInt newSpaceNeeded = 4 + 4 + aParams.Length() + 4;

    __ALFLOGSTRING1( "CAlfGc::AppendCommand - new space needed: %d", newSpaceNeeded)

    if ( iData->iBuffer->Des().MaxLength() - iData->iBuffer->Length() < newSpaceNeeded )

        {

        __ALFLOGSTRING1( "CAlfGc::AppendCommand - allocating new buffer length: %d", iData->iBuffer->Length() + newSpaceNeeded * 2  )

        iData->iBuffer = iData->iBuffer->ReAllocL( iData->iBuffer->Length() + newSpaceNeeded * 2 );

        } 

    TPtr8 ptr = iData->iBuffer->Des();

    TInt length = aParams.Length();

    TInt command = aCommand;

    ptr.Append( (const TUint8*)&command, sizeof(TInt) );

    ptr.Append( (const TUint8*)&length, sizeof(TInt) );

    ptr.Append( aParams );

    TInt padding = 0;

    if (length % 4)

        {

        padding = 4 - length % 4;    

        }

    for ( TInt i = 0 ; i < padding ; i++ )

        {

        ptr.Append( 0xFF );        

        }        

    for ( TInt i = 0 ; i < aParams.Length() ; i++ )

        {

        __ALFLOGSTRING2( "[%d]: %d", i, aParams[i] )

        }

    __ALFLOGSTRING1( "CAlfGc::AppendCommand - end, buffer length: %d", iData->iBuffer->Length() )

    }

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

// 

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

//

void CAlfGc::DrawImage(const CAlfTexture& aTexture, const TAlfRealRect& aDestinationRect)   

    {

    TInt serversideTexture = aTexture.ServerHandle();

    const TAlfCanvasDrawImageParams params = {serversideTexture, 

        aDestinationRect.iTl.iX,

        aDestinationRect.iTl.iY,

        aDestinationRect.iBr.iX,

        aDestinationRect.iBr.iY

     };

    TPckgC<TAlfCanvasDrawImageParams> paramsPckg( params );

    AppendCommand( EAlfCanvasDrawImage, paramsPckg );

    }

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

// 

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

//

void CAlfGc::DrawText(const TDesC& aText, const TAlfRealRect& aDestinationRect)

    {

        TPtrC8 ptr(reinterpret_cast<const TUint8 *>(aText.Ptr()), aText.Length()*2);                

        AppendCommand( EAlfCanvasPrepareDrawText, ptr );

        const TAlfCanvasDrawTextParams params = { 

            aDestinationRect.iTl.iX,

            aDestinationRect.iTl.iY,

            aDestinationRect.iBr.iX,

            aDestinationRect.iBr.iY

            };

        TPckgC<TAlfCanvasDrawTextParams> paramsPckg( params );                    

        AppendCommand( EAlfCanvasDrawText, paramsPckg );        

    }

void CAlfGc::DrawLines(const RArray<TReal32> & aLinesPointCords)

	{

	HBufC8* buffer = NULL;

    TRAP_IGNORE(buffer = AlfGcExternalizeL(aLinesPointCords))

    if (buffer)

        {        

    	AppendCommand( EAlfCanvasDrawLines, *buffer );

    	delete buffer;

    	buffer = NULL;

        }

	}

void CAlfGc::DrawEllipse(const TAlfRealRect& aDestinationRect)

	{

	const TAlfCanvasDrawEllipseParams params = {

        aDestinationRect.iTl.iX,

        aDestinationRect.iTl.iY,

        aDestinationRect.iBr.iX,

        aDestinationRect.iBr.iY

     };

    TPckgC<TAlfCanvasDrawEllipseParams> paramsPckg( params );

    AppendCommand( EAlfCanvasDrawEllipse, paramsPckg );

	}

void CAlfGc::DrawPoints(const RArray<TReal32> & aPointsCords)

	{

	HBufC8* buffer = NULL;

    TRAP_IGNORE(buffer = AlfGcExternalizeL(aPointsCords))

    if (buffer)

        {        

    	AppendCommand( EAlfCanvasDrawPoints, *buffer );

    	delete buffer;

    	buffer = NULL;

        }

	}

void CAlfGc::DrawPolygon(const RArray<TReal32> & aPolygonPointCords)

	{

	HBufC8* buffer = NULL;

    TRAP_IGNORE(buffer = AlfGcExternalizeL(aPolygonPointCords))

    if (buffer)

        {        

    	AppendCommand( EAlfCanvasDrawPolygon, *buffer );

    	delete buffer;

    	buffer = NULL;

        }

	}

void CAlfGc::DrawRects(const RArray<TReal32> & aRectPointCords)

	{

	HBufC8* buffer = NULL;

    TRAP_IGNORE(buffer = AlfGcExternalizeL(aRectPointCords))

    if (buffer)

        {        

    	AppendCommand( EAlfCanvasDrawRects, *buffer );

    	delete buffer;

    	buffer = NULL;

        }

	}

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

// 

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

//

void CAlfGc::SetTextStyle(const CAlfTextStyle& aTextStyle)

    {

    TInt serverSideTextStyleId = aTextStyle.ServerHandle();    

    TAlfCanvasSetTextStyleParams params = {serverSideTextStyleId};

    TPckgC<TAlfCanvasSetTextStyleParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasSetTextStyle, paramsPckg );        

    }

void CAlfGc::SetPenColor(const TRgb& aColor)

	{

	TAlfCanvasSetPenColorParams params = {aColor};

    TPckgC<TAlfCanvasSetPenColorParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasSetPenColor, paramsPckg );        

	}

void CAlfGc::SetPenWidth(const TReal32& aWidth)

	{

	TAlfCanvasSetPenWidthParams params = {aWidth};

    TPckgC<TAlfCanvasSetPenWidthParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasSetPenWidth, paramsPckg );        

	}

void CAlfGc::SetOpacity(const TReal32& aOpacity)

	{

	TAlfCanvasSetOpacityParams params = {aOpacity};

    TPckgC<TAlfCanvasSetOpacityParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasSetOpacity, paramsPckg );        

	}

void CAlfGc::SetPolygonDrawMode(TAlfPolygonDrawMode aPolygonDrawMode)

	{

	TAlfCanvasSetPolygonDrawModeParams params = {aPolygonDrawMode};

    TPckgC<TAlfCanvasSetPolygonDrawModeParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasSetPolygonDrawMode, paramsPckg );	

	}

void CAlfGc::SetTextAlign(TAlfAlignHorizontal aAlignHorizontal, TAlfAlignVertical aAlignVertical)

	{

	TAlfCanvasSetTextAlignParams params = {aAlignHorizontal, aAlignVertical};

    TPckgC<TAlfCanvasSetTextAlignParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasSetTextAlign, paramsPckg );	

	}

    // Transformations

void CAlfGc::LoadIdentity()

	{

	TAlfCanvasLoadIdentityParams params = {0};

    TPckgC<TAlfCanvasLoadIdentityParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasLoadIdentity, paramsPckg );

	}

void CAlfGc::Translate(const TReal32& aX, const TReal32& aY, const TReal32& aZ)

	{

	TAlfCanvasTranslateParams params = {aX, aY, aZ};

    TPckgC<TAlfCanvasTranslateParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasTranslate, paramsPckg );        

	}

void CAlfGc::Scale(const TReal32& aX, const TReal32& aY, const TReal32& aZ)

	{

	TAlfCanvasScaleParams params = {aX, aY, aZ};

    TPckgC<TAlfCanvasScaleParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasScale, paramsPckg );        

	}

void CAlfGc::Rotate(const TReal32& aAngle, const TReal32& aX, const TReal32& aY, const TReal32& aZ)

	{

	TAlfCanvasRotateParams params = {aAngle, aX, aY, aZ};

    TPckgC<TAlfCanvasRotateParams> paramsPckg( params );                    

    AppendCommand( EAlfCanvasRotate, paramsPckg );        

	}