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

**

** 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 <QPainter>

#include <QIcon>

#include <QPixmap>

#include <QDebug>

#include <QBitmap>

/*!

    @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.

    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.

    - 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>

    - left            <name>_l.<ext>

    - center          <name>_c.<ext>

    - right           <name>_r.<ext>

    - 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.

    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.

            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.

            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>

            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())

{

    //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),

    layoutDirection(Qt::LeftToRight),

    graphicsItem(0),

    color(),

    icon(0),

    maskChanged(false),

    clipPath(QPainterPath())

{

    // Remove possible file extension

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

        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),

    color(other.color),

    icon(0),

    maskChanged(false),

    clipPath(QPainterPath())

{

    //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();

    }

        createFrameIcon();

    }

}

/*!

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

*

* \sa HbFrameDrawerPrivate::setBorderApiProtectionFlag()

*/

bool HbFrameDrawerPrivate::testBorderApiProtectionFlag() const

{

}

/*!

* 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)

{

}

/*!

* 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) {

                return suffixList;

        }

    // Otherwise, return default suffix list.

    QStringList list;

    switch (type) {

    }

    return list;

}

/*!

* 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) {

        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()) {

            }

        }

        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.

        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);

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

        }

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

    } 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,

                }

            }

        }

                // store the icon type

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

            }

        }

    }

    maskChanged = false;

}

/*!

\internal

*/

{

    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()) {