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

equal deleted inserted replaced

-:c3690ec91ef8
+:923ff622b8b9
 #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 "hbrepeaticonitem_p.h"
 #include "hbnamespace_p.h"
 #include "hbanchorlayout.h"
-#include "hbanchorlayoutdebug_p.h"
+#include <hbanchor.h>
-#include "hbanchor_p.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
 Generally primitives should be updated only when a state change occurs. When a widget uses primitives to construct
 itself it does not need a paint() method at all since primitives (widget's children) are doing the drawing.
 Painting for the primitives occurs from the graphics scene.
+HbStyle has some caching functionality and thus it should not be instantiated explicitly, but
+accessed only through HbWidget::style() or HbInstance::style() APIs.
 */
 /*!
 	    \deprecated P_PushButton_icon
 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 = HbAnchorLayoutDebug::getOriginalAnchors( layout );
+QList<HbAnchor*> list = layout->anchors();
 for( int i = 0; i < list.size(); i++ ) {
 HbAnchor *anchor = list.at(i);
-if( ( anchor->mStartId == name ) && ( anchor->mStartEdge == edge ) ) {
+if( ( anchor->startNodeId() == name ) && ( anchor->startEdge() == edge ) ) {
-layout->setAnchor( anchor->mStartId, anchor->mStartEdge, anchor->mEndId, anchor->mEndEdge, val );
+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 );
 HbStyle::~HbStyle()
 {
 delete d_ptr;
 }
-/*!
-\deprecated HbStyle::registerPlugin(const QString&)
-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.
 \return HbWidgetBase is returned.
 */
 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);
 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:
 {
 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:
 {
 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:
 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:
 {
 */
 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)) {
 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:
 if (opt) {
 HbMarqueeItem *marqueeItem = static_cast<HbMarqueeItem*>( item );
 if (marqueeItem) {
 marqueeItem->setText(opt->caption);
-marqueeItem->startAnimation();
 }
 }
 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 =
 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>());
 }*/
 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());
 }
 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);
 }
 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
-QGraphicsLayoutItem* lItem = (item && item->isWidget()) ? (QGraphicsLayoutItem*)static_cast<QGraphicsWidget*>(item) : 0;
-if ( !lItem ) {
-lItem = widget->layoutPrimitive(name);
-if ( lItem && !lItem->graphicsItem() ) {
-// assume it is spacer
-static_cast<HbAnchorLayout*>(widget->layout())->setMapping( lItem, name );
-}
-}
-HbDeviceProfile profile(HbDeviceProfile::profile(widget));
 const HbVector<HbCss::Declaration> decl = declarations(styleRules, name, widget, profile);
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Number of matching CSS declarations: " << decl.count();
 #endif
 HbCss::ValueExtractor extractor(decl, layoutParameters, profile);
 hbWidget_p->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax, false);
 }
 }
 }
+QGraphicsLayoutItem* lItem = (item && item->isWidget())
+? (QGraphicsLayoutItem*)static_cast<QGraphicsWidget*>(item)
+: 0;
 if ( lItem ) {
 if ( prop.mFlags & HbCss::ExtractedMinW ) {
 #ifdef HBSTYLE_DEBUG
 qDebug() << "HbStyle::polishItem : -- Setting minimum width: " << prop.mMinW;
 #endif
 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.
 } else {
 qDebug() << "HbStyle::polish : Layout name: " << layoutName;
 }
 #endif
-QStringList meshIds;
+QStringList nodeIds;
-HbAnchorLayout *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<HbAnchorLayout*>(widget->layout());
-if (cached) {
-#ifdef HBSTYLE_DEBUG
-qDebug() << "LayoutName cache hit.";
-#endif
-meshLayout->removeMappings();
-}
-meshLayout->setMapping(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->setMapping(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 matching CSS declarations: " << decl.count();
 #endif
 if ( !HbWidgetBasePrivate::d_ptr(text)->testApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor ) ){
 text->setTextColor(col);
 HbWidgetBasePrivate::d_ptr(text)->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextColor, false);
 }
 }
+if(richtext) {
+#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 );
 }
 // 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
 /*!
 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.
 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 );
+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 ) {
 if( name.isEmpty() ) {
 layout->removeMapping(originalName);
 } else {
 /*!
 \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,
 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
 /*!
 \internal
 */
 void HbStylePrivate::clearStyleSheetCaches()
 {
-widgetLayoutNames.clear();
 styleRulesCache.clear();
 }
 HbWidgetBasePrivate *HbStylePrivate::widgetBasePrivate(HbWidgetBase *widgetBase) const
 {
 return HbWidgetBasePrivate::d_ptr(widgetBase);
 }
 #include "moc_hbstyle.cpp"

changeset 7	923ff622b8b9
parent 6	c3690ec91ef8
child 21	4633027730f5
child 34	ed14f46c0e55