FCL/sf/mw/hb: comparison src/hbcore/style/hbstyle.cpp

equal deleted inserted replaced

-:627c4a0fd0e7
+:c3690ec91ef8
 #include "hbcssparser_p.h"
 #include "hbrepeaticonitem_p.h"
 #include "hbnamespace_p.h"
-#include "hbmeshlayout_p.h"
+#include "hbanchorlayout.h"
+#include "hbanchorlayoutdebug_p.h"
+#include "hbanchor_p.h"
 #include <QGraphicsWidget>
 #include <hbwidget.h>
 #include <hbwidgetbase.h>
 #include "hbdeviceprofile.h"
 Painting for the primitives occurs from the graphics scene.
 */
 /*!
 	    \deprecated P_PushButton_icon
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_PushButton_text
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_PushButton_additionaltext
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_PushButton_background
 \deprecated P_ListViewItem_icon
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_ItemHighlight_background
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_ToolBarExtension_background
 \deprecated P_IndicatorGrou\deprecated P_signalicon
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_IndicatorGrou\deprecated P_batteryicon
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_SignalIndicator_icon
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_SignalLevel_background
 \deprecated P_ProgressBar_waittrack
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_ProgressBar_mintext
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_ProgressBar_maxtext
 \deprecated P_Softkey_background
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_NavigationButton_background
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_IndicatorButton_background
 \deprecated P_ItemViewItem_frame
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_SelectionControl_selectionstart
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_SelectionControl_selectionend
 \deprecated P_ProgressSliderHandle_background
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_ProgressSliderHandle_icon
 is deprecated. HbStyle::Primitive enums are deprecated. Primitives can be accessed by item names using HbWidget::primitive(const QString).
 \deprecated P_ProgressSliderHandle_toucharea
 static const QString COLOR_STYLE_LOCATION = QLatin1String(":/themes/style/hbdefault/rules/widgets/%w/%w_color");
 static const int TOUCHAREA_ZVALUE = 1000;
 static const QString GLOBAL_PARAMETERS_LOCATION = QLatin1String(":/themes/style/hbdefault/variables/layout/zoom/0/hbglobalparameters.css");
+inline void overrideSpacing( HbAnchorLayout *layout, const QString &name, Hb::Edge edge, qreal val )
+{
+if( name.isNull() ) {
+return;
+}
+QList<HbAnchor*> list = HbAnchorLayoutDebug::getOriginalAnchors( layout );
+for( int i = 0; i < list.size(); i++ ) {
+HbAnchor *anchor = list.at(i);
+if( ( anchor->mStartId == name ) && ( anchor->mStartEdge == edge ) ) {
+layout->setAnchor( anchor->mStartId, anchor->mStartEdge, anchor->mEndId, anchor->mEndEdge, val );
+}
+}
+}
 /*!
 Constructor
 */
 HbStyle::HbStyle() :
 d_ptr(new HbStylePrivate)
 {
 Q_D( HbStyle );
 d->q_ptr = this;
-QObject::connect(hbInstance->theme(), SIGNAL(changed()), this, SLOT(_q_onThemeChanged()));
 }
 /*!
 Destructor
 */
 d->nextAvailableId += primitiveCount;
 // register associated style files
 HbWidgetStyleLoader::instance()->addFilePath(
 stylePlugin->layoutPath(),
 HbLayeredStyleLoader::Concern_Layouts,
 HbLayeredStyleLoader::Priority_Core);
 d->pluginStylePaths.insert(pluginName, stylePlugin->layoutPath());
 return pluginInfo->primitiveBaseId;
 }
 d->registeredPlugins.remove(pluginName);
 // unregister associated style files
 HbWidgetStyleLoader::instance()->removeFilePath(
 d->pluginStylePaths.value(pluginName),
 HbLayeredStyleLoader::Concern_Layouts,
 HbLayeredStyleLoader::Priority_Core);
 d->pluginStylePaths.remove(pluginName);
 if( d->registeredPlugins.count() == 0 ){
 // no plugins loaded, can reset the id counter
 }
 /*!
 \deprecated HbStyle::createPrimitive(HbStyle::Primitive, QGraphicsItem*)
 is deprecated. This method will be replaced with an altered version which will use new base primitive enumerations.
 Creates instances of primitive graphics items. This method should be used by all widgets that support styling.
 When changing the style the returned primitives can be replaced with an altered version of the primitives, or with a completely
 different primitive, to create a custom appearance. This shouldn't cause changes to the widget if the functional design
 remains the same.
 case P_ToolButton_icon:
 case P_PushButton_icon:
 case P_ProgressDialog_icon: {
 HbIconItem *iconItem = new HbIconItem(HbIcon(),parent);
 setItemName(iconItem, QLatin1String("icon"));
 return iconItem;
 }
 case P_CheckBox_icon:
 case P_GroupBoxHeading_icon:
 case P_Label_icon:
 case P_GridViewItem_icon: {
 HbIconItem *item = q_check_ptr(new HbIconItem(HbIcon(),parent));
 setItemName(item, QLatin1String("icon"));
 return item;
 }
 case P_DataGroup_icon:
 {
 HbIconItem *item = new HbIconItem(HbIcon(), parent);
 setItemName(item, QLatin1String("dataGroup_Icon"));
 return item;
 }
 case P_DataItem_icon:
 {
 HbIconItem *item = new HbIconItem(HbIcon(), parent);
 setItemName(item, QLatin1String("dataItem_Icon"));
 return item;
 }
 case P_ComboBox_text:
 {
 HbTextItem *textItem = new HbTextItem(parent);
 setItemName(textItem, QLatin1String("combobox_labelfield"));
 ta->setFlag(QGraphicsItem::ItemIsFocusable);
 setItemName(ta, QLatin1String("toucharea"));
 ta->setZValue(TOUCHAREA_ZVALUE);
 return ta;
 }
 case P_ProgressSliderHandle_toucharea:
 {
 HbTouchArea *ta = new HbTouchArea(parent);
 ta->setFlag(QGraphicsItem::ItemIsFocusable);
 setItemName(ta, QLatin1String("toucharea"));
 ta->setZValue(TOUCHAREA_ZVALUE);
 if(parent){
 parent->setHandlesChildEvents(true);
 }
 return ta;
 }
 case P_ProgressSliderHandle_icon:
 return item;
 }
 case P_PushButton_toucharea: // Generic implementation, can add other cases here
 case P_CheckBox_toucharea:
 case P_RatingSlider_toucharea:
 case P_SliderElement_touchhandle:
 {
 HbTouchArea *ta = new HbTouchArea(parent);
 ta->setFlag(QGraphicsItem::ItemIsFocusable);
 setItemName(ta, QLatin1String("toucharea"));
 if(parent){
 parent->setHandlesChildEvents(true);
 }
 return ta;
 }
 case P_ScrollBar_toucharea:
 {
 HbTouchArea *ta = new HbTouchArea(parent);
 ta->setFlags(QGraphicsItem::ItemIsFocusable);
 setItemName(ta, QLatin1String("toucharea"));
 // NOTE:: This is a temporary fix
 //if(parent){
 //    parent->setHandlesChildEvents(true);
 //}
 return ta;
 }
 case P_ComboBoxButton_toucharea:
 {
 HbTouchArea *ta = new HbTouchArea(parent);
 ta->setFlag(QGraphicsItem::ItemIsFocusable);
 setItemName(ta, QLatin1String("combobox_button_toucharea"));
 /*if(parent){
 parent->setHandlesChildEvents(true);
 }*/
 return ta;
 }
 case P_TitleBar_toucharea: {
 HbTouchArea *ta = new HbTouchArea(parent);
 case P_SliderElement_touchgroove:
 {
 HbTouchArea *ta = new HbTouchArea(parent);
 ta->setFlag(QGraphicsItem::ItemIsFocusable);
 if(parent){
 //parent->setHandlesChildEvents(true);
 }
 return ta;
 }
 case P_SliderElement_text:
 case P_ProgressBar_text:
 HbTextItem *ti = new HbTextItem(parent);
 setItemName(ti, QLatin1String("text"));
 ti->setAlignment(Qt::AlignCenter);
 return ti;
 }
 case P_Label_richtext:
 {
 HbRichTextItem *rti = new HbRichTextItem(parent);
 setItemName(rti, QLatin1String("text"));
 return rti;
 }
 case P_ProgressBar_frame:
 {
 HbFrameItem *n = new HbFrameItem(parent);
 n->setZValue(-1);
+n->frameDrawer().setFillWholeRect(true);
 setItemName(n, "frame");
 return n;
 }
 case P_ComboBoxPopup_background:
 }
 case P_DateTimePicker_separator:{
 HbFrameItem *frameItem= new HbFrameItem(parent);//TODO:make it icon once iconitem setGeomoetry works for tumbleview
 return frameItem;
 }
 case P_DataGroup_background :
 {
 HbFrameItem *n = new HbFrameItem(parent);
 n->setZValue(-1);
 setItemName(n, QLatin1String("dataGroup_Background"));
 return n;
 }
 case P_ProgressBar_track:
 {
 HbProgressTrackItem *n = new HbProgressTrackItem(parent);
+n->frameDrawer().setFillWholeRect(true);
 n->setZValue(-2);
 return n;
 }
 case P_ProgressSlider_slidertrack:
 {
 }
 case P_IndicatorButton_handleindication:
 {
 HbIconItem *n = new HbIconItem(parent);
 setItemName(n, QLatin1String("handleindication"));
+return n;
+}
+case P_IndicatorButton_eventindication:
+{
+HbIconItem *n = new HbIconItem(parent);
+n->setFlags(HbIcon::Colorized);
+setItemName(n, QLatin1String("eventindication"));
 return n;
 }
 case P_IndicatorGroup_icon1:
 {
 HbIconItem *n = new HbIconItem(parent);
 case P_TextEdit_frame_highlight:
 {
 HbFrameItem *n = new HbFrameItem(parent);
 n->setZValue(-1);
 return n;
 }
 case P_GroupBoxMarquee_text:
 case P_TitlePane_text:
 {
 HbMarqueeItem *n = new HbMarqueeItem(parent);
 setItemName(n, QLatin1String("text"));
 case P_RatingSlider_frame:
 return  new HbRepeatItem(parent);
 case P_RatingSlider_track:
 return new HbRepeatMaskItem(parent);
 case P_RatingSlider_layout: {
 HbWidgetBase *layout = new HbWidgetBase(parent);
 setItemName(layout, "frame");
 return layout;
 }
 case P_ItemViewItem_focus: {
 HbFrameItem *item = q_check_ptr(new HbFrameItem(parent));
 //setItemName(item, QLatin1String("focus-indicator"));
 return item;
 }
 case P_ItemHighlight_background:
 return new HbFrameItem(parent);
 case P_ItemViewItem_frame: {
 HbFrameItem *item = q_check_ptr(new HbFrameItem(parent));
 setItemName(item,"frame");
 \deprecated HbStyle::updatePrimitive(QGraphicsItem*, HbStyle::Primitive, const QStyleOption*)
 is deprecated. This method will be made private and finally removed since primitive updating will be done in the widgets.
 Updates the state and content of widget's child primitives. Update for a styled primitive should happen always when
 a state change that affects drawing occurs. Such a situation can be for example pressing of a button (change background image), or
 changing a text for a widget having text content. The updatePrimitive() implementation for each primitive element can be considered
 as a part of widget's implementation. Note that it's up to the widget to decide what the styleoption contains and what the updatePrimitive() method
 uses the styleoption data for.
 \sa HbStyle::createPrimitive
 \param item Primitive graphicsitem.
 \param primitive To identify the primitive to create.
 \param option Style option, contains all the information needed to update the primitive, this
 information is widget specific and each widget usually has a styleoption. Styleoption may include
 }
 switch(primitive){
 case P_PushButton_icon:
 {
 if (const HbStyleOptionPushButton *opt =
 qstyleoption_cast<const HbStyleOptionPushButton*>(option)) {
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
 //iconItem->setIconName(opt->icon.iconName());
 iconItem->setIcon(opt->icon); // with this call iconitem refresh issue is there
 iconItem->setMode(d->iconMode(opt->state));
 iconItem->setState(d->iconState(opt->state));
+iconItem->setAlignment(Qt::AlignCenter);
 }
 break;
 }
 case P_GroupBoxHeading_icon:
 {
 if (const HbStyleOptionGroupBox *opt =
 qstyleoption_cast<const HbStyleOptionGroupBox*>(option)) {
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
 if (opt->collapsed) {
 iconItem->setIconName(QLatin1String("qtg_small_expand"));
 } else {
 }
 break;
 }
 case P_DataGroup_icon:
 {
 if (const HbStyleOptionDataGroupHeadingWidget *opt =
 qstyleoption_cast<const HbStyleOptionDataGroupHeadingWidget*>(option)) {
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
 if (opt->expanded) {
 iconItem->setIconName(QLatin1String("qtg_small_collapse"));
 } else {
 break;
 case P_ComboBox_text:
 if (const HbStyleOptionComboBox *opt = qstyleoption_cast<const HbStyleOptionComboBox*>(option)) {
 HbTextItem *comboTextItem = static_cast<HbTextItem*>(item);
 comboTextItem->setText(opt->text);
-}
+comboTextItem->setTextWrapping(Hb::TextNoWrap);
-break;
+}
+break;
 case P_PushButton_text:
 {
 if (const HbStyleOptionPushButton *opt =
 qstyleoption_cast<const HbStyleOptionPushButton*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setText(opt->text);
 //default alignment will come from css,
 //if api flag is set ,then alignment from style is taken.
 if (opt->hasTextAlignment) {
 textItem->setAlignment( opt->textAlignment );
 }
 textItem->setTextWrapping(Hb::TextWordWrap);
 }
 }
 break;
 case P_ProgressDialog_text:
 {
 if (const HbStyleOptionProgressDialog *opt =
 qstyleoption_cast<const HbStyleOptionProgressDialog*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setText(opt->text);
 }
 break;
 }
 case P_PushButton_additionaltext:
 {
 if (const HbStyleOptionPushButton *opt =
 qstyleoption_cast<const HbStyleOptionPushButton*>(option)) {
 HbTextItem *additionalTextItem = static_cast<HbTextItem*>(item);
 additionalTextItem->setText(opt->additionalText);
 //default alignment will come from css,
 //if api flag is set ,then alignment from style is taken.
 if (opt->hasAdditionalTextAlignment) {
 additionalTextItem->setAlignment( opt->additionalTextAlignment );
 }
 additionalTextItem->setTextWrapping(Hb::TextWordWrap);
 }
 }
 break;
 case P_PushButton_toucharea:  // Generic implementation, can add other cases here
 case P_ComboBoxButton_toucharea:
 case P_CheckBox_toucharea:
 touchArea->setZValue(TOUCHAREA_ZVALUE);
 }
 break;
 case P_DataGroup_heading:
 {
 if (const HbStyleOptionDataGroupHeadingWidget *opt =
 qstyleoption_cast<const HbStyleOptionDataGroupHeadingWidget*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setText(opt->heading);
+textItem->setTextWrapping(Hb::TextNoWrap);
 }
 break;
 }
 case P_DataGroup_description:
 {
 if (const HbStyleOptionDataGroupHeadingWidget *opt =
 qstyleoption_cast<const HbStyleOptionDataGroupHeadingWidget*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setText(opt->description);
 }
 break;
 }
 case P_DataForm_heading:
 {
 if (const HbStyleOptionDataForm *opt =
 qstyleoption_cast<const HbStyleOptionDataForm*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setText(opt->heading);
 }
 break;
 }
 case P_DataForm_description:
 {
 if (const HbStyleOptionDataForm *opt =
 qstyleoption_cast<const HbStyleOptionDataForm*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 HbFontSpec spec(HbFontSpec::Secondary);
 QFont descriptionFont = spec.font();
 descriptionFont.setItalic(true);
 if (const HbStyleOptionToolButton *opt = qstyleoption_cast<const HbStyleOptionToolButton*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setText(opt->text);
 }
 break;
 case P_ProgressBar_text: {
 if (const HbStyleOptionProgressBar *opt = qstyleoption_cast<const HbStyleOptionProgressBar*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setAlignment(Qt::AlignCenter);
 textItem->setZValue(100);
 textItem->setText(opt->text);
 }
 break;
 }
 case P_DataGroup_background: {
 if (const HbStyleOptionDataGroupHeadingWidget *opt =
 qstyleoption_cast<const HbStyleOptionDataGroupHeadingWidget *>(option)) {
 HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
 if(!frameItem){
 return;
 }
+QString frameGraphicsName;
+QIcon::Mode mode = QIcon::Disabled;
+if (opt->state & QStyle::State_Enabled) {
+mode = QIcon::Normal;
+}
+if (opt->state & QStyle::State_Active) {
+mode = QIcon::Active;
+}
+if (opt->state & QStyle::State_Selected) {
+mode = QIcon::Selected;
+}
 frameItem->setZValue(-1.0);
-if(opt->pressed) {
+if(mode == QIcon::Disabled) {
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_list_disabled"));
+}
+else if(opt->pressed ) {
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_list_pressed"));
 } else {
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_list_parent_normal"));
 }
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->setGeometry(opt->rect);
 }
 break;
 }
 case P_DataGroupComboBackground: {
-HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
+if (const HbStyleOptionDataGroup *opt = qstyleoption_cast<const HbStyleOptionDataGroup *>(option)) {
-if(!frameItem){
+QString frameGraphicsName;
-return;
+QIcon::Mode mode = QIcon::Disabled;
-}
+HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
-frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_list_parent_normal"));
+if(!frameItem){
-frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
+return;
+}
+if (opt->state & QStyle::State_Enabled) {
+mode = QIcon::Normal;
+}
+if (opt->state & QStyle::State_Active) {
+mode = QIcon::Active;
+}
+if (opt->state & QStyle::State_Selected) {
+mode = QIcon::Selected;
+}
+if (mode == QIcon::Disabled ) {
+frameGraphicsName = QLatin1String("qtg_fr_list_disabled");
+} else  {
+frameGraphicsName = QLatin1String("qtg_fr_list_parent_normal");
+}
+frameItem->frameDrawer().setFrameGraphicsName(frameGraphicsName);
+frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
+}
 break;
 }
 case P_GroupBoxHeading_background: {
 if (const HbStyleOptionGroupBox *opt = qstyleoption_cast<const HbStyleOptionGroupBox *>(option)) {
 HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
 if(!frameItem){
 return;
 }
 QString frameGraphicsName;
 if(opt->groupBoxType == HbStyleOptionGroupBox::GroupBoxSimpleLabel)
 frameGraphicsName = QLatin1String("qtg_fr_list_parent_normal");
 } else {
 frameGraphicsName = QLatin1String("qtg_fr_list_highlight");
 }
 }
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName(frameGraphicsName);
 }
 break;
 }
 case P_GroupBoxContent_background: {
 if (const HbStyleOption *opt = qstyleoption_cast<const HbStyleOption *>(option)) {
 HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
 if(!frameItem){
 return;
 }
 QString frameGraphicsName;
 } else if (opt->state == QStyle::State_Off) {
 frameGraphicsName = QLatin1String("qtg_fr_groupbox_normal");
 } else {
 frameGraphicsName = QLatin1String("qtg_fr_groupbox_highlight");
 }
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName(frameGraphicsName);
 }
 break;
 }
 case P_DataItem_background: {
-HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
+if (const HbStyleOptionDataFormViewItem *opt = qstyleoption_cast<const HbStyleOptionDataFormViewItem *>(option)) {
-if(!frameItem){
+QString frameGraphicsName;
-return;
+HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
-}
+if(!frameItem){
+return;
-frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_list_normal"));
+}
-frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
+QIcon::Mode mode = QIcon::Disabled;
+if (opt->state & QStyle::State_Enabled) {
+mode = QIcon::Normal;
+}
+if (opt->state & QStyle::State_Active) {
+mode = QIcon::Active;
+}
+if (opt->state & QStyle::State_Selected) {
+mode = QIcon::Selected;
+}
+if (mode == QIcon::Disabled ) {
+frameGraphicsName = QLatin1String("qtg_fr_list_disabled");
+} else  {
+frameGraphicsName = QLatin1String("qtg_fr_list_parent_normal");
+}
+frameItem->frameDrawer().setFrameGraphicsName(frameGraphicsName);
+frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
+}
 break;
 }
 case P_DataItem_label: {
 if (const HbStyleOptionDataFormViewItem *opt = qstyleoption_cast<const HbStyleOptionDataFormViewItem *>(option)) {
 HbTextItem *textitem = static_cast<HbTextItem*>( item );
 textitem->setText(opt->label);
+textitem->setTextWrapping(Hb::TextNoWrap);
 }
 break;
 }
 case P_DataItem_description: {
 if (const HbStyleOptionDataFormViewItem *opt = qstyleoption_cast<const HbStyleOptionDataFormViewItem *>(option)) {
 textitem->setText(opt->description);
 }
 break;
 }
 case P_PushButton_background: {
 if (const HbStyleOptionPushButton *opt =
 qstyleoption_cast<const HbStyleOptionPushButton *>(option)) {
 HbFrameItem *frameItem = static_cast<HbFrameItem*>( item );
 QString frameGraphicsName;
 QIcon::Mode mode = QIcon::Disabled;
 QIcon::State state = QIcon::Off;
 }
 }
 break;
 }
 case P_StatusBar_timetext: {
 if (const HbStyleOptionStatusBar *opt =
 qstyleoption_cast<const HbStyleOptionStatusBar*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setText(opt->timeText);
 }
 break;
 }
 case P_IndicatorGroup_icon1:
 case P_IndicatorGroup_icon2:
 case P_IndicatorGroup_icon3:
 case P_IndicatorGroup_icon4:
 {
 const HbStyleOptionIndicatorGroup *opt = qstyleoption_cast<const HbStyleOptionIndicatorGroup *>(option);
 if (opt) {
 HbIconItem *iconItem = qgraphicsitem_cast<HbIconItem*>(item);
 iconItem->setIconName(opt->iconName);
 }
 break;
 }
 case P_IndicatorButton_handleindication: {
 const HbStyleOptionIndicatorButton *opt = qstyleoption_cast<const HbStyleOptionIndicatorButton *>(option);
 if (opt) {
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
 iconItem->setIconName("qtg_graf_titlebar_minimize");
+}
+break;
+}
+case P_IndicatorButton_eventindication: {
+const HbStyleOptionIndicatorButton *opt = qstyleoption_cast<const HbStyleOptionIndicatorButton *>(option);
+if (opt) {
+HbIconItem *iconItem = static_cast<HbIconItem*>(item);
+if (opt->twoIcons) {
+iconItem->setIconName("qtg_mono_new_event");
+iconItem->setVisible(true);
+} else {
+iconItem->setVisible(false);
+}
 }
 break;
 }
 case P_SignalIndicator_icon: {
 }
 }
 break;
 }
 case P_PushButton_focus: {
 if (const HbStyleOptionPushButton *opt =
 qstyleoption_cast<const HbStyleOptionPushButton *>(option)) {
 HbFrameItem *iconItem  = static_cast<HbFrameItem*>(item);
 iconItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_btn_highlight"));
 int margin = 4;
 QRectF focusRect  = opt->rect.adjusted(-margin , -margin , margin , margin);
 }
 switch (opt->toolBarPosition) {
 case HbStyleOptionToolButton::TB_OnlyOne:
 if (opt->orientation == Qt::Vertical) {
 list << QLatin1String("_l") << QLatin1String("_c") << QLatin1String("_r");
 } else {
 list << QLatin1String("_t") << QLatin1String("_c") << QLatin1String("_b");
 }
 break;
 case HbStyleOptionToolButton::TB_Beginning:
 if (opt->orientation == Qt::Vertical) {
 list << QLatin1String("_l") << QLatin1String("_c") << QLatin1String("_cr");
 list << QLatin1String("_ct") << QLatin1String("_c") << QLatin1String("_b");
 }
 break;
 default:
 break;
 }
 frameItem->frameDrawer().setFileNameSuffixList(list);
 if (mode == QIcon::Disabled && state == QIcon::Off) {
 frameGraphicsFooter = QLatin1String("disabled");
 } else if (mode == QIcon::Normal && state == QIcon::On) {
 } else {
 frameGraphicsFooter = QLatin1String("normal");
 }
 frameItem->frameDrawer().setFrameGraphicsName(QString ("%0%1").arg(frameGraphicsHeader).arg(frameGraphicsFooter));
+frameItem->frameDrawer().setMirroringMode(HbIcon::LayoutDirection);
 break;
 }
 case P_SliderTickMark_majoricon: {
 if (const HbStyleOptionSlider *opt =
 qstyleoption_cast<const HbStyleOptionSlider*>(option)) {
 HbIconItem *iconItem = qgraphicsitem_cast<HbIconItem*>(item);
 iconItem->setMode(d->iconMode(opt->state));
 if ( opt->orientation ==Qt::Horizontal ){
 iconItem->setIconName( "qtg_graf_slider_h_tick_major" );
 iconItem->setIconName ( "qtg_graf_slider_v_tick_major" );
 }
 iconItem->setState(d->iconState(opt->state));
 }
 break;
 }
 case P_SliderTickMark_minoricon: {
 if (const HbStyleOptionSlider *opt =
 qstyleoption_cast<const HbStyleOptionSlider*>(option)) {
 HbIconItem *iconItem = qgraphicsitem_cast<HbIconItem*>(item);
 iconItem->setMode(d->iconMode(opt->state));
 if ( opt->orientation ==Qt::Horizontal ){
 iconItem->setIconName( "qtg_graf_slider_h_tick_minor" );
 iconItem->setIconName ( "qtg_graf_slider_v_tick_minor" );
 }
 iconItem->setState(d->iconState(opt->state));
 }
 break;
 }
 case P_SliderTickMark_majorlabel: {
 if (const HbStyleOptionSlider *opt =
 qstyleoption_cast<const HbStyleOptionSlider*>(option)) {
 HbTextItem *textItem = qgraphicsitem_cast<HbTextItem*>(item);
 textItem->setText( opt->text );
 }
 break;
 }
 case P_SliderTickMark_minorlabel: {
 if (const HbStyleOptionSlider *opt =
 qstyleoption_cast<const HbStyleOptionSlider*>(option)) {
 HbTextItem *textItem = qgraphicsitem_cast<HbTextItem*>(item);
 textItem->setText( opt->text );
 }
 break;
 }
 case P_Slider_progressgroove: {
 if (const HbStyleOptionSlider *opt = qstyleoption_cast<const HbStyleOptionSlider *>(option))  {
 HbSliderTrackItem* frameItem = static_cast<HbSliderTrackItem*>(item);
 if(!frameItem->isVisible()) {
 }
 else{
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesVertical);
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_slider_v_filled"));
 frameItem->setInverted(!opt->upsideDown);
 frameItem->frameDrawer().setMirroringMode(HbIcon::Prevented);
 }
 frameItem->frameDrawer().setFillWholeRect(true);
 frameItem->setMaximum(opt->maximum);
 frameItem->setMinimum(opt->minimum);
 frameItem->setValue(opt->sliderValue);
 HbFrameDrawer::FrameType type(HbFrameDrawer::Undefined);
 QString name;
 if (opt->orientation == Qt::Horizontal) {
 type = HbFrameDrawer::ThreePiecesHorizontal;
-if(!opt->groovePressed){
+if (opt->state & QStyle::State_Enabled) {
-name = QLatin1String("qtg_fr_slider_h_frame_normal");
+if(!opt->groovePressed){
-}
+name = QLatin1String("qtg_fr_slider_h_frame_normal");
-else {
+}
-name = QLatin1String("qtg_fr_slider_h_frame_pressed");
+else {
+name = QLatin1String("qtg_fr_slider_h_frame_pressed");
+}
+} else {
+name = QLatin1String("qtg_fr_slider_h_frame_disabled");
 }
 } else if (opt->orientation == Qt::Vertical) {
-if(!opt->groovePressed){
+if (opt->state & QStyle::State_Enabled) {
-name = QLatin1String("qtg_fr_slider_v_frame_normal");
+if(!opt->groovePressed){
-}
+name = QLatin1String("qtg_fr_slider_v_frame_normal");
-else {
+}
-name = QLatin1String("qtg_fr_slider_v_frame_pressed");
+else {
+name = QLatin1String("qtg_fr_slider_v_frame_pressed");
+}
+} else {
+name = QLatin1String("qtg_fr_slider_v_frame_disabled");
 }
 type = HbFrameDrawer::ThreePiecesVertical;
 }
 frameItem->frameDrawer().setFrameGraphicsName(name);
 thumbPath=d->logicalName(HbStyle::P_Slider_thumb, option);
 }
 else
 {
 thumbPath=opt->thumbPath;
+iconItem->setAlignment(Qt::AlignCenter);
 }
 iconItem->setIconName(thumbPath);
 iconItem->setAspectRatioMode(Qt::KeepAspectRatio);
 }
 break;
 if( opt->state & QStyle::State_Sunken) {
 iconItem->setIconName(QLatin1String("qtg_mono_speaker_off"));
 } else {
 iconItem->setIconName(QLatin1String("qtg_mono_speaker"));
 }
 }
 }
 break;
 }
 case P_SliderElement_text:
 {
 break;
 case P_CheckBox_icon: {
 if (const HbStyleOptionCheckBox *opt = qstyleoption_cast<const HbStyleOptionCheckBox *>(option)){
 HbIconItem *iconItem = static_cast<HbIconItem *>(item);
-if (opt->state.testFlag(QStyle::State_On)) {
+if (opt->state.testFlag(QStyle::State_Selected) ) {
-iconItem->setState(QIcon::On);
+if (opt->state.testFlag(QStyle::State_On)) {
-iconItem->setIconName(QLatin1String("qtg_small_selected"));
+iconItem->setState(QIcon::On);
-} else if (opt->state.testFlag(QStyle::State_Off)) {
+iconItem->setIconName(QLatin1String("qtg_small_selected_highlight"));
-iconItem->setState(QIcon::Off);
+} else if (opt->state.testFlag(QStyle::State_Off)) {
-iconItem->setIconName(QLatin1String("qtg_small_unselected"));
+iconItem->setState(QIcon::Off);
-} else if (opt->state.testFlag(QStyle::State_NoChange)) {
+iconItem->setIconName(QLatin1String("qtg_small_unselected_highlight"));
-iconItem->setState(QIcon::On);
+} else if (opt->state.testFlag(QStyle::State_NoChange)) {
-iconItem->setIconName(QLatin1String("qtg_small_selected_partial"));
+iconItem->setState(QIcon::On);
+iconItem->setIconName(QLatin1String("qtg_small_selected_partial"));
+}
+} else {
+if (opt->state.testFlag(QStyle::State_On)) {
+iconItem->setState(QIcon::On);
+iconItem->setIconName(QLatin1String("qtg_small_selected"));
+} else if (opt->state.testFlag(QStyle::State_Off)) {
+iconItem->setState(QIcon::Off);
+iconItem->setIconName(QLatin1String("qtg_small_unselected"));
+} else if (opt->state.testFlag(QStyle::State_NoChange)) {
+iconItem->setState(QIcon::On);
+iconItem->setIconName(QLatin1String("qtg_small_selected_partial"));
+}
 }
 }
 break;
 }
 case P_ItemViewItem_radiobutton:
 if (opt->state & QStyle::State_Sunken) {
 frameGraphicsName = QLatin1String("qtg_fr_combobox_pressed");
 } else {
 frameGraphicsName = QLatin1String("qtg_fr_combobox_normal");
 }
 } else {
 frameGraphicsName = QLatin1String("qtg_fr_combobox_disabled");
 }
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
 frameItem->frameDrawer().setFillWholeRect(true);
 frameItem->frameDrawer().setFrameGraphicsName(frameGraphicsName);
 if (opt->state & QStyle::State_Sunken) {
 iconGraphicsName = QLatin1String("qtg_graf_combobox_button_pressed");
 } else {
 iconGraphicsName = QLatin1String("qtg_graf_combobox_button_normal");
 }
 } else {
 iconGraphicsName = QLatin1String("qtg_graf_combobox_button_disabled");
 }
 iconItem->setIconName(iconGraphicsName);
 iconItem->setMirroringMode ( HbIcon::LayoutDirection );
 iconItem->setAspectRatioMode( Qt::IgnoreAspectRatio);
 }
 break;
 case P_Label_richtext:
 if (const HbStyleOptionLabel *opt = qstyleoption_cast<const HbStyleOptionLabel*>(option)) {
 HbRichTextItem *textItem = static_cast<HbRichTextItem*>(item);
 textItem->setAlignment(opt->alignment);
 textItem->setTextWrapping(opt->textWrapMode);
 if(!opt->fontSpec.isNull()) {
 textItem->setFontSpec(opt->fontSpec);
 }
 if (opt->color.isValid()) {
 case P_MenuItem_checkindicator:
 if (const HbStyleOptionMenuItem *opt = qstyleoption_cast<const HbStyleOptionMenuItem *>(option)) {
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
 if (opt->checked) {
-iconItem->setIconName(QLatin1String("qtg_small_selected"));
+iconItem->setIconName(QLatin1String("qtg_small_tick"));
 } else {
 iconItem->setIcon(HbIcon());
 }
 }
 break;
 icon->setIcon(HbIcon(QLatin1String("qtg_large_warning")));
 break;
 default:
 break;
 }
 } else {
 icon->setIcon(opt->icon);
 }
 }
 break;
 case P_ListViewItem_text:
 if (const HbStyleOptionListViewItem *opt = qstyleoption_cast<const HbStyleOptionListViewItem *>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 if (opt->index == 1) {
 if (opt->multilineSecondaryTextSupported) {
 if (opt->minimumLines != -1) {
 // min & max secondary text row counts set by app
 Hb::TextWrapping wrapping = Hb::TextNoWrap;
 }
 break;
 case P_ListViewItem_icon:
 if (const HbStyleOptionListViewItem *opt = qstyleoption_cast<const HbStyleOptionListViewItem *>(option)) {
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
 setItemName(iconItem, QLatin1String("icon-") + QString::number(opt->index + 1));
 iconItem->setZValue(opt->index + 1);
 if (opt->content.canConvert<HbIcon>()){
 iconItem->setIcon(opt->content.value<HbIcon>());
 else{
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesVertical);
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progbar_v_frame"));
 }
-frameItem->frameDrawer().setFillWholeRect(true);
+//  frameItem->frameDrawer().setFillWholeRect(true);
 }
 break;
 case P_ProgressBar_track:
 if (const HbStyleOptionProgressBar *opt = qstyleoption_cast<const HbStyleOptionProgressBar *>(option)) {
 HbProgressTrackItem* frameItem = static_cast<HbProgressTrackItem*>(item);
 if(!frameItem->isVisible()) {
 break;
 }
-frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
 if(opt->orientation == Qt::Horizontal){
-frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progbar_h_filled"));
+frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progbar_h_filled"));
 }
 else{
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesVertical);
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progbar_v_filled"));
 }
-frameItem->frameDrawer().setFillWholeRect(true);
 frameItem->setMaximum(opt->maximum);
 frameItem->setMinimum(opt->minimum);
 frameItem->setValue(opt->progressValue);
 frameItem->setInverted(opt->inverted);
 //frameItem->setGeometry(opt->rect);
 frameItem->setOrientation(opt->orientation);
 frameItem->update();
 }
 break;
 case P_ProgressBar_waittrack:
 if (const HbStyleOptionProgressBar *opt = qstyleoption_cast<const HbStyleOptionProgressBar *>(option)) {
 HbRepeatIconItem *iconItem = static_cast<HbRepeatIconItem*>(item);
 iconItem->setOrientation(opt->orientation);
 if( !iconItem->isVisible() ) {
 break;
 }
 if(opt->stopWaitAnimation){
 iconItem->stopAnimation();
 }
 }
 break;
 case P_ProgressSlider_frame:
 if (const HbStyleOptionProgressSlider *opt = qstyleoption_cast<const HbStyleOptionProgressSlider *>(option)) {
 HbFrameItem *frameItem = static_cast<HbFrameItem*>(item);
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
 	if (opt->disableState ) {
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_frame_disabled"));
 					}
 					else {
 					     if(opt->pressedState) {
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_frame_pressed"));
 }
 else {
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_frame_normal"));
 }
 					}
 frameItem->frameDrawer().setFillWholeRect(true);
 //frameItem->update();
 }
 break;
 case P_ProgressSlider_track: // The ProgressValue Mask
 if (const HbStyleOptionProgressSlider *opt = qstyleoption_cast<const HbStyleOptionProgressSlider *>(option)) {
 HbProgressTrackItem* frameItem = static_cast<HbProgressTrackItem*>(item);
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
-frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_loaded"));
+					if (opt->disableState ) {
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_loaded_disabled"));
+					}
+					else {
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_loaded"));
+					}
 frameItem->frameDrawer().setFillWholeRect(true);
 frameItem->setMaximum(opt->maximum);
 frameItem->setMinimum(opt->minimum);
 frameItem->setValue(opt->progressValue);
 frameItem->setInverted(opt->inverted);
 frameItem->setOrientation(opt->orientation);
 frameItem->update();
 }
 break;
 case P_ProgressSlider_slidertrack: // The Slider Position Mask
 if (const HbStyleOptionProgressSlider *opt = qstyleoption_cast<const HbStyleOptionProgressSlider *>(option)) {
 HbProgressTrackItem* frameItem = static_cast<HbProgressTrackItem*>(item);
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
-frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_played"));
+					if (opt->disableState ) {
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_played_disabled"));
+					}
+					else {
+frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_progslider_played"));
+					}
 frameItem->frameDrawer().setFillWholeRect(true);
 frameItem->setMaximum(opt->maximum);
 frameItem->setMinimum(opt->minimum);
 frameItem->setValue(opt->progressSliderValue);
 frameItem->setInverted(opt->inverted);
 frameItem->setOrientation(opt->orientation);
-//frameItem->update();
+frameItem->update();
 }
 break;
 case P_ProgressBar_mintext: {
 if (const HbStyleOptionProgressBar *opt =
 qstyleoption_cast<const HbStyleOptionProgressBar*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 if(!item) {
 return;
 }
 textItem->setTextWrapping(Hb::TextWrapAnywhere);
 textItem->setText(opt->minText);
 }
 break;
 }
 case P_ProgressBar_maxtext: {
 if (const HbStyleOptionProgressBar *opt =
 qstyleoption_cast<const HbStyleOptionProgressBar*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 if(!item) {
 return;
 }
 textItem->setTextWrapping(Hb::TextWrapAnywhere);
 textItem->setText(opt->maxText);
 }
 break;
 }
 case P_RatingSlider_frame:{
 if (const HbStyleOptionRatingSlider *opt = qstyleoption_cast<const HbStyleOptionRatingSlider *>(option)) {
 HbRepeatItem *repeatItem = static_cast<HbRepeatItem*>(item);
 repeatItem->setRepeatingNumber(opt->noOfStars);
 if (!opt->unRatedGraphicsName.isEmpty()) {
 repeatItem->setName(opt->unRatedGraphicsName);
 }
 else {
-repeatItem->setName(QLatin1String("qtg_graf_ratingslider_unrated"));
+if(opt->disableState) {
+repeatItem->setName(QLatin1String("qtg_graf_ratingslider_unrated_disabled"));
+}
+else {
+							if(opt->pressedState) {
+								repeatItem->setName(QLatin1String("qtg_graf_ratingslider_unrated_pressed"));
+							}
+							else {
+								repeatItem->setName(QLatin1String("qtg_graf_ratingslider_unrated"));
+							}
+}
 }
 repeatItem->setGeometry(opt->boundingRect);
 repeatItem->update();
 }
 break;
 }
 case P_RatingSlider_track:{
 if (const HbStyleOptionRatingSlider *opt = qstyleoption_cast<const HbStyleOptionRatingSlider *>(option)) {
 HbRepeatMaskItem *repeatItem = static_cast<HbRepeatMaskItem*>(item);
 repeatItem->setMaskValue(opt->progressValue);
 repeatItem->setMaximum(opt->noOfIntervals);
 repeatItem->setInverted(opt->inverted);
 repeatItem->setRepeatingNumber(opt->noOfStars);
 if (!opt->ratedGraphicsName.isEmpty()) {
 repeatItem->setName(opt->ratedGraphicsName);
 }
 else {
-repeatItem->setName(QLatin1String("qtg_graf_ratingslider_rated"));
+if(opt->disableState) {
+repeatItem->setName(QLatin1String("qtg_graf_ratingslider_rated_disabled"));
+}
+else {
+							if(opt->pressedState) {
+								repeatItem->setName(QLatin1String("qtg_graf_ratingslider_rated_pressed"));
+							}
+							else {
+								repeatItem->setName(QLatin1String("qtg_graf_ratingslider_rated"));
+							}
+}
 }
 repeatItem->setGeometry(opt->boundingRect);
 repeatItem->update();
 }
 break;
 iconItem->setBrush(opt->background.value<QBrush>());
 }
 }
 break;
 case P_ItemViewItem_frame:
 if (const HbStyleOptionAbstractViewItem *opt = qstyleoption_cast<const HbStyleOptionAbstractViewItem *>(option)) {
 HbFrameItem *frameItem = static_cast<HbFrameItem*>(item);
 frameItem->setZValue(-4.0);
 frameItem->setGeometry(opt->boundingRect);
 frameItem->frameDrawer().setFrameType(frame.frameType());
 frameItem->frameDrawer().setFrameGraphicsName(frame.frameGraphicsName());
 } else if (opt->viewItemType == Hb::ItemType_TreeViewItem) {
 if (opt->modelItemType == Hb::ParentItem) {
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName( opt->insidePopup ?
 QLatin1String("qtg_fr_popup_list_parent_normal") : QLatin1String("qtg_fr_list_parent_normal"));
 } else if (opt->modelItemType == Hb::SeparatorItem) {
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_list_separator"));
 } else {
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName( opt->insidePopup ?
 QLatin1String("qtg_fr_popup_list_normal") : QLatin1String("qtg_fr_list_normal"));
 }
 } else if ( opt->viewItemType == Hb::ItemType_ListViewItem
 || opt->viewItemType == Hb::ItemType_RadioButtonListViewItem) {
 if (opt->modelItemType == Hb::SeparatorItem) {
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName(QLatin1String("qtg_fr_list_separator"));
 } else {
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName( opt->insidePopup ?
 QLatin1String("qtg_fr_popup_list_normal") : QLatin1String("qtg_fr_list_normal"));
 }
 } else if (opt->viewItemType == Hb::ItemType_GridViewItem
 || opt->viewItemType == HbPrivate::ItemType_ColorGridViewItem) {
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->frameDrawer().setFrameGraphicsName( opt->insidePopup ?
 QLatin1String("qtg_fr_popup_grid_normal") : QLatin1String("qtg_fr_grid_normal"));
 }
 else{
 frameItem->frameDrawer().setFrameGraphicsName(QString());
 }
 //frameItem->setGeometry(opt->boundingRect);
 Q_UNUSED(opt);
 }
 }
 break;
 case P_TumbleView_frame:
 if (const HbStyleOption *opt = qstyleoption_cast<const HbStyleOption*>(option)) {
 if(HbFrameItem *frameItem = qgraphicsitem_cast<HbFrameItem*>(item)) {
 frameItem->frameDrawer().setFrameGraphicsName("qtg_fr_tumbler_overlay");
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->setZValue(-4);
 if(HbFrameItem *frameItem = qgraphicsitem_cast<HbFrameItem*>(item)) {
 frameItem->frameDrawer().setFrameGraphicsName("qtg_fr_tumbler_highlight_pri");
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::ThreePiecesHorizontal);
 frameItem->setZValue(3);
 //TODO:temp fix, issue with css rule picking in derived class
 //frameItem->setGeometry(0,(opt->boundingRect.height()-frameItem->boundingRect().height())/2,opt->boundingRect.width(),opt->boundingRect.height());
 Q_UNUSED(opt);
 }
 }
 break;
 case P_IndexFeedback_popup_text:
 if (const HbStyleOptionIndexFeedback *opt = qstyleoption_cast<const HbStyleOptionIndexFeedback *>(option)) {
 //frameItem->setGeometry(opt->boundingRect);
 Q_UNUSED(opt);
 }
 }
 break;
 case P_DateTimePicker_frame:
 if (const HbStyleOption *opt = qstyleoption_cast<const HbStyleOption*>(option)) {
 if(HbFrameItem *frameItem = qgraphicsitem_cast<HbFrameItem*>(item)) {
 frameItem->frameDrawer().setFrameGraphicsName("qtg_fr_tumbler_overlay");
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->setZValue(1);
 }
 }
 break;
 case P_InputDialog_text:
 if (const HbStyleOptionInputDialog *opt =
 qstyleoption_cast<const HbStyleOptionInputDialog*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 if(!item) {
 return;
 }
 textItem->setTextWrapping(Hb::TextWrapAnywhere);
 textItem->setText(opt->text);
 }
 break;
 case P_InputDialog_additionaltext:
 if (const HbStyleOptionInputDialog *opt =
 qstyleoption_cast<const HbStyleOptionInputDialog*>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 if(!item) {
 return;
 }
 textItem->setTextWrapping(Hb::TextWrapAnywhere);
 textItem->setText(opt->additionalText);
 }
 break;
 default:
 return;
 };
 }
 QGraphicsLayoutItem* lItem = (item && item->isWidget()) ? (QGraphicsLayoutItem*)static_cast<QGraphicsWidget*>(item) : 0;
 if ( !lItem ) {
 lItem = widget->layoutPrimitive(name);
 if ( lItem && !lItem->graphicsItem() ) {
 // assume it is spacer
-static_cast<HbMeshLayout*>(widget->layout())->setItemId( lItem, name );
+static_cast<HbAnchorLayout*>(widget->layout())->setMapping( lItem, name );
 }
 }
 HbDeviceProfile profile(HbDeviceProfile::profile(widget));
 qDebug() << "HbStyle::polishItem : -- Setting aspect ratio mode: " << prop.mAspectRatioMode;
 #endif
 icon->setAspectRatioMode(prop.mAspectRatioMode);
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_IconAspectRatioMode, false);
 }
+if ( prop.mFlags & HbCss::ExtractedAlignment
+&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_IconAlign)) {
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishItem : -- Setting icon alignment: " << prop.mAlignment;
+#endif
+icon->setAlignment( prop.mAlignment );
+hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_IconAlign, false);
+}
 }
 HbTextItem* text = qobject_cast<HbTextItem*>(hbWidget);
 if (text) {
 if ( prop.mFlags & HbCss::ExtractedMinLines
 qDebug() << "HbStyle::polishItem : -- Setting text max lines: " << prop.mMaxLines;
 #endif
 text->setMaximumLines( prop.mMaxLines );
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax, false);
 }
-if ( prop.mFlags & HbCss::ExtractedTextAlign
+if ( prop.mFlags & HbCss::ExtractedAlignment
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign)) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << prop.mTextAlignment;
+qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << prop.mAlignment;
 #endif
-text->setAlignment( prop.mTextAlignment );
+text->setAlignment( prop.mAlignment );
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign, false);
 }
 if ( prop.mFlags & HbCss::ExtractedWrapMode
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode)) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting wrap mode : " << prop.mTextWrapMode;
 #endif
 text->setTextWrapping( prop.mTextWrapMode );
 }
 }
 HbRichTextItem* richtext = qobject_cast<HbRichTextItem*>(hbWidget);
 if (richtext) {
-if ( prop.mFlags & HbCss::ExtractedTextAlign
+if ( prop.mFlags & HbCss::ExtractedAlignment
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign)) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << prop.mTextAlignment;
+qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << prop.mAlignment;
 #endif
-richtext->setAlignment( prop.mTextAlignment );
+richtext->setAlignment( prop.mAlignment );
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign, false);
 }
 if ( prop.mFlags & HbCss::ExtractedWrapMode
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode)) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting wrap mode : " << prop.mTextWrapMode;
 #endif
 richtext->setTextWrapping( prop.mTextWrapMode );
 }
 lItem->setSizePolicy(itemPol);
 }
 if (layoutDefined) {
-HbMeshLayout *layout = static_cast<HbMeshLayout*>(widget->layout());
+HbAnchorLayout *layout = static_cast<HbAnchorLayout*>(widget->layout());
 if ( layout ) {
 if (prop.mFlags & HbCss::ExtractedLeft) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting left override: " << prop.mLeft;
 #endif
-layout->overrideSpacing(name, Hb::LeftEdge, prop.mLeft);
+overrideSpacing(layout, name, Hb::LeftEdge, prop.mLeft);
 }
 if (prop.mFlags & HbCss::ExtractedRight) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting right override: " << prop.mRight;
 #endif
-layout->overrideSpacing(name, Hb::RightEdge, prop.mRight);
+overrideSpacing(layout, name, Hb::RightEdge, prop.mRight);
 }
 if (prop.mFlags & HbCss::ExtractedTop) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting top override: " << prop.mTop;
 #endif
-layout->overrideSpacing(name, Hb::TopEdge, prop.mTop);
+overrideSpacing(layout, name, Hb::TopEdge, prop.mTop);
 }
 if (prop.mFlags & HbCss::ExtractedBottom) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting bottom override: " << prop.mBottom;
 #endif
-layout->overrideSpacing(name, Hb::BottomEdge, prop.mBottom);
+overrideSpacing(layout, name, Hb::BottomEdge, prop.mBottom);
 }
 if (prop.mFlags & HbCss::ExtractedCenterH) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting centerh override: " << prop.mCenterH;
 #endif
-layout->overrideSpacing(name, Hb::CenterHEdge, prop.mCenterH);
+overrideSpacing(layout, name, Hb::CenterHEdge, prop.mCenterH);
 }
 if (prop.mFlags & HbCss::ExtractedCenterV) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting centerv override: " << prop.mCenterV;
 #endif
-layout->overrideSpacing(name, Hb::CenterVEdge, prop.mCenterV);
+overrideSpacing(layout, name, Hb::CenterVEdge, prop.mCenterV);
 }
 }
 }
 }
 Polishes the appearance of the given \a widget.
 This method should be called only by HbWidget (base class). The inherited
 classes should not call this method directly, but use the HbWidget's
 polish loop instead.
 This method reads the CSS and WidgetML definition for a given widget and positions
 the sub-elements inside it. Note you need to set the names for the sub-elements
 with HbStyle::setItemName method before this method is called.
 Note that this method is heavy on the system resources and should be called
 absolutely when necessary by the widget.
 \param widget, HbWidget to be polished
 \param params, style parameters to be returned to the caller
 */
 void HbStyle::polish(HbWidget *widget, HbStyleParameters &params)
 {
 qDebug() << "HbStyle::polish : Layout name: " << layoutName;
 }
 #endif
 QStringList meshIds;
-HbMeshLayout *meshLayout(0);
+HbAnchorLayout *meshLayout(0);
 if (layoutDefined) {
 QString cachedLayoutName = widgetLayoutNames[widget];
 bool cached = (cachedLayoutName == layoutName );
 if ( !cached ) {
 HbWidgetStyleLoader *loader = HbWidgetStyleLoader::instance();
 if ( !loader->loadWidgetML(widget, layoutName, sectionName)) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polish : Failed to load WidgetML";
 #endif
 return;
 }
 widgetLayoutNames[widget] = layoutName;
 if (cachedLayoutName.isNull()) {
 // Cached for the first time. Connect to destroyed signal.
 QObject::connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(widgetDestroyed(QObject*)));
 } else {
 qDebug() << "Cached nth time.";
 #endif
 }
 }
-meshLayout = static_cast<HbMeshLayout*>(widget->layout());
+meshLayout = static_cast<HbAnchorLayout*>(widget->layout());
 if (cached) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "LayoutName cache hit.";
 #endif
-meshLayout->clearItemIds();
+meshLayout->removeMappings();
 }
-meshLayout->setItemId(meshLayout, "");
+meshLayout->setMapping(meshLayout, "");
 meshIds = meshLayout->nodeIds();
 }
 // polish widget and subitems
 QList<QGraphicsItem*> list = widget->childItems();
 foreach (QGraphicsItem* item, list) {
 QString name = HbStyle::itemName(item);
 if ( meshLayout && !name.isEmpty() ) {
 // Assuming that all items with "itemName" are widgets.
-meshLayout->setItemId(static_cast<QGraphicsWidget*>(item), name);
+meshLayout->setMapping(static_cast<QGraphicsWidget*>(item), name);
 // Remove from "meshIds" so that we don't call polishItem
 // twice for this item.
 meshIds.removeAll(name);
 }
 d->polishItem(styleRules, widget, item, name, layoutDefined);
 \param item, graphics item whose themed parameters are supposed to be updated
 */
 void HbStylePrivate::updateThemedItems( const HbVector<HbCss::StyleRule> &styleRules,
 QGraphicsItem *item ) const
 {
 QString name = HbStyle::itemName(item);
 if (name.isEmpty() ) {
 return;
 }
 HbTextItem* text = qgraphicsitem_cast<HbTextItem*>( item );
 HbIconItem* iconItem = qgraphicsitem_cast<HbIconItem*>( item );
 HbMarqueeItem* marqueeItem = qgraphicsitem_cast<HbMarqueeItem*>( item );
 if(! (text || iconItem || marqueeItem ) ){
 return;
 }
 HbDeviceProfile profile;
 const HbVector<HbCss::Declaration> decl = declarations(styleRules, name, 0, profile);
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::updateThemedItems : -- Number of matching CSS declarations: " << decl.count();
 #endif
-ensureColorParameters();
-HbCss::ValueExtractor extractor(decl, colorParameters, profile);
+HbCss::ValueExtractor extractor(decl, profile);
 QColor col;
 bool extracted = extractor.extractColor( col );
 if (!extracted || !col.isValid()) {
 // Setting non black or white default color to make it visisble in black or white theme
 col.setRgb(255,0,255);
 }
 //apply the themed color to text-item
 if(text) {
 #ifdef HBSTYLE_DEBUG
 if ( !extracted ) {
 qDebug() << "HbStyle::getColor : -- No color information found";
 }
 #endif
 if ( !HbWidgetBasePrivate::d_ptr(text)->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor ) ){
 text->setTextColor(col);
 HbWidgetBasePrivate::d_ptr(text)->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor, false);
 }
 }
 if (iconItem) {
 // Applying color to mono-colorised icons from theme. Using setColor()
 // here would be wrong. It would lead to loosing the user-supplied color
 // in some cases so use the special setThemedColor() instead.
 HbIconItemPrivate::d_ptr(iconItem)->setThemedColor( col );
 }
 if(marqueeItem){
 //applying color to the marquee-item from theme
 if(!HbWidgetBasePrivate::d_ptr(marqueeItem)->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor)) {
 marqueeItem->setTextColor( col );
 HbWidgetBasePrivate::d_ptr(marqueeItem)->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor, false);
 }
 }
 }
 /*!
 HbStyle::updateThemedParams()
 Updates the themable parameters of widget (specially those which are specified in css files)
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::updateThemedParams : No style rules found.";
 #endif
 return;
 }
 // update themed items
 QList<QGraphicsItem*> list = widget->childItems();
 foreach (QGraphicsItem* item, list) {
 d->updateThemedItems(styleRules, item);
 }
 }
 /*!
 Checkes whether given widget has orienation specific style
 rules. This can be used for optimizing orientation switch.
 */
 bool HbStyle::hasOrientationSpecificStyleRules(HbWidget *widget)
 {
 HbLayeredStyleLoader *styleLoader =
 HbLayeredStyleLoader::getStack(HbLayeredStyleLoader::Concern_Layouts);
 NODEPTR_N(widget);
 return styleLoader->hasOrientationSpecificStyleRules(n);
 }
 \param item, graphics item
 \param name, name to be set
 */
 void HbStyle::setItemName( QGraphicsItem *item, const QString &name )
 {
-if (item && itemName(item) != name) {
+QString originalName = itemName(item);
+if (item && originalName != name) {
 item->setData( ItemName, name );
 QGraphicsItem* parent = item->parentItem();
 QGraphicsLayoutItem* lItem = (item->isWidget()) ? (QGraphicsLayoutItem*)static_cast<QGraphicsWidget*>(item) : 0;
 if (lItem && parent && parent->isWidget()) {
 QGraphicsWidget* parentW = static_cast<QGraphicsWidget*>(parent);
 if ( parentW->layout() && widgetLayoutNames.contains(parentW) ) {
-HbMeshLayout* layout = static_cast<HbMeshLayout*>(parentW->layout());
+HbAnchorLayout* layout = static_cast<HbAnchorLayout*>(parentW->layout());
 if ( layout->indexOf(lItem) != -1 ) {
-layout->setItemId(lItem, name.isEmpty() ? QString() : name);
+if( name.isEmpty() ) {
+layout->removeMapping(originalName);
+} else {
+if ( !originalName.isEmpty() ) {
+layout->removeMapping(originalName);
+}
+layout->setMapping(lItem, name);
+}
 }
 }
 }
 }
 }
 ? item->data( ItemName ).toString()
 : QString();
 }
 /*!
 Returns a value of a global style parameter. The value is returned in pixels.
 Available parameters can be found from hbglobalparameters.css. By using these
 parameters applications get consistent look.
 \param param Name of the global parameter.
 bool retVal = valueExtractor.extractExpressionValue(expressionString, value);
 value = -value;
 return retVal;
 }
 return valueExtractor.extractVariableValue(param, value);
 }
 /*!
 Returns copy of all global style parameters. Both names and values
 of the parameters are returned. The values are returned in pixels.
 Available parameters can be found from hbglobalparameters.css. By using these
 parameters applications get consistent look. Usage of this API (instead of parameter)
 is recommended if an application needs to fetch several parameters in one place.
 }
 }
 /*!
 Returns values for widget specific style parameters. The names of the parameters
 are passed in with \a params.
 This method should be used only if you need to access widget specific parameters out
 of the polish loop. It is more efficient to use HbWidget::polish(HbStyleParameters &params)
 if you don't need to access the parameters before the (first) polish event.
 HbStylePrivate::HbStylePrivate()
 {
 nextAvailableId = HbStyle::P_CustomBase;
 HbWidgetStyleLoader *loader = HbWidgetStyleLoader::instance();
 if(loader){
 loader->addFilePath(STYLE_LOCATION, HbLayeredStyleLoader::Concern_Layouts,
 HbLayeredStyleLoader::Priority_Core);
 loader->addFilePath(COLOR_STYLE_LOCATION, HbLayeredStyleLoader::Concern_Colors,
 HbLayeredStyleLoader::Priority_Core);
 }
 }
 /*!
 \internal
 */
 HbStylePrivate::~HbStylePrivate()
 {
 layoutParameters.clear();
-colorParameters.clear();
 HbWidgetStyleLoader *loader = HbWidgetStyleLoader::instance();
 if(loader){
 loader->removeFilePath(STYLE_LOCATION, HbLayeredStyleLoader::Concern_Layouts,
 HbLayeredStyleLoader::Priority_Core);
 loader->removeFilePath(COLOR_STYLE_LOCATION, HbLayeredStyleLoader::Concern_Colors,
 HbLayeredStyleLoader::Priority_Core);
 }
-}
-void HbStylePrivate::_q_onThemeChanged()
-{
-colorParameters.clear();
 }
 /*!
 \internal
 */
 }
 }
 default:
 break;
 }
 return QString();
 }
 /*!
 \internal
 */
 HbStyleInterface *HbStylePrivate::stylePluginInterface( HbStyle::Primitive primitive ) const
 {
 if (customPrimitives.contains(primitive)) {
 HbStyleInterfaceInfo* info = customPrimitives.value(primitive);
 QObject* pluginInstance = info->loader->instance();
 HbStyleInterface *stylePlugin = qobject_cast<HbStyleInterface *>(pluginInstance);
 return stylePlugin;
 layoutParameters.insert(decl.property, decl);
 }
 }
 }
-void HbStylePrivate::ensureColorParameters() const
-{
-if (colorParameters.isEmpty()) {
-HbLayeredStyleLoader *styleLoader = HbLayeredStyleLoader::getStack(HbLayeredStyleLoader::Concern_Colors);
-styleLoader->variableRuleSets(&colorParameters);
-}
-}
 /*!
 \internal
 */
 void HbStylePrivate::clearStyleSheetCaches()
 {
 widgetLayoutNames.clear();
 styleRulesCache.clear();
-colorParameters.clear();
 }
 HbWidgetBasePrivate *HbStylePrivate::widgetBasePrivate(HbWidgetBase *widgetBase) const
 {
 return HbWidgetBasePrivate::d_ptr(widgetBase);

changeset 6	c3690ec91ef8
parent 5	627c4a0fd0e7
child 7	923ff622b8b9