Merge lp:~zsombi/ubuntu-ui-toolkit/33-listitem-attached into lp:~zsombi/ubuntu-ui-toolkit/listitem-master

[Zsombor Egri]

Introducing ListItem attached to ListItem's parent item, or to ListView. Yet handles ascending Flickables, further functionality will be introduced in later MRs.

[lp:~zsombi/ubuntu-ui-toolkit/33-listitem-attached]

1319. By Zsombor Egri on 2014-11-06

small fixes

1320. By Zsombor Egri on 2014-11-07

prereq sync

1321. By Zsombor Egri on 2014-11-07

minor adjustments on global flickable interactive handling

1322. By Zsombor Egri on 2014-11-07

fix orphan disconnect warnings

1323. By Zsombor Egri on 2014-11-11

prereq sync

1324. By Zsombor Egri on 2014-11-11

prereq sync

1325. By Zsombor Egri on 2014-11-12

prereq sync

1326. By Zsombor Egri on 2014-11-12

prereq sync

1327. By Zsombor Egri on 2014-11-14

redo binding and property change as flickables may be added to the parent change while initialiozation completes

1328. By Zsombor Egri on 2014-11-14

typo fixed

[Tim Peeters (tpeeters)]

229 + // about to be deleted or reparrented, disable attached

*reparented

[Tim Peeters (tpeeters)]

537 +void UCListItemAttached::disableInteractive(UCListItem *item, bool disable)

maybe it is a matter of taste, but here you have to set the bool to TRUE in order to DISABLE interactive. Wouldn't be the other way around (enableInteractive(item, bool enable)) be more logical?

[Tim Peeters (tpeeters)]

540 + if ((d->globalDisabled && disable) || (!d->globalDisabled && disable)) {

this is the same as: if (disable) {

[Tim Peeters (tpeeters)]

540 + if ((d->globalDisabled && disable) || (!d->globalDisabled && disable)) {
541 + // disabling or re-disabling
542 + d->disablerItem = item;
543 + if (d->globalDisabled == disable) {
544 + // was already disabled, leave
545 + return;
546 + }
547 + d->globalDisabled = disable;
548 + } else if (d->globalDisabled && !disable && d->disablerItem == item) {
549 + // the one disabled it will enable
550 + d->globalDisabled = disable;
551 + d->disablerItem.clear();
552 + } else {
553 + // none of the above, leave
554 + return;
555 + }

same as code below, which is simpler:

if (disable) {
  d->disablerItem = item; // what is this for?
  if (d->globalDisabled) {
    return;
  }
} else if (d->globalDisabled && item == d->disablerItem) {
  d->globalDisabled = false;
  d->disablerItem.clear();
} else {
  // !disabled && (!globalDisabled || item != d->disablerItem)
  return;
}

[Tim Peeters (tpeeters)]

178 +void UCListItemPrivate::promptRebound()

Maybe immediateRebound() is more clear?
Or add a "// rebound without animation"

[Tim Peeters (tpeeters)]

427 +}
428 +// connect all flickables

add empty line inbetween these two

[Tim Peeters (tpeeters)]

354 + void clearFlickableList();
355 + void buildFlickablesList();

rename the first function to clearFlickablesList()

[Zsombor Egri (zsombi)]

> 537 +void UCListItemAttached::disableInteractive(UCListItem *item, bool
> disable)
>
> maybe it is a matter of taste, but here you have to set the bool to TRUE in
> order to DISABLE interactive. Wouldn't be the other way around
> (enableInteractive(item, bool enable)) be more logical?

Well, as you said, it's a matter of taste :) The main purpose of the whole logic is to disable, not to enable. But it all depends on what naming convention do we keep in mind: positive naming, or negative naming. And in that sense you are right, a positive approach would fit better.

[Tim Peeters (tpeeters)]

490 +// register item to be rebount

rebounD, I think..

[Tim Peeters (tpeeters)]

493 + // we cannot bind the item until we have an other one bount

everywhere (also variable names): bount --> bound

[Zsombor Egri (zsombi)]

> > 537 +void UCListItemAttached::disableInteractive(UCListItem *item, bool
> > disable)
> >
> > maybe it is a matter of taste, but here you have to set the bool to TRUE in
> > order to DISABLE interactive. Wouldn't be the other way around
> > (enableInteractive(item, bool enable)) be more logical?
>
> Well, as you said, it's a matter of taste :) The main purpose of the whole
> logic is to disable, not to enable. But it all depends on what naming
> convention do we keep in mind: positive naming, or negative naming. And in
> that sense you are right, a positive approach would fit better.

Ah, the comment already went out. I was to say that I won't change it here :)

[Zsombor Egri (zsombi)]

> 540 + if ((d->globalDisabled && disable) || (!d->globalDisabled &&
> disable)) {
> 541 + // disabling or re-disabling
> 542 + d->disablerItem = item;
> 543 + if (d->globalDisabled == disable) {
> 544 + // was already disabled, leave
> 545 + return;
> 546 + }
> 547 + d->globalDisabled = disable;
> 548 + } else if (d->globalDisabled && !disable && d->disablerItem ==
> item) {
> 549 + // the one disabled it will enable
> 550 + d->globalDisabled = disable;
> 551 + d->disablerItem.clear();
> 552 + } else {
> 553 + // none of the above, leave
> 554 + return;
> 555 + }
>
> same as code below, which is simpler:
>
> if (disable) {
> d->disablerItem = item; // what is this for?
> if (d->globalDisabled) {
> return;
> }
> } else if (d->globalDisabled && item == d->disablerItem) {
> d->globalDisabled = false;
> d->disablerItem.clear();
> } else {
> // !disabled && (!globalDisabled || item != d->disablerItem)
> return;
> }

Right, changed it.
The disablerItem is there to know that we should re-enable the interactive flag only if the same item which disabled requests it. Example, you have a Flickable with ListItems, all having their own ListItemAction declared (not a shared one!!), one ListItem swiped in. You start to swipe an other one, in that moment the previous one will initiate rebounding, and the one you swiped will lock the Flickable and start swiping. At this point this will be the one who requested the lock. The other one finishes the rebound animation, and as part of the animation end, the lock is released. But that should not happen as you may still be dragging the other ListItem, right? So the member makes sure that we only unlock the Flickable when the one locking it requests it.

[Zsombor Egri (zsombi)]

> 178 +void UCListItemPrivate::promptRebound()
>
> Maybe immediateRebound() is more clear?
> Or add a "// rebound without animation"

comment added

[lp:~zsombi/ubuntu-ui-toolkit/33-listitem-attached]

1329. By Zsombor Egri on 2014-11-18

review comments applied

[Zsombor Egri (zsombi)]

All comments addressed

[Tim Peeters (tpeeters)]

thanks

review: Approve

[lp:~zsombi/ubuntu-ui-toolkit/33-listitem-attached]

1330. By Zsombor Egri on 2014-11-19

prereq sync

=== modified file 'components.api'
--- components.api	2014-11-19 15:10:32 +0000
+++ components.api	2014-11-19 15:10:34 +0000
@@ -902,6 +902,7 @@
     Method {
     name: "snapToPosition"
     Parameter { name: "position"; type: "double" }
+    Component { name: "UCListItemAttached"; prototype: "QObject" }
     name: "UCListItemDivider"
     prototype: "QObject"
     Property { name: "visible"; type: "bool" }

=== modified file 'modules/Ubuntu/Components/plugin/plugin.pro'
--- modules/Ubuntu/Components/plugin/plugin.pro	2014-11-19 15:10:32 +0000
+++ modules/Ubuntu/Components/plugin/plugin.pro	2014-11-19 15:10:34 +0000
@@ -72,7 +72,8 @@
     uclistitem.h \
     uclistitem_p.h \
     uclistitemactions.h \
-    uclistitemactions_p.h
+    uclistitemactions_p.h \
+    propertychange_p.h
 
 SOURCES += plugin.cpp \
     uctheme.cpp \
@@ -112,7 +113,9 @@
     adapters/actionsproxy_p.cpp \
     uclistitem.cpp \
     uclistitemactions.cpp \
-    uclistitemactionsattached.cpp
+    uclistitemactionsattached.cpp \
+    uclistitemattached.cpp \
+    propertychange_p.cpp
 
 # adapters
 SOURCES += adapters/alarmsadapter_organizer.cpp

=== added file 'modules/Ubuntu/Components/plugin/propertychange_p.cpp'
--- modules/Ubuntu/Components/plugin/propertychange_p.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/propertychange_p.cpp	2014-11-19 15:10:34 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "propertychange_p.h"
+
+#include <QtQml/private/qqmlabstractbinding_p.h>
+#define foreach Q_FOREACH //workaround to fix private includes
+#include <QtQml/private/qqmlbinding_p.h>     // for QmlBinding
+#undef foreach
+
+/*
+ * The class is used to save properties and their bindings while the property is
+ * altered temporarily.
+ */
+PropertyChange::PropertyChange(QObject *item, const char *property)
+    : m_backedUp(false)
+    , qmlProperty(item, property, qmlContext(item))
+{
+}
+PropertyChange::~PropertyChange()
+{
+    restore(this);
+}
+
+/*
+ * Sets a value to the property. Will back up the original values if it wasn't yet.
+ * This function can be called many times, it will not destroy the backed up value/binding.
+ */
+void PropertyChange::setValue(PropertyChange *change, const QVariant &value)
+{
+    if (!change) {
+        return;
+    }
+    if (!change->m_backedUp) {
+        change->backup.first = QQmlPropertyPrivate::setBinding(change->qmlProperty, 0);
+        change->backup.second = change->qmlProperty.read();
+        change->m_backedUp = true;
+    }
+    change->qmlProperty.write(value);
+}
+
+/*
+ * Restore backed up value or binding.
+ */
+void PropertyChange::restore(PropertyChange *change)
+{
+    if (!change) {
+        return;
+    }
+    if (change->m_backedUp) {
+        // if there was a binding, restore it
+        if (change->backup.first) {
+            QQmlAbstractBinding *prevBinding = QQmlPropertyPrivate::setBinding(change->qmlProperty, change->backup.first);
+            if (prevBinding && prevBinding != change->backup.first) {
+                prevBinding->destroy();
+            }
+        } else {
+            // there was no binding, restore previous value
+            change->qmlProperty.write(change->backup.second);
+        }
+        change->m_backedUp = false;
+    }
+}

=== added file 'modules/Ubuntu/Components/plugin/propertychange_p.h'
--- modules/Ubuntu/Components/plugin/propertychange_p.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/propertychange_p.h	2014-11-19 15:10:34 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PROPERTYCHANGE_P_H
+#define PROPERTYCHANGE_P_H
+
+#include <QtCore/QVariant>
+#include <QtCore/QObject>
+#include <QtQml/QQmlProperty>
+
+class QQmlAbstractBinding;
+class PropertyChange
+{
+public:
+    PropertyChange(QObject *item, const char *property);
+    ~PropertyChange();
+
+    static void setValue(PropertyChange* change, const QVariant &value);
+    static void restore(PropertyChange* change);
+private:
+    bool m_backedUp;
+    QQmlProperty qmlProperty;
+    QPair<QQmlAbstractBinding*, QVariant> backup;
+};
+
+#endif // PROPERTYCHANGE_P_H

=== modified file 'modules/Ubuntu/Components/plugin/uclistitem.cpp'
--- modules/Ubuntu/Components/plugin/uclistitem.cpp	2014-11-19 15:10:32 +0000
+++ modules/Ubuntu/Components/plugin/uclistitem.cpp	2014-11-19 15:10:34 +0000
@@ -197,6 +197,7 @@
     , overshoot(UCUnits::instance().gu(2))
     , color(Qt::transparent)
     , highlightColor(Qt::transparent)
+    , attachedProperties(0)
     , contentItem(new QQuickItem)
     , divider(new UCListItemDivider)
     , leadingActions(0)
@@ -245,6 +246,12 @@
     listenToRebind(false);
 }
 
+// rebound without animation
+void UCListItemPrivate::promptRebound()
+{
+    setPressed(false);
+}
+
 // called when units size changes
 void UCListItemPrivate::_q_updateSize()
 {
@@ -283,14 +290,9 @@
 // connects/disconnects from the Flickable anchestor to get notified when to do rebound
 void UCListItemPrivate::listenToRebind(bool listen)
 {
-    if (flickable.isNull()) {
-        return;
-    }
-    Q_Q(UCListItem);
-    if (listen) {
-        QObject::connect(flickable.data(), SIGNAL(movementStarted()), q, SLOT(_q_rebound()));
-    } else {
-        QObject::disconnect(flickable.data(), SIGNAL(movementStarted()), q, SLOT(_q_rebound()));
+    if (attachedProperties) {
+        Q_Q(UCListItem);
+        attachedProperties->listenToRebind(q, listen);
     }
 }
 
@@ -359,6 +361,11 @@
 {
 }
 
+UCListItemAttached *UCListItem::qmlAttachedProperties(QObject *owner)
+{
+    return new UCListItemAttached(owner);
+}
+
 void UCListItem::componentComplete()
 {
     UCStyledItemBase::componentComplete();
@@ -381,11 +388,18 @@
             d->flickable = qobject_cast<QQuickFlickable*>(data.item->parentItem());
         }
 
+        // attach ListItem properties to the flickable or to the parent item
         if (d->flickable) {
-            // connect to flickable to get width changes
-            QObject::connect(d->flickable, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()));
+            d->attachedProperties = static_cast<UCListItemAttached*>(qmlAttachedPropertiesObject<UCListItem>(d->flickable));
         } else if (data.item) {
-            QObject::connect(data.item, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()));
+            d->attachedProperties = static_cast<UCListItemAttached*>(qmlAttachedPropertiesObject<UCListItem>(data.item));
+        } else {
+            // about to be deleted or reparented, disable attached
+            d->attachedProperties = 0;
+        }
+
+        if (data.item) {
+            QObject::connect(d->flickable ? d->flickable : data.item, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()));
         }
 
         // update size
@@ -437,7 +451,7 @@
 {
     UCStyledItemBase::mousePressEvent(event);
     Q_D(UCListItem);
-    if (!d->flickable.isNull() && d->flickable->isMoving()) {
+    if (d->attachedProperties && d->attachedProperties->isMoving()) {
         // while moving, we cannot select any items
         return;
     }
@@ -445,22 +459,20 @@
         d->setPressed(true);
         // connect the Flickable to know when to rebound
         d->listenToRebind(true);
-        // accept the event so we get the rest of the events as well
-        event->setAccepted(true);
     }
+    // accept the event so we get the rest of the events as well
+    event->setAccepted(true);
 }
 
 void UCListItem::mouseReleaseEvent(QMouseEvent *event)
 {
+    UCStyledItemBase::mouseReleaseEvent(event);
     Q_D(UCListItem);
     // set released
     if (d->pressed) {
+        d->listenToRebind(false);
         Q_EMIT clicked();
     }
-    // save pressed state as UCFocusScope resets it seemlessly
-    bool wasPressed = d->pressed;
-    UCStyledItemBase::mouseReleaseEvent(event);
-    d->pressed = wasPressed;
     d->setPressed(false);
 }
 

=== modified file 'modules/Ubuntu/Components/plugin/uclistitem.h'
--- modules/Ubuntu/Components/plugin/uclistitem.h	2014-11-19 15:10:32 +0000
+++ modules/Ubuntu/Components/plugin/uclistitem.h	2014-11-19 15:10:34 +0000
@@ -23,6 +23,7 @@
 class UCListItemContent;
 class UCListItemDivider;
 class UCListItemActions;
+class UCListItemAttached;
 class UCListItemPrivate;
 class UCListItem : public UCStyledItemBase
 {
@@ -42,6 +43,8 @@
     explicit UCListItem(QQuickItem *parent = 0);
     ~UCListItem();
 
+    static UCListItemAttached *qmlAttachedProperties(QObject *owner);
+
     QQuickItem *contentItem() const;
     UCListItemDivider *divider() const;
     UCListItemActions *leadingActions() const;
@@ -87,4 +90,26 @@
     Q_PRIVATE_SLOT(d_func(), void _q_updateSize())
 };
 
+QML_DECLARE_TYPEINFO(UCListItem, QML_HAS_ATTACHED_PROPERTIES)
+
+class UCListItemAttachedPrivate;
+class UCListItemAttached : public QObject
+{
+    Q_OBJECT
+public:
+    explicit UCListItemAttached(QObject *owner);
+    ~UCListItemAttached();
+
+    bool listenToRebind(UCListItem *item, bool listen);
+    void disableInteractive(UCListItem *item, bool disable);
+    bool isMoving();
+    bool isBoundTo(UCListItem *item);
+
+private Q_SLOTS:
+    void unbindItem();
+private:
+    Q_DECLARE_PRIVATE(UCListItemAttached)
+    QScopedPointer<UCListItemAttachedPrivate> d_ptr;
+};
+
 #endif // UCLISTITEM_H

=== modified file 'modules/Ubuntu/Components/plugin/uclistitem_p.h'
--- modules/Ubuntu/Components/plugin/uclistitem_p.h	2014-11-19 15:10:32 +0000
+++ modules/Ubuntu/Components/plugin/uclistitem_p.h	2014-11-19 15:10:34 +0000
@@ -42,6 +42,7 @@
 
     void _q_updateColors();
     void _q_rebound();
+    void promptRebound();
     void _q_updateSize();
     int index();
     void setPressed(bool pressed);
@@ -57,6 +58,7 @@
     QColor color;
     QColor highlightColor;
     QPointer<QQuickFlickable> flickable;
+    UCListItemAttached *attachedProperties;
     QQuickItem *contentItem;
     UCListItemDivider *divider;
     UCListItemActions *leadingActions;
@@ -67,6 +69,27 @@
     void setContentMoving(bool moved);
 };
 
+class PropertyChange;
+class UCListItemAttachedPrivate
+{
+    Q_DECLARE_PUBLIC(UCListItemAttached)
+public:
+    UCListItemAttachedPrivate(UCListItemAttached *qq);
+    ~UCListItemAttachedPrivate();
+
+    void clearFlickablesList();
+    void buildFlickablesList();
+    void clearChangesList();
+    void buildChangesList(const QVariant &newValue);
+
+    UCListItemAttached *q_ptr;
+    bool globalDisabled;
+    QList< QPointer<QQuickFlickable> > flickables;
+    QList< PropertyChange* > changes;
+    QPointer<UCListItem> boundItem;
+    QPointer<UCListItem> disablerItem;
+};
+
 class UCListItemDivider : public QObject
 {
     Q_OBJECT

=== added file 'modules/Ubuntu/Components/plugin/uclistitemattached.cpp'
--- modules/Ubuntu/Components/plugin/uclistitemattached.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemattached.cpp	2014-11-19 15:10:34 +0000
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ucunits.h"
+#include "uctheme.h"
+#include "uclistitem.h"
+#include "uclistitem_p.h"
+#include "propertychange_p.h"
+#include <QtQuick/private/qquickflickable_p.h>
+
+/*
+ * The properties are attached to the ListItem's parent item or to its closest
+ * Flickable parent, when embedded in ListView or Flickable. There will be only
+ * one attached property per Flickable for all embedded child ListItems, enabling
+ * in this way the controlling of the interactive flag of the Flickable and all
+ * its ascendant Flickables.
+ */
+UCListItemAttachedPrivate::UCListItemAttachedPrivate(UCListItemAttached *qq)
+    : q_ptr(qq)
+    , globalDisabled(false)
+{
+}
+
+UCListItemAttachedPrivate::~UCListItemAttachedPrivate()
+{
+    clearChangesList();
+    clearFlickablesList();
+}
+
+// disconnect all flickables
+void UCListItemAttachedPrivate::clearFlickablesList()
+{
+    Q_Q(UCListItemAttached);
+    Q_FOREACH(const QPointer<QQuickFlickable> &flickable, flickables) {
+        if (flickable.data())
+        QObject::disconnect(flickable.data(), &QQuickFlickable::movementStarted,
+                            q, &UCListItemAttached::unbindItem);
+    }
+    flickables.clear();
+}
+
+// connect all flickables
+void UCListItemAttachedPrivate::buildFlickablesList()
+{
+    Q_Q(UCListItemAttached);
+    QQuickItem *item = qobject_cast<QQuickItem*>(q->parent());
+    if (!item) {
+        return;
+    }
+    clearFlickablesList();
+    while (item) {
+        QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(item);
+        if (flickable) {
+            QObject::connect(flickable, &QQuickFlickable::movementStarted,
+                             q, &UCListItemAttached::unbindItem);
+            flickables << flickable;
+        }
+        item = item->parentItem();
+    }
+}
+
+void UCListItemAttachedPrivate::clearChangesList()
+{
+    // clear property change objects
+    Q_Q(UCListItemAttached);
+    Q_FOREACH(PropertyChange *change, changes) {
+        // deleting PropertyChange will restore the saved property
+        // to its original binding/value
+        delete change;
+    }
+    changes.clear();
+}
+
+void UCListItemAttachedPrivate::buildChangesList(const QVariant &newValue)
+{
+    // collect all ascendant flickables
+    Q_Q(UCListItemAttached);
+    QQuickItem *item = qobject_cast<QQuickItem*>(q->parent());
+    if (!item) {
+        return;
+    }
+    clearChangesList();
+    while (item) {
+        QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(item);
+        if (flickable) {
+            PropertyChange *change = new PropertyChange(item, "interactive");
+            PropertyChange::setValue(change, newValue);
+            changes << change;
+        }
+        item = item->parentItem();
+    }
+}
+
+UCListItemAttached::UCListItemAttached(QObject *owner)
+    : QObject(owner)
+    , d_ptr(new UCListItemAttachedPrivate(this))
+{
+}
+
+UCListItemAttached::~UCListItemAttached()
+{
+}
+
+// register item to be rebound
+bool UCListItemAttached::listenToRebind(UCListItem *item, bool listen)
+{
+    // we cannot bind the item until we have an other one bound
+    bool result = false;
+    Q_D(UCListItemAttached);
+    if (listen) {
+        if (d->boundItem.isNull() || (d->boundItem == item)) {
+            d->boundItem = item;
+            // rebuild flickable list
+            d->buildFlickablesList();
+            result = true;
+        }
+    } else if (d->boundItem == item) {
+        d->boundItem.clear();
+        result = true;
+    }
+    return result;
+}
+
+// reports true if any of the ascendant flickables is moving
+bool UCListItemAttached::isMoving()
+{
+    Q_D(UCListItemAttached);
+    Q_FOREACH(const QPointer<QQuickFlickable> &flickable, d->flickables) {
+        if (flickable && flickable->isMoving()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// returns true if the given ListItem is bound to listen on moving changes
+bool UCListItemAttached::isBoundTo(UCListItem *item)
+{
+    Q_D(UCListItemAttached);
+    return d->boundItem == item;
+}
+
+/*
+ * Disable/enable interactive flag for the ascendant flickables. The item is used
+ * to detect whether the same item is trying to enable the flickables which disabled
+ * it before. The enabled/disabled states are not equivalent to the enabled/disabled
+ * state of the interactive flag.
+ * When disabled, always the last item disabling will be kept as active disabler,
+ * and only the active disabler can enable (restore) the interactive flag state.
+ */
+void UCListItemAttached::disableInteractive(UCListItem *item, bool disable)
+{
+    Q_D(UCListItemAttached);
+    if (disable) {
+        // disabling or re-disabling
+        d->disablerItem = item;
+        if (d->globalDisabled == disable) {
+            // was already disabled, leave
+            return;
+        }
+        d->globalDisabled = true;
+    } else if (d->globalDisabled && d->disablerItem == item) {
+        // the one disabled it will enable
+        d->globalDisabled = false;
+        d->disablerItem.clear();
+    } else {
+        // !disabled && (!globalDisabled || item != d->disablerItem)
+        return;
+    }
+    if (disable) {
+        // (re)build changes list with disabling the interactive value
+        d->buildChangesList(false);
+    } else {
+        d->clearChangesList();
+    }
+}
+
+void UCListItemAttached::unbindItem()
+{
+    Q_D(UCListItemAttached);
+    if (d->boundItem) {
+        // depending on content item's X coordinate, we either do animated or prompt rebind
+        if (d->boundItem->contentItem()->x() != 0.0) {
+            // content is not in origin, rebind
+            UCListItemPrivate::get(d->boundItem.data())->_q_rebound();
+        } else {
+            // do some cleanup
+            UCListItemPrivate::get(d->boundItem.data())->promptRebound();
+        }
+        d->boundItem.clear();
+    }
+    // clear binding list
+    d->clearFlickablesList();
+}