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

#if defined (HB_NVG_CS_ICON)
#include <nvg.h>
// Note: Cases of the following two directory names intentionally differ to
//       match the cases of the corresponding directories in Symbian 4.
#include <VG/openvg.h>
#include <vg/vgcontext_symbian.h>

struct HbNvgAspectRatioSettings
{
    TNvgAlignStatusType nvgAlignStatusAndAspectRatio;
    TNvgMeetOrSliceType type;
};
#endif //HB_NVG_CS_ICON

/*!
    \fn mapKeyAspectRatioToNvgAspectRatio()
    \a aspectRatio
 */
HbNvgAspectRatioSettings mapKeyAspectRatioToNvgAspectRatio(
                                                Qt::AspectRatioMode aspectRatio)
{
    HbNvgAspectRatioSettings settings;
    switch(aspectRatio) {

    case Qt::IgnoreAspectRatio: {
        settings.nvgAlignStatusAndAspectRatio = ENvgPreserveAspectRatio_None;
        settings.type = ENvgMeet;
        break;
    }
    case Qt::KeepAspectRatio: {
        settings.nvgAlignStatusAndAspectRatio = ENvgPreserveAspectRatio_XmidYmid;
        settings.type = ENvgMeet;
        break;
        }
    case Qt::KeepAspectRatioByExpanding: {
        settings.nvgAlignStatusAndAspectRatio = ENvgPreserveAspectRatio_XmidYmid;
        settings.type = ENvgSlice;
        break;
        }
    default: {
        settings.nvgAlignStatusAndAspectRatio = ENvgPreserveAspectRatio_XmidYmid;
        settings.type = ENvgMeet;
        break;
        }
    }
    return settings;
}

/*!
    \fn mapToVgiDisplayFormat()
    \a imageFormat
 */
VGIColorBufferFormat mapToVgiDisplayFormat(QImage::Format imageFormat)
{
    VGIColorBufferFormat format = VGI_COLOR_BUFFER_FORMAT_ARGB8888_PRE;
    switch(imageFormat)
    {
    case QImage::Format_Mono:
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
            format = VGI_COLOR_BUFFER_FORMAT_ARGB8888;
            break;
    case QImage::Format_ARGB32_Premultiplied:
            format = VGI_COLOR_BUFFER_FORMAT_ARGB8888_PRE;
            break;
    case QImage::Format_RGB16:
    case QImage::Format_ARGB8565_Premultiplied:
    case QImage::Format_RGB666:
    case QImage::Format_ARGB6666_Premultiplied:
    case QImage::Format_RGB555:
    case QImage::Format_ARGB8555_Premultiplied:
            break;
    case QImage::Format_RGB888:
            format = VGI_COLOR_BUFFER_FORMAT_RGB888;
            break;
    case QImage::Format_RGB444:
    case QImage::Format_ARGB4444_Premultiplied:
    case QImage::Format_Invalid:
        break;
    }
    return format;
}

static HbNvgRasterizer *nvgRasterizer = 0;

HbNvgRasterizer* HbNvgRasterizer::global()
{
    if (!nvgRasterizer) {
        nvgRasterizer = new HbNvgRasterizer();
    }
    return nvgRasterizer;
}

HbNvgRasterizer::HbNvgRasterizer() : vgiSymbianInit(false), nvgEngine(0)
{
}

HbNvgRasterizer::~HbNvgRasterizer()
{
    terminate();
}

bool HbNvgRasterizer::initialize(int width, int height)
{
    vgiSymbianInit = false;

    TInt err =  VGISymbianInitialize( TSize(width, height), VGI_COLORSPACE_SRGB );
    if( err == KErrAlreadyExists || err == KErrNone) {
        vgiSymbianInit = true;
    }

    if (vgiSymbianInit) {
        TRAP(err, nvgEngine = CNvgEngine::NewL());
        if (err != KErrNone) {
            return (vgiSymbianInit = false);
        }
    }

    return vgiSymbianInit;
}

bool HbNvgRasterizer::terminate()
{
    if (vgiSymbianInit) {
        VGISymbianTerminate();
        vgiSymbianInit = false;
    }

    return true;
}

bool HbNvgRasterizer::rasterize(const QByteArray &nvgData,
                   const QSizeF &renderSize,
                   Qt::AspectRatioMode aspectRatioMode,
                   QImage & destination,
                   QImage::Format imageFormat)
{
    if (destination.isNull()) {
        destination = QImage(renderSize.toSize(), imageFormat);
    }

    TUint8 * imageData = destination.bits();
    TInt stride = destination.bytesPerLine();

    return rasterize(nvgData, renderSize, aspectRatioMode, imageData, stride, imageFormat);
}

bool HbNvgRasterizer::rasterize(const QByteArray &nvgData,
               const QSizeF &renderSize,
               Qt::AspectRatioMode aspectRatioMode,
               void * destination, int stride,
               QImage::Format imageFormat)
{
    bool isIconCreated = false;
    TSize surfaceSize(TSize(renderSize.width(), renderSize.height()));

    if (!vgiSymbianInit) {
        if (!initialize(surfaceSize.iWidth, surfaceSize.iHeight)) {
            return isIconCreated;
        }
    }

    TInt err = VGISymbianResize(surfaceSize);
    if(err != KErrNone) {
        return isIconCreated;
    }

    HbNvgAspectRatioSettings settings = mapKeyAspectRatioToNvgAspectRatio(aspectRatioMode);
    nvgEngine->SetPreserveAspectRatio(settings.nvgAlignStatusAndAspectRatio, settings.type);


    nvgEngine->SetBackgroundColor(0xFFFFFF00);

    TPtr8 data((unsigned char*)nvgData.data(), nvgData.length(), nvgData.length());
    err = nvgEngine->DrawNvg(data, surfaceSize, 0, 0);
    if(err !=KErrNone) {
        return isIconCreated;
    }

    //copy the data from the surface
    VGIColorBufferFormat format = (VGIColorBufferFormat)mapToVgiDisplayFormat(imageFormat);

    err = VGICopyToTarget(format, stride, destination, 0, NULL, VGI_COPY_TRANSPARENT_PIXELS);
    if (err == VGI_OK) {
        isIconCreated = true;
    }

    return isIconCreated;
}