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

**

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

#include "hbnvg_p.h"

#include "hbnvgutil_p.h"

#include "hbnvgcsicon_p.h"

#include "hbnvgtlvicon_p.h"

#include "hbnvgiconfactory_p.h"

#include "hbnvgicondata_p.h"

#include "hbnvgexception_p.h"

#include <QByteArray>

/*!

  Constants for nvg file header offsets

const quint8 NVG_SIGNATURE[]      = "nvg";

{

        if (icons[type]) {

            delete icons[type];

        }

    }

}

{

    }

    return 0;

}

{

}

HbNvgEnginePrivate::HbNvgEnginePrivate():

        mCurrentBufferSize(1, 1),

        mRotateAngle(0.0),

        mCentreY(0.0),

        mPreserveAspectSetting(HbNvgEngine::NvgPreserveAspectRatioXmidYmid),

        mSmilFitSetting(HbNvgEngine::NvgMeet),

        mVgImageBinder(0),

        mCreatingNvgIcon(false),

{

    vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);

    vgSeti(VG_FILL_RULE, VG_NON_ZERO);

}

HbNvgEnginePrivate::~HbNvgEnginePrivate()

{

#ifdef    OPENVG_OBJECT_CACHING

    delete  mCurrentNvgIcon;

#endif

}

void HbNvgEnginePrivate::rotate(float angle, float centreX, float centreY)

{

    mCentreX        = centreX;

    mCentreY        = centreY;

    mRotateAngle    = angle;

}

QSize HbNvgEnginePrivate::contentDimensions(const QByteArray &buffer) const

{

        ret = QSize(0, 0);

    }

    return ret;

}

void HbNvgEnginePrivate::updateClientMatrices()

{

    mMatrixMode = vgGeti(VG_MATRIX_MODE);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);

    vgGetMatrix(mPathMatrix);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

    vgGetMatrix(mImageMatrix);

    vgSeti(VG_MATRIX_MODE, mMatrixMode);

}

void HbNvgEnginePrivate::restoreClientMatrices()

{

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);

    vgLoadMatrix(mPathMatrix);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

    vgLoadMatrix(mImageMatrix);

    vgSeti(VG_MATRIX_MODE, mMatrixMode);

}

{

    mLastError = HbNvgEngine::NvgErrNone;

    updateClientMatrices();

        mLastError = HbNvgEngine::NvgErrNoMemory;

    }

    return mLastError;

}

HbNvgIcon * HbNvgEnginePrivate::createNvgIcon(const QByteArray &buffer, const QSize& size)

{

#ifdef OPENVG_OBJECT_CACHING

    mCreatingNvgIcon    = true;

        delete mCurrentNvgIcon;

    }

#else

    QByteArray tempArray = buffer;

    QSize tempSize = size;

    Q_UNUSED(tempArray);

    Q_UNUSED(tempSize);

    return mCurrentNvgIcon;

}

void HbNvgEnginePrivate::doDrawNvg(const QByteArray & buffer, const QSize &size)

    // if size is null then return without doing anything

    if (size.isNull()) {

        return;

    }

    HbDereferencer nvgIconData(buffer);

    quint8 * signature = nvgIconData.derefInt8Array(NVG_SIGNATURE_LENGTH);

    // checking the 'nvg' signature

        NVG_DEBUGP1("Not an NVG icon");

        throw HbNvgException(HbNvgEngine::NvgErrNotSupported);

    }

    quint16 reserved1 = nvgIconData.derefInt16(NvgOffsetReserved1) & 0x03;

    HbNvgIconFactory::HbNvgIconType iconType = (HbNvgIconFactory::HbNvgIconType)(reserved1 & 0x03);

#ifdef OPENVG_OBJECT_CACHING

    mCurrentNvgIcon = HbNvgIconFactory::create(iconType);

    QScopedPointer <HbNvgIcon> nvgIcon(mCurrentNvgIcon);

#else

    HbNvgIcon * nvGIcon = mIconList.getIcon(iconType);

    if (!nvGIcon) {

        mCurrentNvgIcon = HbNvgIconFactory::create(iconType);

    } else {

        mCurrentNvgIcon = nvGIcon;

    }

#endif

    mCurrentNvgIcon->setPreserveAspectRatio(mPreserveAspectSetting, mSmilFitSetting);

    mCurrentNvgIcon->rotate(mRotateAngle, mCentreX, mCentreY);

    mCurrentNvgIcon->setVgImageBinder(mVgImageBinder);

#ifdef OPENVG_OBJECT_CACHING

    if (mCreatingNvgIcon) {

        mCurrentNvgIcon->create(buffer, size);

        nvgIcon.take();

    } else {

        mCurrentNvgIcon->directDraw(buffer, size);

    }

#else

    mCurrentNvgIcon->directDraw(buffer, size);

#endif

}

void HbNvgEnginePrivate::setBackgroundColor(const QColor &rgba8888Color)

{

    mBackgroundColor = rgba8888Color;

}

void HbNvgEnginePrivate::clearBackground()

{

    qint32 r, g, b, a;

    r += r >> 7; g += g >> 7; b += b >> 7; a += a >> 7;

    const VGfloat Inverse255 =  1.0f / 256.0f;

    const VGfloat clearColor[4] = {(Inverse255 * VGfloat(r)),

                                   (Inverse255 * VGfloat(g)),

                                   (Inverse255 * VGfloat(b)),

                                   (Inverse255 * VGfloat(a))

                                  };

    vgSeti(VG_SCISSORING, VG_FALSE);

    vgSetfv(VG_CLEAR_COLOR, 4, clearColor);

    vgClear(0, 0, mCurrentBufferSize.width(), mCurrentBufferSize.height());

    vgSeti(VG_SCISSORING, VG_TRUE);

}

/*!

 */

{

}

/*!

 Destructor

 */

{

    delete  d_ptr;

}

{

}

{

}