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

**

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

#include "hbstyleoptionslider_p.h"

#include "hbstyleoptionsliderelement_p.h"

#include "hbstyleoptionpushbutton_p.h"

#include "hbstyleoptiontoolbutton_p.h"

#include "hbstyleoptiontooltip_p.h"

#include "hbstyleoptionprogressbar_p.h"

#include "hbstyleoptionmenuitem_p.h"

#include "hbstyleoptionlabel_p.h"

#include "hbstyleoptionscrollbar_p.h"

#include "hbstyleoptioncheckbox_p.h"

#include "hbiconloader_p.h"

#include "hbstyleoptiontitlepane_p.h"

#include "hbstyleoptionstatusbar_p.h"

#include "hbstyleoptionindicatorgroup_p.h"

#include "hbstyleoptionprogressdialog_p.h"

#include "hbstyleoptionnotificationdialog_p.h"

#include "hbstyleoptioncolorgridviewitem_p.h"

#include "hbstyleoptionmessagebox_p.h"

#include "hbstyleoptionnavigationbutton_p.h"

#include "hbstyleoptionindicatorbutton_p.h"

#include "hbstyleoptionsignalindicator_p.h"

#include "hbstyleoptionbatteryindicator_p.h"

#include "hbstyleloader.h"

#include "hbwidgetloader_p.h"

#include "hbwidget_p.h"

#include "hbstyleoptionratingslider_p.h"

#include "hbstyleoptiondataformviewitem_p.h"

#include "hbstyleoptiondatagroup_p.h"

#include "hbstyleoptiondatagroupheadingwidget_p.h"

#include "hbstyleoptiondataform_p.h"

#include "hbstyleoptiongroupbox_p.h"

#include "hbstyleoptioncombobox_p.h"

#include "hbstyleoptioninputdialog_p.h"

#include "hbstyleoptionprogresssliderhandle_p.h"

#include "hbstyleoptionprogressslider_p.h"

#include <hbstyleprimitivedata.h>

#include <hbstyletextprimitivedata.h>

#include <hbstylerichtextprimitivedata.h>

#include <hbstyleiconprimitivedata.h>

#include <hbstyleframeprimitivedata.h>

#include <hbstylemarqueeprimitivedata.h>

#include <hbstyletouchareaprimitivedata.h>

#include <hbicon.h>

#include <hbstyle.h>

#include <hbframedrawer.h>

#include <hbiconitem.h>

#include <hbiconitem_p.h>

#include <hbframeitem.h>

#include <hbframedrawer.h>

#include <hbframedrawer_p.h>

#include <hbframebackground.h>

#include <hbprogresstrackitem_p.h>

#include <hbslidertrackitem_p.h>

#include <hbinstance.h>

#include <hbtextitem.h>

#include <hbtextitem_p.h>

#include <hbmarqueeitem.h>

#include <hbmarqueeitem_p.h>

#include <hbrichtextitem.h>

#include <hbrichtextitem_p.h>

#include <hbtoucharea.h>

#include <hbindicatorleveliconitem_p.h>

#include <hbglobal.h>

#include <hbstyleparameters.h>

#include "hbstyleselector_p.h"

#include "hblayeredstyleloader_p.h"

#include "hbwidgetstyleloader_p.h"

#include "hbcssparser_p.h"

#include "hbrepeaticonitem_p.h"

#include "hbnamespace_p.h"

#include "hbanchorlayout.h"

#include <hbanchor.h>

#include <QGraphicsWidget>

#include <hbwidgetbase.h>

#include "hbdeviceprofile.h"

#include "hbrepeatitem_p.h"

#include <QDebug>

#include <QMetaClassInfo>

#ifdef HB_TEXT_MEASUREMENT_UTILITY

#include "hbinstance_p.h"

#include "hbfeaturemanager_r.h"

#endif

Q_DECLARE_METATYPE(QGraphicsLayout*)

//Uncomment next define(s) in order to get more debug prints.

//Similar define exists also in the engine side.

//#define HBSTYLE_DEBUG

/*!

    @beta

    @hbcore

    \class HbStyle

    \brief HbStyle is the style management class for widgets

    HbStyle is used for the style management of widgets.

    It offers methods to create and update styled primitives. Briefly, styled primitives

    are HbWidgetBase-derived (which is a QGraphicsWidget) classes which draw a certain part of the user interface (for example

    the button background, or the slider thumb).

    A widget that chooses to be styled needs to create its primitives

    by using the createPrimitive method.

    Whenever the widget's state changes in a way that needs changes in drawing the primitive

    (such as button pressed down -> change the button background image) then the widget needs to

    call the updatePrimitive method.

    Generally primitives should be updated only when a state change occurs. When a widget uses primitives to construct

    itself it does not need a paint() method at all since primitives (widget's children) are doing the drawing.

    Painting for the primitives occurs from the graphics scene.

    HbStyle has some caching functionality and thus it should not be instantiated explicitly, but

    accessed only through HbWidget::style() or HbInstance::style() APIs.

*/

// TODO: margins should be defined in layout data once layout specification exists.

static const QString STYLE_LOCATION = QLatin1String(":/themes/style/hbdefault/rules/widgets/%w/%w");

static const QString COLOR_STYLE_LOCATION = QLatin1String(":/themes/style/hbdefault/rules/widgets/%w/%w_color.css");

static const int TOUCHAREA_ZVALUE = 1000;

static const QString GLOBAL_PARAMETERS_LOCATION = QLatin1String(":/themes/style/hbdefault/variables/layout/zoom/0/hbglobalparameters.css");

static const char* LAYOUT_PTR_PROPERTY = "HbStyle_layout_ptr";

static const char* LAYOUT_NAME_PROPERTY = "HbStyle_layout_name";

#ifdef HB_TEXT_MEASUREMENT_UTILITY

static const int AUTOMATIC_TEXT_MEASUREMENT = 2;

#endif

inline void overrideSpacing( HbAnchorLayout *layout, const QString &name, Hb::Edge edge, qreal val )

{

    if( name.isNull() ) {

        return;

    }

    QList<HbAnchor*> list = layout->anchors();

    for( int i = 0; i < list.size(); i++ ) {

        HbAnchor *anchor = list.at(i);

        if( ( anchor->startNodeId() == name ) && ( anchor->startEdge() == edge ) ) {

            anchor->setDirection( val < 0 ? HbAnchor::Negative : HbAnchor::Positive );

            anchor->setPreferredLength( qAbs(val) );

            if (anchor->anchorId().isEmpty()) {

                // assuming it's a fixed anchor

                anchor->setSizePolicy( QSizePolicy::Fixed );

            } else {

                // assuming it's a "spacer" and we want to override the minimum length

                anchor->setMinimumLength( qAbs(val) );

            }

        }

    }

}

/*!

Constructor

Should not be called explicitly. Use HbWidget::style() or HbInstance::style() instead.

*/

HbStyle::HbStyle() :

    d_ptr(new HbStylePrivate)

{

    Q_D( HbStyle );

    d->q_ptr = this;

}

/*!

Destructor

*/

HbStyle::~HbStyle()

{

    delete d_ptr;

}

/*!

   Instantiates widget building blocks. The building blocks are called "primitives" and their main function is to perform the painting (e.g. drawing text).

   A set of base primitives are defined in HbStyle::BasePrimitive enumeration. A widget calling this method should not cast the returned QGraphicsObject

   to the actual primitive object. By following this rule the styling mechanism can be used to change the actual primitive instance to something else than the original one 

   instantiated by the createPrimitive() method. This enables customizing the painting of the UI without touching the widget code.

   Updating of a primitive's state is done by using HbStyle::updatePrimitive() method which uses the style primitive data classes (comparable to

   Qt styleoptions) to get the state information needed for the primitive updating.

    \return QGraphicsObject, the returned primitive should be stored as a QGraphicsObject on the widget side

    \sa HbStyle::updatePrimitive()

    \sa HbStylePrimitiveData

    \sa HbStyleTextPrimitiveData

    \sa HbStyleFramePrimitiveData

    \sa HbStyleIconPrimitiveData

    \sa HbStyleRichTextPrimitiveData

    \sa HbStyleMarqueePrimitiveData

    \sa HbStyleTouchAreaPrimitiveData

 */

QGraphicsObject *HbStyle::createPrimitive(HbStyle::PrimitiveType primitiveType, const QString &itemName, QGraphicsObject *parent) const

{

    QGraphicsObject *bp;

    switch (primitiveType) {

    case PT_TextItem:

        bp = new HbTextItem(parent);

        break;

    case PT_RichTextItem:

        bp = new HbRichTextItem(parent);

        break;

    case PT_FrameItem:

        bp = new HbFrameItem(parent);

        break;

    case PT_IconItem:

        bp = new HbIconItem(parent);

        break;

    case PT_MarqueeItem:

        bp = new HbMarqueeItem(parent);

        break;

    case PT_TouchArea:

        bp = new HbTouchArea(parent);

        break;

    default:

        bp = 0;

    }

    if (bp != 0) {

        setItemName(bp, itemName);

    }

    return bp;

}

/*!

    This method is called by Hb widgets whenever there's a widget state change that results to a change in primitive's state.

    For example if a button's text changes the button widget needs to update the button's text primitive by calling this method.

    Widgets need to use the HbStylePrimitiveData-derived classes to carry the primitive state information from the widget to the style.

    These data classes enable the widget to set the primitives' state information without directly using the primitive APIs. 

    Note that the updating of the primitive attributes is optimized so that if just one value from the primitive data set is updated only that one

    value will be updated to the primitive on the style side. The values on primitive data classes are stored by using HbStyleValue templated class

    which keeps track of whether a primitive data value was assigned or not. On the style side before calling the primitive API the HbStyleValue's

    isSet()-method is called first to check if the widget did assign the primitive data value.

    \return bool, true if correct primitive type was found from the style, false if not.

    \sa HbStyle::createPrimitive()

    \sa HbStylePrimitiveData

    \sa HbStyleTextPrimitiveData

    \sa HbStyleFramePrimitiveData

    \sa HbStyleIconPrimitiveData

    \sa HbStyleRichTextPrimitiveData

    \sa HbStyleMarqueePrimitiveData

    \sa HbStyleTouchAreaPrimitiveData

 */

bool HbStyle::updatePrimitive(QGraphicsObject *primitive, const HbStylePrimitiveData *data, QGraphicsObject *parent) const

{

    Q_UNUSED(parent);

    if (HbTextItem *textItem = qgraphicsitem_cast<HbTextItem*>(primitive)) {

        const HbStyleTextPrimitiveData *td = hbstyleprimitivedata_cast<const HbStyleTextPrimitiveData*>(data);

        if (td->text.isSet())

            textItem->setText(td->text);

        if (td->textColor.isSet())

            textItem->setTextColor(td->textColor);

        if (td->alignment.isSet())

            textItem->setAlignment(td->alignment);

        if (td->elideMode.isSet())

            textItem->setElideMode(td->elideMode);

        if (td->textWrapping.isSet())

            textItem->setTextWrapping(td->textWrapping);

        if (td->isTextVisible.isSet())

            textItem->setTextVisible(td->isTextVisible);

        if (td->isTextClip.isSet())

            textItem->setTextClip(td->isTextClip);

        if (td->geometry.isSet())

            textItem->setGeometry(td->geometry);

        if (td->fadeLengths.isSet())

            textItem->setFadeLengths(td->fadeLengths);

        if (td->minimumLines.isSet())

            textItem->setMinimumLines(td->minimumLines);

        if (td->maximumLines.isSet())

            textItem->setMaximumLines(td->maximumLines);

    } else if (HbIconItem *iconItem = qgraphicsitem_cast<HbIconItem*>(primitive)) {

        const HbStyleIconPrimitiveData *id = hbstyleprimitivedata_cast<const HbStyleIconPrimitiveData*>(data);

        if (id->icon.isSet())

            iconItem->setIcon(id->icon);

        if (id->size.isSet())

            iconItem->setSize(id->size);

        if (id->aspectRatioMode.isSet())

            iconItem->setAspectRatioMode(id->aspectRatioMode);

        if (id->alignment.isSet())

            iconItem->setAlignment(id->alignment);

        if (id->iconMode.isSet())

            iconItem->setMode(id->iconMode);

        if (id->iconState.isSet())

            iconItem->setState(id->iconState);

        if (id->iconName.isSet())

            iconItem->setIconName(id->iconName);

        if (id->iconFlags.isSet())

            iconItem->setFlags(id->iconFlags);

        if (id->mirroringMode.isSet())

            iconItem->setMirroringMode(id->mirroringMode);

        if (id->brush.isSet())

            iconItem->setBrush(id->brush);

        if (id->color.isSet())

            iconItem->setColor(id->color);

    } else if(HbFrameItem *frameItem = qgraphicsitem_cast<HbFrameItem*>(primitive)) {

        const HbStyleFramePrimitiveData *fd =  hbstyleprimitivedata_cast<const HbStyleFramePrimitiveData*>(data);

        HbFrameDrawer *drawer = &(frameItem->frameDrawer()); 

        if (fd->frameGraphicsName.isSet())

            drawer->setFrameGraphicsName(fd->frameGraphicsName);

        if (fd->frameType.isSet())

            drawer->setFrameType(fd->frameType);

        if (fd->borderWidthLeft.isSet() || fd->borderWidthRight.isSet() || fd->borderWidthBottom.isSet() || fd->borderWidthTop.isSet())

            drawer->setBorderWidths(fd->borderWidthLeft, fd->borderWidthTop, fd->borderWidthRight, fd->borderWidthBottom);  

        if (fd->fillWholeRect.isSet())

            drawer->setFillWholeRect(fd->fillWholeRect);       

        if (fd->mirroringMode.isSet())

            drawer->setMirroringMode(fd->mirroringMode);

        if (fd->fileNameSuffixList.isSet())

            drawer->setFileNameSuffixList(fd->fileNameSuffixList);

        if (fd->pixmapMask.isSet())

            drawer->setMask(fd->pixmapMask);

        if (fd->bitmapMask.isSet())

            drawer->setMask(fd->bitmapMask); 

        frameItem->setFrameDrawer(drawer);

    } else if (HbMarqueeItem *marqueeItem = qgraphicsitem_cast<HbMarqueeItem*>(primitive)) {

         const HbStyleMarqueePrimitiveData *md =  hbstyleprimitivedata_cast<const HbStyleMarqueePrimitiveData*>(data);

         if (md->text.isSet())

             marqueeItem->setText(md->text);

         if (md->textColor.isSet())

             marqueeItem->setTextColor(md->textColor);

         if (md->animation.isSet()) {

             if (md->animation)

                 marqueeItem->startAnimation();

             else 

                 marqueeItem->stopAnimation();

         }

         if (md->loopCount.isSet())

             marqueeItem->setLoopCount(md->loopCount);

    } else if (HbTouchArea *touchArea = qgraphicsitem_cast<HbTouchArea*>(primitive)) {

        const HbStyleTouchAreaPrimitiveData *td =  hbstyleprimitivedata_cast<const HbStyleTouchAreaPrimitiveData*>(data);

        if (td->size.isSet())

            touchArea->setSize(td->size);

        if (td->geometry.isSet())

            touchArea->setGeometry(td->geometry);

    } else if (HbRichTextItem *richTextItem = qgraphicsitem_cast<HbRichTextItem*>(primitive)) {

        const HbStyleRichTextPrimitiveData *rd =  hbstyleprimitivedata_cast<const HbStyleRichTextPrimitiveData*>(data);

        if (rd->text.isSet())

            richTextItem->setText(rd->text);

        if (rd->defaultColor.isSet())

            richTextItem->setTextDefaultColor(rd->defaultColor);

        if (rd->alignment.isSet())

            richTextItem->setAlignment(rd->alignment);

        if (rd->textWrappingMode.isSet())

            richTextItem->setTextWrapping(rd->textWrappingMode);

        if (rd->isTextVisible.isSet())

            richTextItem->setTextVisible(rd->isTextVisible);

        if (rd->clipping.isSet())

            richTextItem->setTextClip(rd->clipping);

        if (rd->geometry.isSet())

            richTextItem->setGeometry(rd->geometry);

    }

}

QGraphicsItem *HbStylePrivate::createPrimitive( HbStylePrivate::Primitive primitive, QGraphicsItem *parent )

{

        switch (primitive){

            case P_MenuItem_submenuindicator:

                {

                HbIconItem *item = new HbIconItem(parent);

                HbStyle::setItemName(item, QLatin1String("submenu-indicator"));

                return item;

                }

            case P_MenuItem_checkindicator:

                {

                HbIconItem *item = new HbIconItem(parent);

                HbStyle::setItemName(item, QLatin1String("check-indicator"));

                return item;

                }

            case P_MenuItem_separator:

                {

                HbIconItem *item = new HbIconItem(parent);

                HbStyle::setItemName(item, QLatin1String("separator"));

                return item;

                }

            case P_ToolButton_icon:

            case P_PushButton_icon:

            case P_ProgressDialog_icon: {

                HbIconItem *iconItem = new HbIconItem(HbIcon(),parent);

                HbStyle::setItemName(iconItem, QLatin1String("icon"));

                return iconItem;

                }

            case P_CheckBox_icon:

            case P_GroupBoxHeading_icon:

                HbIconItem *item = q_check_ptr(new HbIconItem(HbIcon(),parent));

                HbStyle::setItemName(item, QLatin1String("icon"));

                return item;

                }

            case P_DataGroup_icon:

                {

                HbIconItem *item = new HbIconItem(HbIcon(), parent);

                HbStyle::setItemName(item, QLatin1String("dataGroup_Icon"));

                return item;

                }

            case P_DataItem_icon:

                {

                HbIconItem *item = new HbIconItem(HbIcon(), parent);

                HbStyle::setItemName(item, QLatin1String("dataItem_Icon"));

                return item;

                }

            case P_ComboBox_text:

                {

                    HbTextItem *textItem = new HbTextItem(parent);

                    HbStyle::setItemName(textItem, QLatin1String("combobox_labelfield"));

                    return  textItem;

                }

            case P_ToolButton_text:

            case P_CheckBox_text:

            case P_ProgressDialog_text:

                {

                    HbTextItem *textItem = new HbTextItem(parent);

                    HbStyle::setItemName(textItem, QLatin1String("text"));

                    textItem->setTextWrapping(Hb::TextWordWrap);

                    return  textItem;

                }

            case P_PushButton_text:

                {

                HbTextItem *ti = new HbTextItem(parent);

                HbStyle::setItemName(ti, QLatin1String("text"));