/*

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

 *

*/

#include "PseodoVGRendererImpl.h"

#include "PseudoVGSurfaceImpl.h"

#include <f32file.h>

#include <s32mem.h>

#include <VG/vgu.h>

const TUint CPseodoVGRendererImpl::ENCODEDDATALENGTH        = 1024;

const TUint CPseodoVGRendererImpl::ENCODEDDATAGRANULARITY   = 64;

const TUint CPseodoVGRendererImpl::KMAJOR_VERSION           = 1;

const TUint CPseodoVGRendererImpl::KMINOR_VERSION           = 0;

const TUint CPseodoVGRendererImpl::KBUILD_VERSION           = 1;

EXPORT_C MVGRendererImpl* CreateVGRendererImplL()

    {

    return CPseodoVGRendererImpl::NewL();

    }

CPseodoVGRendererImpl::CPseodoVGRendererImpl()

    {

    iPaintHandleCount   = 0;

    iPathHandleCount    = 0;

    iEncodedData        = 0;

    iHandle             = 1;

    iCommonHeaderLength = 0;

    iCommonHeader = 0;

    }

CPseodoVGRendererImpl::~CPseodoVGRendererImpl()

    {

    delete iEncodedData;

    }

CPseodoVGRendererImpl* CPseodoVGRendererImpl::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CPseodoVGRendererImpl* CPseodoVGRendererImpl::NewL()

    {

    CPseodoVGRendererImpl* self=CPseodoVGRendererImpl::NewLC();

    CleanupStack::Pop();

    return self;

    }

inline void CPseodoVGRendererImpl::ConstructL()

    {

    iEncodedData = HBufC8::NewL(CPseodoVGRendererImpl::ENCODEDDATALENGTH);

    WriteHeader();

    }

TVersion CPseodoVGRendererImpl::GetVersion() const

    {

    return TVersion(KMAJOR_VERSION, KMINOR_VERSION, KBUILD_VERSION);

    }

const TDesC CPseodoVGRendererImpl::GetName() const

    {

    _LIT(KPseudoVGRenderer, "TLVVGRenderer");

    return KPseudoVGRenderer; 

    }

void CPseodoVGRendererImpl::WriteHeader()

    {

    TUint8 EmptyHeader[KIconHeaderLength]; 

    if(iCommonHeader)

        {

        EncodeData(iCommonHeader, KIconHeaderLength);

        }

    else

        {

        EncodeData(EmptyHeader, KIconHeaderLength);

        }

    const TInt8 *   KNVGFileIdentifier   = (const TInt8*)"nvg";

    EncodeData(KNVGFileIdentifier, 3);

    EncodeInt8(KNVGFileVersion);

    EncodeInt16(KNVGHeaderSize);

    EncodeInt16(KNVGReserved1);

    // Rest of the headers are not used in TLV format

    const TInt8   KUnusedHeaderLength  = 0x2C;

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

        {

        EncodeInt8(0);

        }

    }

void CPseodoVGRendererImpl::vgClear(TInt x, TInt y, TInt width, TInt height)

    {

    EncodeInt8(EvgClear);

    EncodeReal32(x);

    EncodeReal32(y);

    EncodeReal32(width);

    EncodeReal32(height);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgClear"));

#endif

    }

void CPseodoVGRendererImpl::vgSeti(TInt type, TInt value)

    {

    EncodeInt8(EvgSeti);

    EncodeInt16(type);

    EncodeInt16(value);

#ifdef VGRENDERER_LOG

    LogvgSeti((VGParamType)type,value,0);   

#endif

    }

TInt CPseodoVGRendererImpl::vgGeti(TInt type)

    {

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgGeti"));

#endif

        switch( type )

        {

            case VG_IMAGE_MODE:

                return (VGint)VG_DRAW_IMAGE_MULTIPLY;

            case VG_BLEND_MODE:

                return (VGint)VG_BLEND_SRC_OVER;

            case VG_FILTER_CHANNEL_MASK:

                return (VGint)0;  

            default:

                return 0;        

        }

    }

void CPseodoVGRendererImpl::vgSetf (TInt type, TReal32 value)

    {

    EncodeInt8(EvgSetf);

    EncodeInt16(type);

    EncodeReal32(value);

#ifdef VGRENDERER_LOG

    LogvgSetf((VGParamType)type,value,0); 

#endif

    }

void CPseodoVGRendererImpl::vgSetfv(TInt type, TInt count, const TReal32 * values)

    {

    EncodeInt8(EvgSetfv);

    EncodeInt16(type);

    EncodeInt16(count);

    EncodeData(values, count * sizeof(TReal32));

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgSetfv"));

#endif

    }

void CPseodoVGRendererImpl::vgSetiv(TInt type, TInt count, const TInt * values)

    {

     EncodeInt8(EvgSetiv);

    EncodeInt16(type);

    EncodeInt16(count);

    EncodeData(values, count * sizeof(TInt));

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgSetiv"));

#endif

    }

void CPseodoVGRendererImpl::vgSetParameteri(TUint handle, TInt paramType, TInt value)

    {

    EncodeInt8(EvgSetParameteri);

    EncodeInt32(handle);

    EncodeInt16(paramType);

    EncodeInt16(value);

#ifdef VGRENDERER_LOG

    LogvgSetParameteri(handle,paramType,value,0,handle);				   

#endif

    }

void CPseodoVGRendererImpl::vgSetParameterf(TUint handle,TInt paramType,TReal32 value)

    {

    EncodeInt8(EvgSetParameterf);

    EncodeInt32(handle);

    EncodeInt16(paramType);

    EncodeReal32(value);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgSetParameterf"));

#endif

    }

void CPseodoVGRendererImpl::vgSetParameterfv(TUint handle,TInt paramType,TInt count, const TReal32 * values)

    {

    EncodeInt8(EvgSetParameterfv);

    EncodeInt32(handle);

    EncodeInt16(paramType);

    EncodeInt32(count);

    EncodeData(values, count * sizeof(TReal32));

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgSetParameterfv"));

#endif

    }

void CPseodoVGRendererImpl::vgSetColor(TUint paint, TUint rgba)

    {

    EncodeInt8(EvgSetColor);

    EncodeInt32(paint);

    EncodeInt32(rgba);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgSetColor"));

#endif

    }

void CPseodoVGRendererImpl::vgSetPaint(TUint paint, TUint paintModes)

    {

    EncodeInt8(EvgSetPaint);

    EncodeInt32(paint);

    EncodeInt8(paintModes);

#ifdef VGRENDERER_LOG

    LogvgSetPaint(paint,paintModes,0,paint);      

#endif

    }

TUint CPseodoVGRendererImpl::vgCreatePaint()

    {

    iHandle++;

    EncodeInt8(EvgCreatePaint);

    EncodeInt32(iHandle);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgCreatePaint"));

#endif

    return iHandle;

    }

TUint CPseodoVGRendererImpl::vgCreatePath(TInt pathFormat, TInt datatype, TReal32 scale, TReal32 bias,

        TInt segmentCapacityHint, TInt coordCapacityHint, TInt capabilities)

    {

    iHandle++;

    EncodeInt8(EvgCreatePath);

    EncodeInt32(pathFormat);

    EncodeInt8(datatype);

    EncodeReal32(scale);

    EncodeReal32(bias);

    EncodeInt32(segmentCapacityHint);

    EncodeInt32(coordCapacityHint);

    EncodeInt32(capabilities);

    EncodeInt32(iHandle);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgCreatePath"));

#endif

    return iHandle;

    }

void CPseodoVGRendererImpl::vgLoadMatrix(const TReal32 * m)

    {

    EncodeInt8(EvgLoadMatrix);

    EncodeData(m, 9 * sizeof(TReal32));

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgLoadMatrix"));

#endif

    }

void CPseodoVGRendererImpl::vgMultMatrix(const TReal32 * m)

    {

    EncodeInt8(EvgMultMatrix);

    EncodeData(m, 9 * sizeof(TReal32));

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgMultMatrix"));

#endif

    }

void CPseodoVGRendererImpl::vgLoadIdentity()

    {

    EncodeInt8(EvgLoadIdentity);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgLoadIdentity"));

#endif

    }

void CPseodoVGRendererImpl::vgScale(TReal32 sx, TReal32 sy)

    {

    EncodeInt8(EvgScale);

    EncodeReal32(sx);

    EncodeReal32(sy);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgScale"));

#endif

    }

void CPseodoVGRendererImpl::vgTranslate(TReal32 tx, TReal32 ty)

    {

    EncodeInt8(EvgTranslate);

    EncodeReal32(tx);

    EncodeReal32(ty);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgTranslate"));

#endif

    }

void CPseodoVGRendererImpl::vgRotate(TReal32 angle)

    {

    EncodeInt8(EvgRotate);

    EncodeReal32(angle);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgRotate"));

#endif

    }

void CPseodoVGRendererImpl::vgReadPixels(void * /*data*/, TInt /*dataStride*/, TInt /*dataFormat*/, TInt /*sx*/, TInt /*sy*/, TInt /*width*/, TInt /*height*/)

    {

    //TODO

    return;

    }

void CPseodoVGRendererImpl::vgWritePixels(const void * /*data*/, TInt /*dataStride*/, TInt /*dataFormat*/,

                TInt /*dx*/, TInt /*dy*/, TInt /*width*/, TInt /*height*/)

    {

    //TODO

    return;

    }

void CPseodoVGRendererImpl::vgAppendPathData(TUint path,TInt numSegments,

                                            const TUint8 * pathSegments,

                                            const void * pathData)

    {

    EncodeInt8(EvgAppendPathData);

    EncodeInt32(path);

    EncodeInt16(numSegments);

    EncodeData(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;

            }

        }

    EncodeInt16(coordinateCount);

    EncodeData(pathData, coordinateCount * GetPathCoordianteSize(path));

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vgAppendPathData"));

#endif

    }

void CPseodoVGRendererImpl::vgDrawPath(TUint path, TUint capabilities)

    {

    EncodeInt8(EvgDrawPath);

    EncodeInt32(path);

    EncodeInt16(capabilities);

#ifdef VGRENDERER_LOG

#endif

    }

void CPseodoVGRendererImpl::vgClearPath(TUint path, TUint capabilities)

    {

    EncodeInt8(EvgClearPath);

    EncodeInt32(path);

    EncodeInt16(capabilities);

    }

TInt CPseodoVGRendererImpl::vguRect(TUint path,

                                    TReal32 x, TReal32 y,

                                    TReal32 width, TReal32 height)

    {

    EncodeInt8(EvguRect);

    EncodeInt32(path);

    EncodeReal32(x);

    EncodeReal32(y);

    EncodeReal32(width);

    EncodeReal32(height);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vguRect"));

#endif

    return KErrNone;

    }

TInt CPseodoVGRendererImpl::vguEllipse(TUint path,

                                       TReal32 cx, TReal32 cy,

                                       TReal32 width, TReal32 height)

    {

    EncodeInt8(EvguEllipse);

    EncodeInt32(path);

    EncodeReal32(cx);

    EncodeReal32(cy);

    EncodeReal32(width);

    EncodeReal32(height);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vguEllipse"));

#endif

    return KErrNone;

    }

TInt CPseodoVGRendererImpl::vguRoundRect(TUint path, TReal32 x, TReal32 y,

                                        TReal32 width, TReal32 height, TReal32 arcWidth, TReal32 arcHeight)

    {

    EncodeInt8(EvguRoundRect);

    EncodeInt32(path);

    EncodeReal32(x);

    EncodeReal32(y);

    EncodeReal32(width);

    EncodeReal32(height);

    EncodeReal32(arcWidth);

    EncodeReal32(arcHeight);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vguRoundRect"));

#endif

    return KErrNone;

    }

TInt CPseodoVGRendererImpl::vguLine(TUint path,TReal32 x0, TReal32 y0,TReal32 x1, TReal32 y1)

    {

    EncodeInt8(EvguLine);

    EncodeInt32(path);

    EncodeReal32(x0);

    EncodeReal32(y0);

    EncodeReal32(x1);

    EncodeReal32(y1);

#ifdef VGRENDERER_LOG

    iLog.WriteFormat(_L("vguLine"));

#endif

    return KErrNone;

    }

TUint CPseodoVGRendererImpl::vgCreateImage(TInt format, TInt width, TInt height, TInt allowedQuality)

    {

    iHandle++;

    EncodeInt8(EvgCreateImage);

    EncodeInt32(format);

    EncodeInt32(width);

    EncodeInt32(height);

    EncodeInt8(allowedQuality);

    EncodeInt32(iHandle);

    return iHandle;

    }

void CPseodoVGRendererImpl::vgGetPixels(TUint /*dst*/, TInt /*dx*/, TInt /*dy*/, TInt /*sx*/, TInt /*sy*/, TInt /*width*/, TInt /*height*/)

    {

    //TODO: not used in SVGEngine

    }

void CPseodoVGRendererImpl::vgDrawImage(TUint image)

    {

    EncodeInt8(EvgDrawImage);

    EncodeInt32(image);

    }

void CPseodoVGRendererImpl::vgClearImage(TUint image, TInt x, TInt y, TInt width, TInt height)

    {

    EncodeInt8(EvgClearImage);

    EncodeInt32(image);

    EncodeInt32(x);

    EncodeInt32(y);

    EncodeInt32(width);

    EncodeInt32(height);

    }

void CPseodoVGRendererImpl::vgImageSubData(TUint image, const void * data, TInt dataStride,

            TInt dataFormat, TInt x, TInt y, TInt width, TInt height)

    {

    EncodeInt8(EvgImageSubData);

    EncodeInt32(image);

    EncodeInt32(dataStride);

    EncodeInt32(dataFormat);

    EncodeInt32(x);

    EncodeInt32(y);

    EncodeInt32(width);

    EncodeInt32(height);

    // append the actual data