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

equal deleted inserted replaced

-:730c025d4b77
+:f378acbc9cfb
 ** 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 "hbstyleoptionmessagebox_p.h"
 #include "hbstyleoptionnavigationbutton_p.h"
 #include "hbstyleoptionindicatorbutton_p.h"
 #include "hbstyleoptionsignalindicator_p.h"
 #include "hbstyleoptionbatteryindicator_p.h"
-#include "hbstyle_p.h"
 #include "hbstyleloader.h"
 #include "hbwidgetloader_p.h"
 #include "hbwidget_p.h"
 #include "hbstyleoptionratingslider_p.h"
 #include "hbstyleoptiondataformviewitem_p.h"
 #include <hbrichtextitem_p.h>
 #include <hbtoucharea.h>
 #include <hbindicatorleveliconitem_p.h>
 #include <hbglobal.h>
-#include <hbpluginloader_p.h>
-#include "hbstyleinterface_p.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 "hbmeshlayout_p.h"
+#include "hbanchorlayout.h"
+#include <hbanchor.h>
 #include <QGraphicsWidget>
 #include <hbwidget.h>
 #include <hbwidgetbase.h>
 #include "hbdeviceprofile.h"
 #include "hbrepeatitem_p.h"
 #include <QDebug>
+#include <QMetaClassInfo>
+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
 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 childs) are doing the drawing.
+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.
 */
 /*!
 	    \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");
+static const char* LAYOUT_PTR_PROPERTY = "HbStyle_layout_ptr";
+static const char* LAYOUT_NAME_PROPERTY = "HbStyle_layout_name";
+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;
-QObject::connect(hbInstance->theme(), SIGNAL(changed()), this, SLOT(_q_onThemeChanged()));
 }
 /*!
 Destructor
 */
 HbStyle::~HbStyle()
 {
 delete d_ptr;
 }
 /*!
-\deprecated HbStyle::registerPlugin(const QString&)
+\deprecated HbStyle::createPrimitive(HbStyle::Primitive, QGraphicsItem*)
-is deprecated. Style plugins are not supported anymore.
-Registers the style plugin with the Style system. This method can be called by a custom widget
-or application in order to register the style plugin that implements the custom graphics primitives.
-This method results in loading of the plugin, if the plugin is registered for the first time.
-It returns the base ID for the primitives implemented by the style plugin. The custom widget
-can use the range of integers from (BaseID) to (BaseID+count-1) to refer to the custom
-primitives, where count is the number of primitives supported by the plugin. The style
-plugin must return the correct number of primitives when the primitiveCount() method is called.
-In case of errors the method returns < 0. Note also that for each registerPlugin there must be
-a unregisterPlugin call, the last unregisterPlugin call for a plugin causes the plugin to be unloaded.
-If the style plugin implementation returns valid path with layout defition files (CSS+WidgetML)
-from layoutPath() method the layout definitions CSSs gets read when calling registerPlugin().
-\param pluginName, name of the Plugin library to be dynamically loaded
-\return int the base ID to be used for the primitives implemented by the style plugin
-\sa unregisterPlugin()
-*/
-int HbStyle::registerPlugin(const QString &pluginName)
-{
-Q_D( const HbStyle );
-// check if the plugin is already registered
-if (d->registeredPlugins.contains(pluginName)) {
-// increase the reference count
-d->registeredPlugins.value(pluginName)->refCount++;
-// return the base ID of the primitives enumeration
-return d->registeredPlugins.value(pluginName)->primitiveBaseId;
-}
-// load the plugin
-HbPluginLoader* loader = new HbPluginLoader(pluginName);
-if (!loader)
-return -1;
-// get the instance pointer
-QObject* pluginInstance = loader->instance();
-if (!pluginInstance) {
-// try the additional paths
-QFileInfo fileInfo(pluginName);
-foreach (QString additionalPath, hbInstance->libraryPaths()) {
-const QDir pluginDir(additionalPath);
-loader->setPluginName(pluginDir.absoluteFilePath(fileInfo.fileName()));
-pluginInstance = loader->instance();
-if (pluginInstance) {
-break;
-}
-}
-if (!pluginInstance) {
-delete loader;
-return -1;
-}
-}
-HbStyleInterface *stylePlugin = qobject_cast<HbStyleInterface *>(pluginInstance);
-int primitiveCount = stylePlugin->primitiveCount();
-if (primitiveCount <= 0) {
-delete pluginInstance;
-delete loader;
-return -1;
-}
-HbStyleInterfaceInfo* info = new HbStyleInterfaceInfo();
-info->loader = loader;
-info->primitiveBaseId = d->nextAvailableId;
-// make entries for the primitives in the hash table
-for (int i=d->nextAvailableId; i<(d->nextAvailableId+primitiveCount); i++)
-{
-d->customPrimitives.insert(i, info);
-}
-// make entry for the plugin in the registered plugins hash table
-HbStylePluginInfo* pluginInfo = new HbStylePluginInfo();
-pluginInfo->primitiveBaseId = d->nextAvailableId;
-pluginInfo->primitiveCount = primitiveCount;
-pluginInfo->refCount = 1;
-d->registeredPlugins.insert(pluginName, pluginInfo);
-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;
-}
-/*!
-\deprecated HbStyle::unregisterPlugin(const QString&)
-is deprecated. Style plugins are not supported anymore.
-Un-registers the style plugin.
-If the reference count becomes zero, the plugin is unloaded and the primitive IDs are de-registered
-If a client has called registerPlugin() it must unregister the style plugin with this method.
-\param pluginName, name of the Plugin library
-*/
-void HbStyle::unregisterPlugin(const QString &pluginName)
-{
-Q_D( const HbStyle );
-if (d->registeredPlugins.contains(pluginName)) {
-HbStylePluginInfo *info = d->registeredPlugins.value(pluginName);
-info->refCount--;
-// unload plugin and remove from list
-if (info->refCount == 0) {
-HbStyleInterfaceInfo* styleInfo = d->customPrimitives.value(info->primitiveBaseId);
-delete styleInfo->loader->instance();
-delete styleInfo->loader;
-delete styleInfo;
-for (int i=info->primitiveBaseId; i< (info->primitiveBaseId+info->primitiveCount); i++) {
-d->customPrimitives.remove(i);
-}
-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
-d->nextAvailableId = HbStyle::P_CustomBase;
-}
-}
-}
-}
-/*!
-\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.
 */
 QGraphicsItem *HbStyle::createPrimitive( HbStyle::Primitive primitive, QGraphicsItem *parent ) const
 {
-Q_D( const HbStyle );
-if (d->customPrimitives.contains(primitive)) {
-HbStyleInterfaceInfo* info = d->customPrimitives.value(primitive);
-QObject* pluginInstance = info->loader->instance();
-HbStyleInterface *stylePlugin = qobject_cast<HbStyleInterface *>(pluginInstance);
-return stylePlugin->createPrimitive((HbStyle::Primitive)(primitive-info->primitiveBaseId), parent);
-}
 switch (primitive){
 case P_MenuItem_submenuindicator:
 {
 HbIconItem *item = new HbIconItem(parent);
 setItemName(item, QLatin1String("submenu-indicator"));
 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);
+parent->setFiltersChildEvents(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);
+parent->setFiltersChildEvents(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){
+if(parent){
-parent->setHandlesChildEvents(true);
+parent->setFiltersChildEvents(true);
-}*/
+}
 return ta;
 }
-case P_TitleBar_toucharea: {
+case P_TitleBar_toucharea:
+{
 HbTouchArea *ta = new HbTouchArea(parent);
 ta->setFlag(QGraphicsItem::ItemIsFocusable);
 setItemName(ta, QLatin1String("toucharea"));
+return ta;
+}
+case P_IndicatorButton_toucharea:
+case P_TitlePane_toucharea:
+case P_NavigationButton_toucharea:
+{
+HbTouchArea *ta = new HbTouchArea(parent);
+ta->setFlag(QGraphicsItem::ItemIsFocusable);
+setItemName(ta, QLatin1String("toucharea"));
+if (parent){
+parent->setHandlesChildEvents(true);
+}
 return ta;
 }
 case P_SliderElement_touchdecrease:
 case P_SliderElement_touchincrease:
 case P_SliderElement_touchgroove:
 {
 HbTouchArea *ta = new HbTouchArea(parent);
 ta->setFlag(QGraphicsItem::ItemIsFocusable);
 if(parent){
-//parent->setHandlesChildEvents(true);
+parent->setFiltersChildEvents(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;
 }
 return n;
 }
 case P_ItemViewItem_background: {
 HbIconItem *iconItem = q_check_ptr(new HbIconItem(parent));
+iconItem->setZValue(-3.0);
 setItemName(iconItem, QLatin1String("background"));
 return iconItem;
 }
 case P_ListViewItem_text: {
 case P_ComboBox_button: {
 HbIconItem *n = new HbIconItem(QString(), parent);
 return n;
 }
 case P_ItemViewItem_focus: {
-HbFrameItem *item = q_check_ptr(new HbFrameItem(parent));
+HbFrameItem *frameItem = q_check_ptr(new HbFrameItem(parent));
-//setItemName(item, QLatin1String("focus-indicator"));
+frameItem->setZValue(-1.0);
-return item;
+return frameItem;
 }
 case P_ItemHighlight_background:
 return new HbFrameItem(parent);
 case P_ItemViewItem_frame: {
 HbFrameItem *item = q_check_ptr(new HbFrameItem(parent));
+item->setZValue(-4.0);
 setItemName(item,"frame");
 return item;
 }
 case P_ScrollArea_continuationbottom:
 {
 \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
 */
 void HbStyle::updatePrimitive( QGraphicsItem *item, HbStyle::Primitive primitive, const QStyleOption *option ) const
 {
 Q_D( const HbStyle );
-if (d->customPrimitives.contains(primitive)) {
-HbStyleInterfaceInfo* info = d->customPrimitives.value(primitive);
-QObject* pluginInstance = info->loader->instance();
-HbStyleInterface *stylePlugin = qobject_cast<HbStyleInterface *>(pluginInstance);
-return stylePlugin->updatePrimitive(item, (HbStyle::Primitive)(primitive-info->primitiveBaseId), option);
-}
 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:
 case P_TitleBar_toucharea:
+case P_IndicatorButton_toucharea:
+case P_TitlePane_toucharea:
+case P_NavigationButton_toucharea:
 case P_SliderElement_touchdecrease:
 case P_SliderElement_touchincrease:
 case P_SliderElement_touchgroove:
 case P_SliderElement_touchhandle:
 case P_ScrollBar_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: {
 if (opt) {
 HbMarqueeItem *marqueeItem = static_cast<HbMarqueeItem*>( item );
 if (marqueeItem) {
 marqueeItem->setText(opt->caption);
-marqueeItem->startAnimation();
 }
 }
 break;
 }
 }
 }
 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;
 if (const HbStyleOptionNotificationDialog *opt =
 qstyleoption_cast<const HbStyleOptionNotificationDialog *>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setAlignment(opt->textAlignment);
 textItem->setFontSpec(HbFontSpec(HbFontSpec::Secondary));
-textItem->setTextWrapping(opt->wrappingText);
+textItem->setTextWrapping(opt->textTextWrapping);
 textItem->setText(opt->text);
 }
 break;
 case P_NotificationDialog_title:
 if (const HbStyleOptionNotificationDialog *opt =
 qstyleoption_cast<const HbStyleOptionNotificationDialog *>(option)) {
 HbTextItem *textItem = static_cast<HbTextItem*>(item);
 textItem->setAlignment(opt->titleAlignment);
 textItem->setFontSpec(HbFontSpec(HbFontSpec::Primary));
-textItem->setTextWrapping(opt->wrappingTitle);
+textItem->setTextWrapping(opt->titleTextWrapping);
+if (opt->titleTextWrapping == Hb::TextNoWrap) {
+textItem->setElideMode(Qt::ElideNone);
+} else {
+textItem->setElideMode(Qt::ElideRight);
+}
 textItem->setText(opt->title);
 }
 break;
 case P_NotificationDialog_icon:
 if (const HbStyleOptionNotificationDialog *opt =
 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 (iconItem->zValue() != opt->index + 1) {
+iconItem->setZValue(opt->index + 1);
+}
 if (opt->content.canConvert<HbIcon>()){
 iconItem->setIcon(opt->content.value<HbIcon>());
 } if (opt->content.canConvert<QIcon>()){
 iconItem->setIcon(opt->content.value<QIcon>());
 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();
+//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();
 }
 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 != QString()){
+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 != QString()){
+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;
 }*/
 break;
 case P_ItemViewItem_background:
 if (const HbStyleOptionAbstractViewItem *opt = qstyleoption_cast<const HbStyleOptionAbstractViewItem *>(option)) {
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
-iconItem->setZValue(-3.0);
 iconItem->setGeometry(opt->boundingRect);
 if (opt->background.canConvert<HbIcon>()){
 iconItem->setIcon(opt->background.value<HbIcon>());
 } else if (opt->background.canConvert<QBrush>()){
 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);
 if (opt->background.canConvert<HbFrameBackground>()) {
 HbFrameBackground frame = opt->background.value<HbFrameBackground>();
 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());
 }
 }
 break;
 case P_ItemViewItem_focus:
 if (const HbStyleOptionAbstractViewItem *opt = qstyleoption_cast<const HbStyleOptionAbstractViewItem *>(option)) {
 HbFrameItem *frameItem = static_cast<HbFrameItem*>(item);
-frameItem->setZValue(-1.0);
 frameItem->setGeometry(opt->boundingRect);
 if (opt->viewItemType == Hb::ItemType_TreeViewItem
 || opt->viewItemType == Hb::ItemType_ListViewItem
 || opt->viewItemType == Hb::ItemType_RadioButtonListViewItem) {
 break;
 case P_TumbleView_background:
 if (const HbStyleOption *opt = qstyleoption_cast<const HbStyleOption*>(option)) {
 if(HbFrameItem *frameItem = qgraphicsitem_cast<HbFrameItem*>(item)) {
-frameItem->frameDrawer().setFrameGraphicsName("qtg_fr_tumbler_bg");
+//Temporary source to avoid introducing new style primitive for selection dialog mark widget background item.
+QGraphicsItem *parent = frameItem->parentItem();
+const QMetaObject *obj = parent->toGraphicsObject()->metaObject();
+QString className;
+if(obj){
+className = obj->className();
+}
+///////////////////////////////////////////////////////////
+if( !className.compare("HbTumbleView") ){
+frameItem->frameDrawer().setFrameGraphicsName("qtg_fr_tumbler_bg");
+}
+else if( !className.compare("HbSelectionDialogMarkWidget") )
+{
+frameItem->frameDrawer().setFrameGraphicsName("qtg_fr_groupbox");
+}
 frameItem->frameDrawer().setFrameType(HbFrameDrawer::NinePieces);
 frameItem->setZValue(-5);
 //TODO:temp fix, issue with css rule picking in derived class
 //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;
 };
 }
 used by the polish() method
 \internal
 */
 void HbStylePrivate::polishItem(
 const HbVector<HbCss::StyleRule> &styleRules,
-HbWidget* widget,
+HbWidget *widget,
 QGraphicsItem *item,
 const QString &name,
+HbDeviceProfile &profile,
 bool layoutDefined) const
 {
 if (name.isEmpty() && widget != item) {
 return;
 }
 } else {
 qDebug() << "HbStyle::polishItem : -- item name: " << name << "(missing item)";
 }
 #endif
-HbDeviceProfile profile(HbDeviceProfile::profile(widget));
 const HbVector<HbCss::Declaration> decl = declarations(styleRules, name, widget, profile);
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Number of maching CSS declarations: " << decl.count();
+qDebug() << "HbStyle::polishItem : -- Number of matching CSS declarations: " << decl.count();
 #endif
 HbCss::ValueExtractor extractor(decl, layoutParameters, profile);
-HbCss::GeometryValues geomValues;
+HbCss::KnownProperties prop;
-HbCss::PositionValues posValues;
+if ( !extractor.extractKnownProperties(prop) ) {
-bool extracted = extractor.extractGeometry(geomValues);
+#ifdef HBSTYLE_DEBUG
-#ifndef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishItem : -- No polish overrides found";
-Q_UNUSED(extracted);
+#endif
-#endif
+return;
-#ifdef HBSTYLE_DEBUG
+}
-if ( !extracted ) {
-qDebug() << "HbStyle::polishItem : -- No geometry overrides found";
-}
-#endif
-extracted = extractor.extractPosition(posValues);
-#ifdef HBSTYLE_DEBUG
-if ( !extracted ) {
-qDebug() << "HbStyle::polishItem : -- No position overrides found";
-}
-#endif
 if ( item ) {
-if (posValues.mFlags & HbCss::ExtractedZValue) {
+if (prop.mFlags & HbCss::ExtractedZValue) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting zvalue: " << posValues.mZ;
+qDebug() << "HbStyle::polishItem : -- Setting zvalue: " << prop.mZ;
 #endif
-item->setZValue(posValues.mZ);
+item->setZValue(prop.mZ);
 }
 }
 QGraphicsWidget *gWidget = (item && item->isWidget())
 ? static_cast<QGraphicsWidget*>(item)
 : 0;
 if ( gWidget ) {
-if (posValues.mFlags & HbCss::ExtractedLayoutDirection) {
+if (prop.mFlags & HbCss::ExtractedLayoutDir) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting layout direction: " << posValues.mLayoutDirection;
+qDebug() << "HbStyle::polishItem : -- Setting layout direction: " << prop.mLayoutDir;
 #endif
-if (posValues.mLayoutDirection == HbCss::LayoutDirection_LeftToRight) {
+if (prop.mLayoutDir == HbCss::LayoutDirection_LeftToRight) {
 gWidget->setLayoutDirection(Qt::LeftToRight);
-} else if (posValues.mLayoutDirection == HbCss::LayoutDirection_RightToLeft) {
+} else if (prop.mLayoutDir == HbCss::LayoutDirection_RightToLeft) {
 gWidget->setLayoutDirection(Qt::RightToLeft);
 } else {
 gWidget->unsetLayoutDirection();
 }
 }
 }
 HbWidgetBase *hbWidget = qobject_cast<HbWidgetBase*>(gWidget);
 if ( hbWidget ) {
 HbWidgetBasePrivate* hbWidget_p = HbWidgetBasePrivate::d_ptr(hbWidget);
-QFont font;
+if ( prop.mFlags & HbCss::ExtractedFontSpec ) {
-HbFontSpec fontSpec;
+if ( !(prop.mFlags & HbCss::ExtractedFont) ) {
-int dummy;
+#ifdef HBSTYLE_DEBUG
-if (extractor.extractFont(&font, &fontSpec, &dummy)) {
+qDebug() << "HbStyle::polishItem : -- Setting fontspec: " << prop.mFontSpec.role() << prop.mFontSpec.textHeight();
-if ( !fontSpec.isNull() ) {
+#endif
-if ( font == QFont() ) {
+hbWidget->setFontSpec(prop.mFontSpec);
-#ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting fontspec: " << fontSpec.role();
-#endif
-hbWidget->setFontSpec(fontSpec);
-} else {
-#ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting fontspec with overrides: "
-<< fontSpec.role() << font;
-#endif
-hbWidget->setFont(fontSpec.font().resolve(font));
-}
 } else {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting explicit font: " << font;
+qDebug() << "HbStyle::polishItem : -- Setting fontspec with overrides: "
-#endif
+<< prop.mFontSpec.role() << prop.mFontSpec.textHeight() << prop.mFont;
-hbWidget->setFont(font);
+#endif
-}
+hbWidget->setFont(prop.mFontSpec.font().resolve(prop.mFont));
+}
+} else if ( prop.mFlags & HbCss::ExtractedFont ) {
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishItem : -- Setting explicit font: " << prop.mFont;
+#endif
+hbWidget->setFont(prop.mFont);
 }
 HbIconItem* icon = qobject_cast<HbIconItem*>(hbWidget);
 if (icon) {
-Qt::AspectRatioMode mode;
+if (prop.mFlags & HbCss::ExtractedAspectRatioMode
-if (extractor.extractAspectRatioMode(&mode)
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_IconAspectRatioMode)) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting aspect ratio mode: " << mode;
+qDebug() << "HbStyle::polishItem : -- Setting aspect ratio mode: " << prop.mAspectRatioMode;
 #endif
-icon->setAspectRatioMode(mode);
+icon->setAspectRatioMode(prop.mAspectRatioMode);
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_IconAspectRatioMode, false);
 }
-if(!hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_IconBrush)){
+if ( prop.mFlags & HbCss::ExtractedAlignment
-QBrush brush;
+&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_IconAlign)) {
-QString uri;
+#ifdef HBSTYLE_DEBUG
-HbCss::Repeat repeat = HbCss::Repeat_XY;
+qDebug() << "HbStyle::polishItem : -- Setting icon alignment: " << prop.mAlignment;
-Qt::Alignment alignment = Qt::AlignTop | Qt::AlignLeft;
+#endif
-HbCss::Attachment attachment = HbCss::Attachment_Scroll;
+icon->setAlignment( prop.mAlignment );
-HbCss::Origin origin = HbCss::Origin_Padding;
+hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_IconAlign, false);
-HbCss::Origin clip = HbCss::Origin_Border;
-if (extractor.extractBackground(&brush, &uri, &repeat, &alignment, &origin, &attachment, &clip)) {
-#ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting icon background: " << brush;
-#endif
-icon->setBrush( brush );
-} else {
-#ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Resetting icon background";
-#endif
-icon->setBrush( QBrush() );
-}
-hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_IconBrush, false);
 }
 }
 HbTextItem* text = qobject_cast<HbTextItem*>(hbWidget);
 if (text) {
-HbCss::TextValues textValues;
+if ( prop.mFlags & HbCss::ExtractedMinLines
-if ( extractor.extractTextValues( textValues ) ) {
+&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin)) {
-if ( textValues.mFlags & HbCss::ExtractedLineCountMin
+#ifdef HBSTYLE_DEBUG
-&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin)) {
+qDebug() << "HbStyle::polishItem : -- Setting text min lines: " << prop.mMinLines;
-#ifdef HBSTYLE_DEBUG
+#endif
-qDebug() << "HbStyle::polishItem : -- Setting text min lines: " << textValues.mLineCountMin;
+text->setMinimumLines( prop.mMinLines );
-#endif
+hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin, false);
-text->setMinimumLines( textValues.mLineCountMin );
+}
-hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin, false);
+if ( prop.mFlags & HbCss::ExtractedMaxLines
-}
+&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax)) {
-if ( textValues.mFlags & HbCss::ExtractedLineCountMax
+#ifdef HBSTYLE_DEBUG
-&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax)) {
+qDebug() << "HbStyle::polishItem : -- Setting text max lines: " << prop.mMaxLines;
-#ifdef HBSTYLE_DEBUG
+#endif
-qDebug() << "HbStyle::polishItem : -- Setting text max lines: " << textValues.mLineCountMax;
+text->setMaximumLines( prop.mMaxLines );
-#endif
+hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax, false);
-text->setMaximumLines( textValues.mLineCountMax );
+}
-hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax, false);
+if ( prop.mFlags & HbCss::ExtractedAlignment
-}
-}
-if ( posValues.mFlags & HbCss::ExtractedTextAlign
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign)) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << posValues.mTextAlignment;
+qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << prop.mAlignment;
 #endif
-text->setAlignment( posValues.mTextAlignment );
+text->setAlignment( prop.mAlignment );
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign, false);
 }
-if ( posValues.mFlags & HbCss::ExtractedWrapMode
+if ( prop.mFlags & HbCss::ExtractedWrapMode
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode)) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting wrap mode : " << posValues.mTextWrapMode;
+qDebug() << "HbStyle::polishItem : -- Setting wrap mode : " << prop.mTextWrapMode;
 #endif
-text->setTextWrapping( posValues.mTextWrapMode );
+text->setTextWrapping( prop.mTextWrapMode );
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode, false);
 }
 }
 HbRichTextItem* richtext = qobject_cast<HbRichTextItem*>(hbWidget);
 if (richtext) {
-if ( posValues.mFlags & HbCss::ExtractedTextAlign
+if ( prop.mFlags & HbCss::ExtractedAlignment
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign)) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << posValues.mTextAlignment;
+qDebug() << "HbStyle::polishItem : -- Setting text alignment: " << prop.mAlignment;
 #endif
-richtext->setAlignment( posValues.mTextAlignment );
+richtext->setAlignment( prop.mAlignment );
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign, false);
 }
-if ( posValues.mFlags & HbCss::ExtractedWrapMode
+if ( prop.mFlags & HbCss::ExtractedWrapMode
 && !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode)) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting wrap mode : " << posValues.mTextWrapMode;
+qDebug() << "HbStyle::polishItem : -- Setting wrap mode : " << prop.mTextWrapMode;
 #endif
-richtext->setTextWrapping( posValues.mTextWrapMode );
+richtext->setTextWrapping( prop.mTextWrapMode );
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode, false);
 }
 }
 HbFrameItem *frame = qobject_cast<HbFrameItem*>(hbWidget);
 if (frame && !frame->frameDrawer().d->testBorderApiProtectionFlag()) {
-qreal borderWidths[HbCss::NumEdges] = { 0.0,0.0,0.0,0.0 };
+if (prop.mFlags & HbCss::ExtractedBorderWidths) {
-QBrush borderColors[HbCss::NumEdges];
-HbCss::BorderStyle borderStyles[HbCss::NumEdges];
-QSize borderRadii[4];
-if (extractor.extractBorder(borderWidths,borderColors,borderStyles,borderRadii)) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting border widths (l,t,r,b):"
-<< borderWidths[HbCss::LeftEdge]
+<< prop.mBorderWidths[HbCss::LeftEdge]
-<< borderWidths[HbCss::TopEdge]
+<< prop.mBorderWidths[HbCss::TopEdge]
-<< borderWidths[HbCss::RightEdge]
+<< prop.mBorderWidths[HbCss::RightEdge]
-<< borderWidths[HbCss::BottomEdge];
+<< prop.mBorderWidths[HbCss::BottomEdge];
 #endif
 frame->frameDrawer().setBorderWidths(
-borderWidths[HbCss::LeftEdge],
+prop.mBorderWidths[HbCss::LeftEdge],
-borderWidths[HbCss::TopEdge],
+prop.mBorderWidths[HbCss::TopEdge],
-borderWidths[HbCss::RightEdge],
+prop.mBorderWidths[HbCss::RightEdge],
-borderWidths[HbCss::BottomEdge]);
+prop.mBorderWidths[HbCss::BottomEdge]);
 frame->frameDrawer().d->setBorderApiProtectionFlag(false);
 }
 }
 if ( hbWidget->inherits( "HbLineEdit" ) ) {
-HbCss::TextValues textValues;
+if ( prop.mFlags & HbCss::ExtractedMinLines
-if ( extractor.extractTextValues( textValues ) ) {
+&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin)) {
-if ( textValues.mFlags & HbCss::ExtractedLineCountMin
+#ifdef HBSTYLE_DEBUG
-&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin)) {
+qDebug() << "HbStyle::polishItem : -- Setting text min lines: " << prop.mMinLines;
-#ifdef HBSTYLE_DEBUG
+#endif
-qDebug() << "HbStyle::polishItem : -- Setting text min lines: " << textValues.mLineCountMin;
+hbWidget->setProperty( "minRows", prop.mMinLines );
-#endif
+hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin, false);
-hbWidget->setProperty( "minRows", textValues.mLineCountMin );
+}
-hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin, false);
+if ( prop.mFlags & HbCss::ExtractedMaxLines
-}
+&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin)) {
-if ( textValues.mFlags & HbCss::ExtractedLineCountMax
+#ifdef HBSTYLE_DEBUG
-&& !hbWidget_p->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin)) {
+qDebug() << "HbStyle::polishItem : -- Setting text max lines: " << prop.mMaxLines;
-#ifdef HBSTYLE_DEBUG
+#endif
-qDebug() << "HbStyle::polishItem : -- Setting text max lines: " << textValues.mLineCountMax;
+hbWidget->setProperty( "maxRows", prop.mMaxLines );
-#endif
+hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax, false);
-hbWidget->setProperty( "maxRows", textValues.mLineCountMax );
-hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax, false);
-}
 }
 }
 }
-QGraphicsLayoutItem* lItem = (item && item->isWidget()) ? (QGraphicsLayoutItem*)static_cast<QGraphicsWidget*>(item) : 0;
+QGraphicsLayoutItem* lItem = (item && item->isWidget())
-if ( !lItem ) {
+? (QGraphicsLayoutItem*)static_cast<QGraphicsWidget*>(item)
-lItem = widget->layoutPrimitive(name);
+: 0;
-if ( lItem && !lItem->graphicsItem() ) {
+if ( lItem ) {
-// assume it is spacer
+if ( prop.mFlags & HbCss::ExtractedMinW ) {
-static_cast<HbMeshLayout*>(widget->layout())->setItemId( lItem, name );
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishItem : -- Setting minimum width: " << prop.mMinW;
+#endif
+lItem->setMinimumWidth( prop.mMinW );
 }
-}
+if ( prop.mFlags & HbCss::ExtractedMinH ) {
-if ( lItem ) {
+#ifdef HBSTYLE_DEBUG
-if ( geomValues.mFlags & HbCss::ExtractedMinW ) {
+qDebug() << "HbStyle::polishItem : -- Setting minimum height: " << prop.mMinH;
-#ifdef HBSTYLE_DEBUG
+#endif
-qDebug() << "HbStyle::polishItem : -- Setting minimum width: " << geomValues.mMinW;
+lItem->setMinimumHeight( prop.mMinH );
-#endif
-lItem->setMinimumWidth( geomValues.mMinW );
 }
-if ( geomValues.mFlags & HbCss::ExtractedMinH ) {
+if ( prop.mFlags & HbCss::ExtractedPrefW ) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting minimum height: " << geomValues.mMinH;
+qDebug() << "HbStyle::polishItem : -- Setting preferred width: " << prop.mPrefW;
 #endif
-lItem->setMinimumHeight( geomValues.mMinH );
+lItem->setPreferredWidth( prop.mPrefW );
 }
-if ( geomValues.mFlags & HbCss::ExtractedPrefW ) {
+if ( prop.mFlags & HbCss::ExtractedPrefH ) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting preferred width: " << geomValues.mPrefW;
+qDebug() << "HbStyle::polishItem : -- Setting preferred height: " << prop.mPrefH;
 #endif
-lItem->setPreferredWidth( geomValues.mPrefW );
+lItem->setPreferredHeight( prop.mPrefH );
 }
-if ( geomValues.mFlags & HbCss::ExtractedPrefH ) {
+if ( prop.mFlags & HbCss::ExtractedMaxW ) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting preferred height: " << geomValues.mPrefH;
+qDebug() << "HbStyle::polishItem : -- Setting maximum width: " << prop.mMaxW;
 #endif
-lItem->setPreferredHeight( geomValues.mPrefH );
+lItem->setMaximumWidth( prop.mMaxW );
 }
-if ( geomValues.mFlags & HbCss::ExtractedMaxW ) {
+if ( prop.mFlags & HbCss::ExtractedMaxH ) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting maximum width: " << geomValues.mMaxW;
+qDebug() << "HbStyle::polishItem : -- Setting maximum height: " << prop.mMaxH;
 #endif
-lItem->setMaximumWidth( geomValues.mMaxW );
+lItem->setMaximumHeight( prop.mMaxH );
-}
-if ( geomValues.mFlags & HbCss::ExtractedMaxH ) {
-#ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting maximum height: " << geomValues.mMaxH;
-#endif
-lItem->setMaximumHeight( geomValues.mMaxH );
 }
 QSizePolicy itemPol = lItem->sizePolicy();
-if ( geomValues.mFlags & HbCss::ExtractedPolHor ) {
+if ( prop.mFlags & HbCss::ExtractedPolHor ) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting horizontal size policy: " << geomValues.mSizePolicy.horizontalPolicy();
+qDebug() << "HbStyle::polishItem : -- Setting horizontal size policy: " << prop.mSizePolicy.horizontalPolicy();
 #endif
-itemPol.setHorizontalPolicy(geomValues.mSizePolicy.horizontalPolicy());
+itemPol.setHorizontalPolicy(prop.mSizePolicy.horizontalPolicy());
 }
-if ( geomValues.mFlags & HbCss::ExtractedPolVer ) {
+if ( prop.mFlags & HbCss::ExtractedPolVer ) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting vertical size policy: " << geomValues.mSizePolicy.verticalPolicy();
+qDebug() << "HbStyle::polishItem : -- Setting vertical size policy: " << prop.mSizePolicy.verticalPolicy();
 #endif
-itemPol.setVerticalPolicy(geomValues.mSizePolicy.verticalPolicy());
+itemPol.setVerticalPolicy(prop.mSizePolicy.verticalPolicy());
 }
 lItem->setSizePolicy(itemPol);
 }
 if (layoutDefined) {
-HbMeshLayout *layout = static_cast<HbMeshLayout*>(widget->layout());
+HbAnchorLayout *layout = static_cast<HbAnchorLayout*>(widget->layout());
 if ( layout ) {
-if (posValues.mFlags & HbCss::ExtractedLeft) {
+if (prop.mFlags & HbCss::ExtractedLeft) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting left override: " << posValues.mLeft;
+qDebug() << "HbStyle::polishItem : -- Setting left override: " << prop.mLeft;
 #endif
-layout->overrideSpacing(name, Hb::LeftEdge, posValues.mLeft);
+overrideSpacing(layout, name, Hb::LeftEdge, prop.mLeft);
 }
-if (posValues.mFlags & HbCss::ExtractedRight) {
+if (prop.mFlags & HbCss::ExtractedRight) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting right override: " << posValues.mRight;
+qDebug() << "HbStyle::polishItem : -- Setting right override: " << prop.mRight;
 #endif
-layout->overrideSpacing(name, Hb::RightEdge, posValues.mRight);
+overrideSpacing(layout, name, Hb::RightEdge, prop.mRight);
 }
-if (posValues.mFlags & HbCss::ExtractedTop) {
+if (prop.mFlags & HbCss::ExtractedTop) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting top override: " << posValues.mTop;
+qDebug() << "HbStyle::polishItem : -- Setting top override: " << prop.mTop;
 #endif
-layout->overrideSpacing(name, Hb::TopEdge, posValues.mTop);
+overrideSpacing(layout, name, Hb::TopEdge, prop.mTop);
 }
-if (posValues.mFlags & HbCss::ExtractedBottom) {
+if (prop.mFlags & HbCss::ExtractedBottom) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting bottom override: " << posValues.mBottom;
+qDebug() << "HbStyle::polishItem : -- Setting bottom override: " << prop.mBottom;
 #endif
-layout->overrideSpacing(name, Hb::BottomEdge, posValues.mBottom);
+overrideSpacing(layout, name, Hb::BottomEdge, prop.mBottom);
 }
-if (posValues.mFlags & HbCss::ExtractedCenterH) {
+if (prop.mFlags & HbCss::ExtractedCenterH) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting centerh override: " << posValues.mCenterH;
+qDebug() << "HbStyle::polishItem : -- Setting centerh override: " << prop.mCenterH;
 #endif
-layout->overrideSpacing(name, Hb::CenterHEdge, posValues.mCenterH);
+overrideSpacing(layout, name, Hb::CenterHEdge, prop.mCenterH);
 }
-if (posValues.mFlags & HbCss::ExtractedCenterV) {
+if (prop.mFlags & HbCss::ExtractedCenterV) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polishItem : -- Setting centerv override: " << posValues.mCenterV;
+qDebug() << "HbStyle::polishItem : -- Setting centerv override: " << prop.mCenterV;
 #endif
-layout->overrideSpacing(name, Hb::CenterVEdge, posValues.mCenterV);
+overrideSpacing(layout, name, Hb::CenterVEdge, prop.mCenterV);
 }
 }
 }
 }
+void HbStylePrivate::polishAnchor(
+const HbVector<HbCss::StyleRule> &styleRules,
+HbWidget *widget,
+HbAnchor *anchor,
+HbDeviceProfile &profile) const
+{
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polish : -- --";
+qDebug() << "HbStyle::polishAnchor : -- anchor id: " << anchor->anchorId();
+#endif
+const HbVector<HbCss::Declaration> decl = declarations(styleRules, anchor->anchorId(), widget, profile);
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishAnchor : -- Number of matching CSS declarations: " << decl.count();
+#endif
+HbCss::ValueExtractor extractor(decl, layoutParameters, profile);
+HbCss::KnownProperties prop;
+if ( !extractor.extractKnownProperties(prop) ) {
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishAnchor : -- No polish overrides found";
+#endif
+return;
+}
+if ( prop.mFlags & HbCss::ExtractedMinH || prop.mFlags & HbCss::ExtractedMinW ) {
+qreal minLength = prop.mFlags & HbCss::ExtractedMinH ? prop.mMinH : prop.mMinW;
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishAnchor : -- Setting minimum length: " << minLength;
+#endif
+anchor->setMinimumLength( minLength );
+}
+if ( prop.mFlags & HbCss::ExtractedPrefH || prop.mFlags & HbCss::ExtractedPrefW ) {
+qreal prefLength = prop.mFlags & HbCss::ExtractedPrefH ? prop.mPrefH : prop.mPrefW;
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishAnchor : -- Setting preferred length: " << prefLength;
+#endif
+anchor->setPreferredLength( prefLength );
+}
+if ( prop.mFlags & HbCss::ExtractedMaxH || prop.mFlags & HbCss::ExtractedMaxW ) {
+qreal maxLength = prop.mFlags & HbCss::ExtractedMaxH ? prop.mMaxH : prop.mMaxW;
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishAnchor : -- Setting maximum length: " << maxLength;
+#endif
+anchor->setMaximumLength( maxLength );
+}
+if ( prop.mFlags & HbCss::ExtractedPolVer || prop.mFlags & HbCss::ExtractedPolHor ) {
+QSizePolicy::Policy policy = prop.mFlags & HbCss::ExtractedPolVer
+? prop.mSizePolicy.verticalPolicy() : prop.mSizePolicy.horizontalPolicy();
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishAnchor : -- Setting size policy: " << policy;
+#endif
+anchor->setSizePolicy( policy );
+}
+if ( prop.mFlags & HbCss::ExtractedAnchorDir ) {
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polishAnchor : -- Setting anchor direction: " << prop.mAnchorDir;
+#endif
+anchor->setDirection( prop.mAnchorDir );
+}
+}
 #define NODEPTR_N(x) HbCss::StyleSelector::NodePtr n = {n.ptr = (void *)x};
 /*!
 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)
 {
 if (!styleRules.count()) {
 return;
 }
 const HbVector<HbCss::Declaration> decl = declarations(styleRules, "", widget, profile);
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polish : Number of maching CSS declarations: " << decl.count();
+qDebug() << "HbStyle::polish : Number of matching CSS declarations: " << decl.count();
 #endif
 d->ensureLayoutParameters(profile);
 HbCss::ValueExtractor extractor(decl, d->layoutParameters, profile);
 QString layoutName;
 QString sectionName;
 if ( params.count() ) {
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::polish : Extracting parameters.";
+qDebug() << "HbStyle::polish : Extracting custom properties.";
 #endif
-extractor.extractParameters( params.params(), params.values() );
+extractor.extractCustomProperties( params.keys(), params.values() );
 }
-bool layoutDefined = extractor.extractLayout(&layoutName, &sectionName);
+bool layoutDefined = extractor.extractLayout(layoutName, sectionName);
 #ifdef HBSTYLE_DEBUG
 if (!layoutDefined) {
 qDebug() << "HbStyle::polish : Couldn't find layout name for the widget.";
 } else {
 qDebug() << "HbStyle::polish : Layout name: " << layoutName;
 }
 #endif
-QStringList meshIds;
+QStringList nodeIds;
-HbMeshLayout *meshLayout(0);
+HbAnchorLayout *anchorLayout(0);
 if (layoutDefined) {
-QString cachedLayoutName = widgetLayoutNames[widget];
+// check that we do not override the user defined layout
-bool cached = (cachedLayoutName == layoutName );
+const QVariant layoutPtrByStyleV = widget->property( LAYOUT_PTR_PROPERTY );
-if ( !cached ) {
+const QGraphicsLayout *layoutPtrByStyle = layoutPtrByStyleV.isValid() ? layoutPtrByStyleV.value<QGraphicsLayout*>() : 0;
-#ifdef HBSTYLE_DEBUG
+const QGraphicsLayout *existingLayoutPtr = widget->layout();
-qDebug() << "LayoutName cache miss.";
-#endif
+if ( existingLayoutPtr && (existingLayoutPtr!=layoutPtrByStyle) ) {
-HbWidgetStyleLoader *loader = HbWidgetStyleLoader::instance();
+// widget has a layout, but it is not created by the style -> we cannot override.
-if ( !loader->loadWidgetML(widget, layoutName, sectionName)) {
+#ifdef HBSTYLE_DEBUG
-#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::polish : layout overridden by user";
-qDebug() << "HbStyle::polish : Failed to load WidgetML";
+#endif // HBSTYLE_DEBUG
-#endif
+} else {
-return;
+const QVariant existingLayoutNameV = widget->property( LAYOUT_NAME_PROPERTY );
-}
+const QString existingLayoutName = existingLayoutNameV.isValid() ? existingLayoutNameV.toString() : QString();
-widgetLayoutNames[widget] = layoutName;
+const bool cached = (existingLayoutName == layoutName );
-if (cachedLayoutName.isNull()) {
+if ( !cached ) {
-// Cached for the first time. Connect to destroyed signal.
+#ifdef HBSTYLE_DEBUG
-QObject::connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(widgetDestroyed(QObject*)));
+qDebug() << "LayoutName cache miss.";
-#ifdef HBSTYLE_DEBUG
+#endif
-qDebug() << "Cached first time. Connected to destroy signal.";
+HbWidgetStyleLoader *loader = HbWidgetStyleLoader::instance();
-} else {
+if ( !loader->loadWidgetML(widget, layoutName, sectionName)) {
-qDebug() << "Cached nth time.";
+#ifdef HBSTYLE_DEBUG
-#endif
+qDebug() << "HbStyle::polish : Failed to load WidgetML";
-}
+#endif
+return;
+}
+const QVariant ptrVariant = QVariant::fromValue( widget->layout() );
+widget->setProperty( LAYOUT_PTR_PROPERTY, ptrVariant );
+widget->setProperty( LAYOUT_NAME_PROPERTY, QVariant( layoutName ) );
+}
+anchorLayout = static_cast<HbAnchorLayout*>(widget->layout());
+if (cached) {
+#ifdef HBSTYLE_DEBUG
+qDebug() << "LayoutName cache hit.";
+#endif
+anchorLayout->removeMappings();
+}
+anchorLayout->setMapping(anchorLayout, "");
+nodeIds = anchorLayout->nodeIds();
 }
-meshLayout = static_cast<HbMeshLayout*>(widget->layout());
-if (cached) {
-#ifdef HBSTYLE_DEBUG
-qDebug() << "LayoutName cache hit.";
-#endif
-meshLayout->clearItemIds();
-}
-meshLayout->setItemId(meshLayout, "");
-meshIds = meshLayout->nodeIds();
 }
 // polish widget and subitems
-d->polishItem(styleRules, widget, widget, "", false);
+d->polishItem(styleRules, widget, widget, "", profile, false);
 QList<QGraphicsItem*> list = widget->childItems();
 foreach (QGraphicsItem* item, list) {
 QString name = HbStyle::itemName(item);
-if ( meshLayout && !name.isEmpty() ) {
+if ( anchorLayout && !name.isEmpty() ) {
 // Assuming that all items with "itemName" are widgets.
-meshLayout->setItemId(static_cast<QGraphicsWidget*>(item), name);
+anchorLayout->setMapping(static_cast<QGraphicsWidget*>(item), name);
-// Remove from "meshIds" so that we don't call polishItem
+// Remove from "nodeIds" so that we don't call polishItem
 // twice for this item.
-meshIds.removeAll(name);
+nodeIds.removeAll(name);
 }
-d->polishItem(styleRules, widget, item, name, layoutDefined);
+d->polishItem(styleRules, widget, item, name, profile, layoutDefined);
 }
-foreach (QString meshId, meshIds) {
+foreach (QString nodeId, nodeIds) {
-// These are the "missing" mesh items. Need to call polishItem
+// These are the "missing" anchor items. Need to call polishItem
-// for them, too, for getting the mesh anchor spacings right.
+// for them, too, for getting the anchor spacings right.
-// if there are mesh ids, layoutDefined is always true.
+// if there are anchor node ids, layoutDefined is always true.
-if ( !meshId.isEmpty() ) {
+if ( !nodeId.isEmpty() ) {
-d->polishItem(styleRules, widget, 0, meshId, true);
+d->polishItem(styleRules, widget, 0, nodeId, profile, true);
+}
+}
+if ( anchorLayout ) {
+QList<HbAnchor*> anchors = anchorLayout->anchors();
+foreach (HbAnchor* anchor, anchors) {
+if ( !anchor->anchorId().isEmpty() ) {
+d->polishAnchor(styleRules, widget, anchor, profile);
+}
 }
 }
 }
 /*!
 \param styleRules, style-rules of the widget
 \param variableRules, variable-rules of the widget
 \param widget, widget whose themed parameters are supposed to be updated
 \param item, graphics item whose themed parameters are supposed to be updated
 */
-void HbStylePrivate::updateThemedItems( const HbVector<HbCss::StyleRule> &styleRules,
+void HbStylePrivate::updateThemedItems(
-QGraphicsItem *item ) const
+const HbVector<HbCss::StyleRule> &styleRules,
+QGraphicsItem *item,
+HbDeviceProfile &profile) const
 {
 QString name = HbStyle::itemName(item);
 if (name.isEmpty() ) {
 return;
 }
 HbTextItem* text = qgraphicsitem_cast<HbTextItem*>( item );
+HbRichTextItem* richtext = qgraphicsitem_cast<HbRichTextItem*>( item );
 HbIconItem* iconItem = qgraphicsitem_cast<HbIconItem*>( item );
 HbMarqueeItem* marqueeItem = qgraphicsitem_cast<HbMarqueeItem*>( item );
-if(! (text || iconItem || marqueeItem ) ){
+if(! (text || richtext || iconItem || marqueeItem ) ){
 return;
 }
-HbDeviceProfile profile;
 const HbVector<HbCss::Declaration> decl = declarations(styleRules, name, 0, profile);
 #ifdef HBSTYLE_DEBUG
-qDebug() << "HbStyle::updateThemedItems : -- Number of maching CSS declarations: " << decl.count();
+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 );
+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
+if(richtext) {
-iconItem->setColor( col );
+#ifdef HBSTYLE_DEBUG
+if ( !extracted ) {
+qDebug() << "HbStyle::getColor : -- No color information found";
+}
+#endif
+if ( !HbWidgetBasePrivate::d_ptr(richtext)->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor ) ){
+richtext->setTextDefaultColor(col);
+HbWidgetBasePrivate::d_ptr(richtext)->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);
+d->updateThemedItems(styleRules, item, profile);
 }
 }
 /*!
 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);
 }
 /*!
 For clearing caches.
 */
 void HbStyle::widgetDestroyed(QObject* obj)
 {
-widgetLayoutNames.remove((const QGraphicsWidget *)obj);
+Q_UNUSED( obj );
 }
 /*!
 Sets the item name of a graphics item. Item name is not the same as object name.
 \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) ) {
+const QVariant layoutPtrByStyleV = parentW->property( LAYOUT_PTR_PROPERTY );
-HbMeshLayout* layout = static_cast<HbMeshLayout*>(parentW->layout());
+const QGraphicsLayout *layoutPtrByStyle = layoutPtrByStyleV.isValid() ? layoutPtrByStyleV.value<QGraphicsLayout*>() : 0;
+if ( parentW->layout() && (parentW->layout()==layoutPtrByStyle)) {
+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 variable Name of the global parameter.
+\param param Name of the global parameter.
 \param value Returns value of the global parameter.
 \param profile Device profile of the used HbMainWindow. Primary display's.
 device profile HbDeviceProfile::current() is used if the value is omitted.
-\return true if the variable were found.
+\return true if the variable was found.
 */
-bool HbStyle::parameter(const QString& parameter, qreal& value, const HbDeviceProfile &profile) const
+bool HbStyle::parameter(const QString& param, qreal& value, const HbDeviceProfile &profile) const
 {
 HbDeviceProfile effectiveProfile = profile;
 if ( effectiveProfile.isNull() ) {
 effectiveProfile = HbDeviceProfile::current();
 }
 Q_D( const HbStyle );
 d->ensureLayoutParameters(effectiveProfile);
 HbCss::ValueExtractor valueExtractor(d->layoutParameters, true, effectiveProfile);
 // todo: parsing variable/expression is done here so that there is no need to change API
 // also parameters method not changed (this change is done for docml/widgetml parsing)
-if (parameter.startsWith("var(") && parameter.endsWith(")")) {
+if (param.startsWith(QLatin1String("var(")) && param.endsWith(QLatin1String(")"))) {
-return valueExtractor.extractValue(parameter.mid(4,parameter.length()-5), value);
+return valueExtractor.extractVariableValue(param.mid(4,param.length()-5), value);
-} else if (parameter.startsWith("-var(") && parameter.endsWith(")")) {
+} else if (param.startsWith(QLatin1String("-var(")) && param.endsWith(QLatin1String(")"))) {
-bool retVal = valueExtractor.extractValue(parameter.mid(5,parameter.length()-6), value);
+bool retVal = valueExtractor.extractVariableValue(param.mid(5,param.length()-6), value);
 value = -value;
 return retVal;
-} else if (parameter.startsWith("expr(") && parameter.endsWith(")")) {
+} else if (param.startsWith(QLatin1String("expr(")) && param.endsWith(QLatin1String(")"))) {
-QString expressionString = parameter.mid(5,parameter.length()-6);
+QString expressionString = param.mid(5,param.length()-6);
 return valueExtractor.extractExpressionValue(expressionString, value);
-} else if (parameter.startsWith("-expr(") && parameter.endsWith(")")) {
+} else if (param.startsWith(QLatin1String("-expr(")) && param.endsWith(QLatin1String(")"))) {
-QString expressionString = parameter.mid(6,parameter.length()-7);
+QString expressionString = param.mid(6,param.length()-7);
 bool retVal = valueExtractor.extractExpressionValue(expressionString, value);
 value = -value;
 return retVal;
 }
-return valueExtractor.extractValue(parameter, value);
+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.
-\param parameters Contains names and values of all global style parameters.
+\param params Contains names and values of all global style parameters.
 \param profile Device profile of the used HbMainWindow. Primary display's
 device profile HbDeviceProfile::current() is used if the value is omitted.
 */
-void HbStyle::parameters(HbStyleParameters &parameters, const HbDeviceProfile &profile) const
+void HbStyle::parameters(HbStyleParameters &params, const HbDeviceProfile &profile) const
 {
 HbDeviceProfile effectiveProfile = profile;
 if ( effectiveProfile.isNull() ) {
 effectiveProfile = HbDeviceProfile::current();
 }
 d->ensureLayoutParameters(effectiveProfile);
 HbCss::ValueExtractor valueExtractor(d->layoutParameters, true, effectiveProfile);
 qreal value = 0;
 QHash<QString, HbCss::Declaration>::const_iterator i = d->layoutParameters.constBegin();
 while (i != d->layoutParameters.constEnd()) {
-if (valueExtractor.extractValue(i.key(), value)) {
+if (valueExtractor.extractVariableValue(i.key(), value)) {
-parameters.addParameter(i.key(), value);
+params.addParameter(i.key(), value);
 }
 ++i;
 }
+}
+/*!
+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.
+\param parameters, style parameters to be returned to the caller
+\param widget, HbWidget to be polished
+\sa HbStyle::polish, HbStyle::parameters and HbWidget::polish
+*/
+void HbStyle::widgetParameters(HbStyleParameters &params, HbWidget* widget) const
+{
+Q_D( const HbStyle );
+if( !widget || !params.count() ) {
+return;
+}
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::widgetParameters : Parameters for" << widget->metaObject()->className();
+#endif
+HbLayeredStyleLoader *styleLoader = HbLayeredStyleLoader::getStack(HbLayeredStyleLoader::Concern_Layouts);
+if(!styleLoader){
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::widgetParameters : HbLayeredStyleLoader returned a null pointer.";
+#endif
+return;
+}
+HbDeviceProfile profile(HbDeviceProfile::profile(widget));
+NODEPTR_N(widget);
+HbVector<HbCss::StyleRule> styleRules = styleLoader->styleRulesForNode(n, profile.orientation());
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::widgetParameters : Number of style rules:" << styleRules.count();
+#endif
+if (!styleRules.count()) {
+return;
+}
+const HbVector<HbCss::Declaration> decl = declarations(styleRules, "", widget, profile);
+#ifdef HBSTYLE_DEBUG
+qDebug() << "HbStyle::widgetParameters : Number of matching CSS declarations: " << decl.count();
+#endif
+d->ensureLayoutParameters(profile);
+HbCss::ValueExtractor extractor(decl, d->layoutParameters, profile);
+extractor.extractCustomProperties( params.keys(), params.values() );
 }
 /*!
 \internal
 */
 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
 */
 QString HbStylePrivate::logicalName(HbStyle::Primitive primitive, const QStyleOption *option) const
 {
-switch(primitive){
+switch (primitive) {
-case HbStyle::P_Slider_thumb:{
+case HbStyle::P_Slider_thumb: {
 const HbStyleOptionSlider *opt = qstyleoption_cast<const HbStyleOptionSlider *>(option);
-QString iconPath;
+if (opt) {
+QString iconPath;
-switch (opt->orientation){
+switch (opt->orientation) {
-case Qt::Horizontal:{
-if( opt->state&QStyle::State_Sunken)
+case Qt::Horizontal:
-iconPath= "qtg_graf_slider_h_handle_pressed";
+if (opt->state & QStyle::State_Sunken)
-else
+iconPath = "qtg_graf_slider_h_handle_pressed";
-iconPath= "qtg_graf_slider_h_handle_normal";
+else
-return (iconPath);
+iconPath = "qtg_graf_slider_h_handle_normal";
-}
+return iconPath;
-case Qt::Vertical:{
-if( opt->state&QStyle::State_Sunken)
+case Qt::Vertical:
-iconPath= "qtg_graf_slider_v_handle_pressed";
+if (opt->state & QStyle::State_Sunken)
-else
+iconPath = "qtg_graf_slider_v_handle_pressed";
-iconPath= "qtg_graf_slider_v_handle_normal";
+else
-return (iconPath);
+iconPath = "qtg_graf_slider_v_handle_normal";
-}
+return iconPath;
-default: break;
+default:
+break;
+}
 }
 }
-default: break;
-}
+default:
+break;
-return QString();
+}
+return QString();
 }
 /*!
 \internal
 */
 if (state & QStyle::State_On)
 icon = QIcon::On;
 return icon;
 }
-/*!
-\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;
-}
-return 0;
-}
 /*!
 \internal
 */
 void HbStylePrivate::ensureLayoutParameters(const HbDeviceProfile &profile) const
 bool firstParse(layoutParameters.isEmpty());
 bool addSpecialParams(firstParse);
 if (firstParse) {
 HbCss::Parser parser;
 parser.init(GLOBAL_PARAMETERS_LOCATION, true);
-HbCss::StyleSheet *styleSheet = new(HbCss::StyleSheet);
+HbCss::StyleSheet *styleSheet = HbMemoryUtils::create<HbCss::StyleSheet>(HbMemoryManager::HeapMemory);
 parser.parse(styleSheet);
 HbStyleSelector selector;
 selector.styleSheets.append(styleSheet);
 selector.variableRuleSets(&layoutParameters);
 QSizeF pSize = profile.logicalSize();
 {
 HbCss::Declaration decl;
 decl.property = "hb-param-screen-width";
-decl.propertyId = HbCss::UnknownProperty;
+decl.propertyId = HbCss::Property_Unknown;
 HbCss::Value val;
 val.type = HbCss::Value::Number;
 val.variant = HbVariant((double)pSize.width(),HbMemoryManager::HeapMemory);
 decl.values.append(val);
 layoutParameters.insert(decl.property, decl);
 }
 {
 HbCss::Declaration decl;
 decl.property = "hb-param-screen-height";
-decl.propertyId = HbCss::UnknownProperty;
+decl.propertyId = HbCss::Property_Unknown;
 HbCss::Value val;
 val.type = HbCss::Value::Number;
 val.variant = HbVariant((double)pSize.height(),HbMemoryManager::HeapMemory);
 decl.values.append(val);
 layoutParameters.insert(decl.property, decl);
 }
 {
 HbCss::Declaration decl;
 decl.property = "hb-param-screen-short-edge";
-decl.propertyId = HbCss::UnknownProperty;
+decl.propertyId = HbCss::Property_Unknown;
 HbCss::Value val;
 val.type = HbCss::Value::Number;
 val.variant = HbVariant((double)qMin(pSize.height(),pSize.width()),HbMemoryManager::HeapMemory);
 decl.values.append(val);
 layoutParameters.insert(decl.property, decl);
 }
 {
 HbCss::Declaration decl;
 decl.property = "hb-param-screen-long-edge";
-decl.propertyId = HbCss::UnknownProperty;
+decl.propertyId = HbCss::Property_Unknown;
 HbCss::Value val;
 val.type = HbCss::Value::Number;
 val.variant = HbVariant((double)qMax(pSize.height(),pSize.width()),HbMemoryManager::HeapMemory);
 decl.values.append(val);
 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);
 }
 #include "moc_hbstyle.cpp"

branch	GCC_SURGE
changeset 15	f378acbc9cfb
parent 7	923ff622b8b9
child 21	4633027730f5
child 34	ed14f46c0e55