/*

* Copyright (c) 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:  NVG Decoder source file

*

*/

#include "NVGCSIcon.h"

#include "NVGIconData.h"

#include "nvgfittoviewbox.h"

#include "nvg.h"

#include "NVGUtil.h"

#include "OpenVGHandleStore.h"

#include <string.h>

#include <e32math.h>

CNVGCSIcon::CNVGCSIcon()

    :   iNVGIconData(0),

        iPath(VG_INVALID_HANDLE),

        iFillPaint(VG_INVALID_HANDLE),

        iStrokePaint(VG_INVALID_HANDLE),

        iLastFillPaintType(0),

        iLastStrokePaintType(0),

        iLastFillPaintColor(0),

        iLastStrkePaintColor(0),

        iResetFillPaint(0),

        iResetStrokePaint(0)

    {

    }

CNVGCSIcon::~CNVGCSIcon()

    {

    vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

    vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

    delete iNVGIconData;

    delete iOpenVGHandles;

    }

CNVGCSIcon * CNVGCSIcon::NewL(const TDesC8& aBuf)

    {

    CNVGCSIcon* self    = CNVGCSIcon::NewLC(aBuf);

    CleanupStack::Pop(self);

    return self;

    }

CNVGCSIcon * CNVGCSIcon::NewLC(const TDesC8& aBuf)

    {

    CNVGCSIcon* self    = new (ELeave) CNVGCSIcon;

    CleanupStack::PushL(self);

    self->ConstructL(aBuf);

    return self;

    }

void CNVGCSIcon::ConstructL(const TDesC8& aBuf)

    {

    iNVGIconData = CNVGIconData::NewL(aBuf.Length());

    iOpenVGHandles = COpenVGHandleStore::NewL();

    if (iPath == VG_INVALID_HANDLE)

        {

        iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

                        VG_PATH_DATATYPE_S_32, 1.0f/65536.0f, 0.0f, 0, 0,

                        VG_PATH_CAPABILITY_APPEND_TO);

        iOpenVGHandles->AddPathDHL(iPath);

        }

    if (iFillPaint == VG_INVALID_HANDLE)

        {

        iFillPaint = vgCreatePaint();

        iOpenVGHandles->AddPaintDHL(iFillPaint);

        }

    vgSetPaint(iFillPaint, VG_FILL_PATH);

    if (iStrokePaint == VG_INVALID_HANDLE)

        {

        iStrokePaint = vgCreatePaint();

        iOpenVGHandles->AddPaintDHL(iStrokePaint);

        }

    vgSetPaint(iStrokePaint, VG_STROKE_PATH);

    }

TInt CNVGCSIcon::SetViewBox(TReal32 x, TReal32 y, TReal32 w, TReal32 h) __SOFTFP

    {

    iViewBoxX = x;

    iViewBoxY = y;

    iViewBoxW = w;

    iViewBoxH = h;

    return KErrNone;

    }

TInt CNVGCSIcon::SetPreserveAspectRatio(TInt aPreserveAspectSetting, 

        TInt aSmilFitSetting)

    {

    iPreserveAspectSetting = aPreserveAspectSetting;

    iSmilFitSetting = aSmilFitSetting;

    return KErrNone;

    }

TInt CNVGCSIcon::Rotate(TReal32 aAngle, TReal32 aX, TReal32 aY) __SOFTFP

    {

    iRotationAngle  = aAngle;

    iRotationX      = aX;

    iRotationY      = aY;

    return KErrNone;

    }

void CNVGCSIcon::AddPathDataL(VGint numSegments, const VGubyte * pathSegments, const void * pathData)

    {

    iNVGIconData->EncodeInt32L(EPathData);

    iNVGIconData->EncodeInt32L(numSegments);

    iNVGIconData->EncodeDataL(pathSegments, numSegments);

    TInt coordinateCount = 0;

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

        {

        switch (pathSegments[i])

            {

            case VG_HLINE_TO:

            case VG_VLINE_TO:

                coordinateCount += 1;

                break;

            case VG_MOVE_TO:

            case VG_LINE_TO:

            case VG_SQUAD_TO:

                coordinateCount += 2;

                break;                

            case VG_QUAD_TO:

            case VG_SCUBIC_TO:

                coordinateCount += 4;

                break;

            case VG_SCCWARC_TO:

            case VG_SCWARC_TO:

            case VG_LCCWARC_TO:

            case VG_LCWARC_TO:

                coordinateCount += 5;

                break;

            case VG_CUBIC_TO:

                coordinateCount += 6;

                break;

            default:

                break;

            }

        }

    iNVGIconData->EncodeInt16L(coordinateCount);

    iNVGIconData->EncodeDataL(pathData, coordinateCount * 4);

    }

void CNVGCSIcon::AddDrawPathCommandL(VGPath aPath, VGbitfield aPaintMode)

    {

    iOpenVGHandles->AddPathDHL(aPath);

    iNVGIconData->EncodeInt32L(EPath);

    iNVGIconData->EncodeInt32L(aPath);    

    iNVGIconData->EncodeInt32L(aPaintMode);    

    }

void CNVGCSIcon::AddLinearGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)

    {

    iOpenVGHandles->AddPaintDHL(aPaint);

    iNVGIconData->EncodeInt32L(EPaint);

    AddLinearGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);

    }

void CNVGCSIcon::AddRadialGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)

    {

    iOpenVGHandles->AddPaintDHL(aPaint);

    iNVGIconData->EncodeInt32L(EPaint);

    AddRadialGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);

    }

void CNVGCSIcon::AddSetColorCommandL(VGuint aRgba)

    {

    iNVGIconData->EncodeInt32L(EPaint);

    iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_COLOR);

    iNVGIconData->EncodeInt32L(aRgba);

    }

void CNVGCSIcon::AddColorRampCommandL(VGPaint aPaint)

    {

    iNVGIconData->EncodeInt32L(EColorRamp);

    iNVGIconData->EncodeInt32L(aPaint);

    }

void CNVGCSIcon::AddSetTransformCommandL(const VGfloat* aTransformMatrix, TInt aFlag)

    {

    iNVGIconData->EncodeInt32L(ETransform);

    iNVGIconData->EncodeDataL(aTransformMatrix, 9 * sizeof(VGfloat));

    iNVGIconData->EncodeInt32L(aFlag);

    }

void CNVGCSIcon::AddSetStrokeWidthCommandL(VGfloat aStrokeWidth)

    {

    iNVGIconData->EncodeInt32L(EStrokeWidth);

    iNVGIconData->EncodeReal32L(aStrokeWidth);

    }

void CNVGCSIcon::AddSetStrokeMiterLimitCommandL(VGfloat aMiterLimit)

    {

    iNVGIconData->EncodeInt32L(EStrokeMiterLimit);

    iNVGIconData->EncodeReal32L(aMiterLimit);

    }

void CNVGCSIcon::AddStrokeLineJoinCapCommandL(VGint aCapStyle, VGint aJoinStyle)

    {

    iNVGIconData->EncodeInt32L(EStrokeLineJoinCap);

    iNVGIconData->EncodeInt32L(aCapStyle);

    iNVGIconData->EncodeInt32L(aJoinStyle);

    }

void CNVGCSIcon::AddStrokeLinearGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)

    {

    iOpenVGHandles->AddPaintDHL(aPaint);

    iNVGIconData->EncodeInt32L(EStrokePaint);

    AddLinearGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);

    }

void CNVGCSIcon::AddStrokeRadialGradientCommandL(VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix, VGPaint aPaint)

    {

    iOpenVGHandles->AddPaintDHL(aPaint);

    iNVGIconData->EncodeInt32L(EStrokePaint);

    AddRadialGradientCommandDataL(aPaint, aCount, aGradientData, aGradientMatrix);

    }

void CNVGCSIcon::AddStrokeSetColorCommandL(VGuint aRgba)

    {

    iNVGIconData->EncodeInt32L(EStrokePaint);

    AddSetColorCommandDataL(aRgba);

    }

void CNVGCSIcon::AddStrokeColorRampCommandL(VGPaint aPaint)

    {

    iNVGIconData->EncodeInt32L(EStrokeColorRamp);

    iNVGIconData->EncodeInt32L(aPaint);

    }

void CNVGCSIcon::AddLinearGradientCommandDataL(VGPaint aPaint, VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix)

    {

    iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_LINEAR_GRADIENT);

    iNVGIconData->EncodeInt32L(aPaint);

    iNVGIconData->EncodeInt32L(aCount);

    iNVGIconData->EncodeDataL(aGradientData, aCount * sizeof(VGfloat));

    iNVGIconData->EncodeDataL(aGradientMatrix, 9 * sizeof(VGfloat));    

    }

void CNVGCSIcon::AddRadialGradientCommandDataL(VGPaint aPaint, VGint aCount, VGfloat* aGradientData, VGfloat* aGradientMatrix)

    {

    iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_RADIAL_GRADIENT);

    iNVGIconData->EncodeInt32L(aPaint);

    iNVGIconData->EncodeInt32L(aCount);

    iNVGIconData->EncodeDataL(aGradientData, aCount * sizeof(VGfloat));

    iNVGIconData->EncodeDataL(aGradientMatrix, 9 * sizeof(VGfloat));

    }

void CNVGCSIcon::AddSetColorCommandDataL(VGuint aRgba)

    {

    iNVGIconData->EncodeInt32L(VG_PAINT_TYPE_COLOR);

    iNVGIconData->EncodeInt32L(aRgba);

    }

TInt CNVGCSIcon::Draw(const TSize aSize, CNvgEngine * aNVGEngine)

    {

    NVG_DEBUGP2("DRAWING NVGCSIcon %s, ", __FUNCTION__);

    TInt error = KErrNone;

    iNVGEngine = aNVGEngine;

    // Get Matrix modes and all caller matrices (must be restored afterwards)

    UpdateClientMatrices();

    TRAP(error, DoDrawL(aSize));

    // restore everything as we may have changed matrix mode            

    RestoreClientMatrices();

    return error;

    }

TInt CNVGCSIcon::DoDrawL(const TSize aSize)

    {

    TInt ret = KErrNone;

    vgSetPaint(iFillPaint,   VG_FILL_PATH);

    vgSetPaint(iStrokePaint, VG_STROKE_PATH);

    iLastFillPaintColor     = 0;

    iLastStrkePaintColor    = 0;

    iLastFillPaintType      = 0;

    iLastStrokePaintType    = 0;

    VGfloat lCurrentPathMatrix[9];

    vgGetMatrix(lCurrentPathMatrix);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);  

    vgLoadMatrix(lCurrentPathMatrix);

    SetRotation();

#ifdef __MIRROR_    

    vgScale(1.0f, -1.0f);

    vgTranslate(0, (VGfloat)(-aSize.iHeight) );

#endif

    SetViewBoxToViewTransformationL(aSize);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);

    VGfloat currentMatrix[9];

    vgGetMatrix(currentMatrix);

    iNVGIconData->BeginRead();

    while (!iNVGIconData->EOF())

        {

        switch (iNVGIconData->ReadInt32L())

            {

            case EPath:

                {

                VGPath path = (VGPath)iNVGIconData->ReadInt32L();

                VGPaintMode paintMode = (VGPaintMode)iNVGIconData->ReadInt32L();

                if (path == VG_INVALID_HANDLE)

                    {

                    vgDrawPath(iPath, paintMode);

                    }

                else

                    {

                    vgDrawPath(path, paintMode);

                    }

                break;

                }

            case EPathData:

                {                

                if (iPath != VG_INVALID_HANDLE)

                    {

                    VGint numSegments;

                    VGubyte * pathSegments = 0;

                    VGubyte * pathData = 0;

                    numSegments  = iNVGIconData->ReadInt32L();

                    pathSegments = new (ELeave) VGubyte[numSegments];

                    CleanupStack::PushL(TCleanupItem(CleanupArray, pathSegments));

                    if (pathSegments)

                        {

                        iNVGIconData->ReadL(pathSegments, numSegments);

                        VGint coordinateCount = iNVGIconData->ReadInt32L();

                        pathData = new (ELeave) VGubyte[coordinateCount * 4];

                        if (pathData)

                            {

                            CleanupStack::PushL(TCleanupItem(CleanupArray, pathData));

                            iNVGIconData->ReadL(pathData, coordinateCount * 4);

                            vgClearPath(iPath, VG_PATH_CAPABILITY_APPEND_TO);

                            vgAppendPathData(iPath, numSegments, pathSegments, pathData);

                            CleanupStack::PopAndDestroy();

                            }                        

                        }

                    CleanupStack::PopAndDestroy();

                    }

                break;

                }

            case EPaint:

                {

                DrawPaintL(iFillPaint, VG_MATRIX_FILL_PAINT_TO_USER, iLastFillPaintType, iLastFillPaintColor, VG_FILL_PATH);

                break;

                }

            case EColorRamp:

                {

                iNVGIconData->ReadInt32L();

                break;

                }

            case ETransform:

                {

                TInt flag;

                VGfloat transformMatrix[9];

                TPtr8 tmPtr((TUint8 *)transformMatrix, 9 * sizeof(VGfloat));

                iNVGIconData->ReadL(tmPtr, 9 * sizeof(VGfloat));

                flag = iNVGIconData->ReadInt32L();

                vgLoadMatrix(currentMatrix);

                if (flag)

                    {

                    vgMultMatrix(transformMatrix);

                    }

                }

                break;

            case EStrokeWidth:

                {

                VGfloat strokeWidth = iNVGIconData->ReadReal32L();

                vgSetf(VG_STROKE_LINE_WIDTH, strokeWidth);

                break;

                }

            case EStrokeMiterLimit:

                {

                VGfloat miterLimit = iNVGIconData->ReadReal32L();

                vgSetf(VG_STROKE_MITER_LIMIT, miterLimit);

                break;

                }

            case EStrokeLineJoinCap:

                {

                VGint lineJoin = iNVGIconData->ReadInt32L();

                VGint cap = iNVGIconData->ReadInt32L();

                vgSeti(VG_STROKE_JOIN_STYLE, (VGJoinStyle)lineJoin);

                vgSeti(VG_STROKE_CAP_STYLE, (VGCapStyle)cap);

                break;

                }

            case EStrokePaint:

                {

                DrawPaintL(iStrokePaint, VG_MATRIX_STROKE_PAINT_TO_USER, iLastStrokePaintType, iLastStrkePaintColor, VG_STROKE_PATH);

                break;

                }

            case EStrokeColorRamp:

                {

                iNVGIconData->ReadInt32L();

                break;

                }

            default:

                {

                User::Leave(KErrCorrupt);

                break;

                }

            }

        }

    iNVGIconData->EndRead();

    return ret;

    }

void CNVGCSIcon::DrawColorRampL(VGPaint aPaint)

    {

    TInt stopCount = iNVGIconData->ReadInt32L();

    VGfloat * colorRamps = new (ELeave) VGfloat[stopCount];

    CleanupStack::PushL(TCleanupItem(CleanupArray, colorRamps));

    iNVGIconData->ReadL((TUint8 *)colorRamps, stopCount * sizeof(VGfloat));

    vgSetParameteri(aPaint, VG_PAINT_COLOR_RAMP_SPREAD_MODE, VG_COLOR_RAMP_SPREAD_PAD);

    vgSetParameterfv(aPaint, VG_PAINT_COLOR_RAMP_STOPS, stopCount, colorRamps);                    

    CleanupStack::PopAndDestroy();

    }

void CNVGCSIcon::DrawPaintL(VGPaint aPaint, VGMatrixMode aMatrixMode, TUint & aLastPaintType, TUint & aLastPaintColor, VGPaintMode aPaintMode)

    {

    VGPaintType paintType = (VGPaintType)iNVGIconData->ReadInt32L();

    if (paintType == VG_PAINT_TYPE_LINEAR_GRADIENT ||

        paintType == VG_PAINT_TYPE_RADIAL_GRADIENT)

        {

        VGPaintParamType paintPType = VG_PAINT_LINEAR_GRADIENT;

        if (paintType == VG_PAINT_TYPE_RADIAL_GRADIENT)

            {

            paintPType = VG_PAINT_RADIAL_GRADIENT;

            }

        VGPaint paintHandle = iNVGIconData->ReadInt32L();

        TInt count = iNVGIconData->ReadInt32L();

        VGfloat gradientData[5];

        VGfloat gradientMatrix[9];

        iNVGIconData->ReadL((TUint8 *)gradientData, count * sizeof(VGfloat));

        iNVGIconData->ReadL((TUint8 *)gradientMatrix, 9 * sizeof(VGfloat));

        if (paintHandle)

            {

            vgSetPaint(paintHandle,   aPaintMode);

            vgSeti(VG_MATRIX_MODE, aMatrixMode);

            vgLoadMatrix(gradientMatrix);

            if (aPaintMode == VG_FILL_PATH)

                {

                iResetFillPaint = 1;

                }

            else

                {

                iResetStrokePaint = 1;

                }

            }

        else

            {

        if (aLastPaintType != paintType)

            {

            vgSetParameteri(aPaint, VG_PAINT_TYPE, paintType);

            }

        vgSetParameterfv(aPaint, paintPType, count, gradientData);

        vgSeti(VG_MATRIX_MODE, aMatrixMode);

        vgLoadMatrix(gradientMatrix);

            }

        vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);

        }

    else if (paintType == VG_PAINT_TYPE_COLOR)

        {

        if (aPaintMode == VG_FILL_PATH && iResetFillPaint)

            {

            iResetFillPaint = 0;

            vgSetPaint(aPaint, aPaintMode);

            }

        else if (aPaintMode == VG_STROKE_PATH && iResetStrokePaint)

            {

            iResetStrokePaint = 0;

            vgSetPaint(aPaint, aPaintMode);

            }

        TUint color = static_cast<TUint>(iNVGIconData->ReadInt32L());

        if (aLastPaintType != paintType)

            {

            vgSetParameteri(aPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

            vgSetColor(aPaint, color);

            }

        else