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

**

** 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 "hbnvgcsicon_p.h"

#include "hbnvgicondata_p.h"

#include "hbnvgfittoviewbox_p.h"

#include "hbnvgutil_p.h"

#include "hbopenvghandlestore_p.h"

#include "hbnvgexception_p.h"

#include <QScopedPointer>

#include <QScopedArrayPointer>

/*!

  NVG-CS version

 */

const int Version2   = 2;

/*!

  File offsets

 */

const int NVG_VIEWBOX_WIDTH_OFS = 44;

const int NVG_VIEWBOX_HEIGHT_OFS = 48;

const int NVG_VIEWBOX_X_OFS = 36;

const int NVG_VIEWBOX_Y_OFS = 40;

const int NVG_PATHDATATYPE_OFS = 26;

const int NVG_SCALE_OFS = 28;

const int NVG_BIAS_OFS = 32;

const int NVG_COMMANDSECTION_OFS = 2;

const int NVG_RGBA_OFS = 4;

const int NVG_HEADERSIZE_OFS = 4;

const int NVG_PAINTSECTION_LINEARGRAD_TRANSFORM_OFFSET = 20;

const int NVG_PAINTSECTION_RADIALGRAD_TRANSFORM_OFFSET = 24;

const int NVG_VERSION_OFS         = 3;

/*!

  NVG-CS commands

 */ 

const int CMD_SET_FILL_PAINT           = 4  << 24;

const int CMD_SET_COLOR_RAMP           = 6  << 24;

const int CMD_DRAW_PATH                = 7  << 24;

const int CMD_SET_TRANSFORMATION       = 8  << 24;

const int CMD_SET_STROKE_PAINT         = 5  << 24;

const int CMD_SET_STROKE_WIDTH         = 9  << 24;

const int CMD_SET_STROKE_LINE_JOIN_CAP = 10 << 24;

const int CMD_SET_STROKE_MITER_LIMIT   = 11 << 24;

/*!

 Stroke cap style

 */

const int CAP_BUTT        = 1;

const int CAP_SQUARE      = 2;

const int CAP_ROUND       = 3;

/*!

 Stroke join style

 */

const int LINE_JOIN_BEVEL = 1;

const int LINE_JOIN_MITER = 2;

const int LINE_JOIN_ROUND = 3;

/*!

 Fill paint type

 */

const int PAINT_FLAT      = 1;

const int PAINT_LGRAD     = 2;

const int PAINT_RGRAD     = 3;

/*!

 Stroke paint type

 */

const int STROKE_LGRAD        = 2;

const int STROKE_RGRAD        = 3;

const int STROKE_COLOR_RAMP   = 4;

/*!

 Transform encoding values

 */

const int TRANSFORM_COMPLETE    = 0;

const int TRANSFORM_SCALING     = 2;

const int TRANSFORM_SHEARING    = 4;

const int TRANSFORM_ROTATION    = 8;

const int TRANSFORM_TRANSLATION = 16;

const VGfloat IdentityMatrix[] = {

    1.0f, 0.0f, 0.0f,

    0.0f, 1.0f, 0.0f,

    0.0f, 0.0f , 1.0f

};

    /**

     * @fn      Constructor

     * @Version

     * @parameter: buffer - None

     *

     * @return: None

     */

HbNvgCsIcon::HbNvgCsIcon()

        :   mPaintFill(VG_INVALID_HANDLE),

        mPaintStroke(VG_INVALID_HANDLE),

        mVgPath(VG_INVALID_HANDLE),

        mLastPathDataType(0),

        mDoFill (VG_FALSE),

        mDoStroke(VG_FALSE),

        mCreatingNvgIcon(0),

        mPreserveAspectSetting(HbNvgEngine::NvgPreserveAspectRatioXmidYmid),

        mSmilFitSetting(HbNvgEngine::NvgMeet),

        mNvgIconData(0),

        mOpenVgHandles(0),

        mLastFillPaintType(0),

        mLastStrokePaintType(0),

        mLastFillPaintColor(0),

        mLastStrkePaintColor(0),

        mResetFillPaint(0),

        mResetStrokePaint(0),

        mMirroringMode(false)

{

}

void HbNvgCsIcon::setIconData(const QByteArray &buffer)

{

    mNvgIconData = new HbNvgIconData(buffer.size());

    Q_CHECK_PTR(mNvgIconData);

    mOpenVgHandles = new HbOpenVgHandleStore();

    Q_CHECK_PTR(mNvgIconData);

}

HbNvgCsIcon::~HbNvgCsIcon()

{

    if (mPaintFill) {

        vgDestroyPaint(mPaintFill);

    }

    if (mPaintStroke) {

        vgDestroyPaint(mPaintStroke);

    }

    if (mVgPath) {

        vgDestroyPath(mVgPath);

    }

    vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH);

    vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH);

    delete mNvgIconData;

    delete mOpenVgHandles;

}

void HbNvgCsIcon::setViewBox(float x, float y, float w, float h)

{

    mViewBoxX = x;

    mViewBoxY = y;

    mViewBoxW = w;

    mViewBoxH = h;

}

void  HbNvgCsIcon::setPreserveAspectRatio(HbNvgEngine::NvgAlignStatusType preserveAspectSetting,

        HbNvgEngine::NvgMeetOrSliceType smilFitSetting)

{

    mPreserveAspectSetting = preserveAspectSetting;

    mSmilFitSetting = smilFitSetting;

}

void HbNvgCsIcon::setMirroringMode(bool mirroringMode)

{

    mMirroringMode = mirroringMode;

}

void HbNvgCsIcon::rotate(float angle, float xValue, float yValue)

{

     mRotationAngle  = angle;

     mRotationX      = xValue;

     mRotationY      = yValue;

}

void HbNvgCsIcon ::directDraw(const QByteArray &buffer, const QSize &targetSize)

{

    drawCommandSection(buffer, targetSize, 0);

}

void HbNvgCsIcon::create(const QByteArray &buffer, const QSize& targetSize)

{

    drawCommandSection(buffer, targetSize, 1);

}

void HbNvgCsIcon::drawCommandSection(const QByteArray &buffer, const QSize & targetSize,

        int objectCaching)

{       

    mCreatingNvgIcon = objectCaching;

    HbDereferencer iconData(buffer);

    qint16 lHeaderSize  = iconData.derefInt16(NVG_HEADERSIZE_OFS);

    quint8 nvgVersion   = iconData.derefInt8(NVG_VERSION_OFS);

    HbNvgEngine::NvgErrorType errInit = HbNvgEngine::NvgErrNone;

    errInit = initializeGc();

    if (HbNvgEngine::NvgErrNone != errInit){

       throw HbNvgException(errInit);

    }

    qint16 lPathDataType = iconData.derefInt16(NVG_PATHDATATYPE_OFS);

    float lScale         = iconData.derefReal32(NVG_SCALE_OFS);

    float lBias          = iconData.derefReal32(NVG_BIAS_OFS);

    errInit = createPathHandle(lPathDataType, lScale, lBias);

    if (HbNvgEngine::NvgErrNone != errInit){

        throw HbNvgException(errInit);

    }

    VGfloat lCurrentPathMatrix[9];

    vgGetMatrix(lCurrentPathMatrix);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);

    // We use the caller's base batrix regardless of which mode the caller was.

    // The caller may have set the matrix in VG_MATRIX_IMAGE_USER_TO_SURFACE mode

    // as it thinks it is drawing images (textures).

    // But even though the texture gets stroked instead, we must use the caller's

    // transformation matrix.

    // Everything gets restored to the original values before we return.

    vgLoadMatrix(lCurrentPathMatrix);

//    applyScissoring(lCurrentPathMatrix, targetSize);

    /*

     * set the rotation angle if available

     */

    setRotation();

    if (mMirroringMode) {

	    vgTranslate((VGfloat)(targetSize.width()), 0); 

	    vgScale(-1.0f, 1.0f);

	    }

#ifdef __MIRROR_

     vgScale(1.0f, -1.0f);

     vgTranslate(0, (VGfloat)(-targetSize.height()));

#endif

    //viewbox parameters

    float lViewboxX   = iconData.derefReal32(NVG_VIEWBOX_X_OFS);

    float lViewboxY   = iconData.derefReal32(NVG_VIEWBOX_Y_OFS);

    float lViewboxW   = iconData.derefReal32(NVG_VIEWBOX_WIDTH_OFS);

    float lViewboxH   = iconData.derefReal32(NVG_VIEWBOX_HEIGHT_OFS);

    applyViewboxToViewPortTransformation(targetSize, lViewboxX, lViewboxY, lViewboxW, lViewboxH);

    quint32 offsetSectionLength = iconData.getLength() - lHeaderSize;

    quint8 * offsetPtr = iconData.derefInt8Array(offsetSectionLength, lHeaderSize);

    HbDereferencer offsetSection(offsetPtr, offsetSectionLength);

    quint16 lOffsetVectorCount = offsetSection.derefInt16();

    offsetPtr = iconData.derefInt8Array(offsetSectionLength - sizeof(quint16), lHeaderSize + sizeof(quint16));

    HbDereferencer offsetVector(offsetPtr, offsetSectionLength - sizeof(quint16));

    qint32 commandSectionOffset = lOffsetVectorCount * sizeof(quint16);

    HbDereferencer commandSection((offsetVector.getPtr() + commandSectionOffset), 

            iconData.getLength() - commandSectionOffset - lHeaderSize - sizeof(quint16));

    // from version 2 onwards command section will start on word boundary

    if (nvgVersion >= Version2 && ((lOffsetVectorCount  & 0x01) == 0))

        {

        commandSection.skip(2);

        }

    quint16 lCmdCount = commandSection.derefInt16();

    commandSection.skip(NVG_COMMANDSECTION_OFS);   

    /*

     * from version 2 onwards there will be a padding added

     * after the command count to make it word aligned

     */

    if (nvgVersion >= Version2)

        {

        commandSection.skip(2);

        }

    executeNVGCSCommandLoop(lCmdCount, &iconData, &offsetVector, &commandSection, nvgVersion);

}

void HbNvgCsIcon::executeNVGCSCommandLoop(quint16 commandCount, HbDereferencer *iconData, 

        HbDereferencer * offsetVector,HbDereferencer * commandSection, quint8 nvgVersion)

    {

    quint32 transVal;

    VGfloat lCurrentPathMatrix[9];

    vgGetMatrix(lCurrentPathMatrix);

    qint32 lOffsetIx = 0;

    for (int i=0; i < commandCount; i++)

        {

        quint32 currentCommand = commandSection->derefInt32();

        lOffsetIx = currentCommand & 0x0000ffff;

        switch (currentCommand & 0xff000000)

            {

            case CMD_SET_FILL_PAINT:

                {

                mFillAlpha        = (currentCommand & 0x00ff0000) >> 16;

                quint16 offset    = offsetVector->derefInt16(lOffsetIx * sizeof(quint16));

                HbDereferencer section = getCommandSection(offset, iconData, nvgVersion);

                setFillPaint(&section); 

                }

                break;    

            case CMD_SET_COLOR_RAMP:

                {

                quint16 offset = offsetVector->derefInt16(lOffsetIx * sizeof(quint16));

                HbDereferencer section = getCommandSection(offset, iconData, nvgVersion);

                setColorRamp(&section);

                }

                break;

            case CMD_DRAW_PATH:

                {

                if ((currentCommand & 0x00010000)) 

                    {

                    mDoStroke = VG_TRUE;

                    }

                if ((currentCommand & 0x00020000))

                    {

                    mDoFill = VG_TRUE;

                    }

                quint16 offset = offsetVector->derefInt16(lOffsetIx * sizeof(quint16));

                HbDereferencer section = getCommandSection(offset, iconData, nvgVersion);

                drawPath(&section);

                }

                break;

            case CMD_SET_TRANSFORMATION:

                {

                setTransform(commandSection, transVal, lCurrentPathMatrix);

                commandSection->skip(transVal * sizeof(quint32));

                }

                break;

            case CMD_SET_STROKE_PAINT:

                {

                mStrokeAlpha = (currentCommand & 0x00ff0000) >> 16;

                quint16 offset = offsetVector->derefInt16(lOffsetIx * sizeof(quint16));

                HbDereferencer section = getCommandSection(offset, iconData, nvgVersion);

                setStrokePaint(&section); 

                }

                break;

            case CMD_SET_STROKE_WIDTH:

                {

                float lStrokeWidth;

                commandSection->skip(sizeof(quint32));

                /*

                 * check for alignment and copy data if not aligned, else directly convert

                 * version 2 or above guarantees that is always word aligned

                 */

                quint8 * cptr = commandSection->derefInt8Array(sizeof(float), 0); 

                if (nvgVersion < Version2 && !isAligned4(cptr))

                    {

                    memcpy(reinterpret_cast<void *>(&lStrokeWidth),

                              reinterpret_cast<void *>(cptr), sizeof(lStrokeWidth));

                    }

                else

                    {

                    lStrokeWidth = commandSection->derefReal32();

                    }

                COND_COM_OC(mCreatingNvgIcon,

                        addSetStrokeWidthCommand(lStrokeWidth),

                        vgSetf(VG_STROKE_LINE_WIDTH, lStrokeWidth));

                }

                break;

            case CMD_SET_STROKE_MITER_LIMIT:

                {

                float lMiterLimit;

                commandSection->skip(sizeof(float));

                /*

                 * check for alignment and copy data if not aligned, else directly convert

                 * version 2 or above guarantees that is always word aligned

                 */

                quint8 * cptr = commandSection->derefInt8Array(sizeof(float), 0); 

                if (nvgVersion < Version2 && !isAligned4(cptr))

                    {

                    memcpy(reinterpret_cast<void *>(&lMiterLimit),

                              reinterpret_cast<void *>(cptr), sizeof(lMiterLimit));

                    }

                else

                    {

                    lMiterLimit = commandSection->derefReal32();

                    }

                COND_COM_OC(mCreatingNvgIcon,

                        addSetStrokeMiterLimitCommand(lMiterLimit),

                        vgSetf(VG_STROKE_MITER_LIMIT, lMiterLimit));

                }

                break;

            case CMD_SET_STROKE_LINE_JOIN_CAP:

                {

                quint8 lJoinType =(currentCommand & 0x0000ff00)>>8;

                quint8 lCapType = (currentCommand & 0x000000ff);

                VGCapStyle capStyle;

                switch(lCapType)

                    {

                    case CAP_SQUARE:

                        capStyle = VG_CAP_SQUARE;

                        break;

                    case CAP_ROUND:

                        capStyle = VG_CAP_ROUND;

                        break;

                    case CAP_BUTT:

                    default:

                        capStyle = VG_CAP_BUTT;

                        break;

                    }

                VGJoinStyle lineJoinStyle;

                switch(lJoinType)

                    {

                    case LINE_JOIN_BEVEL:

                        lineJoinStyle = VG_JOIN_BEVEL;

                        break;

                    case LINE_JOIN_ROUND:

                        lineJoinStyle = VG_JOIN_ROUND;

                        break;

                    case LINE_JOIN_MITER:

                    default:

                        lineJoinStyle = VG_JOIN_MITER;

                        break;

                    }

                COND_COM_OC(mCreatingNvgIcon,

                        addStrokeLineJoinCapCommand(capStyle, lineJoinStyle),

                        vgSeti(VG_STROKE_CAP_STYLE, capStyle);

                        vgSeti(VG_STROKE_JOIN_STYLE, lineJoinStyle););

                }

                break;

            default:

                {

                throw HbNvgException(HbNvgEngine::NvgErrCorrupt);			

                }

            }

        // go to the next command

        commandSection->skip(sizeof(quint32));

        }

    }

HbDereferencer HbNvgCsIcon::getCommandSection(quint16 offset, HbDereferencer * iconData, int nvgVersion)

    {

    // the max length that the command section can have

    int commandSectionLength = iconData->getLength() - offset;

    if (commandSectionLength <= 0){

        throw HbNvgException(HbNvgEngine::NvgErrCorrupt);

    }

    HbDereferencer section(iconData->derefInt8Array(commandSectionLength, offset), commandSectionLength);

    /*

     * all the section are expected to be word aligned

     * all of the nvg-cs icon will be version 2 or above

     * the else won't be there as nvg version will always be greater than 2

     */

    if (nvgVersion >= Version2) {

        if (!isAligned4(offset)) {

            throw HbNvgException(HbNvgEngine::NvgErrCorrupt);

        }

    }else{

        /*

         * no need to do anything here as once the nvgdecoder release

         * its version will be always greater than 2

         * infact the check for version will be removed

         */ 

    }

    return section;

    }

void HbNvgCsIcon::applyViewboxToViewPortTransformation(const QSize& targetSize, 

        float viewboxX, float viewboxY, float viewboxW, float viewboxH)

    {

    HbNvgFitToViewBoxImpl *viewBoxTx = new HbNvgFitToViewBoxImpl();

    Q_CHECK_PTR(viewBoxTx);

    QScopedPointer<HbNvgFitToViewBoxImpl> viewboxTrnsfr(viewBoxTx);

    /*

     * this is bit unreadable,

     * need to find a better design to separate the object caching solution from normal rendering,

     */

    COND_COM_OC_NOC(

            {

            if (mCreatingNvgIcon) {

                setViewBox(viewboxX, viewboxY, viewboxW, viewboxH);

                }