diff -r 4633027730f5 -r e6ad4ef83b23 src/hbcore/gui/hbtoolbutton.cpp
--- a/src/hbcore/gui/hbtoolbutton.cpp	Wed Aug 18 10:05:37 2010 +0300
+++ b/src/hbcore/gui/hbtoolbutton.cpp	Thu Sep 02 20:44:51 2010 +0300
@@ -26,13 +26,10 @@
 #include "hbtoolbutton.h"
 #include "hbtoolbutton_p.h"
 #include "hbtooltip.h"
-#include "hbstyleoptiontoolbutton_p.h"
 #include "hbtoolbarextension.h"
 #include "hbtoolbarextension_p.h"
 #include "hbaction.h"
 #include "hbaction_p.h"
-#include "hbstyle_p.h"
-#include <hbglobal.h>
 #include "hbcolorscheme.h"
 #include "hbtextitem.h"
 #include "hbiconitem.h"
@@ -41,6 +38,12 @@
 
 #include "hbglobal_p.h" // remove when removing HB_DEPRECATED
 
+#include "hbstyle_p.h" // for iconmodes...
+
+#include <hbstyleframeprimitivedata.h>
+#include <hbstyleiconprimitivedata.h>
+#include <hbstyletextprimitivedata.h>
+
 #include <QGraphicsSceneHelpEvent>
 #include <QGraphicsSceneMouseEvent>
 #include <QCoreApplication>
@@ -103,7 +106,7 @@
     frameItem(0),
     customBackground(),
     backgroundVisible(true),
-    toolBarPosition(HbStyleOptionToolButton::TB_None),
+    toolBarPosition(TB_None),
     orientation(Qt::Vertical),
     mDialogToolBar(false),
     toolbarExtensionFrame(false),
@@ -120,19 +123,23 @@
     Q_Q(HbToolButton);
     if (backgroundVisible) {
         if (!frameItem){
-            frameItem = HbStylePrivate::createPrimitive(HbStylePrivate::P_ToolButton_frame, q);
+            frameItem = q->style()->createPrimitive(HbStyle::PT_FrameItem, "background", q);
         }
     } else if (frameItem) {
         delete frameItem;
         frameItem = 0;
     }
     if (!textItem) {
-            textItem = static_cast<HbTextItem *>(HbStylePrivate::createPrimitive(HbStylePrivate::P_ToolButton_text, q));            
-        textItem->setTextWrapping(Hb::TextWordWrap);
-    } // I dare you to optimize this
+        textItem = q->style()->createPrimitive(HbStyle::PT_TextItem, "text", q);
+        }
+    HbStyleTextPrimitiveData textData;
+    textData.textWrapping = Hb::TextWordWrap;
+    q->style()->updatePrimitive(textItem, &textData, q);
+        
     if (!iconItem) {
-            iconItem = HbStylePrivate::createPrimitive(HbStylePrivate::P_ToolButton_icon, q);
+        iconItem = q->style()->createPrimitive(HbStyle::PT_IconItem, "icon", q);
     }
+    
 }
 
 void HbToolButtonPrivate::setOrientation(Qt::Orientation orientation)
@@ -144,7 +151,7 @@
     }    
 }
 
-void HbToolButtonPrivate::setToolBarPosition(HbStyleOptionToolButton::ToolBarPosition position)
+void HbToolButtonPrivate::setToolBarPosition(ToolButtonPosition position)
 {
     Q_Q(HbToolButton);
     if (toolBarPosition != position) {
@@ -185,7 +192,174 @@
 {
     Q_Q(HbToolButton);
     q->setProperty(name, value);
-    q->repolish();
+        q->repolish();
+}
+
+
+bool HbToolButtonPrivate::useTransparentGraphics() const
+{
+    Q_Q(const HbToolButton);
+    if (q->mainWindow() && q->mainWindow()->currentView()) {
+        if (q->mainWindow()->currentView()->viewFlags() & HbView::ViewTitleBarTransparent) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool HbToolButtonPrivate::isToolBarExtension() const
+{
+    return (action != 0 && toolbarExtensionFrame);
+}
+
+
+
+
+void HbToolButtonPrivate::framePrimitiveData(HbStyleFramePrimitiveData *data)
+{
+
+    Q_Q(HbToolButton);
+
+    data->fillWholeRect = true;
+   
+    if (orientation == Qt::Vertical) {
+        data->frameType = HbFrameDrawer::ThreePiecesHorizontal;
+    } else {
+        data->frameType = HbFrameDrawer::ThreePiecesVertical;
+    }
+
+    QStringList list;
+    QString frameGraphicsFooter;
+    // data->state already set by abstractbutton's data init
+    QIcon::Mode mode = HbStylePrivate::iconMode(data->state);
+    QIcon::State state = HbStylePrivate::iconState(data->state);
+    
+    // custom background
+    if (!q->background().isNull()) {
+        data->frameGraphicsName = customBackground.iconName(mode, state);
+        return;
+    }
+
+    // in toolbar extension
+    if(isToolBarExtension()) {
+       if (mode == QIcon::Normal && state == QIcon::On) {
+           if(!q->isCheckable()){
+                data->frameGraphicsName = QLatin1String("qtg_fr_popup_grid_pressed");
+            } else {
+                data->frameGraphicsName = QLatin1String("qtg_fr_tb_ext");
+            }
+        }
+    data->frameType = HbFrameDrawer::NinePieces;
+    return;
+    }
+
+    if (!toolBarPosition) {
+        if (mode == QIcon::Disabled && state == QIcon::Off) {
+            data->frameGraphicsName = QLatin1String("qtg_fr_btn_disabled");
+        } else if (mode == QIcon::Normal && state == QIcon::On) {
+            if(!q->isCheckable()){
+                data->frameGraphicsName = QLatin1String("qtg_fr_btn_pressed");
+            } else {
+                data->frameGraphicsName = QLatin1String("qtg_fr_btn_latched");
+            }
+        } else if (mode == QIcon::Selected && state == QIcon::Off) {
+            data->frameGraphicsName = QLatin1String("qtg_fr_btn_highlight");
+        } else {
+            data->frameGraphicsName = QLatin1String("qtg_fr_btn_normal");
+        }
+        data->frameType = HbFrameDrawer::NinePieces;
+        return;
+    }
+// For toolbar:
+
+                QString frameGraphicsHeader;
+                if (!mDialogToolBar){
+                    if (useTransparentGraphics()) {
+                        frameGraphicsHeader = orientation == Qt::Vertical ?
+                                              QLatin1String("qtg_fr_tb_trans_h_"):
+                                              QLatin1String("qtg_fr_tb_trans_v_");
+                    } else {
+                        frameGraphicsHeader = orientation == Qt::Vertical ?
+                                              QLatin1String("qtg_fr_tb_h_"):
+                                              QLatin1String("qtg_fr_tb_v_");
+                    }
+                }else {
+                    frameGraphicsHeader = QLatin1String("qtg_fr_popup_sk_");
+                    data->mirroringMode = HbIcon::LayoutDirection;
+                }
+
+                switch (toolBarPosition) {
+                    case TB_OnlyOne:
+                        if (orientation == Qt::Vertical) {
+                            list << QLatin1String("_l") << QLatin1String("_c") << QLatin1String("_r");
+                        } else {
+                            list << QLatin1String("_t") << QLatin1String("_c") << QLatin1String("_b");
+                        }
+                        break;
+                    case TB_Beginning:
+                        if (orientation== Qt::Vertical) {
+                            list << QLatin1String("_l") << QLatin1String("_c") << QLatin1String("_cr");
+                        } else {
+                            list << QLatin1String("_t") << QLatin1String("_c") << QLatin1String("_cb");
+                        }
+                        break;
+                    case TB_Middle:
+                        if (orientation == Qt::Vertical) {
+                            list << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_cr");
+                        } else {
+                            list << QLatin1String("_ct") << QLatin1String("_c") << QLatin1String("_cb");
+                        }
+                        break;
+                    case TB_End:
+                        if (orientation== Qt::Vertical) {
+                            list << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_r");
+                        } else {
+                            list << QLatin1String("_ct") << QLatin1String("_c") << QLatin1String("_b");
+                        }
+                        break;
+
+                    default:
+                    case TB_None:
+                    break;
+                }; // switch case end
+                
+
+
+                data->fileNameSuffixList = list;
+                if (mode == QIcon::Disabled && state == QIcon::Off) {
+                    frameGraphicsFooter = QLatin1String("disabled");
+                } else if (mode == QIcon::Normal && state == QIcon::On) {
+                    if(!q->isCheckable()) {
+                        frameGraphicsFooter = QLatin1String("pressed");
+                    } else {
+                        frameGraphicsFooter = QLatin1String("latched");
+                    }
+                } else if (mode == QIcon::Selected && state == QIcon::Off) {
+                    frameGraphicsFooter = QLatin1String("highlight");
+                } else {
+                    frameGraphicsFooter = QLatin1String("normal");
+                }
+                data->frameGraphicsName = QString ("%0%1").arg(frameGraphicsHeader).arg(frameGraphicsFooter);
+                data->mirroringMode = HbIcon::LayoutDirection;
+                return;
+
+}
+void HbToolButtonPrivate::iconPrimitiveData(HbStyleIconPrimitiveData *data)
+{
+    Q_Q(HbToolButton);
+    if (q->action())
+        data->icon = q->action()->icon();
+
+    data->iconMode = HbStylePrivate::iconMode(data->state);
+    data->iconState = HbStylePrivate::iconState(data->state);
+    return;
+}
+void HbToolButtonPrivate::textPrimitiveData(HbStyleTextPrimitiveData *data)
+{
+    Q_Q(HbToolButton);
+    if (q->action())
+        data->text = q->action()->text();
+    return;
 }
 
 QSizeF HbToolButtonPrivate::getMinimumSize()
@@ -341,29 +515,6 @@
     }
 }
 
-
-/*!
-
-    \deprecated HbToolButton::primitive(HbStyle::Primitive)
-         is deprecated.
-
-    \reimp
- */
-QGraphicsItem *HbToolButton::primitive(HbStyle::Primitive primitive) const
-{
-    Q_D(const HbToolButton);
-    switch (primitive) {
-        case HbStylePrivate::P_ToolButton_frame:
-            return d->frameItem;
-        case HbStylePrivate::P_ToolButton_icon:
-            return d->iconItem;
-        case HbStylePrivate::P_ToolButton_text:
-            return d->textItem;
-        default:
-            return 0;
-    }
-}
-
 /*!
     \reimp
  */
@@ -371,7 +522,7 @@
 {
     Q_D(HbToolButton);
 
-    HbStyleOptionToolButton option;
+    
     if (d->action) {
         setCheckable(d->action->isCheckable());
         setChecked(d->action->isChecked());
@@ -393,74 +544,48 @@
         setToolTip(QString());
     }
 
-    initStyleOption(&option);
     setProperty("dialogtoolbar", d->mDialogToolBar);
     if (d->frameItem) {
-        HbStylePrivate::updatePrimitive(d->frameItem, HbStylePrivate::P_ToolButton_frame, &option);
+        HbStyleFramePrimitiveData data;
+        initPrimitiveData(&data, d->frameItem);
+        style()->updatePrimitive(d->frameItem, &data, this);
+        d->frameItem->update();
     }
     if (d->textItem) {
+        HbStyleTextPrimitiveData data;
+        initPrimitiveData(&data, d->textItem);
         bool itemHasNoContents = false;
-        if (option.text.isEmpty() || option.text.isNull() ||
-            (property(BUTTONSTYLE).toInt() == HbToolButtonPrivate::ToolButtonIcon)) {
-            itemHasNoContents = true;
+        if (data.text.isSet()) {
+            if ( data.text.value().isEmpty() || data.text.value().isNull() ||
+                (property(BUTTONSTYLE).toInt() == HbToolButtonPrivate::ToolButtonIcon)) {
+                itemHasNoContents = true;
+            }
         }
         d->textItem->setFlag(QGraphicsItem::ItemHasNoContents, itemHasNoContents);
-        if(!itemHasNoContents)
-            HbStylePrivate::updatePrimitive(d->textItem, HbStylePrivate::P_ToolButton_text, &option);
+        if(!itemHasNoContents) {
+
+            style()->updatePrimitive(d->textItem, &data, this);
+            d->textItem->update();
+        }
     }
     if (d->iconItem) {
+        HbStyleIconPrimitiveData data;
+        initPrimitiveData(&data, d->iconItem);
+
         bool itemHasNoContents = false;
-        if (option.icon.isNull() || (property(BUTTONSTYLE).toInt() == HbToolButtonPrivate::ToolButtonText)) {
-            itemHasNoContents = true;
-        } else {
-            HbStylePrivate::updatePrimitive(d->iconItem, HbStylePrivate::P_ToolButton_icon, &option);
-            if (option.icon.flags() & HbIcon::Colorized) {
-                static_cast<HbIconItem *>(d->iconItem)->setFlags(HbIcon::Colorized);
-            }
-            if (option.icon.mirroringMode() != HbIcon::Default) {
-                HbIconItem *iconItem = static_cast<HbIconItem *>(d->iconItem);
-                iconItem->setMirroringMode( option.icon.mirroringMode() );
+        if (data.icon.isSet()) {
+            if (data.icon.value().isNull() || (property(BUTTONSTYLE).toInt() == HbToolButtonPrivate::ToolButtonText)) {
+                itemHasNoContents = true;
+            } else {
+                    style()->updatePrimitive(d->iconItem, &data, this);
+                    d->iconItem->update();
             }
         }
         d->iconItem->setFlag(QGraphicsItem::ItemHasNoContents, itemHasNoContents);
     }
+
 }
 
-/*!
-    Initializes \a option with the values from this HbToolButton. This method is useful for
-    subclasses when they need a HbStyleOptionToolButton, but don't want to fill in all the
-    information themselves.
- */
-void HbToolButton::initStyleOption(HbStyleOptionToolButton *option)
-{
-    Q_D(HbToolButton);
-    HbAbstractButton::initStyleOption(option);
-
-    Q_ASSERT(option);
-    option->customBackground = d->customBackground;
-    option->backgroundVisible = d->backgroundVisible;
-    option->toolBarPosition = d->toolBarPosition;
-    option->orientation = d->orientation;
-    option->isCheckable = d->checkable;
-    option->useSecondaryGraphics = d->mDialogToolBar;
-    option->useTransparentGraphics = false;
-    if (mainWindow() && mainWindow()->currentView()) {
-        if (mainWindow()->currentView()->viewFlags() & HbView::ViewTitleBarTransparent) {
-            option->useTransparentGraphics = true;
-        }
-    }
-
-    if (d->action) {
-        option->text = d->action->text();
-        HbAction *hbAction = qobject_cast<HbAction*>(d->action);
-        if (hbAction)
-            option->icon = hbAction->icon();
-        else
-            option->icon = d->action->icon();
-
-        option->isToolBarExtension = d->toolbarExtensionFrame;
-    }
-}
 
 /*!
     \internal
@@ -513,7 +638,7 @@
     if (event->type() == QEvent::GraphicsSceneHelp) {
         Q_D(HbToolButton);
         // Check whether toolbutton is inside a toolbar.
-        if (d->toolBarPosition != HbStyleOptionToolButton::TB_None) {
+        if (d->toolBarPosition != HbToolButtonPrivate::TB_None) {
             d->showToolTip();
             event->accept();
             return true;
@@ -522,6 +647,20 @@
     return HbAbstractButton::sceneEvent(event);
 }
 
+void HbToolButton::initPrimitiveData(HbStylePrimitiveData *primitiveData, const QGraphicsObject *primitive)
+{
+    Q_D(HbToolButton);
+    HbAbstractButton::initPrimitiveData(primitiveData, primitive);
+    QString itemName = HbStyle::itemName(primitive);
+    if (itemName == QLatin1String("background")) {
+        d->framePrimitiveData(hbstyleprimitivedata_cast<HbStyleFramePrimitiveData*>(primitiveData));
+    } else if (itemName == QLatin1String("text")) {
+        d->textPrimitiveData(hbstyleprimitivedata_cast<HbStyleTextPrimitiveData*>(primitiveData));
+    } else if (itemName == QLatin1String("icon")) {
+        d->iconPrimitiveData(hbstyleprimitivedata_cast<HbStyleIconPrimitiveData*>(primitiveData));
+    }
+}
+
 /*!
     \reimp
  */