#include <hbstyleprimitivedata.h>

#include <hbstyletextprimitivedata.h>

#include <hbstylerichtextprimitivedata.h>

#include <hbstyleiconprimitivedata.h>

#include <hbstyleframeprimitivedata.h>

#include <hbstylemarqueeprimitivedata.h>

#include <hbstyletouchareaprimitivedata.h>

#ifdef HB_TEXT_MEASUREMENT_UTILITY

#include "hbinstance_p.h"

#include "hbtextmeasurementutility_r.h"

#endif

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

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

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

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

  \deprecated HbStyle::HbStyle()

        is deprecated. Use HbWidget::style() or HbInstance::style() instead.

   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.

    \param primitiveType enumeration of the base primitive

    \param itemName string which identifies a primitive in the widget (e.g. "background", or "text"). The item name matches with primitive names in widget's CSS file.

    \param parent parent for the primitive, although the default is 0 usually the widget is given as a parent for the primitive

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

    \param primitive the primitive to be updated

    \param data primitive data needed for updating the primitive

    \param parent optionally the parent can be given

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

    bool ret = false;

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

        if (td->fontSpec.isSet())

            textItem->setFontSpec(td->fontSpec);

        ret = true;

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

        ret = true;

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

        ret = true;

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

        ret = true;

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

        ret = true;

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

        ret = true;

    }

    if (ret) {

        if (data->geometry.isSet() 

            && primitive->isWidget()) {

            static_cast<QGraphicsWidget*>(primitive)->setGeometry(data->geometry);

        }

    }

    return ret;

}

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

{

        switch (primitive){

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

            case P_Label_icon: {

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

            case P_GridViewItem_icon: {

                Q_ASSERT_X(false, "HbStyle" , "P_GridViewItem_icon no more supported. Use refactored styling");

                return 0;

            }

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

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

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

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

                    textItem->setTextWrapping(Hb::TextWordWrap);

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

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

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

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

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