/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbtlvrenderer_p.h"

#include "hbnvgimagebinder_p.h"

#include "hbnvgutil_p.h"

#include "hbnvgicondata_p.h"

#include "hbnvgtlvicon_p.h"

#include "hbnvgexception_p.h"

#include <QScopedArrayPointer>

#include <QtDebug>

        : mVgImageBinder(0)

{

    mTargetWidth        = width;

    mTargetHeight       = height;

    mPrepareToBindImage = 0;

    mScaled = false;

    vgGetMatrix(mUserMatrix);

    mNvgIconData = new HbNvgIconData(buffer);

    Q_CHECK_PTR(mNvgIconData);

    mDataLength  = buffer.size();

}

void HbTlvRenderer::initialize()

    mNvgIconData->beginRead();

    mNvgIconData->read(mNvgHeader, sizeof(mNvgHeader));

}

HbTlvRenderer::~HbTlvRenderer()

{

        VGDESTROYPATH(mPathHandle);

    }

        vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

        vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

        if (mTlvVgHandleList[i].mVgHandle) {

            switch (mTlvVgHandleList[i].mHandleType) {

            case HbTlvVgHandlePair::VgPath:

                VGDESTROYPATH(mTlvVgHandleList[i].mVgHandle);

                break;

            case HbTlvVgHandlePair::VgPaint:

                VGDESTROYPAINT(mTlvVgHandleList[i].mVgHandle);

                break;

            case HbTlvVgHandlePair::VgImage:

                VGDESTROYIMAGE(mTlvVgHandleList[i].mVgHandle);

                break;

            }

        }

    }

    }

}

{

    quint16 type;

    quint16 value;

    type = mNvgIconData->readInt16();

    value = mNvgIconData->readInt16();

    vgSeti((VGParamType)type, value);

    NVG_DEBUGSTMT(logVgSeti((VGParamType)type, value));

}

{

    quint16 type   = mNvgIconData->readInt16();

    VGfloat value     = mNvgIconData->readReal32();

    vgSetf((VGParamType)type, value);

    NVG_DEBUGSTMT(logVgSetf((VGParamType)type, value));

}

{

    quint8  handle;

    quint16 type;

    quint16 value;

    handle = mNvgIconData->readInt32();

    type = mNvgIconData->readInt16();

    value = mNvgIconData->readInt16();

    vgSetParameteri(getHandle(handle), type, value);

    NVG_DEBUGSTMT(logVgSetParameteri(getHandle(handle), type, value, handle));

}

{

    quint32 handle = mNvgIconData->readInt32();

    quint16 type = mNvgIconData->readInt16();

    quint32 value = mNvgIconData->readReal32();

    vgSetParameterf(getHandle(handle), type, value);

    NVG_DEBUGP4("vgSetParameterf(%d, %d, %d)\n", handle, type, value);

}

{

    quint32 handle = mNvgIconData->readInt32();

    quint16 type = mNvgIconData->readInt16();

    quint32 countt = mNvgIconData->readInt32();

    float *fArr = new float[countt];

    Q_CHECK_PTR(fArr);

    QScopedArrayPointer<float> value(fArr);

        value[i] = mNvgIconData->readReal32();

    }

    vgSetParameterfv(getHandle(handle), type, countt, value.data());

    NVG_DEBUGSTMT(logVgSetParameterfv(getHandle(handle), type, countt, value.data()));

}

{

    quint32 paintvalue = mNvgIconData->readInt32();

    quint32 rgba = mNvgIconData->readInt32();

    vgSetColor(getHandle(paintvalue), rgba);

}

{

    quint32 paintvalue = mNvgIconData->readInt32();

    quint8 value = mNvgIconData->readInt8();

    vgSetPaint(getHandle(paintvalue), value);

    NVG_DEBUGSTMT(logVgSetPaint(getHandle(paintvalue), value, paintvalue));

}

QPoint HbTlvRenderer::getTranslatedPoint(VGfloat *trMatrix, const QPoint &point)

{

    QPoint trPoint;

    trPoint.setX(trMatrix[0] * point.x() + trMatrix[3] * point.y() + trMatrix[6]);

    trPoint.setY(trMatrix[1] * point.x() + trMatrix[4] * point.y() + trMatrix[7]);

    return trPoint;

}

VGfloat HbTlvRenderer::minVal4(VGfloat x1, VGfloat x2, VGfloat x3, VGfloat x4)

{

    VGfloat min = x1;

    if (min > x2) {

        min = x2;

    }

    if (min > x3) {

        min = x3;

    }

    if (min > x4) {

        min = x4;

    }

    return min;

}

VGfloat HbTlvRenderer::maxVal4(VGfloat x1, VGfloat x2, VGfloat x3, VGfloat x4)

{

    VGfloat max = x1;

    if (max < x2) {

        max = x2;

    }

    if (max < x3) {

        max = x3;

    }

    if (max < x4) {

        max = x4;

    }

    return max;

}

{

    quint16 type = mNvgIconData->readInt16();

    quint16 count = mNvgIconData->readInt16();

    VGint *intArr = new VGint[count];

    Q_CHECK_PTR(intArr);

    QScopedArrayPointer<VGint> value(intArr);

        value[i] = mNvgIconData->readInt32();

    }

    if (type == VG_SCISSOR_RECTS) {

        VGfloat * matrix = mUserMatrix;

        // calculate the rectangle with respect to the transformation applied

            QPoint leftBottom  = getTranslatedPoint(matrix,

                                                    QPoint(value[sx], value[sy]));

            QPoint leftTop     = getTranslatedPoint(matrix,

                                                    QPoint(value[sx], value[sy] + value[sh]));

            QPoint rightBottom = getTranslatedPoint(matrix,

                                                    QPoint(value[sx] + value[sw], value[sy]));

            QPoint rightTop    = getTranslatedPoint(matrix,

                                                    QPoint(value[sx] + value[sw], value[sy] + value[sh]));

            VGfloat minX = leftBottom.x();

            VGfloat minY = leftBottom.y();

            VGfloat maxX = leftBottom.x();

            VGfloat maxY = leftBottom.y();

            minX = minVal4(leftBottom.x(), leftTop.x(), rightBottom.x(), rightTop.x());

            minY = minVal4(leftBottom.y(), leftTop.y(), rightBottom.y(), rightTop.y());

            maxX = maxVal4(leftBottom.x(), leftTop.x(), rightBottom.x(), rightTop.x());

            maxY = maxVal4(leftBottom.y(), leftTop.y(), rightBottom.y(), rightTop.y());

            VGfloat newW = maxX - minX;

            VGfloat newH = maxY - minY;

            value[sx] = minX;

            value[sy] = minY;

            value[sw] = newW;

            value[sh] = newH;

        }

    }

    NVG_DEBUGSTMT(logvgSetXv((VGParamType)type, count, 'i', value.data()));

}

{

    VGfloat matrix[9];

        matrix[i] = mNvgIconData->readReal32();

    }

    // keep the caller's matrix as base

    if (matrixMode == VG_MATRIX_PATH_USER_TO_SURFACE ||

            matrixMode == VG_MATRIX_IMAGE_USER_TO_SURFACE /* need to check?*/) {

        vgLoadMatrix(mUserMatrix);

        vgMultMatrix(matrix);

    } else {

        vgLoadMatrix(matrix);

    }

#ifdef HB_NVG_DEBUG

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[0], matrix[1], matrix[2]);

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[3], matrix[4], matrix[5]);

    NVG_DEBUGP4("    %f, %f, %f)", matrix[6], matrix[7], matrix[8]);

#endif

}

{

    VGfloat matrix[9];

        matrix[i] = mNvgIconData->readReal32();

    }

    vgMultMatrix(matrix);

#ifdef HB_NVG_DEBUG

    NVG_DEBUGP2("VGfloat mlMatrix%d[] = {", ++matrixCount);

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[0], matrix[1], matrix[2]);

    NVG_DEBUGP4("    %f, %f, %f, ", matrix[3], matrix[4], matrix[5]);

    NVG_DEBUGP4("    %f, %f, %f)", matrix[6], matrix[7], matrix[8]);

#endif

}

{

    if (vgGeti(VG_MATRIX_MODE) == (VGint)VG_MATRIX_PATH_USER_TO_SURFACE) {

        vgLoadIdentity();

    }

    NVG_DEBUGP1("vgLoadIdentity();\n");

}

{

    VGfloat sx = mNvgIconData->readReal32();

    VGfloat sy = mNvgIconData->readReal32();

    vgScale(sx, sy);

    NVG_DEBUGP3("vgScale(%f, %f)\n", sx, sy);

}

{

    VGfloat tx = mNvgIconData->readReal32();

    VGfloat ty = mNvgIconData->readReal32();

    vgTranslate(tx, ty);

    NVG_DEBUGP3("vgTranslate(%f, %f)\n", tx, ty);

}

{

    quint16         numSegments;

    mNvgIconData->readInt32();

    numSegments = mNvgIconData->readInt16();

    VGubyte *pSegArr = new VGubyte[numSegments];

    Q_CHECK_PTR(pSegArr);

    QScopedArrayPointer<VGubyte>pathSegments(pSegArr);

        pathSegments[j] = mNvgIconData->readInt8();

    }

    Q_CHECK_PTR(pDataArr);

        pathData[i] = mNvgIconData->readInt32();

    }

    vgAppendPathData(mPathHandle, numSegments, pathSegments.data(), pathData.data());

    NVG_DEBUGP3("vgappendPathData((VGPath)%d, (SENGMENTS)%d)\n", mPathHandle, numSegments);

}

{

    quint16 value;

    mNvgIconData->readInt32();

    value = mNvgIconData->readInt16();

    vgDrawPath(mPathHandle, value);

    NVG_DEBUGSTMT(logVgDrawPath(mPathHandle, value));

}

{

    quint16 value;

    mNvgIconData->readInt32();

    value = mNvgIconData->readInt16();

    vgClearPath(mPathHandle, value);

    NVG_DEBUGP1("vgClearPath()\n");

}

{

    quint32  encodedHandle = mNvgIconData->readInt32();

    VGPaint paintH = VGCREATEPAINT();

    if (paintH == VG_INVALID_HANDLE) {

        throw HbNvgException(openVgErrorToHbNvgError(vgGetError()));

    mTlvVgHandleList.append(HbTlvVgHandlePair(paintH, encodedHandle, HbTlvVgHandlePair::VgPaint));

    NVG_DEBUGP2("%d = vgCreatePaint()\n", getHandle(encodedHandle));

}

{

    float x;

    float y;

    float width;

    float height;

    mNvgIconData->readInt32();

    x   = mNvgIconData->readReal32();

    y   = mNvgIconData->readReal32();

    width   = mNvgIconData->readReal32();

    height  = mNvgIconData->readReal32();

    vguRect(mPathHandle, x, y, width, height);

}

{

    float cx;

    float cy;

    float width;

    float height;

    mNvgIconData->readInt32();

    cx = mNvgIconData->readReal32();

    cy = mNvgIconData->readReal32();

    width  = mNvgIconData->readReal32();

    height = mNvgIconData->readReal32();

    vguEllipse(mPathHandle, cx, cy, width, height);

    NVG_DEBUGP6("vguEllipse( %d ,%f, %f, %f, %f)\n", mPathHandle, cx, cy, width, height);

}