Merge lp:~zsombi/ubuntu-ui-toolkit/themingWithItemChangeListener into lp:ubuntu-ui-toolkit/staging

[Zsombor Egri]

Use QQuickItemChangeListener to listen parent changes, skipping the meta object model. Convert UCThemingExtension into a Q_INTERFACE so object_cast<> can work with it saving the need to memorise on an item whether it is an extended item or not.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1681
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2393/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/1121
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1123
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1123/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/1120

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2393/rebuild

review: Approve (continuous-integration)

[lp:~zsombi/ubuntu-ui-toolkit/themingWithItemChangeListener]

1682. By Zsombor Egri on 2015-10-20

no more connect in themes, use PODVector to store attached themed items and call venet handling straight to update the theme

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1682
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2394/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/1122
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1124
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1124/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/1121

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2394/rebuild

review: Approve (continuous-integration)

[lp:~zsombi/ubuntu-ui-toolkit/themingWithItemChangeListener]

1683. By Zsombor Egri on 2015-10-20

parent changes are no longer QObjects, nor attached objects; thus no more need for initTheme() and qml data to be present when initializing it

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1683
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2395/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/1123/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1125/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/1122/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2395/rebuild

review: Needs Fixing (continuous-integration)

[lp:~zsombi/ubuntu-ui-toolkit/themingWithItemChangeListener]

1684. By Zsombor Egri on 2015-10-20

remove event handling as there's no need for that, anyone interested in theme changes should be derived from UCThemingExtension

1685. By Zsombor Egri on 2015-10-20

fixing API file

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1685
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2396/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/1124
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1126
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1126/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/1123

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2396/rebuild

review: Approve (continuous-integration)

[Cris Dywan (kalikiana)]

For branches like this I very much appreciate that bzr culture favors leaving history intact so I can go through some of the development steps and retrace the reasoning.
I'm wondering if there's any additional tests that should be done to ensure letting go of the custom event and catching inherited changes doesn't cause surprised, but I can't think of any.. we might just see that in upcoming branches if they hit it.
So, as far as I can find, it looks sensible.

review: Approve

=== modified file 'components.api'
--- components.api	2015-10-15 14:17:25 +0000
+++ components.api	2015-10-20 10:21:28 +0000
@@ -1400,7 +1400,6 @@
 Ubuntu.Components.UCFontUtils 1.0 0.1: QtObject
     function double sizeToPixels(string size)
     function double modularScale(string size)
-UCItemAttached: QtObject
 UCListItemDivider: Item
     property color colorFrom
     property color colorTo

=== modified file 'src/Ubuntu/Components/plugin/plugin.cpp'
--- src/Ubuntu/Components/plugin/plugin.cpp	2015-10-01 12:34:29 +0000
+++ src/Ubuntu/Components/plugin/plugin.cpp	2015-10-20 10:21:28 +0000
@@ -230,7 +230,6 @@
     qmlRegisterType<UCUbuntuShapeOverlay>(uri, 1, 2, "UbuntuShapeOverlay");
 
     // register 1.3 API
-    qmlRegisterType<UCItemAttached>();
     qmlRegisterType<UCListItem, 1>(uri, 1, 3, "ListItem");
     qmlRegisterType<UCListItemExpansion>();
     qmlRegisterType<UCTheme>(uri, 1, 3, "ThemeSettings");

=== modified file 'src/Ubuntu/Components/plugin/uclabel.cpp'
--- src/Ubuntu/Components/plugin/uclabel.cpp	2015-09-28 16:18:19 +0000
+++ src/Ubuntu/Components/plugin/uclabel.cpp	2015-10-20 10:21:28 +0000
@@ -78,6 +78,7 @@
  */
 UCLabel::UCLabel(QQuickItem* parent)
     : QQuickText(parent)
+    , UCThemingExtension(this)
     , m_textSize(Medium)
     , m_flags(0)
 {
@@ -91,7 +92,6 @@
 
 void UCLabel::init()
 {
-    initTheming(this);
     postThemeChanged();
     updatePixelSize();
     m_defaultFont = font();
@@ -103,13 +103,6 @@
     connect(this, &UCLabel::colorChanged, this, &UCLabel::_q_customColor, Qt::DirectConnection);
 }
 
-void UCLabel::customEvent(QEvent *event)
-{
-    if (UCThemeEvent::isThemeEvent(event)) {
-        handleThemeEvent(static_cast<UCThemeEvent*>(event));
-    }
-}
-
 void UCLabel::postThemeChanged()
 {
     if (m_flags & ColorSet) {

=== modified file 'src/Ubuntu/Components/plugin/uclabel.h'
--- src/Ubuntu/Components/plugin/uclabel.h	2015-10-01 12:34:29 +0000
+++ src/Ubuntu/Components/plugin/uclabel.h	2015-10-20 10:21:28 +0000
@@ -23,7 +23,7 @@
 class UCLabel : public QQuickText, public UCThemingExtension
 {
     Q_OBJECT
-
+    Q_INTERFACES(UCThemingExtension)
     Q_ENUMS(TextSize)
     Q_PROPERTY(TextSize textSize MEMBER m_textSize WRITE setTextSize NOTIFY textSizeChanged FINAL)
 
@@ -61,7 +61,6 @@
 protected:
     // from QQuickItem
     void classBegin();
-    void customEvent(QEvent *event);
 
     // from UCItemExtension
     void preThemeChanged(){}

=== modified file 'src/Ubuntu/Components/plugin/uclistitem.cpp'
--- src/Ubuntu/Components/plugin/uclistitem.cpp	2015-10-12 14:32:17 +0000
+++ src/Ubuntu/Components/plugin/uclistitem.cpp	2015-10-20 10:21:28 +0000
@@ -61,7 +61,7 @@
     QColor colorFrom;
     QColor colorTo;
     QGradientStops gradient;
-    UCListItemPrivate *listItem;
+    UCListItem *listItem;
 };
 
 UCListItemDivider::UCListItemDivider(UCListItem *parent)
@@ -77,14 +77,16 @@
 {
     Q_D(UCListItemDivider);
     QQml_setParent_noEvent(this, listItem);
-    d->listItem = UCListItemPrivate::get(listItem);
+    d->listItem = listItem;
     setParentItem(listItem);
     // anchor to left/right/bottom of the ListItem
     QQuickAnchors *anchors = d->anchors();
-    anchors->setLeft(d->listItem->left());
-    anchors->setRight(d->listItem->right());
-    anchors->setBottom(d->listItem->bottom());
+    UCListItemPrivate *pListItem = UCListItemPrivate::get(listItem);
+    anchors->setLeft(pListItem->left());
+    anchors->setRight(pListItem->right());
+    anchors->setBottom(pListItem->bottom());
     // connect visible change so we relayout contentItem
+    // FIXME: do this with itemChange!!!
     connect(this, SIGNAL(visibleChanged()), listItem, SLOT(_q_relayout()));
 }
 
@@ -132,7 +134,8 @@
         dividerNode = d->sceneGraphContext()->createRectangleNode();
     }
 
-    bool lastItem = d->listItem->countOwner ? (d->listItem->index() == (d->listItem->countOwner->property("count").toInt() - 1)): false;
+    UCListItemPrivate *pListItem = UCListItemPrivate::get(d->listItem);
+    bool lastItem = pListItem->countOwner ? (pListItem->index() == (pListItem->countOwner->property("count").toInt() - 1)): false;
     if (!lastItem && (d->gradient.size() > 0) && ((d->colorFrom.alphaF() >= (1.0f / 255.0f)) || (d->colorTo.alphaF() >= (1.0f / 255.0f)))) {
         dividerNode->setRect(boundingRect());
         dividerNode->setGradientStops(d->gradient);
@@ -1174,7 +1177,7 @@
 {
     Q_Q(UCListItem);
     // themes 1.2 and below should not have context menu support, so leave
-    quint16 version(getTheme()->version());
+    quint16 version(q->getTheme()->version());
     if (version <= BUILD_VERSION(1, 2)) {
         return;
     }
@@ -1643,7 +1646,7 @@
 {
     Q_D(UCListItem);
     d->customColor = false;
-    d->highlightColor = d->getTheme()->getPaletteColor("selected", "background");
+    d->highlightColor = getTheme()->getPaletteColor("selected", "background");
     update();
     Q_EMIT highlightColorChanged();
 }

=== modified file 'src/Ubuntu/Components/plugin/ucstyleditembase.cpp'
--- src/Ubuntu/Components/plugin/ucstyleditembase.cpp	2015-10-06 07:16:37 +0000
+++ src/Ubuntu/Components/plugin/ucstyleditembase.cpp	2015-10-20 10:21:28 +0000
@@ -108,6 +108,7 @@
  */
 UCStyledItemBase::UCStyledItemBase(QQuickItem *parent)
     : QQuickItem(*(new UCStyledItemBasePrivate), parent)
+    , UCThemingExtension(this)
 {
     Q_D(UCStyledItemBase);
     d->init();
@@ -115,6 +116,7 @@
 
 UCStyledItemBase::UCStyledItemBase(UCStyledItemBasePrivate &dd, QQuickItem *parent)
     : QQuickItem(dd, parent)
+    , UCThemingExtension(this)
 {
     Q_D(UCStyledItemBase);
     d->init();
@@ -308,7 +310,7 @@
     // either styleComponent or styleName is valid
     QQmlComponent *component = styleComponent;
     if (!component) {
-        component = getTheme()->createStyleComponent(styleDocument + ".qml", q, styleVersion);
+        component = q->getTheme()->createStyleComponent(styleDocument + ".qml", q, styleVersion);
     }
     if (!component) {
         return false;
@@ -442,25 +444,21 @@
  * if any, or to the system default theme.
  */
 
-void UCStyledItemBasePrivate::preThemeChanged()
+void UCStyledItemBase::preThemeChanged()
 {
-    wasStyleLoaded = (styleItem != Q_NULLPTR);
-    preStyleChanged();
+    Q_D(UCStyledItemBase);
+    d->wasStyleLoaded = (d->styleItem != Q_NULLPTR);
+    d->preStyleChanged();
 }
-void UCStyledItemBasePrivate::postThemeChanged()
+void UCStyledItemBase::postThemeChanged()
 {
-    Q_EMIT q_func()->themeChanged();
-    if (!wasStyleLoaded) {
+    Q_EMIT themeChanged();
+    Q_D(UCStyledItemBase);
+    if (!d->wasStyleLoaded) {
         return;
     }
-    postStyleChanged();
-    loadStyleItem();
-}
-
-void UCStyledItemBase::classBegin()
-{
-    QQuickItem::classBegin();
-    d_func()->initTheming(this);
+    d->postStyleChanged();
+    d->loadStyleItem();
 }
 
 void UCStyledItemBase::componentComplete()
@@ -509,13 +507,4 @@
     return QQuickItem::childMouseEventFilter(child, event);
 }
 
-// catch UCThemeEvent
-void UCStyledItemBase::customEvent(QEvent *event)
-{
-    Q_D(UCStyledItemBase);
-    if (UCThemeEvent::isThemeEvent(event)) {
-        d->handleThemeEvent(static_cast<UCThemeEvent*>(event));
-    }
-}
-
 #include "moc_ucstyleditembase.cpp"

=== modified file 'src/Ubuntu/Components/plugin/ucstyleditembase.h'
--- src/Ubuntu/Components/plugin/ucstyleditembase.h	2015-09-14 11:26:44 +0000
+++ src/Ubuntu/Components/plugin/ucstyleditembase.h	2015-10-20 10:21:28 +0000
@@ -20,20 +20,22 @@
 #define UCSTYLEDITEMBASE_H
 
 #include <QtQuick/QQuickItem>
+#include "ucthemingextension.h"
 
 class UCStyledItemBasePrivate;
 class UCTheme;
 class UCStyleHints;
-class UCStyledItemBase : public QQuickItem
+class UCStyledItemBase : public QQuickItem, public UCThemingExtension
 {
     Q_OBJECT
+    Q_INTERFACES(UCThemingExtension)
     Q_PROPERTY(bool activeFocusOnPress
                READ activefocusOnPress WRITE setActiveFocusOnPress
                NOTIFY activeFocusOnPressChanged REVISION 1)
     Q_PRIVATE_PROPERTY(UCStyledItemBase::d_func(), QQmlComponent *style READ style WRITE setStyle RESET resetStyle NOTIFY styleChanged FINAL DESIGNABLE false)
     Q_PRIVATE_PROPERTY(UCStyledItemBase::d_func(), QQuickItem *__styleInstance READ styleInstance NOTIFY styleInstanceChanged FINAL DESIGNABLE false)
     Q_PRIVATE_PROPERTY(UCStyledItemBase::d_func(), QString styleName READ styleName WRITE setStyleName NOTIFY styleNameChanged FINAL REVISION 2)
-    Q_PRIVATE_PROPERTY(d_func(), UCTheme *theme READ getTheme WRITE setTheme RESET resetTheme NOTIFY themeChanged FINAL REVISION 2)
+    Q_PROPERTY(UCTheme *theme READ getTheme WRITE setTheme RESET resetTheme NOTIFY themeChanged FINAL REVISION 2)
 public:
     explicit UCStyledItemBase(QQuickItem *parent = 0);
 
@@ -53,11 +55,13 @@
 protected:
     UCStyledItemBase(UCStyledItemBasePrivate &, QQuickItem *parent);
 
-    void classBegin();
+    // from UCThemingExtension interface
+    virtual void preThemeChanged();
+    virtual void postThemeChanged();
+
     void componentComplete();
     void mousePressEvent(QMouseEvent *event);
     bool childMouseEventFilter(QQuickItem *child, QEvent *event);
-    void customEvent(QEvent *event);
 
 private:
     Q_DECLARE_PRIVATE(UCStyledItemBase)

=== modified file 'src/Ubuntu/Components/plugin/ucstyleditembase_p.h'
--- src/Ubuntu/Components/plugin/ucstyleditembase_p.h	2015-10-06 07:16:37 +0000
+++ src/Ubuntu/Components/plugin/ucstyleditembase_p.h	2015-10-20 10:21:28 +0000
@@ -25,8 +25,9 @@
 
 class QQuickMouseArea;
 class UCStyledItemBase;
-class UCStyledItemBasePrivate : public QQuickItemPrivate, public UCThemingExtension
+class UCStyledItemBasePrivate : public QQuickItemPrivate
 {
+    Q_INTERFACES(UCThemingExtension)
     Q_DECLARE_PUBLIC(UCStyledItemBase)
 public:
 
@@ -55,9 +56,6 @@
     virtual void postStyleChanged() {}
     virtual bool loadStyleItem(bool animated = true);
 
-    virtual void preThemeChanged();
-    virtual void postThemeChanged();
-
 public:
 
     QPointer<QQmlContext> styleItemContext;

=== modified file 'src/Ubuntu/Components/plugin/uctheme.cpp'
--- src/Ubuntu/Components/plugin/uctheme.cpp	2015-09-21 13:29:17 +0000
+++ src/Ubuntu/Components/plugin/uctheme.cpp	2015-10-20 10:21:28 +0000
@@ -460,6 +460,7 @@
     }
     loadPalette();
     Q_EMIT nameChanged();
+    updateThemedItems();
 }
 void UCTheme::resetName()
 {
@@ -625,16 +626,20 @@
 
 void UCTheme::attachItem(QQuickItem *item, bool attach)
 {
-    UCItemAttached *theming = static_cast<UCItemAttached*>(qmlAttachedPropertiesObject<UCItemAttached>(item, false));
-    if (!theming) {
-        return;
-    }
     if (attach) {
-        connect(this, SIGNAL(nameChanged()), theming, SLOT(reloadTheme()), Qt::DirectConnection);
-        connect(this, SIGNAL(versionChanged()), theming, SLOT(reloadTheme()), Qt::DirectConnection);
+        m_attachedItems.append(item);
     } else {
-        disconnect(this, SIGNAL(nameChanged()), theming, SLOT(reloadTheme()));
-        disconnect(this, SIGNAL(versionChanged()), theming, SLOT(reloadTheme()));
+        m_attachedItems.removeOne(item);
+    }
+}
+
+void UCTheme::updateThemedItems()
+{
+    for (int i = 0; i < m_attachedItems.count(); i++) {
+        UCThemingExtension *extension = qobject_cast<UCThemingExtension*>(m_attachedItems[i]);
+        if (extension) {
+            extension->itemThemeReloaded(this);
+        }
     }
 }
 
@@ -671,6 +676,7 @@
     }
     m_version = version;
     Q_EMIT versionChanged();
+    updateThemedItems();
 }
 
 /*

=== modified file 'src/Ubuntu/Components/plugin/uctheme.h'
--- src/Ubuntu/Components/plugin/uctheme.h	2015-09-21 07:21:36 +0000
+++ src/Ubuntu/Components/plugin/uctheme.h	2015-10-20 10:21:28 +0000
@@ -28,6 +28,8 @@
 #include <QtQml/QQmlParserStatus>
 #include <QtQml/QQmlProperty>
 
+#include <QtQml/private/qpodvector_p.h>
+
 #include "ucdefaulttheme.h"
 
 class UCStyledItemBase;
@@ -110,6 +112,7 @@
     void updateThemePaths();
     QUrl styleUrl(const QString& styleName, quint16 version, bool *isFallback = NULL);
     void loadPalette(bool notify = true);
+    void updateThemedItems();
 
     class PaletteConfig
     {
@@ -161,6 +164,7 @@
     QPointer<QObject> m_palette; // the palette might be from the default style if the theme doesn't define palette
     QList<ThemeRecord> m_themePaths;
     UCDefaultTheme m_defaultTheme;
+    QPODVector<QQuickItem*, 4> m_attachedItems;
     QQmlEngine *m_engine;
     quint16 m_version;
     bool m_defaultStyle:1;

=== modified file 'src/Ubuntu/Components/plugin/ucthemingextension.cpp'
--- src/Ubuntu/Components/plugin/ucthemingextension.cpp	2015-09-21 14:24:05 +0000
+++ src/Ubuntu/Components/plugin/ucthemingextension.cpp	2015-10-20 10:21:28 +0000
@@ -23,103 +23,85 @@
 #include <QtGui/QGuiApplication>
 
 /*
- * The UCThemingExtension class provides theme handling on Items extending an existing
+ * The UCThemingExtension interface provides theme handling on Items extending an existing
  * QQuickItem derivate class. Items subject fo theming should derive from this class
- * and implement the virtual methods, as well as add the following two methods:
- * 1) classBegin(item) should be called from the QQuickItem::classBegin() method
- * 2) handleThemeEvent() should be called from QQuickItem::customEvent() method
+ * and implement the pure virtual methods.
  * The item can expose the theme property and use the getters defined by the
  * class.
- * Iin case the item exposes the theme property, it can use the getters from the
+ * In case the item exposes the theme property, it can use the getters from the
  * extension and declare the themeChanged signal.
  */
 
-static int themeUpdatedId = QEvent::registerEventType();
-static int themeReloadedId = QEvent::registerEventType();
-
-UCThemeEvent::UCThemeEvent(UCTheme *reloadedTheme)
-    : QEvent((QEvent::Type)themeReloadedId)
-    , m_oldTheme(Q_NULLPTR)
-    , m_newTheme(reloadedTheme)
-{
-    setAccepted(false);
-}
-
-UCThemeEvent::UCThemeEvent(UCTheme *oldTheme, UCTheme *newTheme)
-    : QEvent((QEvent::Type)themeUpdatedId)
-    , m_oldTheme(oldTheme)
-    , m_newTheme(newTheme)
-{
-    setAccepted(false);
-}
-
-UCThemeEvent::UCThemeEvent(const UCThemeEvent &other)
-    : QEvent(other.type())
-    , m_oldTheme(other.m_oldTheme)
-    , m_newTheme(other.m_newTheme)
-{
-    setAccepted(false);
-}
-
-bool UCThemeEvent::isThemeEvent(const QEvent *event)
-{
-    return ((int)event->type() == themeUpdatedId) || ((int)event->type() == themeReloadedId);
-}
-
-void UCThemingExtension::forwardEvent(QQuickItem *item, UCThemeEvent *event)
-{
-    Q_FOREACH(QQuickItem *child, item->childItems()) {
-        QGuiApplication::sendEvent(child, event);
-        // StyledItem will handle the broadcast itself depending on whether the theme change was appropriate or not
-        // and will complete the ascendantStyled/theme itself
-        if (child->childItems().size() > 0 && !UCItemAttached::isThemed(child)) {
-            forwardEvent(child, event);
-        }
-    }
-}
-
-void UCThemingExtension::broadcastThemeChange(QQuickItem *item, UCTheme *oldTheme, UCTheme *newTheme)
-{
-    UCThemeEvent event(oldTheme, newTheme);
-    forwardEvent(item, &event);
-}
-
-void UCThemingExtension::broadcastThemeReloaded(QQuickItem *item, UCTheme *theme)
-{
-    UCThemeEvent event(theme);
-    forwardEvent(item, &event);
+void notifyThemeChange(QQuickItem *item, UCTheme *oldTheme, UCTheme *newTheme)
+{
+    Q_FOREACH(QQuickItem *child, item->childItems()) {
+        UCThemingExtension *extension = qobject_cast<UCThemingExtension*>(child);
+        if (extension) {
+            extension->itemThemeChanged(oldTheme, newTheme);
+        }
+        // StyledItem will handle the broadcast itself depending on whether the theme change was appropriate or not
+        // and will complete the ascendantStyled/theme itself
+        if (!extension) {
+            notifyThemeChange(child, oldTheme, newTheme);
+        }
+    }
+}
+
+void notifyThemeReloaded(QQuickItem *item, UCTheme *theme)
+{
+    Q_FOREACH(QQuickItem *child, item->childItems()) {
+        UCThemingExtension *extension = qobject_cast<UCThemingExtension*>(child);
+        if (extension) {
+            extension->itemThemeReloaded(theme);
+        }
+        // StyledItem will handle the broadcast itself depending on whether the theme change was appropriate or not
+        // and will complete the ascendantStyled/theme itself
+        if (!extension) {
+            notifyThemeReloaded(child, theme);
+        }
+    }
 }
 
 /*************************************************************************
  * Attached to every Item in the system
  */
-UCItemAttached::UCItemAttached(QObject *owner)
-    : QObject(owner)
-    , m_item(static_cast<QQuickItem*>(owner))
+static uint xdata = QObject::registerUserData();
+class UCItemAttached : public QObjectUserData, public QQuickItemChangeListener
+{
+public:
+    explicit UCItemAttached(QQuickItem *owner = 0);
+    ~UCItemAttached();
+
+    QQuickItem *m_item;
+    QQuickItem *m_prevParent;
+
+    void itemParentChanged(QQuickItem *item, QQuickItem *newParent);
+
+private:
+
+    friend class UCThemingExtension;
+};
+
+UCItemAttached::UCItemAttached(QQuickItem *owner)
+    : m_item(owner)
     , m_prevParent(Q_NULLPTR)
-    , m_extension(Q_NULLPTR)
 {
-    // get parent item changes
-    connect(m_item, &QQuickItem::parentChanged, this, &UCItemAttached::handleParentChanged);
+    QQuickItemPrivate::get(m_item)->addItemChangeListener(this, QQuickItemPrivate::Parent);
 }
 
 UCItemAttached::~UCItemAttached()
 {
-}
-
-UCItemAttached *UCItemAttached::qmlAttachedProperties(QObject *owner)
-{
-    return new UCItemAttached(owner);
-}
-
-bool UCItemAttached::isThemed(QQuickItem *item)
-{
-    UCItemAttached *attached = static_cast<UCItemAttached*>(qmlAttachedPropertiesObject<UCItemAttached>(item, false));
-    return attached && (attached->m_extension != Q_NULLPTR);
+    QQuickItemPrivate::get(m_item)->removeItemChangeListener(this, QQuickItemPrivate::Parent);
+}
+
+bool UCThemingExtension::isThemed(QQuickItem *item)
+{
+    UCThemingExtension *extension = qobject_cast<UCThemingExtension*>(item);
+    return extension != Q_NULLPTR;
 }
 
 // handle parent changes
-void UCItemAttached::handleParentChanged(QQuickItem *newParent)
+void UCItemAttached::itemParentChanged(QQuickItem *, QQuickItem *newParent)
 {
     if (newParent == m_prevParent || QQuickItemPrivate::get(m_item)->wasDeleted) {
         return;
@@ -128,41 +110,43 @@
     // make sure we have these handlers attached to each intermediate item
     QQuickItem *oldThemedAscendant = UCThemingExtension::ascendantThemed(m_prevParent);
     QQuickItem *newThemedAscendant = UCThemingExtension::ascendantThemed(newParent);
-    UCTheme *oldTheme = oldThemedAscendant ? oldThemedAscendant->property("theme").value<UCTheme*>() : &UCTheme::defaultTheme();
-    UCTheme *newTheme = newThemedAscendant ? newThemedAscendant->property("theme").value<UCTheme*>() : &UCTheme::defaultTheme();
+    UCThemingExtension *oldExtension = qobject_cast<UCThemingExtension*>(oldThemedAscendant);
+    UCThemingExtension *newExtension = qobject_cast<UCThemingExtension*>(newThemedAscendant);
+    UCTheme *oldTheme = oldExtension ? oldExtension->getTheme() : &UCTheme::defaultTheme();
+    UCTheme *newTheme = newExtension ? newExtension->getTheme() : &UCTheme::defaultTheme();
 
     if (oldTheme != newTheme) {
+        UCThemingExtension *extension = qobject_cast<UCThemingExtension*>(m_item);
         // send the event to m_item first
-        UCThemeEvent event(oldTheme, newTheme);
-        if (m_extension) {
+        if (extension) {
             // only items with extensions should get this event
-            m_extension->handleThemeEvent(&event);
+            extension->itemThemeChanged(oldTheme, newTheme);
         }
         // then broadcast to children, but only if the item is not a styled one
-        if (!m_extension) {
-            UCThemingExtension::forwardEvent(m_item, &event);
+        if (!extension) {
+            notifyThemeChange(m_item, oldTheme, newTheme);
         }
     }
     m_prevParent = newParent;
 }
 
-void UCItemAttached::reloadTheme()
-{
-    Q_ASSERT(m_extension);
-    m_extension->preThemeChanged();
-    m_extension->postThemeChanged();
-    UCThemingExtension::broadcastThemeReloaded(m_item, static_cast<UCTheme*>(sender()));
-}
-
 /*************************************************************************
  *
  */
-UCThemingExtension::UCThemingExtension()
-    : themedItem(Q_NULLPTR)
-    , attachedThemer(Q_NULLPTR)
-    , theme(&UCTheme::defaultTheme())
+UCThemingExtension::UCThemingExtension(QQuickItem *extendedItem)
+    : theme(&UCTheme::defaultTheme())
+    , themedItem(extendedItem)
     , themeType(Inherited)
 {
+    theme->attachItem(themedItem, true);
+    themedItem->setUserData(xdata, new UCItemAttached(themedItem));
+}
+
+UCThemingExtension::~UCThemingExtension()
+{
+    if (theme) {
+        theme->attachItem(themedItem, false);
+    }
 }
 
 // set the parent of the theme if the themeType is Custom
@@ -172,47 +156,50 @@
         return;
     }
     QQuickItem *upperThemed = ascendantThemed(QQuickItemPrivate::get(themedItem)->parentItem);
-    UCItemAttached *attached = static_cast<UCItemAttached*>(qmlAttachedPropertiesObject<UCItemAttached>(upperThemed));
-    UCTheme *parentTheme = (attached && attached->m_extension) ? attached->m_extension->getTheme() : &UCTheme::defaultTheme();
+    UCThemingExtension *extension = qobject_cast<UCThemingExtension*>(upperThemed);
+    UCTheme *parentTheme = extension ? extension->getTheme() : &UCTheme::defaultTheme();
     if (parentTheme != theme) {
         theme->setParentTheme(parentTheme);
     }
 }
 
-void UCThemingExtension::initTheming(QQuickItem *item)
+void UCThemingExtension::itemThemeChanged(UCTheme*, UCTheme *newTheme)
 {
-    themedItem = item;
-    attachedThemer = static_cast<UCItemAttached*>(qmlAttachedPropertiesObject<UCItemAttached>(themedItem));
-    Q_ASSERT(attachedThemer);
-    attachedThemer->m_extension = this;
-    theme->attachItem(item, true);
+    switch (themeType) {
+    case Inherited: {
+        setTheme(newTheme, Inherited);
+        return;
+    }
+    case Custom: {
+        // set the theme's parent
+        theme->setParentTheme(newTheme);
+        return;
+    }
+    default: break;
+    }
 }
 
-void UCThemingExtension::handleThemeEvent(UCThemeEvent *event)
+void UCThemingExtension::itemThemeReloaded(UCTheme *theme)
 {
-    if ((int)event->type() == themeUpdatedId) {
-        switch (themeType) {
-        case Inherited: {
-            setTheme(event->newTheme(), Inherited);
-            return;
-        }
-        case Custom: {
-            // set the theme's parent
-            theme->setParentTheme(event->newTheme());
-            return;
-        }
-        default: break;
-        }
-    } else if ((int)event->type() == themeReloadedId) {
-        // no need to handle Inherited case, those items are all attached to the theme changes
-        switch (themeType) {
-        case Custom: {
+    switch (themeType) {
+    case Inherited: {
+        preThemeChanged();
+        postThemeChanged();
+        return;
+    }
+    case Custom: {
+        if (theme == this->theme) {
+            preThemeChanged();
+            postThemeChanged();
+            // forward to children
+            notifyThemeReloaded(themedItem, theme);
+        } else {
             // emit theme's parentThemeChanged()
-            Q_EMIT theme->parentThemeChanged();
-            return;
-        }
-        default: break;
-        }
+            Q_EMIT this->theme->parentThemeChanged();
+        }
+        return;
+    }
+    default: break;
     }
 }
 
@@ -250,26 +237,26 @@
     postThemeChanged();
 
     // broadcast to the children
-    broadcastThemeChange(themedItem, oldTheme, theme);
+    notifyThemeChange(themedItem, oldTheme, theme);
 }
 
 void UCThemingExtension::resetTheme()
 {
     QQuickItem *upperThemed = ascendantThemed(QQuickItemPrivate::get(themedItem)->parentItem);
-    UCItemAttached *attached = static_cast<UCItemAttached*>(qmlAttachedPropertiesObject<UCItemAttached>(upperThemed));
-    UCTheme *theme = (attached && attached->m_extension) ? attached->m_extension->getTheme() : &UCTheme::defaultTheme();
+    UCThemingExtension *extension = qobject_cast<UCThemingExtension*>(upperThemed);
+    UCTheme *theme = extension ? extension->getTheme() : &UCTheme::defaultTheme();
     setTheme(theme, Inherited);
 }
 
 // returns the closest themed ascendant
 QQuickItem *UCThemingExtension::ascendantThemed(QQuickItem *item)
 {
-    while (item && !UCItemAttached::isThemed(item)) {
-        // make sure it also has the theming attached
-        qmlAttachedPropertiesObject<UCItemAttached>(item);
+    while (item && !isThemed(item)) {
+        // if the item has no xdata set, means we haven't been here yet
+        if (!item->userData(xdata)) {
+            item->setUserData(xdata, new UCItemAttached(item));
+        }
         item = item->parentItem();
     }
     return item;
 }
-
-#include "moc_ucthemingextension.cpp"

=== modified file 'src/Ubuntu/Components/plugin/ucthemingextension.h'
--- src/Ubuntu/Components/plugin/ucthemingextension.h	2015-09-21 14:24:05 +0000
+++ src/Ubuntu/Components/plugin/ucthemingextension.h	2015-10-20 10:21:28 +0000
@@ -24,54 +24,10 @@
 #include <QtCore/QPointer>
 #include <QtQml>
 
+#include <QtQuick/private/qquickitem_p.h>
+
 class QQuickItem;
-class UCStyledItemBase;
 class UCTheme;
-class UCThemingExtension;
-class UCItemAttached : public QObject
-{
-    Q_OBJECT
-public:
-    explicit UCItemAttached(QObject *owner = 0);
-    ~UCItemAttached();
-    static bool isThemed(QQuickItem *item);
-    static UCItemAttached *qmlAttachedProperties(QObject *owner);
-
-    QQuickItem *m_item;
-    QQuickItem *m_prevParent;
-    UCThemingExtension *m_extension;
-
-private:
-    Q_SLOT void handleParentChanged(QQuickItem *newParent);
-    Q_SLOT void reloadTheme();
-
-    friend class UCThemingExtension;
-};
-QML_DECLARE_TYPEINFO(UCItemAttached, QML_HAS_ATTACHED_PROPERTIES)
-
-class UCThemeEvent : public QEvent
-{
-public: // statics
-    static bool isThemeEvent(const QEvent *event);
-
-public:
-    explicit UCThemeEvent(UCTheme *reloadedTheme);
-    UCThemeEvent(UCTheme *oldTheme, UCTheme *newTheme);
-    UCThemeEvent(const UCThemeEvent &other);
-
-    UCTheme *oldTheme() const
-    {
-        return m_oldTheme;
-    }
-    UCTheme *newTheme() const
-    {
-        return m_newTheme;
-    }
-private:
-    UCTheme *m_oldTheme;
-    UCTheme *m_newTheme;
-};
-
 class UCThemingExtension
 {
 public:
@@ -80,31 +36,30 @@
         Custom
     };
 
-    explicit UCThemingExtension();
+    explicit UCThemingExtension(QQuickItem *extendedItem);
+    virtual ~UCThemingExtension();
 
     virtual void preThemeChanged() = 0;
     virtual void postThemeChanged() = 0;
-
-    virtual void initTheming(QQuickItem *item);
-    virtual void handleThemeEvent(UCThemeEvent *event);
+    virtual void itemThemeChanged(UCTheme *, UCTheme*);
+    virtual void itemThemeReloaded(UCTheme *);
 
     UCTheme *getTheme() const;
     void setTheme(UCTheme *newTheme, ThemeType type = Custom);
     void resetTheme();
 
+    static bool isThemed(QQuickItem *item);
     static QQuickItem *ascendantThemed(QQuickItem *item);
 
-    static void forwardEvent(QQuickItem *item, UCThemeEvent *event);
-    static void broadcastThemeChange(QQuickItem *item, UCTheme *oldTheme, UCTheme *newTheme);
-    static void broadcastThemeReloaded(QQuickItem *item, UCTheme *theme);
-
 protected:
+    QPointer<UCTheme> theme;
     QQuickItem *themedItem;
-    UCItemAttached *attachedThemer;
-    QPointer<UCTheme> theme;
     ThemeType themeType;
 
     void setParentTheme();
 };
 
+#define UCThemingExtension_iid "org.qt-project.Qt.UCThemingExtension"
+Q_DECLARE_INTERFACE(UCThemingExtension, UCThemingExtension_iid)
+
 #endif // UCITEMEXTENSION_H

=== modified file 'tests/unit_x11/tst_subtheming/tst_subtheming.cpp'
--- tests/unit_x11/tst_subtheming/tst_subtheming.cpp	2015-10-06 07:16:37 +0000
+++ tests/unit_x11/tst_subtheming/tst_subtheming.cpp	2015-10-20 10:21:28 +0000
@@ -55,6 +55,7 @@
         UCTheme *rootTheme = globalTheme();
         QVERIFY(rootTheme);
         rootTheme->setName(theme);
+
     }
 
     void setTheme(const QString &theme, QQuickItem *watchedItem)
@@ -282,11 +283,11 @@
         UCStyledItemBase *mainItem = qobject_cast<UCStyledItemBase*>(view->rootObject());
 
         QSignalSpy parentChangeSpy(testSet, SIGNAL(parentThemeChanged()));
-        UCStyledItemBasePrivate::get(testItem)->setTheme(testSet);
+        testItem->setTheme(testSet);
         parentChangeSpy.wait(200);
         QCOMPARE(parentChangeSpy.count(), 1);
         // test if the parent is correct
-        QCOMPARE(testSet->parentTheme(), UCStyledItemBasePrivate::get(mainItem)->getTheme());
+        QCOMPARE(testSet->parentTheme(), mainItem->getTheme());
     }
 
     void test_parent_set_reset_triggers_parent_change()
@@ -299,11 +300,11 @@
 
         // reset mainItem's theme should trigger parentChanged on testSet
         QSignalSpy parentChangeSpy(testSet, SIGNAL(parentThemeChanged()));
-        UCStyledItemBasePrivate::get(mainItem)->resetTheme();
+        mainItem->resetTheme();
         parentChangeSpy.wait(200);
         QCOMPARE(parentChangeSpy.count(), 1);
-        QCOMPARE(UCStyledItemBasePrivate::get(mainItem)->getTheme(), &UCTheme::defaultTheme());
-        QCOMPARE(testSet->parentTheme(), UCStyledItemBasePrivate::get(mainItem)->getTheme());
+        QCOMPARE(mainItem->getTheme(), &UCTheme::defaultTheme());
+        QCOMPARE(testSet->parentTheme(), mainItem->getTheme());
     }
 
     void test_parent_set_namechange_triggers_parent_change()
@@ -315,11 +316,11 @@
         // change mainItem.theme.name should trigger parentChanged on testSet
         QSignalSpy parentChangeSpy(testSet, SIGNAL(parentThemeChanged()));
         QSignalSpy themeChangeSpy(mainItem, SIGNAL(themeChanged()));
-        UCStyledItemBasePrivate::get(mainItem)->getTheme()->setName("Ubuntu.Components.Themes.SuruDark");
+        mainItem->getTheme()->setName("Ubuntu.Components.Themes.SuruDark");
         UbuntuTestCase::waitForSignal(&themeChangeSpy);
         parentChangeSpy.wait(200);
         QCOMPARE(parentChangeSpy.count(), 1);
-        QCOMPARE(testSet->parentTheme(), UCStyledItemBasePrivate::get(mainItem)->getTheme());
+        QCOMPARE(testSet->parentTheme(), mainItem->getTheme());
     }
 
 
@@ -333,10 +334,10 @@
         // verify theme changes
         UCStyledItemBase *styled = qobject_cast<UCStyledItemBase*>(view->rootObject());
         QVERIFY(styled);
-        QCOMPARE(UCStyledItemBasePrivate::get(styled)->getTheme()->name(), QString("Ubuntu.Components.Themes.SuruDark"));
+        QCOMPARE(styled->getTheme()->name(), QString("Ubuntu.Components.Themes.SuruDark"));
         // a deeper item's style name
         styled = view->findItem<UCStyledItemBase*>("secondLevelStyled");
-        QCOMPARE(UCStyledItemBasePrivate::get(styled)->getTheme()->name(), QString("Ubuntu.Components.Themes.SuruDark"));
+        QCOMPARE(styled->getTheme()->name(), QString("Ubuntu.Components.Themes.SuruDark"));
     }
 
     // changing StyledItem.theme.name for different items within a tree where
@@ -355,7 +356,7 @@
         // change theme name (theme)
         UCStyledItemBase *styled = view->findItem<UCStyledItemBase*>(itemName);
         QSignalSpy themeChangeSpy(styled, SIGNAL(themeChanged()));
-        UCStyledItemBasePrivate::get(styled)->getTheme()->setName("Ubuntu.Components.Themes.SuruDark");
+        styled->getTheme()->setName("Ubuntu.Components.Themes.SuruDark");
         UbuntuTestCase::waitForSignal(&themeChangeSpy);
         UCTheme *theme = view->globalTheme();
         QCOMPARE(theme->name(), QString("Ubuntu.Components.Themes.SuruDark"));
@@ -401,11 +402,11 @@
                     view->findItem<UCStyledItemBase*>(applyOnItem);
         QVERIFY(styledItem);
         // the theme is declared, but should not be set yet!!!
-        QVERIFY2(UCStyledItemBasePrivate::get(styledItem)->getTheme() != theme, "ThemeSettings should not be set yet!");
+        QVERIFY2(styledItem->getTheme() != theme, "ThemeSettings should not be set yet!");
         theme->setName(themeName);
         // set the style on the item
         QSignalSpy themeChangeSpy(styledItem, SIGNAL(themeChanged()));
-        UCStyledItemBasePrivate::get(styledItem)->setTheme(theme);
+        styledItem->setTheme(theme);
         UbuntuTestCase::waitForSignal(&themeChangeSpy);
         // test on the items
         for (int i = 0; i < testItems.count(); i++) {
@@ -413,8 +414,8 @@
             QString themeName = expectedStyleNames[i];
             bool success = sameTheme[i];
             styledItem = view->findItem<UCStyledItemBase*>(itemName);
-            QCOMPARE(UCStyledItemBasePrivate::get(styledItem)->getTheme() == theme, success);
-            QCOMPARE(UCStyledItemBasePrivate::get(styledItem)->getTheme()->name(), themeName);
+            QCOMPARE(styledItem->getTheme() == theme, success);
+            QCOMPARE(styledItem->getTheme()->name(), themeName);
         }
     }
 
@@ -451,15 +452,15 @@
 
         QScopedPointer<ThemeTestCase> view(new ThemeTestCase("TestStyleChange.qml"));
         UCStyledItemBase *testItem = view->findItem<UCStyledItemBase*>(testStyledItem);
-        QCOMPARE(UCStyledItemBasePrivate::get(testItem)->getTheme()->name(), testStyledItemThemes[0]);
+        QCOMPARE(testItem->getTheme()->name(), testStyledItemThemes[0]);
 
         UCTheme *theme = view->findItem<UCTheme*>("Theme");
         theme->setName("Ubuntu.Components.Themes.SuruDark");
         UCStyledItemBase *suruItem = view->findItem<UCStyledItemBase*>(suruStyledItem);
         QSignalSpy themeChangeSpy(suruItem, SIGNAL(themeChanged()));
-        UCStyledItemBasePrivate::get(suruItem)->setTheme(theme);
+        suruItem->setTheme(theme);
         UbuntuTestCase::waitForSignal(&themeChangeSpy);
-        QCOMPARE(UCStyledItemBasePrivate::get(testItem)->getTheme()->name(), testStyledItemThemes[1]);
+        QCOMPARE(testItem->getTheme()->name(), testStyledItemThemes[1]);
 
         // get items and reparent
         QQuickItem *sourceItem = view->findItem<QQuickItem*>(sourceItemName);
@@ -470,7 +471,7 @@
         QSignalSpy themeSpy(testItem, SIGNAL(themeChanged()));
         sourceItem->setParentItem(newParentItem);
         themeSpy.wait(200);
-        QCOMPARE(UCStyledItemBasePrivate::get(testItem)->getTheme()->name(), testStyledItemThemes[2]);
+        QCOMPARE(testItem->getTheme()->name(), testStyledItemThemes[2]);
         QCOMPARE(themeSpy.count(), 1);
     }
 
@@ -480,8 +481,8 @@
         UCStyledItemBase *main = qobject_cast<UCStyledItemBase*>(view->rootObject());
         QVERIFY(main);
         UCStyledItemBase *test = view->findItem<UCStyledItemBase*>("firstLevelStyled");
-        QCOMPARE(UCStyledItemBasePrivate::get(main)->getTheme()->name(),
-                 UCStyledItemBasePrivate::get(test)->getTheme()->name());
+        QCOMPARE(main->getTheme()->name(),
+                 test->getTheme()->name());
     }
 
     void test_no_change_in_other_suru_dark()
@@ -510,7 +511,7 @@
         QScopedPointer<ThemeTestCase> view(new ThemeTestCase("ChangeDefaultPaletteInChildren.qml"));
         QQuickItem *loader = view->findItem<QQuickItem*>("loader");
         UCStyledItemBase *main = qobject_cast<UCStyledItemBase*>(view->rootObject());
-        UCTheme *mainSet = UCStyledItemBasePrivate::get(main)->getTheme();
+        UCTheme *mainSet = main->getTheme();
         QQuickItem *item = loader->property("item").value<QQuickItem*>();
         QVERIFY(item);
 
@@ -590,20 +591,20 @@
         UCStyledItemBase *movableItem = view->findItem<UCStyledItemBase*>("movable");
 
         // verify movableItem's theme
-        QCOMPARE(UCStyledItemBasePrivate::get(root)->getTheme(), UCStyledItemBasePrivate::get(movableItem)->getTheme());
+        QCOMPARE(root->getTheme(), movableItem->getTheme());
 
         // set the theme for root
         QSignalSpy themeChangeSpy(root, SIGNAL(themeChanged()));
-        UCStyledItemBasePrivate::get(root)->setTheme(suruTheme);
+        root->setTheme(suruTheme);
         UbuntuTestCase::waitForSignal(&themeChangeSpy);
-        QCOMPARE(UCStyledItemBasePrivate::get(root)->getTheme(), UCStyledItemBasePrivate::get(movableItem)->getTheme());
+        QCOMPARE(root->getTheme(), movableItem->getTheme());
 
         // set the parent item of the test item to 0
         QSignalSpy spy(movableItem, SIGNAL(themeChanged()));
         movableItem->setParentItem(Q_NULLPTR);
         spy.wait(500);
         QCOMPARE(spy.count(), 1);
-        QCOMPARE(UCStyledItemBasePrivate::get(movableItem)->getTheme(), &UCTheme::defaultTheme());
+        QCOMPARE(movableItem->getTheme(), &UCTheme::defaultTheme());
     }
 
     void test_reparented_styleditem_special_case()
@@ -617,19 +618,19 @@
         UCStyledItemBase *movableItem = view->findItem<UCStyledItemBase*>("movable");
 
         // check the themes
-        QCOMPARE(UCStyledItemBasePrivate::get(root)->getTheme()->name(), QString("Ubuntu.Components.Themes.Ambiance"));
-        QCOMPARE(UCStyledItemBasePrivate::get(customThemedItem)->getTheme()->name(), QString("CustomTheme"));
-        QCOMPARE(UCStyledItemBasePrivate::get(movableItem)->getTheme()->name(), QString("Ubuntu.Components.Themes.Ambiance"));
+        QCOMPARE(root->getTheme()->name(), QString("Ubuntu.Components.Themes.Ambiance"));
+        QCOMPARE(customThemedItem->getTheme()->name(), QString("CustomTheme"));
+        QCOMPARE(movableItem->getTheme()->name(), QString("Ubuntu.Components.Themes.Ambiance"));
 
         // move the movableItem under customThemedItem
         movableItem->setParentItem(customThemedItem);
-        QCOMPARE(UCStyledItemBasePrivate::get(movableItem)->getTheme()->name(), QString("CustomTheme"));
+        QCOMPARE(movableItem->getTheme()->name(), QString("CustomTheme"));
 
         // set a new theme for the root, and make sure our theme stays the same
         QSignalSpy themeChangeSpy(root, SIGNAL(themeChanged()));
-        UCStyledItemBasePrivate::get(root)->setTheme(suruTheme);
+        root->setTheme(suruTheme);
         UbuntuTestCase::waitForSignal(&themeChangeSpy);
-        QCOMPARE(UCStyledItemBasePrivate::get(movableItem)->getTheme()->name(), QString("CustomTheme"));
+        QCOMPARE(movableItem->getTheme()->name(), QString("CustomTheme"));
     }
 
     void test_theme_versions_data()
@@ -710,7 +711,7 @@
     {
         QScopedPointer<ThemeTestCase> view(new ThemeTestCase("StyleKept.qml"));
         UCStyledItemBase *button = view->findItem<UCStyledItemBase*>("TestButton");
-        UCTheme *theme = UCStyledItemBasePrivate::get(button)->getTheme();
+        UCTheme *theme = button->getTheme();
         QVERIFY(theme);
 
         QVERIFY(button->findChild<QQuickItem*>("TestStyle"));