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

**

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

#include "hbnvg_p.h"

#include <QFile>

#include "hbiconsource_p.h"

#include "hbmemoryutils_p.h"

#include <hbtlvwrapper_p.h>

#include "hbthemeserverutils_p.h"

/*!

    @hbserver

    \class HbNvgIconProcessor

    \brief HbNvgIconProcessor is responsible for retrieving the Nvg vector data from the NVG icon file,

    and copy the icon data to the cpu shared memory.

*/

/*!

    \fn HbNvgIconProcessor::HbNvgIconProcessor()

    Constructor

    \a key denotes the unique identifier for the cache item

    \a options indicate different ways of loading icons

    \a format indicates the icon format e.g. svg/nvg etc.

 */

HbNvgIconProcessor::HbNvgIconProcessor(

    const HbIconKey &key,

    const HbIconLoader::IconLoaderOptions &options,

    const QString &type)

{

    iconKey = key;

    iconOptions = options;

    iconType = type;

    defaultSize = QSize(0, 0);

    size = QSize(0, 0);

}

/*!

    \fn HbNvgIconProcessor::~HbNvgIconProcessor()

    Destructor

 */

HbNvgIconProcessor::~HbNvgIconProcessor()

{

}

/*!

    \fn HbNvgIconProcessor::createNvgData()

    Retrieves the NVG data from the file

    \a iconPath the path to the icon file

 */

bool HbNvgIconProcessor::createIconData(const QString& iconPath)

{

    if (!iconKey.size.isValid()) {

        return false;

    }

    bool isDefaultSize =  iconKey.size.isNull();

    if (iconType == "SVG") {

        quint32 domhandle = 0;

        defaultSize = (HbTlvWrapper::instance())->contentDimensions((QString&)iconPath, domhandle);

        QSizeF renderSize = QSizeF(defaultSize);

        if (!isDefaultSize) {

            renderSize.scale(iconKey.size, iconKey.aspectRatioMode);

        }

        if (domhandle) {

            size = renderSize.toSize();

        }

    } else {

        HbIconSource *source = HbThemeServerUtils::getIconSource(iconPath);

        QSizeF renderSize = source->defaultSize();

        defaultSize = renderSize.toSize();

        if (!isDefaultSize) {

            renderSize.scale(iconKey.size, iconKey.aspectRatioMode);

        }

        size = renderSize.toSize();

    }

    return true;

}

/*!

    \fn HbNvgIconProcessor::sharedIconDataCost()

    Returns the size of the Nvg icon data in bytes

 */

int HbNvgIconProcessor::sharedIconDataCost() const

{

    int size = byteArray.size();

    return size;

}

/*!

    \fn HbNvgIconProcessor::sharedIconData()

    Copies the Nvg vector data to the shared memory

 */

HbSharedIconInfo HbNvgIconProcessor::sharedIconData()const

{

    HbSharedIconInfo data;

    data.type = INVALID_FORMAT;

    if (!byteArray.isNull()) {

        GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

        try {

            //alloc function of memory manager can throw

            data.nvgData.offset =  manager->alloc(byteArray.size());

            data.nvgData.defaultWidth = defaultSize.width();

            data.nvgData.defaultHeight = defaultSize.height();

            data.nvgData.width = size.width();

            data.nvgData.height = size.height();

            data.type = NVG;

            data.nvgData.dataSize = byteArray.size();

            memcpy(HbMemoryUtils::getAddress<char>(HbMemoryManager::SharedMemory, data.nvgData.offset),

                   byteArray.data(), byteArray.size());

        }

        catch (std::bad_alloc &badAlloc) {

            Q_UNUSED(badAlloc)

        }

    }

    return data;

}