/*

* 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:   Implements CHuiVg10Gc, an OpenVG 1.0 version of the HUITK

*                graphics context.

*

*/

#include "HuiVg10Gc.h"  // Class definition

#include "HuiVg10RenderPlugin.h"

#include "HuiVg10Texture.h"

#include "HuiVg10RenderSurface.h"

#include "uiacceltk/HuiSegmentedTexture.h"

#include "uiacceltk/HuiFont.h"

#include "uiacceltk/HuiImage.h"

#include "uiacceltk/HuiTextMesh.h"

#include "uiacceltk/HuiCurvePath.h"

#include "uiacceltk/HuiTransformation.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/huifixmath.h"

#include "HuiRenderSurface.h"

#include "../../CommonInc/uiacceltkdomaincrkeys.h"

#include <e32math.h>

#include <VG/vgu.h>

#ifdef __NVG

#pragma message( "NVG Defined!" )

    #include <nvg.h>

    #include <AknIconHeader.h>

    #include <AknIconUtils.h>

    #include "NVGIcon.h"

#endif

const TInt KHuiMaxVgScissorRects = 32;

/** Only render colorful rectangles instead of real graphics 

 *  content. Useful for debugging broken OpenVG drivers.

 */

//#define RENDER_DEBUG_RECTANGLES

CHuiVg10Gc* CHuiVg10Gc::NewL()

    {

    CHuiVg10Gc* self = CHuiVg10Gc::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

CHuiVg10Gc* CHuiVg10Gc::NewLC()

    {

    CHuiVg10Gc* self = new (ELeave) CHuiVg10Gc();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CHuiVg10Gc::CHuiVg10Gc()

        : CHuiGc()

    {

    }

void CHuiVg10Gc::ConstructL()

    {

    // iMatrix stack must be allocated here because InitState() is not allowed to leave

    iMatrixStack = CHuiMatrixStack::NewL();

#ifdef __NVG

    CHuiVg10RenderPlugin& renderer = (CHuiVg10RenderPlugin&) CHuiStatic::Renderer();

    iNvgEngine = &renderer.NvgEngine();

#endif    

    }

CHuiVg10Gc::~CHuiVg10Gc()

    {

#ifdef __NVG

    // Don't delete the iNvgEngine, it's owned by the plugin!

    iNvgEngine = NULL;

#endif    

    delete iMatrixStack;

    vgDestroyPath(iPath);

    vgDestroyPath(iImagePath);

    vgDestroyPath(iRectPath);

    vgDestroyPath(iRoundRectPath);

    vgDestroyPath(iLinePath);

    vgDestroyPath(iBorderPath);

    vgDestroyPath(iArcPath);

    vgDestroyPaint(iPaint);

    vgDestroyPaint(iGradientPaint);

    vgDestroyPath(iEllipsePath);

    }

void CHuiVg10Gc::Push(THuiGcMatrix aMatrix)

    {

    if (aMatrix == EHuiGcMatrixModel)

        {

        // Replicate the current OpenVG matrix to the matrix stack

        UpdateClientMatrix();

        iMatrixStack->Push();

        // Save the matrix flags

        iMatrixFlagsStack.Append(iMatrixFlags);

        }

    }

void CHuiVg10Gc::Pop(THuiGcMatrix aMatrix)

    {

    if (aMatrix == EHuiGcMatrixModel)

        {

        // Replicate the current matrix to OpenVG

        iMatrixStack->Pop();

        CHuiMatrixStack::TMatrix& matrix = iMatrixStack->Current();

        vgLoadMatrix((VGfloat*)matrix.iMatrix);

        // Restore the matrix flags

        iMatrixFlags = iMatrixFlagsStack[iMatrixFlagsStack.Count() - 1];

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

        HUI_VG_INVARIANT();

        }

    }

void CHuiVg10Gc::LoadIdentity(THuiGcMatrix aMatrix)

    {

    if (aMatrix == EHuiGcMatrixModel)

        {

        vgLoadIdentity();

        TRect displayArea = DisplayArea();            

        TInt h = displayArea.Height();

        TInt w = displayArea.Width();

        // DisplayArea is rotated if orientation is rotated, so we must "counter rotate"

        // to avoid rotating too much.

        if(Orientation() == EOrientationCCW90 || Orientation() == EOrientationCW90)

            {

            TInt tmp = w;

            w = h;

            h = tmp;

            }

        // Flip the Y axis to match Hitchcock's coordinate system

        vgTranslate(0, h); 

        vgScale(1.0f, -1.0f);

        if(Orientation() == EOrientationCCW90)

            {

            // Rotate around origo and move back to displayarea

            vgRotate(90);

            vgTranslate(0, -w);

            }

        else if(Orientation() == EOrientationCW90)

            {            

            // Rotate around origo and move back to displayarea

            vgRotate(-90);

            vgTranslate(-h, 0);

            }

        else if (Orientation() == EOrientation180)

            {

            // Rotate around origo and move back to displayarea

            vgRotate(-180);

            vgTranslate(-w, -h);            

            }                   

        else

            {

            // Nothing to do ?

            }

        // Reset the flags for this matrix

        iMatrixFlags = 0;

        HUI_VG_INVARIANT();

        }

    }

void CHuiVg10Gc::Multiply(THuiGcMatrix aStack, TReal32 aMatrix[16])

    {

    if (aStack == EHuiGcMatrixModel)

        {

        const VGfloat m[9] = 

            {

            aMatrix[0], aMatrix[1], aMatrix[2],

            aMatrix[4], aMatrix[5], aMatrix[6],

            aMatrix[8], aMatrix[9], aMatrix[10],

            };

        vgMultMatrix(m);

        HUI_VG_INVARIANT();

        }

    }

void CHuiVg10Gc::Translate(THuiGcMatrix aMatrix,

                           TReal32 aX, TReal32 aY, TReal32 /*aZ*/) __SOFTFP

    {

    if (aMatrix == EHuiGcMatrixModel)

        {

        vgTranslate(aX, aY);

        HUI_VG_INVARIANT();

        }

    }

void CHuiVg10Gc::Scale(THuiGcMatrix aMatrix,

                         TReal32 aX, TReal32 aY, TReal32 /*aZ*/) __SOFTFP

    {

    if (aMatrix == EHuiGcMatrixModel)

        {

        vgScale(aX, aY);

        HUI_VG_INVARIANT();

        }

    }

void CHuiVg10Gc::Shear(THuiGcMatrix aMatrix,

                       TReal32 aX, TReal32 aY, TReal32 /*aZ*/) __SOFTFP

    {

    if (aMatrix == EHuiGcMatrixModel)

        {

        vgShear(aX, aY);

        HUI_VG_INVARIANT();

        }

    }

void CHuiVg10Gc::Rotate(THuiGcMatrix aMatrix, TReal32 aAngle,

                        TReal32 aX, TReal32 aY, TReal32 aZ) __SOFTFP

    {

    if (aMatrix != EHuiGcMatrixModel)

        {

        return;

        }

    // Only rotation around the unit Z axis is supported

	if (aX != 0.0f || aY != 0.0f || Abs(aZ) != 1.0f)

	    {

	    return;

	    }

    if (aZ < 0)

        {

        aAngle = -aAngle;

        }

    iMatrixFlags |= EMatrixFlagsRotation;

    vgRotate(aAngle);

    HUI_VG_INVARIANT();

    }

// Replicate the current OpenVG matrix to the matrix stack

void CHuiVg10Gc::UpdateMatrix(VGMatrixMode aMatrix)

    {

    VGfloat m[9];

    ASSERT(vgGeti(VG_MATRIX_MODE) == VG_MATRIX_IMAGE_USER_TO_SURFACE);

    vgGetMatrix(m);

    vgSeti(VG_MATRIX_MODE, aMatrix);

    vgLoadMatrix(m);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

    HUI_VG_INVARIANT();

    }

void CHuiVg10Gc::UpdateClientMatrix()

    {

    // Replicate the current OpenVG matrix to the matrix stack

    vgGetMatrix((VGfloat*)iMatrixStack->Current().iMatrix);

    // The matrix is *probably* not an identity transform

    iMatrixStack->Current().iIsIdentity = EFalse;

    HUI_VG_INVARIANT();

    }

void CHuiVg10Gc::CreateVgObjectsL()

    {

    // Make sure we have enough resources to work with

    ASSERT(vgGeti(VG_MAX_SCISSOR_RECTS) >= 1);

    // Create the default VG objects

    iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                         5, 8, VG_PATH_CAPABILITY_APPEND_TO);

    iImagePath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                              5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

    iArcPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                            2, 7, VG_PATH_CAPABILITY_APPEND_TO);

    iPaint = vgCreatePaint();

    iGradientPaint = vgCreatePaint();

    iBlendMode = VG_BLEND_SRC_OVER;

    // Initialize a rectangle path with dummy coordinates

    iRectPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                             5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

    iRoundRectPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                                 5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

    iEllipsePath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                                 5, 8, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

    const VGubyte rectSegments[] =

        {

        VG_MOVE_TO_ABS,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_CLOSE_PATH

        };

    const VGfloat rectCoords[] = 

        {

         0.0f, 0.0f,             // (x, y)

         1.0f, 0.0f,             // (width, 0)

         0.0f, 1.0f,             // (0, height)

        -1.0f, 0.0f,             // (-width, 0)

        };

    vgAppendPathData(iRectPath, 5, rectSegments, rectCoords);

    vgRemovePathCapabilities(iRectPath, VG_PATH_CAPABILITY_APPEND_TO);

    vgAppendPathData(iImagePath, 5, rectSegments, rectCoords);

    vgRemovePathCapabilities(iImagePath, VG_PATH_CAPABILITY_APPEND_TO);

    // Initialize a line path with dummy coordinates

    iLinePath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                             2, 4, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

    const VGubyte lineSegments[] =

        {

        VG_MOVE_TO_ABS,

        VG_LINE_TO_ABS,

        };

    const VGfloat lineCoords[] = 

        {

        0.0f, 0.0f,             // (x, y)

        1.0f, 1.0f,             // (x, y)

        };

    vgAppendPathData(iLinePath, 2, lineSegments, lineCoords);

    vgRemovePathCapabilities(iLinePath, VG_PATH_CAPABILITY_APPEND_TO);

    // Initialize a path for drawing borders

    iBorderPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 

                               11, 10 * 2, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY);

    const VGubyte borderSegments[12] =

        {

        VG_MOVE_TO_ABS,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_LINE_TO_REL,

        VG_CLOSE_PATH,

        };

    const VGfloat borderCoords[10 * 2] = 

        {

        0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

        0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

        0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

        0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

        };

    vgAppendPathData(iBorderPath, 12, borderSegments, borderCoords);

    vgRemovePathCapabilities(iBorderPath, VG_PATH_CAPABILITY_APPEND_TO);

    // Get hardware configuration

    TInt hwConf = 0; // the defaulf value for everything is 0 to allow new flags to be defined

    HuiUtil::GetValueFromCentralRepository( KUIAccelTKHWConfigurationFlags, hwConf );

    if ( hwConf & KHuiAntialiasing )

        {

        SetQuality( EHuiQualityAccurate );

        }

    else

        {

        SetQuality( EHuiQualityFast );

        }

    iVgObjectsCreated = ETrue;

    }

void CHuiVg10Gc::InitState()

    {

    // Clean matrix stack in case there is anything left

    // We can't construct a new stack here because we are not allowed to leave.

    // We keep the original stack and just delete the contents leaving one 

    // identity matrix that is always added when a new matrix stack is created

    TInt i = 0;

    // One identity matrix will remain.

    // When a new matrix stack is created, one identity matrix is added

    // It can never be removed, the code would panic.

    for ( i = 0; i < iMatrixStack->Count() - 2; i++ )

        {

        iMatrixStack->Pop(); 

        }

    // remove flags from stack, too.

    iMatrixFlagsStack.Reset();

    iScissorRect = TRect(0, 0, 0, 0);

    iMatrixFlags = 0;

    if (!iVgObjectsCreated)

        {

        TRAP_IGNORE(CreateVgObjectsL());    

        }

    // Default paint

    vgSetParameteri(iPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

    vgSetPaint(iPaint, VG_FILL_PATH | VG_STROKE_PATH);

    // Gradient paint

    vgSetParameteri(iGradientPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);

    HUI_VG_INVARIANT();

    // Reset default state

    Enable(EFeatureBlending);

    Disable(EFeatureDepthTest);

	iStateScissorTest = ETrue;    

    Disable(EFeatureClipping);

    // Use the image matrix as the primary matrix

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

    RestoreState();

    HUI_VG_INVARIANT();

    }

void CHuiVg10Gc::SetQuality(THuiQuality aQuality)

    {

    CHuiGc::SetQuality(aQuality);

    switch (Quality())

        {

        case EHuiQualityAccurate:

            vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);

            vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_BETTER);

            break;

        case EHuiQualityFast:

            vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);

            vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_FASTER);

            break;

        default:

            break;

        }

    HUI_VG_INVARIANT();

    }

void CHuiVg10Gc::SetFillRule( THuiFillMode aFillMode )

    {   

    switch (aFillMode)

       {

       case EHuiFillNonZero:

           vgSeti(VG_FILL_RULE, VG_NON_ZERO);

           break;

       case EHuiFillEvenOdd:

           vgSeti(VG_FILL_RULE, VG_EVEN_ODD);

           break;

       default:

           break;

       }

    HUI_VG_INVARIANT();   

    }

void CHuiVg10Gc::RestoreState() const

    {

    // Restore paint

    vgSetPaint(iPaint, VG_FILL_PATH | VG_STROKE_PATH);        

    // Restore scissor test state

    if(iStateScissorTest)

        {

        vgSeti(VG_SCISSORING, VG_TRUE);

        }

    else

        {

        vgSeti(VG_SCISSORING, VG_FALSE);

        }

    // Restore scissor rects

    // This fixes CHuiFxEffect cached draw

    TInt count = iClipRegion.Count();

    VGint coords[KHuiMaxVgScissorRects * 4];

    if(count > KHuiMaxVgScissorRects)

        {

        count = KHuiMaxVgScissorRects; //only 32 scissor rects supported    

        }

    TInt numberOfCoords = count*4;

    for ( TInt i = 0, j=0 ; i < numberOfCoords ; j++)

        { 

        coords[i++] = iClipRegion[j].iTl.iX;

        coords[i++] = iClipRegion[j].iTl.iY;

        coords[i++] = iClipRegion[j].Width();

        coords[i++] = iClipRegion[j].Height();      

        }

    vgSetiv(VG_SCISSOR_RECTS, numberOfCoords, coords);          

    HUI_VG_INVARIANT();

    }

void CHuiVg10Gc::RestoreFlaggedState() const

    {

    // Get the changed stateflags from the renderplugin

    CHuiVg10RenderPlugin& renderer = (CHuiVg10RenderPlugin&) CHuiStatic::Renderer();

    TInt flags = renderer.GetRestoreStateFlags();

    // First a quick check, if nothing needs to be done

    if(!flags)