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

**

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

#include "hbframedrawer_p.h"

#include "hbimagetraces_p.h"

#include <hbinstance.h>

#include <hbiconimpl_p.h>

#include <hbiconloader_p.h>

#include "hbmaskableiconimpl_p.h"

#include <QPainter>

#include <QIcon>

#include <QPixmap>

#include <QDebug>

#include <QBitmap>

/*!

	@stable

    @hbcore

    \class HbFrameDrawer

    \brief HbFrameDrawer draws frames graphics.

    This class is not intended to be derived from.

    Frame graphics mean graphics that consist of either 3 or 9 parts that are positioned

    and scaled followingly.

    A 9-piece frame consists of a 3x3 grid, where the corner parts have a fixed size and

    the other parts are scaled.

    A 3-piece frame consists of 3 parts tiled either horizontally of vertically. The side

    parts preserve their aspect ratio and the center part is scaled to fill the remaining space.

    For convenience, frame drawer can also draw the frame with a single graphic.

    The frame drawer implements the logic of scaling and positioning the frame parts and

    takes care that there are no visible gaps between the frame parts when the whole frame

    is painted to the display even if the frame bounding rectangle uses floating point accuracy.

    Filenames for 9-piece frame graphics are defined according to the following.

    - top left        <name>_tl.<ext>

    - top             <name>_t.<ext>

    - top right       <name>_tr.<ext>

    - left            <name>_l.<ext>

    - center          <name>_c.<ext>

    - right           <name>_r.<ext>

    - bottom left     <name>_bl.<ext>

    - bottom          <name>_b.<ext>

    - bottom right    <name>_br.<ext>

    Filenames for 3-piece horizontal frame graphics are defined according to the following.

    - left            <name>_l.<ext>

    - center          <name>_c.<ext>

    - right           <name>_r.<ext>

    Filenames for 3-piece vertical frame graphics are defined according to the following.

    - top             <name>_t.<ext>

    - center          <name>_c.<ext>

    - bottom          <name>_b.<ext>

    \note The suffixes (e.g. "_l") in the filenames can be redefined with method

    HbFrameDrawer::setFileNameSuffixList().

    \note If all of the frame pieces cannot be found, the frame drawer falls back to a single

    frame graphics piece with filename <name>.<ext> to draw the frame.

    If even that does not exist, nothing is drawn.

    See class HbIcon for information of supported icon formats and file locations.

    The frame drawer stores the whole generated frame graphics in a pixmap for

    improving the speed of the paint operations. Therefore, the frame drawer instance should not

    be re-created each time the frame needs to be rendered.

    Example of how to create a frame drawer and use it.

    \dontinclude ultimatecodesnippet/ultimatecodesnippet.cpp

    \skip nine-piece

    \until }

    \sa class HbFrameItem

*/

/*!

  \enum HbFrameDrawer::FrameType

  \b Undefined The frame type is undefined. It must be defined before being able to draw the frame.

  \b OnePiece The frame consist of a single graphic piece, which is scaled to the frame's bounding rectangle.

  \b ThreePiecesHorizontal The frame consists of three graphic pieces that are tiled horizontally.

            As default, the side parts preserve their aspect ratio and the center part is scaled to fill the remaining space.

            Filenames for 3-piece horizontal frame graphics are defined according to the following.

            - left            <name>_l.<ext>

            - center          <name>_c.<ext>

            - right           <name>_r.<ext>

  \b ThreePiecesVertical The frame consists of three graphic pieces that are tiled vertically.

            As default, the side parts preserve their aspect ratio and the center part is scaled to fill the remaining space.

            Filenames for 3-piece vertical frame graphics are defined according to the following.

            - top             <name>_t.<ext>

            - center          <name>_c.<ext>

            - bottom          <name>_b.<ext>

  \b NinePieces The frame consists of a 3x3 grid of graphic pieces, where as default the corner

            parts have a fixed size and the other parts are scaled.

            Filenames for 9-piece frame graphics are defined according to the following.

            - top left        <name>_tl.<ext>

            - top             <name>_t.<ext>

            - top right       <name>_tr.<ext>

            - left            <name>_l.<ext>

            - center          <name>_c.<ext>

            - right           <name>_r.<ext>

            - bottom left     <name>_bl.<ext>

            - bottom          <name>_b.<ext>

            - bottom right    <name>_br.<ext>

*/

#define DEFAULT_OPTIONS (HbIconLoader::ReturnUnknownIcon | HbIconLoader::BitmapIcons | HbIconLoader::VectorIcons)

// Same rounding function is used everywhere for consistency

static inline int realToInt(qreal r)

{

    return (int)(r + 0.5);

}

/*!

\internal

*/

HbFrameDrawerPrivate::HbFrameDrawerPrivate() :

    QSharedData(),

    type(HbFrameDrawer::Undefined),

    frameParts(0),

    mirroring(HbIcon::Default),

    defaultMirroring(Unknown),

    flags(0),

    layoutDirection(Qt::LeftToRight),

    graphicsItem(0),

    color(),

    icon(0),

    maskChanged(false),

    clipPath(QPainterPath())

{

    borderWidths[0]=0.0;

    borderWidths[1]=0.0;

    borderWidths[2]=0.0;

    borderWidths[3]=0.0;

    //Register the HbFrameDrawerPrivate Instance to HbIconLoader

    HbIconLoader::global()->storeFrameDrawerInfo(this);

}

/*!

\internal

*/

HbFrameDrawerPrivate::HbFrameDrawerPrivate(const QString &frameGraphicsName, HbFrameDrawer::FrameType type) :

    QSharedData(),

    frameGraphicsName(frameGraphicsName),

    type(type),

    mask(QPixmap()),

    frameParts(0),

    mirroring(HbIcon::Default),

    defaultMirroring(Unknown),

    flags( 0 ),

    layoutDirection(Qt::LeftToRight),

    graphicsItem(0),

    color(),

    icon(0),

    maskChanged(false),

    clipPath(QPainterPath())

{

    borderWidths[0]=0.0;

    borderWidths[1]=0.0;

    borderWidths[2]=0.0;

    borderWidths[3]=0.0;

    // Remove possible file extension

    int index = this->frameGraphicsName.lastIndexOf(QChar('.'));

    if (index>0) {

        this->frameGraphicsName.resize(index);

    }

    //Register the HbFrameDrawerPrivate Instance to HbIconLoader

    HbIconLoader::global()->storeFrameDrawerInfo(this);

}

/*!

\internal

*/

HbFrameDrawerPrivate::HbFrameDrawerPrivate(const HbFrameDrawerPrivate &other) :

    QSharedData(other),

    frameGraphicsName(other.frameGraphicsName),

    type(other.type),

    rect(other.rect),

    mask(QPixmap()),

    frameParts(other.frameParts),

    mirroring(other.mirroring),

    defaultMirroring(other.defaultMirroring),

    flags( other.flags ),

    layoutDirection( other.layoutDirection ),

    graphicsItem( other.graphicsItem ),

    color(other.color),

    icon(0),

    maskChanged(false),

    clipPath(QPainterPath())

{

    borderWidths[0]=other.borderWidths[0];

    borderWidths[1]=other.borderWidths[1];

    borderWidths[2]=other.borderWidths[2];

    borderWidths[3]=other.borderWidths[3];

    //Register the HbFrameDrawerPrivate Instance to HbIconLoader

    HbIconLoader::global()->storeFrameDrawerInfo(this);

}

/*!

\internal

*/

HbFrameDrawerPrivate::~HbFrameDrawerPrivate()

{

    unLoadIcon();

    //Unregister the HbFrameDrawerPrivate Instance to HbIconLoader

    HbIconLoader::global()->removeFrameDrawerInfo(this);

}

/*!

\internal

*/

void HbFrameDrawerPrivate::prepareFrameIcon()

{

    if (!frameParts) {

        checkFrameParts();

    }

    if ((!icon ) && (!fallbackMaskableIconList.count()) ) {

        createFrameIcon();

    }

}

/*!

* Returns whether this frame drawer's border widths have been set by API

*

* \sa HbFrameDrawerPrivate::setBorderApiProtectionFlag()

*/

bool HbFrameDrawerPrivate::testBorderApiProtectionFlag() const

{

	return flags & HbFrameDrawerPrivate::BorderWidthSetByApi;

}

/*!

* Clears the flag denoting that the border widths have been set by API.

* This will cause control of border widths to return to the CSS system.

*

* \sa HbFrameDrawerPrivate::testBorderApiProtectionFlag()

*/

void HbFrameDrawerPrivate::setBorderApiProtectionFlag(bool on)

{

	if(on){

		flags |= HbFrameDrawerPrivate::BorderWidthSetByApi;

	}else{

		flags &= ~HbFrameDrawerPrivate::BorderWidthSetByApi;

	}

}

/*!

* Checks whether all the frame parts are available for the given frame type.

* Fallback is 1-part frame rendering.

* \internal

*/

void HbFrameDrawerPrivate::checkFrameParts()

{

    // fall back is 1 piece frame

    frameParts = 1;

    if (type == HbFrameDrawer::ThreePiecesHorizontal || type == HbFrameDrawer::ThreePiecesVertical) {

        if (HbIconLoader::iconsExist(frameGraphicsName, fileNameSuffixList())) {

            frameParts = 3;

        }

    } else if (type == HbFrameDrawer::NinePieces) {

        if (HbIconLoader::iconsExist(frameGraphicsName, fileNameSuffixList())) {

            frameParts = 9;

        }

    }

}

/*!

\internal

*/

QStringList HbFrameDrawerPrivate::fileNameSuffixList() const

{

    // If the suffix list has been set explicitly, return that if it contains enough suffixes.

    if (!suffixList.isEmpty()) {

        switch (type) {

            case HbFrameDrawer::ThreePiecesHorizontal: // fall through

            case HbFrameDrawer::ThreePiecesVertical:

                if (suffixList.count() >= 3) {

                    return suffixList;

                }

                break;

            case HbFrameDrawer::NinePieces:

                if (suffixList.count() >= 9) {

                    return suffixList;

                }

                break;

            default:

                return suffixList;

        }

    } 

    // Otherwise, return default suffix list.

    QStringList list;

    switch (type) {

        case HbFrameDrawer::ThreePiecesHorizontal:

            list << "_l" << "_c" << "_r";

            break;

        case HbFrameDrawer::ThreePiecesVertical:

            list << "_t" << "_c" << "_b";

            break;

        case HbFrameDrawer::NinePieces:

            list << "_tl" << "_t" << "_tr" << "_l" << "_c" << "_r" << "_bl" << "_b" << "_br";

            break;

        default:

            break;

    }

    return list;

}

/*!

* Creates a consolidated HbIconImpl (Icon) with the available piece information 

* If failed to create the same, then creates HbIconImpls for the pieces.

* \internal

*/

void HbFrameDrawerPrivate::createFrameIcon()

{

    // Divide rectangle area to the frame parts first.

    HbMultiPartSizeData data;

    QSize frameIconSize = divideSpace(data);

    data.multiPartIconId = multiPartIconId();

    multiPartSizeData = data;

    // Create the frame icon and add it in the icon cache

    HbIconLoader *loader = HbIconLoader::global();

    //If it's one-piece frame-item, it's loaded using HbIconLoader::loadIcon()

    if (frameParts == 1) {

        HbIconImpl * iconImpl =  loader->loadIcon(frameGraphicsName, HbIconLoader::AnyType,

                                 HbIconLoader::AnyPurpose,

                                 frameIconSize,

                                 Qt::IgnoreAspectRatio,

                                 QIcon::Normal,

                                 iconLoaderOptions());

        if (iconImpl) {

            icon = new HbMaskableIconImpl(iconImpl);

        }

    } else {

        QStringList multiPieceFileNames;

        QStringList list = fileNameSuffixList();

        int nameListCount = list.count();

        for (int i = 0; i < nameListCount; i++) {

            multiPieceFileNames.append(frameGraphicsName + list[i]);

            if (data.pixmapSizes[i].isEmpty()) {

                data.pixmapSizes[i] = QSize(0,0);

            }

        }

        QVector<HbIconImpl *> listOfIcons;

        //For multi-piece frame-items, HbIocnLoader::loadMultipieceIcon is used

        //This function returns the consolidate (stitched) icon created on the themeserver.

        //If the consolidated icon-creation on themeserver fails, then server returns a list

        //of individual frame-items.

        HbIconImpl * iconImpl = loader->loadMultiPieceIcon(multiPieceFileNames, data, frameIconSize,

                                          Qt::IgnoreAspectRatio, QIcon::Normal, iconLoaderOptions(),

                                          listOfIcons, color);

        if (iconImpl) {

            icon = new HbMaskableIconImpl(iconImpl);

        } else {

            int implCount = listOfIcons.count();

            for (int i = 0; i < implCount; i++) {

                fallbackMaskableIconList.append(new HbMaskableIconImpl(listOfIcons[i]));

            }

        }

    }

}

/*!

\internal

*/

void HbFrameDrawerPrivate::paint(QPainter *painter)

{

    // createFrameIcon() must be called before calling this method.

    QRectF centeredRect(rect);

    QRect integerRect = rect.toRect();

    if (icon) {

        QSize size = icon->size();

        if (integerRect.width() != size.width()) {

            centeredRect.adjust((rect.width() - size.width()) / 2, 0, 0, 0);

            centeredRect.setWidth(size.width());

        }

        if (integerRect.height() != size.height()) {

            centeredRect.adjust(0, (rect.height() - size.height()) / 2, 0, 0);

            centeredRect.setHeight(size.height());

        }

        if (!mask.isNull() && maskChanged) {

            icon->setMask(mask);

        } 

        //paint the stitched icon

        icon->paint(painter, centeredRect, Qt::AlignHCenter, clipPath);

        if ( icon->isCreatedOnServer() ) {

            iconType = icon->iconImpl()->iconData().type;

        }

        #ifdef HB_FRAME_DRAWER_TRACES

        qDebug() << "FRAMENAME: " << frameGraphicsName << "Drawn at: "

        << centeredRect.topLeft().x() << "," << centeredRect.topLeft().y() << " | "

        << centeredRect.bottomRight().x() << "," << centeredRect.bottomRight().y();

        #endif

    } else {

        for (int i = 0; i < fileNameSuffixList().count(); i++) {

            if (i < fallbackMaskableIconList.count() && fallbackMaskableIconList[i]) {

                QPoint position = multiPartSizeData.targets[i].topLeft();

                if (isMirrored()) {

                    int centerTopRightX = (int)(centeredRect.topLeft().x() + centeredRect.width());

                    int targetTopRightX = multiPartSizeData.targets[i].topLeft().x()

                                          + multiPartSizeData.targets[i].width();

                    position.setX((int)(centeredRect.topLeft().x() + (centerTopRightX - targetTopRightX)));

                } else {

                    position.setX((int)(centeredRect.topLeft().x() + position.x()));

                }

                position.setY((int)(centeredRect.topLeft().y() + position.y()));

                if ((!mask.isNull()) && maskChanged) {

                    QBitmap pieceMask ;

                    QRect maskRect(position.x(), position.y(), multiPartSizeData.targets[i].width(), multiPartSizeData.targets[i].height());

                    pieceMask = mask.copy(maskRect);

                    fallbackMaskableIconList[i]->setMask(pieceMask);

                }

                if (!multiPartSizeData.targets[i].isEmpty()) {

                    fallbackMaskableIconList[i]->paint(painter,

                            QRect(position, multiPartSizeData.pixmapSizes[i]),

                            Qt::AlignHCenter, clipPath);

                }

            }

        }

        if ( fallbackMaskableIconList[0]->iconImpl()

             && fallbackMaskableIconList[0]->iconImpl()->isCreatedOnServer() ) {

            if ( fallbackMaskableIconList[0]->iconImpl()->iconData().type != INVALID_FORMAT ) {

                // store the icon type

                iconType = fallbackMaskableIconList[0]->iconImpl()->iconData().type;

            }

        }

    }

    maskChanged = false;

}

/*!

\internal

*/

bool HbFrameDrawerPrivate::fillWholeRect() const 

{

    return flags & HbFrameDrawerPrivate::FillWholeRect;

}

/*!

* Calculates frame part rectangles and icon sizes based on the following information.

* - frame bounding rectangle

* - frame inner rectangle (optional)

* - default sizes of the frame corner (9-piece) or side (3-piece) graphics.

* 

* Note! Integer pixel sizes are used in this function to avoid one pixel gaps between the frame parts.

* \internal

*/

QSize HbFrameDrawerPrivate::divideSpace(HbMultiPartSizeData &data)

{

    // Do not need to divide space if there is only one frame part.

    if (frameParts == 1) {

        QSizeF size = rect.size();

        // If the whole rect is not filled, use default graphics size to define one of the dimensions.

        if (type == HbFrameDrawer::ThreePiecesHorizontal && !fillWholeRect()) {

            qreal defaultHeight = defaultSize("").height();

            if (defaultHeight < size.height()) {

                size.setHeight(defaultHeight);

            }

        } else if (type == HbFrameDrawer::ThreePiecesVertical && !fillWholeRect()) {

            qreal defaultWidth = defaultSize("").width();

            if (defaultWidth < size.width()) {

                size.setWidth(defaultWidth);

            }

        }

        // Using same rounding as in other code below

        return QSize(realToInt(size.width()), realToInt(size.height()));

    }