const qint32 Version2   = 2;

const qint32 NVG_VIEWBOX_WIDTH_OFS = 44;

const qint32 NVG_VIEWBOX_HEIGHT_OFS = 48;

const qint32 NVG_VIEWBOX_X_OFS = 36;

const qint32 NVG_VIEWBOX_Y_OFS = 40;

const qint32 NVG_PATHDATATYPE_OFS = 26;

const qint32 NVG_SCALE_OFS = 28;

const qint32 NVG_BIAS_OFS = 32;

const qint32 NVG_COMMANDSECTION_OFS = 2;

const qint32 NVG_RGBA_OFS = 4;

const qint32 NVG_HEADERSIZE_OFS = 4;

const qint32 NVG_PAINTSECTION_LINEARGRAD_TRANSFORM_OFFSET = 20;

const qint32 NVG_PAINTSECTION_RADIALGRAD_TRANSFORM_OFFSET = 24;

const qint32 NVG_VERSION_OFS         = 3;

 */

const qint32 CMD_SET_FILL_PAINT           = 4  << 24;

const qint32 CMD_SET_COLOR_RAMP           = 6  << 24;

const qint32 CMD_DRAW_PATH                = 7  << 24;

const qint32 CMD_SET_TRANSFORMATION       = 8  << 24;

const qint32 CMD_SET_STROKE_PAINT         = 5  << 24;

const qint32 CMD_SET_STROKE_WIDTH         = 9  << 24;

const qint32 CMD_SET_STROKE_LINE_JOIN_CAP = 10 << 24;

const qint32 CMD_SET_STROKE_MITER_LIMIT   = 11 << 24;

const qint32 CAP_BUTT        = 1;

const qint32 CAP_SQUARE      = 2;

const qint32 CAP_ROUND       = 3;

const qint32 LINE_JOIN_BEVEL = 1;

const qint32 LINE_JOIN_MITER = 2;

const qint32 LINE_JOIN_ROUND = 3;

const qint32 PAINT_FLAT      = 1;

const qint32 PAINT_LGRAD     = 2;

const qint32 PAINT_RGRAD     = 3;

const qint32 STROKE_LGRAD        = 2;

const qint32 STROKE_RGRAD        = 3;

const qint32 STROKE_COLOR_RAMP   = 4;

const qint32 TRANSFORM_COMPLETE    = 0;

const qint32 TRANSFORM_SCALING     = 2;

const qint32 TRANSFORM_SHEARING    = 4;

const qint32 TRANSFORM_ROTATION    = 8;

const qint32 TRANSFORM_TRANSLATION = 16;

const VGfloat identityMatrix[] = {

/**

 * @fn      Constructor

 * @Version

 * @parameter: buffer - None

 *

 * @return: None

 */

        mDoFill(VG_FALSE),

        mMirrored(false)

/*!

    set the aspectRatio \a preserveAspectSetting and \a smilFitSetting

    to be applied on the nvgicon.

*/

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

        HbNvgEngine::HbNvgMeetType smilFitSetting)

void HbNvgCsIcon::enableMirroring(bool mirroringMode)

    mMirrored = mirroringMode;

/*!

    Set the \a angle for rotation of the nvgicon at the

    coordiantes  \a x and \a y.

*/

    mRotationAngle  = angle;

    mRotationX      = xValue;

    mRotationY      = yValue;

/*!

    Do the direct draw of the nvg graphic data \a buffer of size \a targetSize

    and return the status of the draw.

*/

/*!

    Create the nvg graphic data \a buffer of size \a targetSize

    and return the status of the draw.

*/

                                     qint32 objectCaching)

{

    qint16 headerSize  = iconData.derefInt16(NVG_HEADERSIZE_OFS);

    HbNvgEngine::HbNvgErrorType errInit = HbNvgEngine::NvgErrNone;

    if (HbNvgEngine::NvgErrNone != errInit) {

    qint16 pathDataType = iconData.derefInt16(NVG_PATHDATATYPE_OFS);

    float scale         = iconData.derefReal32(NVG_SCALE_OFS);

    float bias          = iconData.derefReal32(NVG_BIAS_OFS);

    errInit = createPathHandle(pathDataType, scale, bias);

    if (HbNvgEngine::NvgErrNone != errInit) {

        throw HbNvgException(errInit);

    }

    VGfloat currentPathMatrix[9];

    vgGetMatrix(currentPathMatrix);

    vgLoadMatrix(currentPathMatrix);

//    applyScissoring(currentPathMatrix, targetSize);

    if (mMirrored) {

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

        vgScale(-1.0f, 1.0f);

    }

    vgScale(1.0f, -1.0f);

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

    float viewboxX   = iconData.derefReal32(NVG_VIEWBOX_X_OFS);

    float viewboxY   = iconData.derefReal32(NVG_VIEWBOX_Y_OFS);

    float viewboxW   = iconData.derefReal32(NVG_VIEWBOX_WIDTH_OFS);

    float viewboxH   = iconData.derefReal32(NVG_VIEWBOX_HEIGHT_OFS);

    applyViewboxToViewPortTransformation(targetSize, viewboxX, viewboxY, viewboxW, viewboxH);

    quint32 offsetSectionLength = iconData.getLength() - headerSize;

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

    quint16 offsetVectorCount = offsetSection.derefInt16();

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

    qint32 commandSectionOffset = offsetVectorCount * sizeof(quint16);

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

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

    if (nvgVersion >= Version2 && ((offsetVectorCount  & 0x01) == 0)) {

    }

    quint16 cmdCount = commandSection.derefInt16();

    commandSection.skip(NVG_COMMANDSECTION_OFS);

    if (nvgVersion >= Version2) {

    }

    executeNvgCsCommandLoop(cmdCount, &iconData, &offsetVector, &commandSection, nvgVersion);

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

        HbDereferencer * offsetVector, HbDereferencer * commandSection, quint8 nvgVersion)

{

    VGfloat currentPathMatrix[9];

    vgGetMatrix(currentPathMatrix);

    qint32 offsetIx = 0;

    for (qint32 i = 0; i < commandCount; i++) {

        offsetIx = currentCommand & 0x0000ffff;

        switch (currentCommand & 0xff000000) {

        case CMD_SET_FILL_PAINT: {

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

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

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

            setFillPaint(&section);

        }

        break;

        case CMD_SET_COLOR_RAMP: {

            quint16 offset = offsetVector->derefInt16(offsetIx * 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(offsetIx * sizeof(quint16));

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

            drawPath(&section);

        }

        break;

        case CMD_SET_TRANSFORMATION: {

            setTransform(commandSection, transVal, currentPathMatrix);

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

        }

        break;

        case CMD_SET_STROKE_PAINT: {

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

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

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

            setStrokePaint(&section);

        }

        break;

        case CMD_SET_STROKE_WIDTH: {

            float strokeWidth;

            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 *>(&strokeWidth),

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

            } else {

                strokeWidth = commandSection->derefReal32();

            }

            COND_COM_OC(mCreatingNvgIcon,

                        addSetStrokeWidthCommand(strokeWidth),

                        vgSetf(VG_STROKE_LINE_WIDTH, strokeWidth));

        }

        break;

        case CMD_SET_STROKE_MITER_LIMIT: {

            float miterLimit;

            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 *>(&miterLimit),

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

            } else {

                miterLimit = commandSection->derefReal32();

            }

            COND_COM_OC(mCreatingNvgIcon,

                        addSetStrokeMiterLimitCommand(miterLimit),

                        vgSetf(VG_STROKE_MITER_LIMIT, miterLimit));

        }

        break;

        case CMD_SET_STROKE_LINE_JOIN_CAP: {

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

            quint8 capType = (currentCommand & 0x000000ff);

            VGCapStyle capStyle;

            switch (capType) {

            case CAP_SQUARE:

                capStyle = VG_CAP_SQUARE;

            case CAP_ROUND:

                capStyle = VG_CAP_ROUND;

            case CAP_BUTT:

            default:

                capStyle = VG_CAP_BUTT;

                break;

            }

            VGJoinStyle lineJoinStyle;

            switch (joinType) {

            case LINE_JOIN_BEVEL:

                lineJoinStyle = VG_JOIN_BEVEL;

                break;

            case LINE_JOIN_ROUND:

                lineJoinStyle = VG_JOIN_ROUND;

            case LINE_JOIN_MITER:

            default:

                lineJoinStyle = VG_JOIN_MITER;

                break;

            }

            COND_COM_OC(mCreatingNvgIcon,

        }

        break;

        default: {

            throw HbNvgException(HbNvgEngine::NvgErrCorrupt);

        }

        }

}

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

{

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

    if (commandSectionLength <= 0) {

    } else {

         */

    return section;