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

[Zsombor Egri]

Implement list item expansion

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1631
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2196/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/924
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/926
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/926/artifact/work/output/*zip*/output.zip
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/923

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

review: Needs Fixing (continuous-integration)

[Zsombor Egri (zsombi)]

Must fix tst_listitem.qml to use the proper version.

review: Needs Fixing

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

1632. By Zsombor Egri on 2015-09-02

separate 1.2 tests from 1.3

1633. By Zsombor Egri on 2015-09-02

1.2 fixed

1634. By Zsombor Egri on 2015-09-02

1.3 specific tests

1635. By Zsombor Egri on 2015-09-02

staging merge

1636. By Zsombor Egri on 2015-09-02

API updated

[Zsombor Egri (zsombi)]

Tests fixed

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1636
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2199/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/927
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/929
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/929/artifact/work/output/*zip*/output.zip
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/926

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

review: Needs Fixing (continuous-integration)

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

1637. By Zsombor Egri on 2015-09-02

commented out import breaking tests restored

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1637
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2200/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/928
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/930
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/930/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/927

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

review: Approve (continuous-integration)

[Cris Dywan (kalikiana)]

+ state: (listItemStyle.completed && styledItem.expansion.expanded) ?
The .completed property feels a bit.. hackish - why not use Component.onCompleted in the style? Why isn't that the same? I could be missing something obvious, so if this is needed maybe it can be documented a bit.

ViewItems.LockExpanded - shouldn't this be ViewItems.UnlockExpanded to prevent one from accidentally unsetting it? For instance

ViewItems.expansionFlags: ViewItems.CollapseOnOutsidePress

looks as though it only changes one flag, and you'd probably assume the actions are still locked when expanding, when in fact they won't be because the flags were replaced. If the flag was reversed that wouldn't happen.

+ property real expandedHeight//: units.gu(12)

Leftover? Remember what your mother said about leftovers, get rid of them or it will rain tomorrow ;-)

Also, can we have something in the toolkit gallery on the new list items page?

review: Needs Fixing

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

1638. By Zsombor Egri on 2015-09-04

commented code removed

1639. By Zsombor Egri on 2015-09-04

LockExpanded changed into UnlockExpanded, documentation updated

1640. By Zsombor Egri on 2015-09-04

Completion handled in style; refinement on the UnlockExpanded handling; minor improvement on overridden slots

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1640
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2206/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/934/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/936/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/933/console

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

review: Needs Fixing (continuous-integration)

[Cris Dywan (kalikiana)]

You forgot to update components.api!

review: Needs Fixing

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

1641. By Zsombor Egri on 2015-09-04

API updated

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1641
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2207/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/935
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/937
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/937/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/934

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

review: Approve (continuous-integration)

[Cris Dywan (kalikiana)]

Looking good. Thanks a lot!

review: Approve

=== modified file 'components.api'
--- components.api	2015-09-03 13:27:49 +0000
+++ components.api	2015-09-04 10:38:07 +0000
@@ -454,6 +454,7 @@
     property bool selected
     property ListItemActions trailingActions
 Ubuntu.Components.ListItem 1.3: ListItem
+    readonly property UCListItemExpansion expansion
 Ubuntu.Components.ListItemActions 1.2: QtObject
     readonly property Action actions
     default readonly property QtObject data
@@ -473,6 +474,7 @@
     readonly property bool animatePanels
     property Item dragPanel
     property PropertyAnimation dropAnimation
+    readonly property Flickable flickable 1.3
     readonly property int listItemIndex 1.3
     function swipeEvent(SwipeEvent event)
     function rebound()
@@ -1245,6 +1247,9 @@
 UCListItemDivider: Item
     property color colorFrom
     property color colorTo
+UCListItemExpansion: QtObject
+    property bool expanded
+    property double height
 UCStateSaverAttached: QtObject
     property bool enabled
     property string properties
@@ -1392,6 +1397,14 @@
     signal dragUpdated(ListItemDrag event)
     property bool selectMode
     property QList<int> selectedIndices
+Ubuntu.Components.ViewItems 1.3: ViewItems
+    property QList<int> expandedIndices
+    property int expansionFlags
+    signal expandedIndicesChanged(QList<int> indices)
+Ubuntu.Components.ViewItems.ExpansionFlag: Enum
+    CollapseOnOutsidePress
+    Exclusive
+    UnlockExpanded
 Ubuntu.Components.i18n 1.0 0.1: QtObject
     property string domain
     property string language

=== modified file 'src/Ubuntu/Components/Themes/Ambiance/1.2/ListItemStyle.qml'
--- src/Ubuntu/Components/Themes/Ambiance/1.2/ListItemStyle.qml	2015-07-22 18:57:58 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/1.2/ListItemStyle.qml	2015-09-04 10:38:07 +0000
@@ -25,7 +25,7 @@
      * Take over the ListItem's index context property as repeater used in panel
      * overrides the property.
      */
-    readonly property int listItemIndex: index
+    readonly property int listItemIndex: (typeof index !== "undefined") ? index : internals.childIndex()
 
     /*
      * Coloring properties
@@ -343,6 +343,19 @@
         readonly property real threshold: units.gu(1.5)
         property bool snapIn: false
 
+        // returns the child index of the ListItem when not used in model driven view
+        function childIndex() {
+            if (styledItem.parent) {
+                for (var i = 0; i < styledItem.parent.children.length; i++) {
+                    if (styledItem.parent.children[i] == styledItem) {
+                        return i;
+                    }
+                }
+            } else {
+                return -1;
+            }
+        }
+
         // update snap direction
         function updateSnapDirection() {
             if (prevX < listItemStyle.x && (snapChangerLimit <= listItemStyle.x)) {

=== modified file 'src/Ubuntu/Components/Themes/Ambiance/1.3/ListItemStyle.qml'
--- src/Ubuntu/Components/Themes/Ambiance/1.3/ListItemStyle.qml	2015-07-22 18:57:58 +0000
+++ src/Ubuntu/Components/Themes/Ambiance/1.3/ListItemStyle.qml	2015-09-04 10:38:07 +0000
@@ -337,6 +337,7 @@
         property real snapChangerLimit: 0.0
         readonly property real threshold: units.gu(1.5)
         property bool snapIn: false
+        property bool completed: false
 
         // update snap direction
         function updateSnapDirection() {
@@ -419,4 +420,68 @@
     function rebound() {
         snapAnimation.snapTo(0);
     }
+
+    // expansion
+    Component.onCompleted: internals.completed = true
+    state: (internals.completed && styledItem.expansion.expanded) ? (listItemStyle.flickable ? "expandedWithFlickable" : "expandedNoFlickable") : ""
+    states: [
+        State {
+            name: "expandedNoFlickable"
+            PropertyChanges {
+                target: styledItem
+                height: styledItem.expansion.height
+            }
+        },
+        State {
+            name: "expandedWithFlickable"
+            PropertyChanges {
+                target: styledItem
+                height: styledItem.expansion.height
+            }
+            PropertyChanges {
+                target: listItemStyle.flickable
+                // we do not need to restore the original values
+                restoreEntryValues: false
+                // and we should not get any binding updates even
+                explicit: true
+                contentY: {
+                    var bottom = styledItem.y + styledItem.expansion.height - listItemStyle.flickable.contentY + listItemStyle.flickable.originY;
+                    var dy = bottom - listItemStyle.flickable.height;
+                    if (dy > 0) {
+                        return listItemStyle.flickable.contentY + dy - listItemStyle.flickable.originY;
+                    } else {
+                        return listItemStyle.flickable.contentY;
+                    }
+                }
+            }
+        }
+    ]
+    transitions: [
+        Transition {
+            from: ""
+            to: "expandedWithFlickable"
+            reversible: true
+            enabled: listItemStyle.animatePanels
+            ParallelAnimation {
+                UbuntuNumberAnimation {
+                    target: listItemStyle.flickable
+                    property: "contentY"
+                }
+                UbuntuNumberAnimation {
+                    target: styledItem
+                    property: "height"
+                }
+            }
+        },
+        Transition {
+            from: ""
+            to: "expandedNoFlickable"
+            reversible: true
+            enabled: listItemStyle.animatePanels
+            UbuntuNumberAnimation {
+                target: styledItem
+                property: "height"
+            }
+        }
+    ]
 }

=== modified file 'src/Ubuntu/Components/plugin/plugin.cpp'
--- src/Ubuntu/Components/plugin/plugin.cpp	2015-08-24 16:02:50 +0000
+++ src/Ubuntu/Components/plugin/plugin.cpp	2015-09-04 10:38:07 +0000
@@ -224,6 +224,8 @@
 
     // register 1.3 API
     qmlRegisterType<UCListItem13>(uri, 1, 3, "ListItem");
+    qmlRegisterType<UCListItemExpansion>();
+    qmlRegisterUncreatableType<UCViewItemsAttached13>(uri, 1, 3, "ViewItems", "No create");
     qmlRegisterType<UCTheme>(uri, 1, 3, "ThemeSettings");
     qmlRegisterType<UCStyledItemBase, 2>(uri, 1, 3, "StyledItem");
     qmlRegisterSingletonType<UCNamespaceV13>(uri, 1, 3, "Ubuntu", registerUbuntuNamespace13);

=== modified file 'src/Ubuntu/Components/plugin/plugin.pri'
--- src/Ubuntu/Components/plugin/plugin.pri	2015-08-20 15:34:26 +0000
+++ src/Ubuntu/Components/plugin/plugin.pri	2015-09-04 10:38:07 +0000
@@ -130,6 +130,7 @@
     $$PWD/ucserviceproperties.cpp \
     $$PWD/privates/listitemdragarea.cpp \
     $$PWD/privates/listitemdraghandler.cpp \
+    $$PWD/privates/listitemexpansion.cpp \
     $$PWD/ucnamespace.cpp \
     $$PWD/ucdeprecatedtheme.cpp \
     $$PWD/ucdefaulttheme.cpp \

=== modified file 'src/Ubuntu/Components/plugin/privates/listitemdragarea.cpp'
--- src/Ubuntu/Components/plugin/privates/listitemdragarea.cpp	2015-04-13 11:11:59 +0000
+++ src/Ubuntu/Components/plugin/privates/listitemdragarea.cpp	2015-09-04 10:38:07 +0000
@@ -47,13 +47,12 @@
     setObjectName("drag_area");
 }
 
-void ListItemDragArea::init()
+void ListItemDragArea::init(UCViewItemsAttached *viewItems)
 {
     setParentItem(static_cast<QQuickItem*>(parent()));
     QQuickAnchors *anchors = QQuickItemPrivate::get(this)->anchors();
     anchors->setFill(parentItem());
-    viewAttached = static_cast<UCViewItemsAttached*>(
-                qmlAttachedPropertiesObject<UCViewItemsAttached>(listView));
+    viewAttached = viewItems;
     reset();
 }
 

=== modified file 'src/Ubuntu/Components/plugin/privates/listitemdragarea.h'
--- src/Ubuntu/Components/plugin/privates/listitemdragarea.h	2015-02-24 15:57:53 +0000
+++ src/Ubuntu/Components/plugin/privates/listitemdragarea.h	2015-09-04 10:38:07 +0000
@@ -27,7 +27,7 @@
     Q_OBJECT
 public:
     explicit ListItemDragArea(QQuickItem *parent = 0);
-    void init();
+    void init(UCViewItemsAttached *viewItems);
     void reset();
 
 protected:

=== added file 'src/Ubuntu/Components/plugin/privates/listitemexpansion.cpp'
--- src/Ubuntu/Components/plugin/privates/listitemexpansion.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/Components/plugin/privates/listitemexpansion.cpp	2015-09-04 10:38:07 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2015 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 "uclistitem.h"
+#include "uclistitem_p.h"
+
+UCListItemExpansion::UCListItemExpansion(QObject *parent)
+    : QObject(parent)
+    , m_listItem(static_cast<UCListItem13*>(parent))
+    , m_height(0.0)
+    , m_filtering(false)
+{
+}
+
+bool UCListItemExpansion::expandedLocked()
+{
+    UCListItemPrivate *listItem = UCListItemPrivate::get(m_listItem);
+    UCViewItemsAttachedPrivate *viewItems = UCViewItemsAttachedPrivate::get(listItem->parentAttached);
+    return expanded() && !((viewItems->expansionFlags & UCViewItemsAttached::UnlockExpanded) == UCViewItemsAttached::UnlockExpanded);
+}
+
+void UCListItemExpansion::enableClickFiltering(bool enable)
+{
+    if (m_filtering == enable) {
+        return;
+    }
+    m_filtering = enable;
+    if (m_filtering) {
+        m_listItem->window()->installEventFilter(this);
+    } else {
+        m_listItem->window()->removeEventFilter(this);
+    }
+}
+
+// event filter for external mouse presses to collapse when pressed outside
+bool UCListItemExpansion::eventFilter(QObject *target, QEvent *event)
+{
+    if (event->type() == QEvent::MouseButtonPress) {
+        QMouseEvent *mouse = static_cast<QMouseEvent*>(event);
+        QQuickWindow *window = qobject_cast<QQuickWindow*>(target);
+        if (window) {
+            QPointF myPos(window->contentItem()->mapToItem(m_listItem, mouse->localPos()));
+            if (!m_listItem->contains(myPos)) {
+                UCListItemPrivate *listItem = UCListItemPrivate::get(m_listItem);
+                UCViewItemsAttachedPrivate *viewItems = UCViewItemsAttachedPrivate::get(listItem->parentAttached);
+                if (viewItems) {
+                    // collapse all as there can be only one expanded when the flag is set
+                    viewItems->collapseAll();
+                }
+            }
+        }
+    }
+    return false;
+}
+
+
+bool UCListItemExpansion::expanded()
+{
+    UCListItemPrivate *listItem = UCListItemPrivate::get(m_listItem);
+    UCViewItemsAttachedPrivate *viewItems = UCViewItemsAttachedPrivate::get(listItem->parentAttached);
+    return (viewItems && viewItems->expansionList.contains(listItem->index()));
+}
+
+void UCListItemExpansion::setExpanded(bool expanded)
+{
+    if (this->expanded() == expanded) {
+        return;
+    }
+    UCListItemPrivate *listItem = UCListItemPrivate::get(m_listItem);
+    UCViewItemsAttachedPrivate *viewItems = UCViewItemsAttachedPrivate::get(listItem->parentAttached);
+    if (viewItems) {
+        if (viewItems->expansionFlags & UCViewItemsAttached::Exclusive) {
+            // collapse all the expanded ones
+            viewItems->collapseAll();
+        }
+        if (expanded) {
+            viewItems->expand(listItem->index(), m_listItem);
+        } else {
+            viewItems->collapse(listItem->index());
+        }
+    }
+    UCListItemPrivate::get(m_listItem)->loadStyleItem();
+    // no need to emit changed signal, as ViewItems.expandedIndicesChanged is connected to the change signal
+}
+
+void UCListItemExpansion::setHeight(qreal height)
+{
+    if (m_height == height) {
+        return;
+    }
+    m_height = height;
+    Q_EMIT heightChanged();
+}

=== modified file 'src/Ubuntu/Components/plugin/uclistitem.cpp'
--- src/Ubuntu/Components/plugin/uclistitem.cpp	2015-08-31 07:50:45 +0000
+++ src/Ubuntu/Components/plugin/uclistitem.cpp	2015-09-04 10:38:07 +0000
@@ -200,6 +200,7 @@
     , leadingActions(0)
     , trailingActions(0)
     , mainAction(0)
+    , expansion(Q_NULLPTR)
 {
 }
 UCListItemPrivate::~UCListItemPrivate()
@@ -325,7 +326,7 @@
 bool UCListItemPrivate::loadStyleItem(bool animated)
 {
     // the style should be loaded only if one of the condition is satisfied
-    if (!swiped && !selectMode() && !dragMode()) {
+    if (!swiped && !selectMode() && !dragMode() && !(expansion && expansion->expanded())) {
         return false;
     }
 
@@ -339,6 +340,7 @@
         preStyleChanged();
         return false;
     }
+    myStyle->updateFlickable(flickable);
     // bring the panels foreground
     styleItem->setZ(0);
     listItemStyle()->setAnimatePanels(true);
@@ -866,8 +868,74 @@
  *
  * \sa ViewItems::dragMode, ViewItems::dragUpdated
  *
+ * \section2 Expansion
+ * Since Ubuntu.Components 1.3, ListItem supports expansion. ListItems declared
+ * in a view can expand exclusively, having leading and trailing panes locked
+ * when expanded and to be collapsed when tapping outside of the expanded area.
+ * The expansion is driven by the \l expansion group property, and the behavior
+ * by the \l ViewItems::expansionFlags and \l ViewItems::expandedIndices
+ * attached properties. Each ListItem which is required to expand should set a
+ * proper height in the \l expansion.height property, which should be bigger
+ * than the collapsed height of the ListItem is. The expansion itself is driven
+ * by the \l expansion.expanded property, which can be set freely depending on
+ * the use case, on click, on long press, etc.
+ *
+ * The default expansion behavior is set to be exclusive and locked, meaning
+ * there can be only one ListItem expanded within a view and neither leading
+ * nor trailing action panels cannot be swiped in. Expanding an other ListItem
+ * will collapse the previosuly expanded one. There can be cases when tapping
+ * outside of the expanded area of a ListItem we woudl need the expanded one
+ * to collapse automatically. This can be achieved by setting \c ViewItems.CollapseOnOutsidePress
+ * flag to \l ViewItems::expansionFlags. This flag will also turn on \c ViewItems.Exclusive
+ * flag, as tapping outside practicly forbids more than one item to be expanded
+ * at a time.
+ * \qml
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ *
+ * ListView {
+ *     width: units.gu(40)
+ *     height: units.gu(71)
+ *     model: ListModel {
+ *         Component.onCompleted: {
+ *             for (var i = 0; i < 50; i++) {
+ *                 append({data: i});
+ *             }
+ *         }
+ *     }
+ *     ViewItems.expansionFlags: ViewItems.CollapseOnOutsidePress
+ *     delegate: ListItem {
+ *         Label {
+ *             text: "Model item #" + modelData
+ *         }
+ *         trailingActions: ListItemActions {
+ *             actions: [
+ *                 Action {
+ *                     icon: "search"
+ *                 },
+ *                 Action {
+ *                     icon: "edit"
+ *                 },
+ *                 Action {
+ *                     icon: "copy"
+ *                 }
+ *             ]
+ *         }
+ *         expansion.height: units.gu(15)
+ *         onClicked: expansion.expanded = true
+ *     }
+ * }
+ * \endqml
+ * The example above collapses the expanded item whenever it is tapped or mouse
+ * pressed outside of the expanded list item.
+ * \note Set 0 to \l ViewItems::expansionFlags if no restrictions on expanded items
+ * is required (i.e multiple expanded items are allowed, swiping leading/trailing
+ * actions when expanded).
+ * \note Do not bind \l expansion.height to the ListItem's height as is will cause
+ * binding loops.
+ *
  * \section2 Note on styling
- * ListItem's styling differs from the other component sstyling, as ListItem loads
+ * ListItem's styling differs from the other components styling, as ListItem loads
  * the style only when either of the leadin/trailing panels are swiped, or when the
  * item enters in select- or drag mode. The component does not assume any visuals
  * to be present in the style.
@@ -904,6 +972,11 @@
 {
 }
 
+QObject *UCListItem::attachedViewItems(QObject *object, bool create)
+{
+    return qmlAttachedPropertiesObject<UCViewItemsAttached>(object, create);
+}
+
 void UCListItem::classBegin()
 {
     UCStyledItemBase::classBegin();
@@ -956,7 +1029,7 @@
                 this, SLOT(_q_syncDragMode()));
 
         // if selection or drag mode is on, initialize style, with animations turned off
-        if (d->parentAttached->selectMode() || d->parentAttached->dragMode()) {
+        if (d->parentAttached->selectMode() || d->parentAttached->dragMode() || (d->expansion && d->expansion->expanded())) {
             d->loadStyleItem(false);
         }
         // set the object name for testing purposes
@@ -986,10 +1059,10 @@
         QQuickItem *parentAttachee = data.item;
         if (d->flickable && d->flickable->inherits("QQuickListView")) {
             // attach to ListView
-            d->parentAttached = static_cast<UCViewItemsAttached*>(qmlAttachedPropertiesObject<UCViewItemsAttached>(d->flickable));
+            d->parentAttached = static_cast<UCViewItemsAttached*>(attachedViewItems(d->flickable, true));
             parentAttachee = d->flickable;
         } else if (data.item) {
-            d->parentAttached = static_cast<UCViewItemsAttached*>(qmlAttachedPropertiesObject<UCViewItemsAttached>(data.item));
+            d->parentAttached = static_cast<UCViewItemsAttached*>(attachedViewItems(data.item, true));
         } else {
             // mark as not ready, so no action should be performed which depends on readyness
             d->ready = false;
@@ -997,6 +1070,11 @@
             d->parentAttached = 0;
         }
 
+        if (d->styleItem) {
+            UCListItemStyle * myStyle = static_cast<UCListItemStyle*>(d->styleItem);
+            myStyle->updateFlickable(d->flickable);
+        }
+
         if (parentAttachee) {
             QObject::connect(parentAttachee, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()), Qt::DirectConnection);
             // update size
@@ -1184,7 +1262,7 @@
     Q_D(UCListItem);
     UCStyledItemBase::mouseMoveEvent(event);
 
-    if (d->selectMode() || d->dragMode()) {
+    if (d->selectMode() || d->dragMode() || (d->expansion && d->expansion->expandedLocked())) {
         // no move is allowed while selectable mode is on
         return;
     }
@@ -1662,4 +1740,48 @@
     d->defaultThemeVersion = BUILD_VERSION(1, 3);
 }
 
+QObject *UCListItem13::attachedViewItems(QObject *object, bool create)
+{
+    return qmlAttachedPropertiesObject<UCViewItemsAttached13>(object, create);
+}
+
+void UCListItem13::itemChange(ItemChange change, const ItemChangeData &data)
+{
+    UCListItem::itemChange(change, data);
+
+    Q_D(UCListItem);
+    // ViewItems drives expansion
+    if (d->parentAttached) {
+        connect(d->parentAttached.data(), SIGNAL(expandedIndicesChanged(QList<int>)),
+                this, SLOT(_q_updateExpansion(QList<int>)), Qt::UniqueConnection);
+    }
+}
+
+/*!
+ * \qmlpropertygroup ::ListItem::expansion
+ * \qmlproperty bool ListItem::expansion.expanded
+ * \qmlproperty real ListItem::expansion.height
+ * \since Ubuntu.Components 1.3
+ * The group drefines the expansion state of the ListItem.
+ */
+UCListItemExpansion *UCListItem13::expansion()
+{
+    Q_D(UCListItem);
+    if (!d->expansion) {
+        d->expansion = new UCListItemExpansion(this);
+    }
+    return d->expansion;
+}
+
+void UCListItem13::_q_updateExpansion(const QList<int> &indices)
+{
+    Q_UNUSED(indices);
+    Q_D(UCListItem);
+    Q_EMIT expansion()->expandedChanged();
+    // make sure the style is loaded
+    if (indices.contains(d->index())) {
+        d->loadStyleItem();
+    }
+}
+
 #include "moc_uclistitem.cpp"

=== modified file 'src/Ubuntu/Components/plugin/uclistitem.h'
--- src/Ubuntu/Components/plugin/uclistitem.h	2015-07-28 19:29:19 +0000
+++ src/Ubuntu/Components/plugin/uclistitem.h	2015-09-04 10:38:07 +0000
@@ -62,6 +62,7 @@
     void resetHighlightColor();
 
 protected:
+    virtual QObject *attachedViewItems(QObject *object, bool create);
     void classBegin();
     void componentComplete();
     QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data);
@@ -109,17 +110,24 @@
     Q_PRIVATE_SLOT(d_func(), void _q_syncDragMode())
 };
 
+class UCListItemExpansion;
 class UCListItem13 : public UCListItem
 {
     Q_OBJECT
+    Q_PROPERTY(UCListItemExpansion* expansion READ expansion CONSTANT)
 protected:
+    virtual QObject *attachedViewItems(QObject *object, bool create);
+    void itemChange(ItemChange change, const ItemChangeData &data);
     void mousePressEvent(QMouseEvent *event);
     void mouseReleaseEvent(QMouseEvent *event);
 private:
+    Q_SLOT void _q_updateExpansion(const QList<int> &indices);
     bool shouldShowContextMenu(QMouseEvent *event);
     void popoverClosed();
 public:
     explicit UCListItem13(QQuickItem *parent = 0);
+
+    UCListItemExpansion *expansion();
 };
 
 class UCListItemDividerPrivate;
@@ -158,8 +166,15 @@
     Q_PROPERTY(bool selectMode READ selectMode WRITE setSelectMode NOTIFY selectModeChanged)
     Q_PROPERTY(QList<int> selectedIndices READ selectedIndices WRITE setSelectedIndices NOTIFY selectedIndicesChanged)
     Q_PROPERTY(bool dragMode READ dragMode WRITE setDragMode NOTIFY dragModeChanged)
+    Q_ENUMS(ExpansionFlag)
 public:
-    explicit UCViewItemsAttached(QObject *owner);
+    enum ExpansionFlag {
+        Exclusive = 0x01,
+        UnlockExpanded = 0x02,
+        CollapseOnOutsidePress = Exclusive | 0x04
+    };
+    Q_DECLARE_FLAGS(ExpansionFlags, ExpansionFlag)
+    explicit UCViewItemsAttached(QObject *owner = 0);
     ~UCViewItemsAttached();
 
     static UCViewItemsAttached *qmlAttachedProperties(QObject *owner);
@@ -191,8 +206,68 @@
 private:
     Q_DECLARE_PRIVATE(UCViewItemsAttached)
 };
+Q_DECLARE_OPERATORS_FOR_FLAGS(UCViewItemsAttached::ExpansionFlags)
 QML_DECLARE_TYPEINFO(UCViewItemsAttached, QML_HAS_ATTACHED_PROPERTIES)
 
+// FIXME keep the 1.3 properties in a separate class, workaround for bug
+// https://bugs.launchpad.net/ubuntu/+source/qtdeclarative-opensource-src/+bug/1389721
+// enums and flag are added to UCViewItemsAttached like normal
+class UCViewItemsAttached13 : public UCViewItemsAttached
+{
+    Q_OBJECT
+    Q_PROPERTY(QList<int> expandedIndices READ expandedIndices WRITE setExpandedIndices NOTIFY expandedIndicesChanged)
+    Q_PROPERTY(int expansionFlags READ expansionFlags WRITE setExpansionFlags NOTIFY expansionFlagsChanged)
+public:
+    explicit UCViewItemsAttached13(QObject *owner = 0);
+    static UCViewItemsAttached13 *qmlAttachedProperties(QObject *owner);
+
+    QList<int> expandedIndices() const;
+    void setExpandedIndices(QList<int> indices);
+    int expansionFlags() const;
+    void setExpansionFlags(int flags);
+
+Q_SIGNALS:
+    void expandedIndicesChanged(const QList<int> &indices);
+    void expansionFlagsChanged();
+
+private:
+    UCViewItemsAttachedPrivate *d_ptr;
+    Q_DECLARE_PRIVATE_D(d_ptr, UCViewItemsAttached)
+};
+QML_DECLARE_TYPEINFO(UCViewItemsAttached13, QML_HAS_ATTACHED_PROPERTIES)
+
+class UCListItemExpansion : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool expanded READ expanded WRITE setExpanded NOTIFY expandedChanged)
+    Q_PROPERTY(qreal height MEMBER m_height WRITE setHeight NOTIFY heightChanged)
+public:
+    explicit UCListItemExpansion(QObject *parent = 0);
+
+    bool expandedLocked();
+    void enableClickFiltering(bool enable);
+
+    bool expanded();
+    void setExpanded(bool expanded);
+    void setHeight(qreal height);
+
+Q_SIGNALS:
+    void expandedChanged();
+    void heightChanged();
+
+protected:
+    bool eventFilter(QObject *, QEvent *);
+
+private:
+    UCListItem13 *m_listItem;
+    qreal m_height;
+    bool m_filtering:1;
+
+    friend class UCListItem;
+    friend class UCListItem13;
+    friend class UCListItemPrivate;
+};
+
 class UCDragEvent : public QObject
 {
     Q_OBJECT

=== modified file 'src/Ubuntu/Components/plugin/uclistitem_p.h'
--- src/Ubuntu/Components/plugin/uclistitem_p.h	2015-08-31 07:50:45 +0000
+++ src/Ubuntu/Components/plugin/uclistitem_p.h	2015-09-04 10:38:07 +0000
@@ -95,6 +95,7 @@
     UCListItemActions *leadingActions;
     UCListItemActions *trailingActions;
     UCAction *mainAction;
+    UCListItemExpansion *expansion;
 
     // getters/setters
     QQmlListProperty<QObject> data();
@@ -147,17 +148,25 @@
     bool isDragUpdatedConnected();
     void updateSelectedIndices(int fromIndex, int toIndex);
 
+    // expansion
+    void expand(int index, UCListItem13 *listItem, bool emitChangeSignal = true);
+    void collapse(int index, bool emitChangeSignal = true);
+    void collapseAll();
+    void toggleExpansionFlags(bool enable);
+
+    QSet<int> selectedList;
+    QMap<int, QPointer<UCListItem13> > expansionList;
+    QList< QPointer<QQuickFlickable> > flickables;
+    QList< PropertyChange* > changes;
+    QPointer<UCListItem> boundItem;
+    QPointer<UCListItem> disablerItem;
     QQuickFlickable *listView;
     ListItemDragArea *dragArea;
+    UCViewItemsAttached::ExpansionFlags expansionFlags;
     bool globalDisabled:1;
     bool selectable:1;
     bool draggable:1;
     bool ready:1;
-    QSet<int> selectedList;
-    QList< QPointer<QQuickFlickable> > flickables;
-    QList< PropertyChange* > changes;
-    QPointer<UCListItem> boundItem;
-    QPointer<UCListItem> disablerItem;
 };
 
 #endif // UCVIEWITEM_P_H

=== modified file 'src/Ubuntu/Components/plugin/uclistitemstyle.cpp'
--- src/Ubuntu/Components/plugin/uclistitemstyle.cpp	2015-04-13 13:42:03 +0000
+++ src/Ubuntu/Components/plugin/uclistitemstyle.cpp	2015-09-04 10:38:07 +0000
@@ -21,6 +21,7 @@
 #include <QtQml/QQmlContext>
 #include <QtQml/QQmlInfo>
 #include <QtQuick/private/qquickanimation_p.h>
+#include <QtQuick/private/qquickflickable_p.h>
 
 /*!
  * \qmltype ListItemStyle
@@ -41,6 +42,7 @@
     , m_snapAnimation(0)
     , m_dropAnimation(0)
     , m_dragPanel(0)
+    , m_flickable(Q_NULLPTR)
     , m_animatePanels(true)
 {
 }
@@ -54,21 +56,29 @@
         setAnimatePanels(context->contextProperty("animated").toBool());
     }
     m_listItem = qmlContext(this)->contextProperty("styledItem").value<UCListItem*>();
+    // get the flickable value
+    if (m_listItem) {
+        m_flickable = UCListItemPrivate::get(m_listItem)->flickable.data();
+    }
 }
 
 void UCListItemStyle::componentComplete()
 {
     QQuickItem::componentComplete();
 
-    // look for overridden slots
-    for (int i = metaObject()->methodOffset(); i < metaObject()->methodCount(); i++) {
-        const QMetaMethod method = metaObject()->method(i);
-        if (method.name() == QByteArrayLiteral("swipeEvent")) {
-            m_swipeEvent = method;
-        } else if (method.name() == QByteArrayLiteral("rebound")) {
-            m_rebound = method;
-        }
-    }
+    // look for overridden slots, indexOfMethod returns th elast index of the overridden method
+    m_rebound = metaObject()->method(metaObject()->indexOfMethod("rebound()"));
+    m_swipeEvent = metaObject()->method(metaObject()->indexOfMethod("swipeEvent(QVariant)"));
+//    qDebug() << m_rebound.isValid() << m_swipeEvent.isValid();
+//    for (int i = metaObject()->methodOffset(); i < metaObject()->methodCount(); i++) {
+//        const QMetaMethod method = metaObject()->method(i);
+//        if (method.name() == QByteArrayLiteral("swipeEvent")) {
+//            qDebug() << method.methodSignature();
+//            m_swipeEvent = method;
+//        } else if (method.name() == QByteArrayLiteral("rebound")) {
+//            m_rebound = method;
+//        }
+//    }
 
     // connect snapAnimation's stopped() and the owning ListItem's contentMovementeEnded() signals
     if (m_listItem && m_snapAnimation) {
@@ -92,6 +102,25 @@
 }
 
 /*!
+ * \qmlproperty Flickable ListItemStyle::flickable
+ * \readonly
+ * \since Ubuntu.Components.Styles 1.3
+ * The property holds the Flickable (or ListView) holding the ListItem styled.
+ */
+QQuickFlickable *UCListItemStyle::flickable()
+{
+    return m_flickable;
+}
+void UCListItemStyle::updateFlickable(QQuickFlickable *flickable)
+{
+    if (m_flickable == flickable) {
+        return;
+    }
+    m_flickable = flickable;
+    Q_EMIT flickableChanged();
+}
+
+/*!
  * \qmlmethod ListItemStyle::swipeEvent(SwipeEvent event)
  * The function is called by the ListItem when a swipe action is performed, i.e.
  * when the swipe is started, the position is updated or the swipe ends. The

=== modified file 'src/Ubuntu/Components/plugin/uclistitemstyle.h'
--- src/Ubuntu/Components/plugin/uclistitemstyle.h	2015-04-13 13:42:03 +0000
+++ src/Ubuntu/Components/plugin/uclistitemstyle.h	2015-09-04 10:38:07 +0000
@@ -62,6 +62,7 @@
 class QQuickPropertyAnimation;
 class QQuickBehavior;
 class UCListItem;
+class QQuickFlickable;
 class UCListItemStyle : public QQuickItem
 {
     Q_OBJECT
@@ -70,6 +71,7 @@
     Q_PROPERTY(bool animatePanels READ animatePanels NOTIFY animatePanelsChanged)
     Q_PROPERTY(QQuickItem *dragPanel MEMBER m_dragPanel NOTIFY dragPanelChanged)
     Q_PROPERTY(int listItemIndex READ index NOTIFY listItemIndexChanged FINAL REVISION 1)
+    Q_PROPERTY(QQuickFlickable *flickable READ flickable NOTIFY flickableChanged REVISION 1)
 public:
     explicit UCListItemStyle(QQuickItem *parent = 0);
 
@@ -78,6 +80,8 @@
     bool animatePanels() const;
     void setAnimatePanels(bool animate);
     int index();
+    QQuickFlickable *flickable();
+    void updateFlickable(QQuickFlickable *flickable);
 
 Q_SIGNALS:
     void snapAnimationChanged();
@@ -85,6 +89,7 @@
     void animatePanelsChanged();
     void dragPanelChanged();
     Q_REVISION(1) void listItemIndexChanged();
+    Q_REVISION(1) void flickableChanged();
 
 public Q_SLOTS:
     void swipeEvent(UCSwipeEvent *event);
@@ -102,6 +107,7 @@
     QQuickAbstractAnimation *m_snapAnimation;
     QQuickPropertyAnimation *m_dropAnimation;
     QQuickItem *m_dragPanel;
+    QQuickFlickable *m_flickable;
     bool m_animatePanels:1;
 
     friend class UCListItemPrivate;

=== modified file 'src/Ubuntu/Components/plugin/ucviewitemsattached.cpp'
--- src/Ubuntu/Components/plugin/ucviewitemsattached.cpp	2015-03-17 16:48:59 +0000
+++ src/Ubuntu/Components/plugin/ucviewitemsattached.cpp	2015-09-04 10:38:07 +0000
@@ -104,6 +104,7 @@
     : QObjectPrivate()
     , listView(0)
     , dragArea(0)
+    , expansionFlags(UCViewItemsAttached::Exclusive)
     , globalDisabled(false)
     , selectable(false)
     , draggable(false)
@@ -556,7 +557,7 @@
         return;
     }
     dragArea = new ListItemDragArea(listView);
-    dragArea->init();
+    dragArea->init(q_func());
 }
 
 void UCViewItemsAttachedPrivate::leaveDragMode()
@@ -611,3 +612,142 @@
         Q_EMIT q->selectedIndicesChanged();
     }
 }
+
+
+UCViewItemsAttached13::UCViewItemsAttached13(QObject *owner)
+    : UCViewItemsAttached(owner)
+{
+    d_ptr = UCViewItemsAttachedPrivate::get(this);
+}
+
+UCViewItemsAttached13 *UCViewItemsAttached13::qmlAttachedProperties(QObject *owner)
+{
+    return new UCViewItemsAttached13(owner);
+}
+
+/*!
+ * \qmlattachedproperty list<int> ViewItems::expandedIndices
+ * \since Ubuntu.Components 1.3
+ * The property contains the indexes of the ListItems marked as expanded. The
+ * indexes are model indexes when used in ListView, and child indexes in other
+ * components. The property being writable, initial expansion configuration
+ * can be provided for a view, and provides ability to save the expansion state.
+ * \note If the \l ViewItems::expansionFlags is having \c ViewItems.Exclusive
+ * flags set, only the last item from the list will be considered and set as
+ * expanded.
+ */
+QList<int> UCViewItemsAttached13::expandedIndices() const
+{
+    Q_D(const UCViewItemsAttached);
+    return d->expansionList.keys();
+}
+void UCViewItemsAttached13::setExpandedIndices(QList<int> indices)
+{
+    Q_UNUSED(indices);
+    Q_D(UCViewItemsAttached);
+    d->collapseAll();
+    if (indices.size() > 0) {
+        if (d->expansionFlags & UCViewItemsAttached::Exclusive) {
+            // take only the last one from the list
+            d->expand(indices.last(), QPointer<UCListItem13>(), false);
+        } else {
+            for (int i = 0; i < indices.size(); i++) {
+                d->expand(indices[i], QPointer<UCListItem13>(), false);
+            }
+        }
+    }
+    Q_EMIT expandedIndicesChanged(d->expansionList.keys());
+}
+
+// insert listItem into the expanded indices map
+void UCViewItemsAttachedPrivate::expand(int index, UCListItem13 *listItem, bool emitChangeSignal)
+{
+    expansionList.insert(index, QPointer<UCListItem13>(listItem));
+    if (listItem && ((expansionFlags & UCViewItemsAttached::CollapseOnOutsidePress) == UCViewItemsAttached::CollapseOnOutsidePress)) {
+        listItem->expansion()->enableClickFiltering(true);
+    }
+    if (emitChangeSignal) {
+        Q_EMIT static_cast<UCViewItemsAttached13*>(q_func())->expandedIndicesChanged(expansionList.keys());
+    }
+}
+
+// collapse the item at index
+void UCViewItemsAttachedPrivate::collapse(int index, bool emitChangeSignal)
+{
+    UCListItem13 *item = expansionList.take(index).data();
+    bool wasExpanded = item && item->expansion()->expanded();
+    if (item && ((expansionFlags & UCViewItemsAttached::CollapseOnOutsidePress) == UCViewItemsAttached::CollapseOnOutsidePress)) {
+        item->expansion()->enableClickFiltering(false);
+    }
+    if (emitChangeSignal && wasExpanded) {
+        Q_EMIT static_cast<UCViewItemsAttached13*>(q_func())->expandedIndicesChanged(expansionList.keys());
+    }
+}
+
+void UCViewItemsAttachedPrivate::collapseAll()
+{
+    bool emitChangedSignal = (expansionList.keys().size() > 0);
+    while (expansionList.keys().size() > 0) {
+        collapse(expansionList.keys().last(), false);
+    }
+    if (emitChangedSignal) {
+        Q_EMIT static_cast<UCViewItemsAttached13*>(q_func())->expandedIndicesChanged(expansionList.keys());
+    }
+}
+
+/*!
+ * \qmlattachedproperty ExpansionFlags ViewItems::expansionFlags
+ * \since Ubuntu.Components 1.3
+ * Flags driving the expansion behavior.
+ * \table
+ * \header
+ *  \li Flag
+ *  \li description
+ * \row
+ *  \li ViewItems.Exclusive
+ *  \li When set, only one ListItem can be expanded at a time. \b {Set by default}.
+ * \row
+ *  \li ViewItems.UnlockExpanded
+ *  \li When set, the ListItem's leading/trailing actions can be swiped in.
+ * \row
+ *  \li ViewItems.CollapseOnOutsidePress
+ *  \li When set, the active expaned ListItem collapses automatically when clicked
+ *      outside of its area. The flag also turns \c ViewItems.Exclusive flag on.
+ * \endtable
+ */
+int UCViewItemsAttached13::expansionFlags() const
+{
+    Q_D(const UCViewItemsAttached);
+    return d->expansionFlags;
+}
+void UCViewItemsAttached13::setExpansionFlags(int flags)
+{
+    Q_D(UCViewItemsAttached);
+    if (d->expansionFlags == (ExpansionFlags)flags) {
+        return;
+    }
+
+    // disable current flag based restrictions
+    d->toggleExpansionFlags(false);
+    d->expansionFlags = (ExpansionFlags)flags;
+    // enable flag based restrictions
+    d->toggleExpansionFlags(true);
+    Q_EMIT expansionFlagsChanged();
+}
+
+void UCViewItemsAttachedPrivate::toggleExpansionFlags(bool enable)
+{
+    bool hasClickOutsideFlag = (expansionFlags & UCViewItemsAttached::CollapseOnOutsidePress) == UCViewItemsAttached::CollapseOnOutsidePress;
+    if (!hasClickOutsideFlag) {
+        return;
+    }
+    QMapIterator<int, QPointer<UCListItem13> > i(expansionList);
+    while (i.hasNext()) {
+        UCListItem13 *item = i.next().value().data();
+        // using expansion getter we will get the group created
+        if (item && item->expansion()) {
+            UCListItemPrivate *listItem = UCListItemPrivate::get(item);
+            listItem->expansion->enableClickFiltering(enable);
+        }
+    }
+}

=== added file 'tests/resources/listitems/ListItemExpansion.qml'
--- tests/resources/listitems/ListItemExpansion.qml	1970-01-01 00:00:00 +0000
+++ tests/resources/listitems/ListItemExpansion.qml	2015-09-04 10:38:07 +0000
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2015 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/>.
+ */
+
+import QtQuick 2.4
+import QtQuick.Layouts 1.1
+import Ubuntu.Components 1.3
+
+MainView {
+    id: main
+    width: units.gu(40)
+    height: units.gu(71)
+
+    Action {
+        id: deleteAction
+        iconName: "delete"
+    }
+    property list<Action> contextualActions: [
+        Action {
+            iconName: "edit"
+        },
+        Action {
+            iconName: "share"
+        },
+        Action {
+            iconName: "stock_website"
+        }
+    ]
+    Page {
+        title: "Expansion"
+        Column {
+            anchors.fill: parent
+            spacing: units.dp(4)
+            UbuntuListView {
+                id: listView
+                onEnabledChanged: print("enabled", enabled)
+                width: parent.width
+                height: parent.height / 2
+                clip: true
+                ViewItems.onExpandedIndicesChanged: print(ViewItems.expandedIndices)
+                ViewItems.expansionFlags: ViewItems.CollapseOnOutsidePress
+
+                model: ListModel {
+                    Component.onCompleted: {
+                        for (var i = 0; i < 3; i++) {
+                            append({label: "List item #"+i, sectionData: "Locked"});
+                        }
+                        for (i = 3; i < 11; i++) {
+                            append({label: "List item #"+i, sectionData: "Limited, live move"});
+                        }
+                        for (i = 11; i < 25; i++) {
+                            append({label: "List item #"+i, sectionData: "Unlimited, drag'n'drop"});
+                        }
+                    }
+                }
+
+                delegate: ListItem {
+                    id: item
+                    objectName: "ListItem-" + index
+                    leadingActions: ListItemActions {
+                        actions: deleteAction
+                    }
+                    trailingActions: ListItemActions {
+                        actions: contextualActions
+                    }
+                    expansion.height: units.gu(15)
+
+                    RowLayout {
+                        anchors {
+                            fill: parent
+                            margins: units.gu(0.5)
+                            leftMargin: anchors.rightMargin
+                            rightMargin: units.gu(2)
+                        }
+                        Captions {
+                            id: captions
+                            title.text: label
+                            subtitle.text: "from index #" + index
+                        }
+                        Button {
+                            text: "Enable drag mode"
+                            onClicked: listView.ViewItems.dragMode = true
+                        }
+                    }
+
+                    onPressAndHold: {
+                        print("expand/collapse")
+                        expansion.expanded = !expansion.expanded
+                    }
+                }
+            }
+            ListItem {
+                Label { text: "Standalone ListItem" }
+                expansion.height: units.gu(15)
+                onPressAndHold: expansion.expanded = !expansion.expanded;
+            }
+            ListItem {
+                Label { text: "Other Standalone ListItem" }
+                expansion.height: units.gu(15)
+                onPressAndHold: expansion.expanded = !expansion.expanded;
+            }
+
+            Button {
+                text: "Set ListView.ViewItems.expandedIndices"
+                onClicked: listView.ViewItems.expandedIndices = [0, 1, 2]
+            }
+        }
+    }
+}

=== modified file 'tests/unit_x11/tst_components/ListItemTestCase.qml'
--- tests/unit_x11/tst_components/ListItemTestCase.qml	2015-08-31 07:50:45 +0000
+++ tests/unit_x11/tst_components/ListItemTestCase.qml	2015-09-04 10:38:07 +0000
@@ -135,4 +135,9 @@
         mouseRelease(dragArea, dragPos.x, dragPos.y + dy);
         spyWait();
     }
+
+    function expand(item, expand) {
+        item.expansion.expanded = expand;
+        wait(400);
+    }
 }

=== added file 'tests/unit_x11/tst_components/ListItemTestCase13.qml'
--- tests/unit_x11/tst_components/ListItemTestCase13.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_components/ListItemTestCase13.qml	2015-09-04 10:38:07 +0000
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2015 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/>.
+ */
+
+import QtQuick 2.4
+import QtTest 1.0
+import Ubuntu.Test 1.0
+import Ubuntu.Components 1.3
+
+/*
+ * Common test case functions for ListItem. A CPO for unit tests.
+ */
+UbuntuTestCase {
+    when: windowShown
+
+    SignalSpy {
+        id: signalSpy
+    }
+
+    // set up the spy component for an item and a signal
+    function setupSpy(item, signalName) {
+        if (item.hasOwnProperty("leadingActions")) {
+            signalSpy.target = item;
+            signalSpy.signalName = signalName;
+            signalSpy.clear();
+        }
+    }
+    // wait on the previosuly set up spy
+    function spyWait(timeout) {
+        if (timeout == undefined) {
+            timeout = 500;
+        }
+        if (signalSpy.target) {
+            signalSpy.wait(timeout);
+            signalSpy.clear();
+            signalSpy.target = null;
+        } else {
+            wait(timeout);
+        }
+    }
+
+    // rebounds a ListItem
+    function rebound(item, watchTarget) {
+        if (watchTarget === undefined) {
+            watchTarget = item;
+        }
+
+        if (watchTarget.contentItem.x != watchTarget.contentItem.anchors.leftMargin) {
+            mouseClick(item, 1, 1);
+            tryCompareFunction(function() {
+                return watchTarget.contentItem.x == watchTarget.contentItem.anchors.leftMargin;
+            }, true, 500);
+        }
+    }
+
+    // delayed swipe, gives few millisecond timeout between each move
+    // so Repeater has time to create the panel actions in style
+    function swipe(item, x, y, dx, dy) {
+        setupSpy(item, "contentMovementEnded");
+        flick(item, x, y, dx, dy, 0, 0, undefined, undefined, 100);
+        spyWait();
+    }
+    function swipeNoWait(item, x, y, dx, dy) {
+        flick(item, x, y, dx, dy, 0, 0, undefined, undefined, 100);
+    }
+
+    function tug(item, x, y, dx, dy) {
+        setupSpy(item, "contentMovementEnded");
+        TestExtras.touchDrag(0, item, Qt.point(x, y), Qt.point(dx, dy));
+        spyWait();
+    }
+
+    // returns the leading or trailing panel item
+    function panelItem(item, leading) {
+        return findInvisibleChild(item, (leading ? "ListItemPanelLeading" : "ListItemPanelTrailing"));
+    }
+
+    function toggleSelectMode(view, enabled, scrollToTop) {
+        if (view.hasOwnProperty("positionViewAtBeginning") && scrollToTop) {
+            // use the topmost listItem to wait for rendering completion
+            view.positionViewAtBeginning();
+        }
+        var listItem = findChild(view, "listItem0");
+        verify(listItem);
+        view.ViewItems.selectMode = enabled;
+        // waitForRendering aint seems to be reliable here, so we wait ~400 msecs
+        wait(400);
+    }
+
+    function toggleDragMode(view, enabled) {
+        // use the topmost listItem to wait for rendering completion
+        view.positionViewAtBeginning();
+        var listItem = findChild(view, "listItem0");
+        verify(listItem);
+        view.ViewItems.dragMode = enabled;
+        // waitForRendering aint seems to be reliable here, so we wait ~400 msecs
+        wait(400);
+    }
+
+    function drag(view, from, to) {
+        var dragArea = findChild(view, "drag_area");
+        verify(dragArea, "Cannot locate drag area");
+
+        // grab the source item
+        view.positionViewAtBeginning(from,ListView.Beginning);
+        var panel = findChild(view, "drag_panel" + from);
+        verify(panel, "Cannot locate source panel");
+        var dragPos = dragArea.mapFromItem(panel, centerOf(panel).x, centerOf(panel).y);
+        // move the mouse
+        var dy = Math.abs(to - from) * panel.height + units.gu(1);
+        dy *= (to > from) ? 1 : -1;
+        mousePress(dragArea, dragPos.x, dragPos.y);
+        wait(100);
+        var draggedItem = findChild(view.contentItem, "DraggedListItem");
+        if (draggedItem) {
+            setupSpy(draggedItem.__styleInstance.dropAnimation, "stopped");
+        }
+        // use 10 steps to be sure the move is properly detected by the drag area
+        mouseMoveSlowly(dragArea, dragPos.x, dragPos.y, 0, dy, 10, 100);
+        // drop it, needs two mouse releases, this generates the Drop event also
+        mouseRelease(dragArea, dragPos.x, dragPos.y + dy);
+        // needs one more mouse release
+        mouseRelease(dragArea, dragPos.x, dragPos.y + dy);
+        spyWait();
+    }
+
+    function expand(item, expand) {
+        item.expansion.expanded = expand;
+        wait(400);
+    }
+}

=== modified file 'tests/unit_x11/tst_components/tst_listitem.qml'
--- tests/unit_x11/tst_components/tst_listitem.qml	2015-07-31 06:55:59 +0000
+++ tests/unit_x11/tst_components/tst_listitem.qml	2015-09-04 10:38:07 +0000
@@ -17,7 +17,7 @@
 import QtQuick 2.4
 import QtTest 1.0
 import Ubuntu.Test 1.0
-import Ubuntu.Components 1.3
+import Ubuntu.Components 1.2
 import Ubuntu.Components.Styles 1.2
 import QtQml.Models 2.1
 
@@ -304,26 +304,6 @@
             clickSpy.wait();
         }
 
-        SignalSpy {
-            id: visibleSpy
-            signalName: "visibleChanged"
-        }
-
-        function test_context_menu() {
-            mouseClick(testItem, testItem.width / 2, testItem.height / 2, Qt.RightButton);
-            wait(1000);
-            compare(testItem.highlighted, true, "List item didn't highlight on right-click");
-            var context_menu = findChild(main, "listItemContextMenu");
-            verify(context_menu, "Context menu didn't open on right-click");
-            waitForRendering(context_menu);
-            var edit = findChildWithProperty(context_menu, "text", "Edit");
-            verify(edit, "Context menu has no 'Edit' item");
-            visibleSpy.target = context_menu;
-            mouseClick(edit, edit.width / 2, edit.height / 2);
-            compare(edit.text, 'Edit Again', "Item wasn't triggered'");
-            visibleSpy.wait()
-        }
-
         function test_no_click_when_swiped() {
             var item = findChild(listView, "listItem0");
             clickSpy.target = item;

=== added file 'tests/unit_x11/tst_components/tst_listitem13.qml'
--- tests/unit_x11/tst_components/tst_listitem13.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_components/tst_listitem13.qml	2015-09-04 10:38:07 +0000
@@ -0,0 +1,1211 @@
+/*
+ * Copyright 2015 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/>.
+ */
+
+import QtQuick 2.4
+import QtTest 1.0
+import Ubuntu.Test 1.0
+import Ubuntu.Components 1.3
+import Ubuntu.Components.Styles 1.3
+import QtQml.Models 2.1
+
+Item {
+    id: main
+    width: units.gu(50)
+    height: units.gu(100)
+
+    Action {
+        id: stockAction
+        iconName: "torch-on"
+        objectName: "stockAction"
+        text: 'Switch lights on'
+    }
+    ListItemActions {
+        id: leading
+        actions: [
+            Action {
+                iconName: "starred"
+                text: 'Bookmark'
+                objectName: "leading_1"
+            },
+            Action {
+                iconName: "edit"
+                text: 'Edit'
+                objectName: "leading_2"
+                onTriggered: text = 'Edit Again'
+            },
+            Action {
+                iconName: "camcorder"
+                text: 'Record'
+                objectName: "leading_3"
+            }
+        ]
+    }
+    ListItemActions {
+        id: trailing
+        actions: [
+            stockAction,
+        ]
+    }
+    ListItemActions {
+        id: actionsDefault
+    }
+    ListModel {
+        id: objectModel
+        function reset() {
+            clear();
+            for (var i = 0; i < 25; i++) {
+                append({data: i});
+            }
+        }
+        Component.onCompleted: reset()
+    }
+
+    Component {
+        id: customDelegate
+        Rectangle {
+            width: units.gu(10)
+            color: "green"
+            objectName: "custom_delegate"
+        }
+    }
+
+    Column {
+        id: testColumn
+        width: parent.width
+        ListItem {
+            id: defaults
+            width: parent.width
+        }
+        ListItem {
+            id: highlightTest
+        }
+        ListItem {
+            id: clickedConnected
+            onClicked: {}
+            onPressAndHold: {}
+        }
+        ListItem {
+            id: testItem
+            width: parent.width
+            color: "blue"
+            leadingActions: leading
+            trailingActions: trailing
+            Label {
+                id: bodyItem
+                anchors.fill: parent
+                text: "Data"
+            }
+        }
+        ListItem {
+            id: controlItem
+            Button {
+                id: button
+                objectName: "button_in_list"
+                anchors.centerIn: parent
+                text: "Button"
+            }
+        }
+        ListView {
+            id: listView
+            width: parent.width
+            height: units.gu(28)
+            clip: true
+            model: objectModel
+            ViewItems.selectMode: false
+            LayoutMirroring.childrenInherit: true
+            delegate: ListItem {
+                objectName: "listItem" + index
+                color: "lightgray"
+                leadingActions: leading
+                trailingActions: trailing
+                Label {
+                    text: "Data: " + modelData + " @" + index
+                }
+            }
+        }
+        Flickable {
+            id: testFlickable
+            width: parent.width
+            height: units.gu(21)
+            ListView {
+                id: nestedListView
+                width: parent.width
+                height: units.gu(28)
+                clip: true
+                model: 10
+                delegate: ListItem {
+                    objectName: "listItem" + index
+                    leadingActions: leading
+                }
+            }
+        }
+        Flickable {
+            id: flickable
+            width: parent.width
+            height: units.gu(14)
+            clip: true
+            contentHeight: column.height
+            Column {
+                id: column
+                width: parent.width
+                Repeater {
+                    model: 10
+                    ListItem {
+                        objectName: "listItem" + index
+                        color: "lightgreen"
+                    }
+                }
+            }
+        }
+    }
+
+    ListItemTestCase13 {
+        id: testCase
+        name: "ListItem13API"
+        when: windowShown
+
+        SignalSpy {
+            id: movingSpy
+            signalName: "contentMovementEnded"
+        }
+        SignalSpy {
+            id: highlightedSpy
+            signalName: "highlightedChanged"
+            target: testItem
+        }
+
+        SignalSpy {
+            id: clickSpy
+            signalName: "clicked"
+            target: testItem;
+        }
+
+        SignalSpy {
+            id: actionSpy
+            signalName: "onTriggered"
+        }
+        SignalSpy {
+            id: interactiveSpy
+            signalName: "interactiveChanged"
+        }
+
+        SignalSpy {
+            id: dropSpy
+            signalName: "stopped"
+        }
+
+        function initTestCase() {
+            TestExtras.registerTouchDevice();
+            waitForRendering(main);
+        }
+
+        function cleanup() {
+            listView.model = objectModel;
+            testItem.action = null;
+            testItem.contentItem.anchors.margins = 0;
+            testItem.selected = false;
+            testColumn.ViewItems.selectMode = false;
+            waitForRendering(testItem.contentItem, 200);
+            controlItem.selected = false;
+            waitForRendering(controlItem.contentItem, 200);
+            movingSpy.clear();
+            highlightedSpy.clear();
+            clickSpy.clear();
+            actionSpy.clear();
+            pressAndHoldSpy.clear();
+            buttonSpy.clear();
+            interactiveSpy.clear();
+            listView.interactive = true;
+            listView.ViewItems.selectMode = false;
+            listView.ViewItems.dragMode = false;
+            // make sure we collapse
+            mouseClick(defaults, 0, 0)
+            movingSpy.target = null;
+            movingSpy.clear();
+            interactiveSpy.target = null;
+            interactiveSpy.clear();
+            trailing.delegate = null;
+            listView.positionViewAtBeginning();
+            // keep additional timeout for proper cleanup
+            wait(200);
+        }
+
+        function test_0_defaults() {
+            verify(defaults.contentItem !== null, "Defaults is null");
+            compare(defaults.color, "#000000", "Transparent by default");
+            compare(defaults.highlightColor, theme.palette.selected.background, "theme.palette.selected.background color by default")
+            compare(defaults.highlighted, false, "Not highlighted by default");
+            compare(defaults.divider.visible, true, "divider is visible by default");
+            compare(defaults.divider.anchors.leftMargin, 0, "divider's left margin is 0");
+            compare(defaults.divider.anchors.rightMargin, 0, "divider's right margin is 0");
+            var mappedDividerPos = defaults.mapFromItem(defaults.divider, defaults.divider.x, defaults.divider.y);
+            compare(mappedDividerPos.x, 0, "divider's left anchor is wrong");
+            compare(mappedDividerPos.x + defaults.divider.width, defaults.width, "divider's right anchor is wrong");
+            compare(defaults.divider.height, units.dp(2), "divider's thickness is wrong");
+            compare(defaults.divider.colorFrom, "#000000", "colorFrom differs.");
+            fuzzyCompare(defaults.divider.colorFrom.a, 0.14, 0.01, "colorFrom alpha differs");
+            compare(defaults.divider.colorTo, "#ffffff", "colorTo differs.");
+            fuzzyCompare(defaults.divider.colorTo.a, 0.07, 0.01, "colorTo alpha differs");
+            compare(defaults.action, null, "No action by default.");
+            compare(defaults.style, null, "Style is loaded upon first use.");
+            compare(defaults.__styleInstance, null, "__styleInstance must be null.");
+            compare(defaults.selected, false, "Not selected by default");
+            compare(defaults.selectMode, false, "Not selectable by default");
+            compare(testColumn.ViewItems.selectMode, false, "The parent attached property is not selectable by default");
+            compare(testColumn.ViewItems.selectedIndices.length, 0, "No item is selected by default");
+            compare(listView.ViewItems.dragMode, false, "Drag mode is off on ListView");
+
+            compare(actionsDefault.delegate, null, "ListItemActions has no delegate set by default.");
+            compare(actionsDefault.actions.length, 0, "ListItemActions has no actions set.");
+        }
+
+        Component { id: customStyle; ListItemStyle {} }
+
+        function test_children_in_content_item() {
+            compare(bodyItem.parent, testItem.contentItem, "Content is not in the right holder!");
+        }
+
+        function test_highlightedChanged_on_click() {
+            highlightedSpy.target = testItem;
+            mousePress(testItem, testItem.width / 2, testItem.height / 2);
+            highlightedSpy.wait();
+            mouseRelease(testItem, testItem.width / 2, testItem.height / 2);
+        }
+        function test_highlightedChanged_on_tap() {
+            highlightedSpy.target = testItem;
+            TestExtras.touchPress(0, testItem, centerOf(testItem));
+            highlightedSpy.wait();
+            TestExtras.touchRelease(0, testItem, centerOf(testItem));
+            // local cleanup, wait few msecs to suppress double tap
+            wait(400);
+        }
+
+        function test_clicked_on_mouse() {
+            clickSpy.target = testItem;
+            mouseClick(testItem, testItem.width / 2, testItem.height / 2);
+            clickSpy.wait();
+        }
+        function test_clicked_on_tap() {
+            clickSpy.target = testItem;
+            TestExtras.touchClick(0, testItem, centerOf(testItem));
+            clickSpy.wait();
+        }
+
+        SignalSpy {
+            id: visibleSpy
+            signalName: "visibleChanged"
+        }
+
+        function test_context_menu() {
+            mouseClick(testItem, testItem.width / 2, testItem.height / 2, Qt.RightButton);
+            wait(1000);
+            compare(testItem.highlighted, true, "List item didn't highlight on right-click");
+            var context_menu = findChild(main, "listItemContextMenu");
+            verify(context_menu, "Context menu didn't open on right-click");
+            waitForRendering(context_menu);
+            var edit = findChildWithProperty(context_menu, "text", "Edit");
+            verify(edit, "Context menu has no 'Edit' item");
+            visibleSpy.target = context_menu;
+            mouseClick(edit, edit.width / 2, edit.height / 2);
+            compare(edit.text, 'Edit Again', "Item wasn't triggered'");
+            visibleSpy.wait()
+        }
+
+        function test_no_click_when_swiped() {
+            var item = findChild(listView, "listItem0");
+            clickSpy.target = item;
+            clickSpy.clear();
+            swipe(item, centerOf(item).x, centerOf(item).y, units.gu(20), 0);
+
+            // click over the contentItem
+            movingSpy.target = item;
+            mouseClick(item.contentItem, 1, 1);
+            compare(clickSpy.count, 0, "No click() should be emitted on a swiped in ListItem.");
+            movingSpy.wait();
+        }
+
+        function test_no_pressAndHold_when_swiped() {
+            var item = findChild(listView, "listItem0");
+            pressAndHoldSpy.target = item;
+            pressAndHoldSpy.clear();
+            swipe(item, centerOf(item).x, centerOf(item).y, units.gu(20), 0);
+
+            // press and hold
+            movingSpy.target = item;
+            mouseLongPress(item.contentItem, 1, 1);
+            mouseRelease(item.contentItem, 1, 1);
+            mouseRelease(item.contentItem, 1, 1);
+            compare(pressAndHoldSpy.count, 0, "No pressAndHold() should be emitted on a swiped in ListItem.");
+            movingSpy.wait();
+        }
+
+        function test_vertical_listview_move_cancels_highlight_data() {
+            return [
+                {tag: "With touch", mouse: false},
+                {tag: "With mouse", mouse: true},
+            ];
+        }
+        function test_vertical_listview_move_cancels_highlight(data) {
+            var listItem = findChild(listView, "listItem0");
+            verify(listItem, "Cannot find listItem0");
+
+            // convert positions and use the listView to move
+            var pos = listView.mapFromItem(listItem, listItem.width / 2, 0);
+            if (data.mouse) {
+                // provide slow move
+                mousePress(listView, pos.x, pos.y);
+                for (var i = 1; i < 4; i++) {
+                    pos.y += i * units.gu(0.5);
+                    mouseMove(listView, pos.x, pos.y, 100);
+                }
+                compare(listItem.highlighted, false, "highlighted still!");
+                mouseRelease(listView, pos.x, pos.y, undefined, undefined, 100);
+            } else {
+                // convert pos to point otherwise touch functions will get (0,0) points!!!
+                var pt = Qt.point(pos.x, pos.y);
+                TestExtras.touchPress(0, listView, pt);
+                for (i = 1; i < 4; i++) {
+                    pt.y += i * units.gu(0.5);
+                    TestExtras.touchMove(0, listView, pt);
+                    wait(100);
+                }
+                compare(listItem.highlighted, false, "highlighted still!");
+                TestExtras.touchRelease(0, listView, pt);
+            }
+        }
+
+        function test_background_height_change_on_divider_visible() {
+            // make sure the testItem's divider is shown
+            testItem.divider.visible = true;
+            var margins = testItem.contentItem.anchors.topMargin + testItem.contentItem.anchors.bottomMargin;
+            compare(testItem.contentItem.height, testItem.height - margins - testItem.divider.height, "ListItem's background height must be less than the item itself.");
+            testItem.divider.visible = false;
+            waitForRendering(testItem.contentItem);
+            compare(testItem.contentItem.height, testItem.height - margins, "ListItem's background height must be the same as the item itself.");
+            testItem.divider.visible = true;
+        }
+
+        function test_tug_actions_data() {
+            var item = findChild(listView, "listItem0");
+            return [
+                {tag: "Trailing, mouse", item: item, pos: centerOf(item), dx: -units.gu(20), positiveDirection: false, mouse: true},
+                {tag: "Leading, mouse", item: item, pos: centerOf(item), dx: units.gu(20), positiveDirection: true, mouse: true},
+                {tag: "Trailing, touch", item: item, pos: centerOf(item), dx: -units.gu(20), positiveDirection: false, mouse: false},
+                {tag: "Leading, touch", item: item, pos: centerOf(item), dx: units.gu(20), positiveDirection: true, mouse: false},
+            ];
+        }
+        function test_tug_actions(data) {
+            listView.positionViewAtBeginning();
+            if (data.mouse) {
+                swipe(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            } else {
+                tug(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            }
+            if (data.positiveDirection) {
+                verify(data.item.contentItem.x > 0, data.tag + " actions did not show up");
+            } else {
+                verify(data.item.contentItem.x < 0, data.tag + " actions did not show up");
+            }
+
+            // dismiss
+            rebound(data.item);
+        }
+
+        function test_tug_ignored_on_right_button() {
+            listView.positionViewAtBeginning();
+            var item = findChild(listView, "listItem0");
+            movingSpy.target = item;
+            flick(item, centerOf(item).x, centerOf(item).y, units.gu(20), 0, 0, 0, Qt.RightButton, undefined, 100);
+            compare(movingSpy.count, 0, "Action panel should not budge!")
+        }
+
+        function test_rebound_when_pressed_outside_or_clicked_data() {
+            var item0 = findChild(listView, "listItem0");
+            var item1 = findChild(listView, "listItem1");
+            return [
+                {tag: "Click on an other Item", item: item0, pos: centerOf(item0), dx: -units.gu(20), clickOn: item1, mouse: true},
+                {tag: "Click on the same Item", item: item0, pos: centerOf(item0), dx: -units.gu(20), clickOn: item0, mouse: true},
+                {tag: "Tap on an other Item", item: item0, pos: centerOf(item0), dx: -units.gu(20), clickOn: item1, mouse: false},
+                {tag: "Tap on the same Item", item: item0, pos: centerOf(item0), dx: -units.gu(20), clickOn: item0, mouse: false},
+            ];
+        }
+        function test_rebound_when_pressed_outside_or_clicked(data) {
+            listView.positionViewAtBeginning();
+            if (data.mouse) {
+                swipe(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            } else {
+                tug(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            }
+            verify(data.item.contentItem.x != 0, "The component wasn't tugged!");
+            // dismiss
+            rebound(data.clickOn, data.item)
+        }
+
+        function test_listview_not_interactive_while_tugged_data() {
+            var item0 = findChild(listView, "listItem0");
+            var item1 = findChild(listView, "listItem1");
+            return [
+                {tag: "Trailing", item: item0, pos: centerOf(item0), dx: -units.gu(20), clickOn: item1, mouse: true},
+                {tag: "Leading", item: item0, pos: centerOf(item0), dx: units.gu(20), clickOn: item0.contentItem, mouse: true},
+                {tag: "Trailing", item: item0, pos: centerOf(item0), dx: -units.gu(20), clickOn: item1, mouse: false},
+                {tag: "Leading", item: item0, pos: centerOf(item0), dx: units.gu(20), clickOn: item0.contentItem, mouse: false},
+            ];
+        }
+        function test_listview_not_interactive_while_tugged(data) {
+            listView.positionViewAtBeginning();
+            interactiveSpy.target = listView;
+            compare(listView.interactive, true, "ListView is not interactive");
+            interactiveSpy.target = listView;
+            if (data.mouse) {
+                swipe(data.item, data.pos.x, data.pos.y, data.dx, data.dy);
+            } else {
+                tug(data.item, data.pos.x, data.pos.y, data.dx, data.dy);
+            }
+            // animation should no longer be running!
+            compare(listView.interactive, true, "The ListView is still non-interactive!");
+            compare(interactiveSpy.count, 2, "Less/more times changed!");
+            // check if it snapped in
+            verify(data.item.contentItem.x != 0.0, "Not snapped in!!");
+            // dismiss
+            rebound(data.clickOn, data.item);
+            fuzzyCompare(data.item.contentItem.x, data.item.contentItem.anchors.leftMargin, 0.1, "Not snapped out!!");
+        }
+
+        function test_visualized_actions_data() {
+            var listItem0 = findChild(listView, "listItem0");
+            var listItem1 = findChild(listView, "listItem1");
+            return [
+                {tag: "Leading actions", item: listItem0, leading: true, expected: ["leading_1", "leading_2", "leading_3"]},
+                {tag: "Trailing actions", item: listItem0, leading: false, expected: ["stockAction"]},
+            ];
+        }
+        function test_visualized_actions(data) {
+            swipe(data.item, centerOf(data.item).x, centerOf(data.item).y, data.leading ? units.gu(20) : -units.gu(20), 0);
+
+            // check if the action is visible
+            var panel = panelItem(data.item, data.leading);
+            verify(panel, "Panel not visible");
+            for (var i in data.expected) {
+                var actionItem = findChild(panel, data.expected[i]);
+                verify(actionItem, data.expected[i] + " action not found");
+            }
+            // dismiss
+            rebound(data.item);
+        }
+
+        function test_listitem_margins_data() {
+            var item = findChild(listView, "listItem1");
+            return [
+                {tag: "leading", item: item, dx: units.gu(10), leading: true},
+                {tag: "trailing", item: item, dx: -units.gu(10), leading: false}
+            ];
+        }
+        function test_listitem_margins(data) {
+            data.item.contentItem.anchors.margins = units.gu(1);
+            swipe(data.item, centerOf(data.item).x, centerOf(data.item).y, data.dx, 0);
+            var panel = panelItem(data.item, data.leading);
+            verify(panel && panel.visible, "Panel not visible.");
+            // cleanup
+            rebound(data.item);
+            compare(data.item.contentItem.x, units.gu(1), "contentItem.x differs from margin");
+            data.item.contentItem.anchors.margins = 0;
+        }
+
+        function test_selecting_action_rebounds_data() {
+            var item0 = findChild(listView, "listItem0");
+            return [
+                {tag: "With mouse", item: item0, pos: centerOf(item0), dx: units.gu(20), leading: true, select: "leading_1", mouse: true},
+                {tag: "With touch", item: item0, pos: centerOf(item0), dx: units.gu(20), leading: true, select: "leading_1", mouse: false},
+            ]
+        }
+        function test_selecting_action_rebounds(data) {
+            listView.positionViewAtBeginning();
+            if (data.mouse) {
+                swipe(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            } else {
+                tug(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            }
+            verify(data.item.contentItem.x > 0, "Not snapped in!");
+            var panel = panelItem(data.item, data.leading);
+            verify(panel, "panelItem not found");
+            var selectedAction = findChild(panel, data.select);
+            verify(selectedAction, "Cannot select action " + data.select);
+
+            // dismiss
+            movingSpy.target = data.item;
+            if (data.mouse) {
+                mouseClick(selectedAction, centerOf(selectedAction).x, centerOf(selectedAction).y);
+            } else {
+                TestExtras.touchClick(0, selectedAction, centerOf(selectedAction));
+            }
+            movingSpy.wait();
+            fuzzyCompare(data.item.contentItem.x, data.item.contentItem.anchors.leftMargin, 0.1, "Content not snapped out");
+        }
+
+        function test_custom_trailing_delegate() {
+            trailing.delegate = customDelegate;
+            listView.positionViewAtBeginning();
+            var item = findChild(listView, "listItem0");
+            movingSpy.target = item;
+            swipeNoWait(item, centerOf(item).x, centerOf(item).y, -units.gu(20), 0);
+            var panel = panelItem(item, false);
+            verify(panel, "Panel is not visible");
+            var custom = findChild(panel, "custom_delegate");
+            verify(custom, "Custom delegate not in use");
+            movingSpy.wait();
+            // cleanup
+            rebound(item);
+        }
+
+        // execute as last so we make sure we have the panel created
+        function test_snap_data() {
+            var listItem = findChild(listView, "listItem0");
+            verify(listItem, "ListItem cannot be found");
+
+            return [
+                // the list snaps out if the panel is dragged in > overshoot GU (hardcoded for now)
+                {tag: "Snap out leading", item: listItem, dx: units.gu(2), snapIn: false},
+                {tag: "Snap in leading", item: listItem, dx: units.gu(6), snapIn: true},
+                {tag: "Snap out trailing", item: listItem, dx: -units.gu(2), snapIn: false},
+                {tag: "Snap in trailing", item: listItem, dx: -units.gu(6), snapIn: true},
+            ];
+        }
+        function test_snap(data) {
+            swipe(data.item, centerOf(data.item).x, centerOf(data.item).y, data.dx, 0);
+            waitForRendering(data.item.contentItem, 400);
+            if (data.snapIn) {
+                verify(data.item.contentItem.x != 0.0, "Not snapped to be visible");
+                // cleanup
+                rebound(data.item);
+            } else {
+                tryCompareFunction(function() { return data.item.contentItem.x; }, data.item.contentItem.anchors.leftMargin, 1000, "Not snapped back");
+            }
+        }
+
+        function test_snap_gesture_data() {
+            var listItem = findChild(listView, "listItem0");
+            var front = Qt.point(listItem.contentItem.anchors.leftMargin + units.gu(1), listItem.height / 2);
+            var rear = Qt.point(listItem.width - (listItem.contentItem.anchors.rightMargin + units.gu(1)), listItem.height / 2);
+            return [
+                // the first dx must be big enough to drag the panel in, it is always the last dx value
+                // which decides the snap direction
+                {tag: "Snap out, leading", item: listItem, grabPos: front, dx: [units.gu(10), -units.gu(3)], snapIn: false},
+                {tag: "Snap in, leading", item: listItem, grabPos: front, dx: [units.gu(10), -units.gu(1), units.gu(1.5)], snapIn: true},
+                // have less first dx as the trailing panel is shorter
+                {tag: "Snap out, trailing", item: listItem, grabPos: rear, dx: [-units.gu(5), units.gu(2)], snapIn: false},
+                {tag: "Snap in, trailing", item: listItem, grabPos: rear, dx: [-units.gu(5), units.gu(1), -units.gu(1.5)], snapIn: true},
+            ];
+        }
+        function test_snap_gesture(data) {
+            // performe the moves
+            movingSpy.target = data.item;
+            var pos = data.grabPos;
+            mousePress(data.item, pos.x, pos.y);
+            for (var i in data.dx) {
+                var dx = data.dx[i];
+                mouseMoveSlowly(data.item, pos.x, pos.y, data.dx[i], 0, 5, 100);
+                pos.x += data.dx[i];
+            }
+            mouseRelease(data.item, pos.x, pos.y);
+            movingSpy.wait();
+
+            if (data.snapIn) {
+                // the contenTitem must be dragged in (snapIn)
+                verify(data.item.contentItem.x != 0.0, "Not snapped in!");
+                // dismiss
+                rebound(data.item);
+            } else {
+                fuzzyCompare(data.item.contentItem.x, data.item.contentItem.anchors.leftMargin, 0.1, "Not snapped out!");
+            }
+        }
+
+        function test_verify_action_value_data() {
+            listView.positionViewAtBeginning();
+            var item0 = findChild(listView, "listItem0");
+            var item1 = findChild(listView, "listItem1");
+            return [
+                // testItem is the child item @index 3 in the topmost Column.
+                {tag: "Standalone item, child index 3", item: testItem, result: 3},
+                {tag: "ListView, item index 0", item: item0, result: 0},
+                {tag: "ListView, item index 1", item: item1, result: 1},
+            ];
+        }
+        function test_verify_action_value(data) {
+            // tug actions in
+            swipe(data.item, 1, centerOf(data.item).y, units.gu(40), 0);
+            wait(2000);
+            verify(data.item.contentItem.x != data.item.contentItem.anchors.leftMargin, "Not snapped in");
+
+            var panel = panelItem(data.item, "Leading");
+            var action = findChild(panel, "leading_2");
+            verify(action, "actions panel cannot be reached");
+            // we test the action closest to the list item's contentItem
+            actionSpy.target = data.item.leadingActions.actions[1];
+
+            // select the action
+            movingSpy.target = data.item;
+            mouseClick(action, centerOf(action).x, centerOf(action).y);
+            movingSpy.wait();
+
+            // check the action param
+            actionSpy.wait();
+            // SignalSpy.signalArguments[0] is an array of arguments, where the index is set as index 0
+            var param = actionSpy.signalArguments[0];
+            compare(param[0], data.result, "Action parameter differs");
+        }
+
+        function test_highlight_data() {
+            return [
+                {tag: "No actions", item: highlightTest, x: centerOf(highlightTest).x, y: centerOf(highlightTest).y, pressed: false},
+                {tag: "Leading/trailing actions", item: testItem, x: centerOf(testItem).x, y: centerOf(testItem).y, pressed: true},
+                {tag: "Active component content", item: controlItem, x: units.gu(1), y: units.gu(1), pressed: true},
+                {tag: "Center of active component content", item: controlItem, x: centerOf(controlItem).x, y: centerOf(controlItem).y, pressed: false},
+                {tag: "clicked() connected", item: clickedConnected, x: centerOf(clickedConnected).x, y: centerOf(clickedConnected).y, pressed: true},
+            ];
+        }
+        function test_highlight(data) {
+            highlightedSpy.target = data.item;
+            mouseClick(data.item, data.x, data.y);
+            if (data.pressed) {
+                highlightedSpy.wait();
+            } else {
+                compare(highlightedSpy.count, 0, "Should not be highlighted!");
+            }
+        }
+
+        SignalSpy {
+            id: pressAndHoldSpy
+            signalName: "pressAndHold"
+        }
+        SignalSpy {
+            id: buttonSpy
+            signalName: "clicked"
+            target: button
+        }
+        function test_pressandhold_suppress_click() {
+            var center = centerOf(testItem);
+            pressAndHoldSpy.target = testItem;
+            clickSpy.target = testItem;
+            clickSpy.clear();
+            mouseLongPress(testItem, center.x, center.y);
+            mouseRelease(testItem, center.x, center.y);
+            pressAndHoldSpy.wait();
+            compare(clickSpy.count, 0, "Click must be suppressed when long pressed");
+        }
+
+        function test_pressandhold_not_emitted_when_swiped() {
+            var center = centerOf(testItem);
+            pressAndHoldSpy.target = testItem;
+            // move mouse slowly from left to right, the swipe threshold is 1.5 GU!!!,
+            // so any value less than that will emit pressAndHold
+            mouseMoveSlowly(testItem, center.x, center.y, units.gu(2), 0, 10, 100);
+            mouseRelease(testItem, center.x + units.gu(1), center.y);
+            compare(pressAndHoldSpy.count, 0, "pressAndHold should not be emitted!");
+            // make sure we have collapsed item
+            rebound(testItem);
+        }
+
+        function test_pressandhold_not_emitted_when_pressed_over_active_component() {
+            var press = centerOf(button);
+            pressAndHoldSpy.target = controlItem;
+            mouseLongPress(button, press.x, press.y);
+            compare(pressAndHoldSpy.count, 0, "")
+            mouseRelease(button, press.x, press.y);
+        }
+
+        function test_click_on_button_suppresses_listitem_click() {
+            buttonSpy.target = button;
+            clickSpy.target = controlItem;
+            mouseClick(button, centerOf(button).x, centerOf(button).y);
+            buttonSpy.wait();
+            compare(clickSpy.count, 0, "ListItem clicked() must be suppressed");
+        }
+
+        function test_pressandhold_connected_causes_highlight() {
+            highlightedSpy.target = clickedConnected;
+            mouseLongPress(clickedConnected, centerOf(clickedConnected).x, centerOf(clickedConnected).y);
+            highlightedSpy.wait();
+            mouseRelease(clickedConnected, centerOf(clickedConnected).x, centerOf(clickedConnected).y);
+        }
+
+        function test_listitem_blocks_ascendant_flickables() {
+            var listItem = findChild(nestedListView, "listItem0");
+            verify(listItem, "Cannot find test item");
+            interactiveSpy.target = testFlickable;
+            // tug leading
+            swipe(listItem, centerOf(listItem).x, centerOf(listItem).y, listItem.width / 2, 0);
+            // check if interactive got changed
+            interactiveSpy.wait();
+
+            // cleanup!!!
+            rebound(listItem);
+        }
+
+        function test_action_type_set() {
+            stockAction.parameterType = Action.None;
+            compare(stockAction.parameterType, Action.None, "No parameter type for stockAction!");
+            testItem.action = stockAction;
+            compare(stockAction.parameterType, Action.Integer, "No parameter type for stockAction!");
+        }
+
+        function test_action_triggered_on_clicked() {
+            testItem.action = stockAction;
+            actionSpy.target = stockAction;
+            mouseClick(testItem, centerOf(testItem).x, centerOf(testItem).y);
+            actionSpy.wait();
+        }
+
+        function test_action_suppressed_on_longpress() {
+            testItem.action = stockAction;
+            actionSpy.target = stockAction;
+            clickSpy.target = testItem;
+            pressAndHoldSpy.target = testItem;
+            mouseLongPress(testItem, centerOf(testItem).x, centerOf(testItem).y);
+            mouseRelease(testItem, centerOf(testItem).x, centerOf(testItem).y);
+            pressAndHoldSpy.wait();
+            compare(clickSpy.count, 0, "Click must be suppressed.");
+            compare(actionSpy.count, 0, "Action triggered must be suppressed");
+        }
+
+        function test_select_indices_updates_selected_items() {
+            listView.ViewItems.selectedIndices = [0,1,2];
+            toggleSelectMode(listView, true);
+            for (var i in listView.ViewItems.selectedIndices) {
+                var index = listView.ViewItems.selectedIndices[i];
+                var listItem = findChild(listView, "listItem" + index);
+                compare(listItem.selected, true, "ListItem at index " + index + " is not selected!");
+            }
+            toggleSelectMode(listView, false);
+            listView.ViewItems.selectedIndices = [];
+        }
+
+        function test_toggle_selectMode_data() {
+            return [
+                {tag: "When not selected", index: 0, selected: false},
+                {tag: "When selected", index: 0, selected: true},
+            ]
+        }
+        function test_toggle_selectMode(data) {
+            var listItem = findChild(listView, "listItem" + data.index)
+            verify(listItem, "Cannot get test item");
+            listItem.selected = data.selected;
+            toggleSelectMode(listView, true);
+            // testItem is the 4th child, so index is 3
+            verify(findChild(listItem, "selection_panel" + data.index), "Cannot find selection panel");
+            compare(listItem.contentItem.enabled, true, "contentItem is not disabled.");
+        }
+
+        SignalSpy {
+            id: selectedSpy
+            signalName: "selectedChanged"
+        }
+
+        function test_toggle_selected_data() {
+            return [
+                // item = <test-item>, clickOk: <item-to-click-on>, offsetX|Y: <clickOn offset clicked>
+                {tag: "Click over selection", selectableHolder: testColumn, item: controlItem, clickOn: "listitem_select", offsetX: units.gu(0.5), offsetY: units.gu(0.5), xfail: false},
+                {tag: "Click over contentItem", selectableHolder: testColumn, item: controlItem, clickOn: "ListItemHolder", offsetX: units.gu(0.5), offsetY: units.gu(0.5), xfail: true},
+                {tag: "Click over control", selectableHolder: testColumn, item: controlItem, clickOn: "button_in_list", offsetX: units.gu(0.5), offsetY: units.gu(0.5), xfail: true},
+            ];
+         }
+        function test_toggle_selected(data) {
+            // make test item selectable first, so the panel is created
+            toggleSelectMode(data.selectableHolder, true);
+            // get the control to click on
+            var clickOn = findChild(data.item, data.clickOn);
+            verify(clickOn, "control to be clicked on not found");
+            // click on the selection and check selected changed
+            selectedSpy.target = data.item;
+            selectedSpy.clear();
+            mouseClick(clickOn, data.offsetX, data.offsetY);
+            if (data.xfail) {
+                expectFail(data.tag, "Clicking anywhere else but selection panel should not toggle selection state!");
+            }
+            selectedSpy.wait();
+        }
+
+        SignalSpy {
+            id: selectedIndicesSpy
+            signalName: "selectedIndicesChanged"
+            target: listView.ViewItems
+        }
+
+        function test_selectedIndices_change() {
+            // move to the end of the view
+            listView.positionViewAtEnd();
+            var listItem = findChild(listView, "listItem" + (listView.count - 1));
+            verify(listItem, "Cannot get tested list item");
+            toggleSelectMode(listView, true, false);
+            selectedSpy.target = listItem;
+            selectedSpy.clear();
+
+            listItem.selected = true;
+            selectedSpy.wait();
+            selectedIndicesSpy.wait();
+        }
+
+        function test_no_tug_when_selectable() {
+            movingSpy.target = testItem;
+            toggleSelectMode(testColumn, true);
+
+            // try to tug leading
+            movingSpy.clear();
+            swipeNoWait(testItem, centerOf(testItem).x, centerOf(testItem).y, units.gu(10), 0);
+            compare(movingSpy.count, 0, "No tug allowed when in selection mode");
+        }
+
+        function test_selectable_and_click() {
+            toggleSelectMode(testColumn, true);
+
+            clickSpy.target = testItem;
+            mouseClick(testItem, centerOf(testItem).x, centerOf(testItem).y);
+            clickSpy.wait();
+        }
+
+        function test_selectable_and_pressandhold() {
+            toggleSelectMode(testColumn, true);
+
+            pressAndHoldSpy.target = testItem;
+            mouseLongPress(testItem, centerOf(testItem).x, centerOf(testItem).y);
+            mouseRelease(testItem, centerOf(testItem).x, centerOf(testItem).y);
+            pressAndHoldSpy.wait();
+        }
+
+        function test_proper_attached_properties_data() {
+            return [
+                {tag: "Attached to ListView", item: listView},
+                {tag: "Attached to Column in Flickable", item: column},
+            ];
+        }
+        function test_proper_attached_properties(data) {
+            var listItem = findChild(data.item, "listItem0");
+            verify(listItem, "ListItem not found!");
+            toggleSelectMode(data.item, true);
+            // check if the selection mode was activated by looking after the first selection panel
+            var panel = findChild(listItem, "selection_panel0");
+            // turn off selection mode so we have a proper cleanup
+            toggleSelectMode(data.item, true);
+            verify(panel, "Selection panel not found, wrong attached property target?");
+        }
+
+        function test_dragmode_availability_data() {
+            return [
+                {tag: "Attached to Column", item: testColumn, lookupOn: testItem, xfail: true},
+                {tag: "Attached to ListView", item: listView, lookupOn: findChild(listView, "listItem0"), xfail: false},
+            ];
+        }
+        function test_dragmode_availability(data) {
+            if (data.xfail) {
+                ignoreWarning(warningFormat(85, 5, "QML Column: Dragging mode requires ListView"));
+            }
+            data.item.ViewItems.dragMode = true;
+            wait(400);
+            var panel = findChild(data.lookupOn, "drag_panel0");
+            if (data.xfail) {
+                expectFailContinue(data.tag, "There should be no drag handler shown!")
+            }
+            verify(panel, "No drag handler found!");
+        }
+
+        function test_drag_data() {
+            return [
+                {tag: "Live 0->1 OK", live: true, from: 0, to: 1, count: 1, accept: true, indices:[1,0,2,3,4]},
+                {tag: "Live 0->2 OK", live: true, from: 0, to: 2, count: 2, accept: true, indices:[1,2,0,3,4]},
+                {tag: "Live 0->3 OK", live: true, from: 0, to: 3, count: 3, accept: true, indices:[1,2,3,0,4]},
+                {tag: "Live 3->0 OK", live: true, from: 3, to: 0, count: 3, accept: true, indices:[3,0,1,2,4]},
+                        // do not accept moves
+                {tag: "Live 0->1 NOK", live: true, from: 0, to: 1, count: 0, accept: false, indices:[0,1,2,3,4]},
+                {tag: "Live 0->2 NOK", live: true, from: 0, to: 2, count: 0, accept: false, indices:[0,1,2,3,4]},
+                {tag: "Live 0->3 NOK", live: true, from: 0, to: 3, count: 0, accept: false, indices:[0,1,2,3,4]},
+                {tag: "Live 3->0 NOK", live: true, from: 3, to: 0, count: 0, accept: false, indices:[0,1,2,3,4]},
+
+                        // non-live updates
+                {tag: "Drop 0->1 OK", live: false, from: 0, to: 1, count: 1, accept: true, indices:[1,0,2,3,4]},
+                {tag: "Drop 0->2 OK", live: false, from: 0, to: 2, count: 1, accept: true, indices:[1,2,0,3,4]},
+                {tag: "Drop 0->3 OK", live: false, from: 0, to: 3, count: 1, accept: true, indices:[1,2,3,0,4]},
+                {tag: "Drop 3->0 OK", live: false, from: 3, to: 0, count: 1, accept: true, indices:[3,0,1,2,4]},
+                        // do not accept moves
+                {tag: "Drop 0->1 NOK", live: false, from: 0, to: 1, count: 0, accept: false, indices:[0,1,2,3,4]},
+                {tag: "Drop 0->2 NOK", live: false, from: 0, to: 2, count: 0, accept: false, indices:[0,1,2,3,4]},
+                {tag: "Drop 0->3 NOK", live: false, from: 0, to: 3, count: 0, accept: false, indices:[0,1,2,3,4]},
+                {tag: "Drop 3->0 NOK", live: false, from: 3, to: 0, count: 0, accept: false, indices:[0,1,2,3,4]},
+            ];
+        }
+
+        function test_drag(data) {
+            var moveCount = 0;
+            function liveUpdate(event) {
+                if (event.status == ListItemDrag.Started) {
+                    return;
+                }
+                if (data.accept) {
+                    moveCount++;
+                    listView.model.move(event.from, event.to, 1);
+                }
+                event.accept = data.accept;
+            }
+            function singleDrop(event) {
+                if (event.status == ListItemDrag.Dropped) {
+                    if (data.accept) {
+                        moveCount++;
+                        listView.model.move(event.from, event.to, 1);
+                    }
+                    event.accept = data.accept;
+                } else if (event.status == ListItemDrag.Moving) {
+                    event.accept = false;
+                }
+            }
+
+            objectModel.reset();
+            waitForRendering(listView);
+            listView.positionViewAtBeginning();
+            var func = data.live ? liveUpdate : singleDrop;
+            listView.ViewItems.dragUpdated.connect(func);
+
+            // enter drag mode
+            toggleDragMode(listView, true);
+            drag(listView, data.from, data.to);
+            compare(moveCount, data.count, "Move did not happen or more than one item was moved");
+            // compare array indices
+            for (var i in data.indices) {
+                compare(listView.model.get(i).data, data.indices[i], "data at index " + i + " is not the expected one");
+            }
+
+            // cleanup
+            listView.ViewItems.dragUpdated.disconnect(func);
+            toggleDragMode(listView, false);
+        }
+
+        // preconditions:
+        // the first 2 items cannot be dragged anywhere, nothing can be dropped in this area
+        // the 3-> items can be interchanged in between, cannot be dragged outside
+        function test_drag_restricted_data() {
+            return [
+                {tag: "[0,1] locked, drag 0->1 NOK", from: 0, to: 1, count: 0, indices: [0,1,2,3,4]},
+                {tag: "[0,1] locked, drag 1->2 NOK", from: 1, to: 2, count: 0, indices: [0,1,2,3,4]},
+                {tag: "[0,1] locked, drag 2->1 NOK", from: 2, to: 1, count: 0, indices: [0,1,2,3,4]},
+                {tag: "[0,1] locked, drag 2->0 NOK", from: 2, to: 0, count: 0, indices: [0,1,2,3,4]},
+                        // drag
+                {tag: "[0,1] locked, drag 2->3 OK", from: 2, to: 3, count: 1, indices: [0,1,3,2,4]},
+            ];
+        }
+        function test_drag_restricted(data) {
+            var moveCount = 0;
+            function updateHandler(event) {
+                if (event.status == ListItemDrag.Started) {
+                    if (event.from < 2) {
+                        event.accept = false;
+                    } else {
+                        event.minimumIndex = 2;
+                    }
+                } else if (event.status == ListItemDrag.Moving) {
+                    listView.model.move(event.from, event.to, 1);
+                    moveCount++;
+                }
+            }
+
+            objectModel.reset();
+            waitForRendering(listView);
+            listView.positionViewAtBeginning();
+            listView.ViewItems.dragUpdated.connect(updateHandler);
+
+            // enter drag mode
+            toggleDragMode(listView, true);
+            drag(listView, data.from, data.to);
+            compare(moveCount, data.count, "Move did not happen or more than one item was moved");
+            // compare array indices
+            for (var i in data.indices) {
+                compare(listView.model.get(i).data, data.indices[i], "data at index " + i + " is not the expected one");
+            }
+
+            // cleanup
+            listView.ViewItems.dragUpdated.disconnect(updateHandler);
+            toggleDragMode(listView, false);
+        }
+
+        function test_drag_keeps_selected_indexes_data() {
+            return [
+                {tag: "[0,1,2] selected, move 0->3, live", selected: [0,1,2], from: 0, to: 3, expected: [0,1,3], live: true},
+                {tag: "[1,2] selected, move 3->2, live", selected: [1,2], from: 3, to: 2, expected: [1,3], live: true},
+                {tag: "[1,2] selected, move 0->3, live", selected: [1,2], from: 0, to: 3, expected: [0,1], live: true},
+                {tag: "[1,2] selected, move 3->0, live", selected: [1,2], from: 3, to: 0, expected: [2,3], live: true},
+                // non-live updates
+                {tag: "[0,1,2] selected, move 0->3, non-live", selected: [0,1,2], from: 0, to: 3, expected: [0,1,3], live: false},
+                {tag: "[1,2] selected, move 3->2, non-live", selected: [1,2], from: 3, to: 2, expected: [1,3], live: false},
+                {tag: "[1,2] selected, move 0->3, non-live", selected: [1,2], from: 0, to: 3, expected: [0,1], live: false},
+                {tag: "[1,2] selected, move 3->0, non-live", selected: [1,2], from: 3, to: 0, expected: [2,3], live: false},
+            ];
+        }
+        function test_drag_keeps_selected_indexes(data) {
+            function updateHandler(event) {
+                if (event.status == ListItemDrag.Started) {
+                    return;
+                }
+                if (data.live || event.status == ListItemDrag.Dropped) {
+                    listView.model.move(event.from, event.to, 1);
+                } else {
+                    event.accept = false;
+                }
+            }
+            objectModel.reset();
+            waitForRendering(listView);
+            listView.ViewItems.selectedIndices = data.selected;
+            listView.ViewItems.dragUpdated.connect(updateHandler);
+            toggleDragMode(listView, true);
+            drag(listView, data.from, data.to);
+            listView.ViewItems.dragUpdated.disconnect(updateHandler);
+            toggleDragMode(listView, false);
+
+            // NOTE: the selected indexes order is arbitrar and cannot be predicted by the test
+            // therefore we check the selected indexes presence in the expected list.
+            compare(listView.ViewItems.selectedIndices.length, data.expected.length, "The selected indexes and expected list size differs");
+            for (var i = 0; i < listView.ViewItems.selectedIndices.length; i++) {
+                var index = data.expected.indexOf(listView.ViewItems.selectedIndices[i]);
+                verify(index >= 0, "Index " + listView.ViewItems.selectedIndices[i] + " is not expected to be selected!");
+            }
+        }
+
+        // must run this immediately after the defaults are checked otherwise drag handler connected check will fail
+        function test_1_warn_missing_dragUpdated_signal_handler() {
+            ignoreWarning(warningFormat(121, 9, "QML ListView: ListView has no ViewItems.dragUpdated() signal handler implemented. No dragging will be possible."));
+            toggleDragMode(listView, true);
+            drag(listView, 0, 1);
+            toggleDragMode(listView, true);
+        }
+
+        DelegateModel {
+            id: delegateModel
+            delegate: ListItem {
+                objectName: "listItem" + index
+                Label { text: modelData }
+            }
+        }
+        ObjectModel {
+            id: objectModel2
+            Repeater {
+                model: 3
+                ListItem {
+                    objectName: "listItem" + index
+                    Label { text: modelData }
+                }
+            }
+        }
+        function test_warn_model_data() {
+            var list = [1,2,3,4,5,6,7,8,9,10];
+            return [
+                {tag: "number", model: 20, warning: "Dragging is only supported when using a QAbstractItemModel, ListModel or list."},
+                {tag: "list", model: list, warning: ""},
+                {tag: "ListModel", model: objectModel, warning: ""},
+                {tag: "DelegateModel with number", model: delegateModel, modelModel: 20, warning: "Dragging is only supported when using a QAbstractItemModel, ListModel or list."},
+                {tag: "DelegateModel with list", model: delegateModel, modelModel: list, warning: ""},
+                {tag: "DelegateModel with ListModel", model: delegateModel, modelModel: objectModel, warning: ""},
+                {tag: "ObjectModel", model: objectModel2, warning: ""},
+            ];
+        }
+        function test_warn_model(data) {
+            function dummyFunc() {}
+            if (data.warning !== "") {
+                ignoreWarning(warningFormat(121, 9, "QML ListView: " + data.warning));
+            }
+            listView.model = data.model;
+            if (typeof data.modelModel !== "undefined") {
+                listView.model.model = data.modelModel;
+            }
+            waitForRendering(listView, 500);
+            listView.ViewItems.dragUpdated.connect(dummyFunc);
+            toggleDragMode(listView, true);
+            toggleDragMode(listView, false);
+            listView.ViewItems.dragUpdated.disconnect(dummyFunc);
+        }
+
+        function test_rtl_actions_data() {
+            return [
+                {tag: "Leading actions", item: "listItem0", leading: true, expected: ["leading_1", "leading_2", "leading_3"]},
+                {tag: "Trailing actions", item: "listItem0", leading: false, expected: ["stockAction"]},
+            ];
+        }
+        function test_rtl_actions(data) {
+            listView.LayoutMirroring.enabled = true;
+            waitForRendering(listView, 500);
+            var listItem = findChild(listView, data.item);
+            swipe(listItem, centerOf(listItem).x, centerOf(listItem).y, data.leading ? -units.gu(20) : units.gu(20), 0);
+
+            // check if the action is visible
+            var panel = panelItem(listItem, data.leading);
+            verify(panel, "Panel not visible");
+            for (var i in data.expected) {
+                var actionItem = findChild(panel, data.expected[i]);
+                verify(actionItem, data.expected[i] + " action not found");
+            }
+            // dismiss
+            rebound(listItem);
+            listView.LayoutMirroring.enabled = false;
+            waitForRendering(listView, 500);
+        }
+
+        function test_rtl_selection_panel_position() {
+            listView.LayoutMirroring.enabled = true;
+            waitForRendering(listView, 500);
+            toggleSelectMode(listView, true);
+            // get the panel
+            var listItem = findChild(listView, "listItem0");
+            verify(listItem, "ListItem cannot be found");
+            var panel = findChild(listView, "selection_panel0");
+            verify(panel, "Selection panel not found.");
+            verify(listItem.mapFromItem(panel, panel.x, panel.y).x > centerOf(listItem).x, "Panel is not in its proper place!");
+            toggleSelectMode(listView, false);
+            listView.LayoutMirroring.enabled = false;
+            waitForRendering(listView, 500);
+        }
+
+        function test_rtl_drag_panel_position() {
+            listView.LayoutMirroring.enabled = true;
+            waitForRendering(listView, 500);
+            toggleDragMode(listView, true);
+            // get the panel
+            var listItem = findChild(listView, "listItem0");
+            verify(listItem, "ListItem cannot be found");
+            var panel = findChild(listView, "drag_panel0");
+            verify(panel, "Drag panel not found.");
+            verify(listItem.mapFromItem(panel, panel.x, panel.y).x < centerOf(listItem).x, "Panel is not in its proper place!");
+            toggleDragMode(listView, false);
+            listView.LayoutMirroring.enabled = false;
+            waitForRendering(listView, 500);
+        }
+
+        function test_listitem_actions_width_bug1465582_data() {
+            return [
+                {tag: "leading", dx: units.gu(5), action: "leading_1"},
+                {tag: "trailing", dx: -units.gu(5), action: "stockAction"},
+            ];
+        }
+        function test_listitem_actions_width_bug1465582(data) {
+            var height = testItem.height;
+            testItem.height = units.gu(15);
+
+            swipe(testItem, centerOf(testItem).x, centerOf(testItem).y, data.dx);
+
+            var icon = findChild(testItem, data.action);
+            verify(icon);
+            compare(icon.width, units.gu(5), "icon width should be the same no matter of the height set");
+
+            rebound(testItem);
+
+            // restore height
+            testItem.height = height;
+        }
+    }
+}

=== added file 'tests/unit_x11/tst_components/tst_listitem_expansion.qml'
--- tests/unit_x11/tst_components/tst_listitem_expansion.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_components/tst_listitem_expansion.qml	2015-09-04 10:38:07 +0000
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2014-2015 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/>.
+ */
+
+import QtQuick 2.4
+import QtTest 1.0
+import Ubuntu.Test 1.0
+import Ubuntu.Components 1.3
+import Ubuntu.Components.Styles 1.3
+
+Item {
+    width: units.gu(40)
+    height: units.gu(71)
+
+    ListModel {
+        id: testModel
+        Component.onCompleted: reload()
+        function reload() {
+            clear();
+            for (var i = 0; i < 25; i++) {
+                append({data: i});
+            }
+        }
+    }
+
+    ListItemActions {
+        id: actions
+        actions: Action {
+            iconName: "delete"
+        }
+    }
+
+    property real expandedHeight
+
+    Column {
+        id: defColumn
+        anchors.fill: parent
+        spacing: units.gu(0.5)
+        ListItem {
+            id: defaults
+        }
+
+        ListView {
+            id: listView
+            width: parent.width
+            height: units.gu(28)
+            clip: true
+            model: testModel
+            delegate: ListItem {
+                objectName: "listItem" + index
+                Label { text: "ListItem " + modelData }
+                expansion.height: expandedHeight
+                leadingActions: actions
+            }
+        }
+        Flickable {
+            id: flickable
+            width: parent.width
+            height: units.gu(28)
+            clip: true
+            contentHeight: flickableColumn.height
+            Column {
+                id: flickableColumn
+                width: parent.width
+                Repeater {
+                    model: testModel
+                    ListItem {
+                        objectName: "listItem" + index
+                        Label { text: "ListItem " + modelData }
+                        expansion.height: expandedHeight
+                        leadingActions: actions
+                        onClicked: expansion.expanded = !expansion.expanded
+                    }
+                }
+            }
+        }
+    }
+
+    ListItemTestCase13 {
+        name: "ListItemExpansion"
+        when: windowShown
+
+        function init() {
+            expandedHeight = units.gu(12);
+        }
+
+        function cleanup() {
+            expandedHeight = 0;
+            // move both views to the top
+            listView.positionViewAtBeginning();
+            flickable.contentY = 0;
+
+            listView.ViewItems.expandedIndices = [];
+            flickableColumn.ViewItems.expandedIndices = [];
+            listView.ViewItems.expansionFlags = ViewItems.Exclusive;
+            flickableColumn.ViewItems.expansionFlags = ViewItems.Exclusive;
+            wait(200);
+        }
+
+        function initTestCase() {
+            compare(defaults.expansion.expanded, false, "Not expanded by default");
+            compare(defaults.expansion.height, 0, "No expansion height by default");
+            verify(defColumn.ViewItems.expandedIndices, "ViewItems.expandedIndices not defined");
+            verify(defColumn.ViewItems.expansionFlags, ViewItems.Exclusive);
+        }
+
+        function test_exclusive_expansion_data() {
+            return [
+                {tag: "ListView", test: listView, expand1: 0, expand2: 2},
+                {tag: "Flickable", test: flickableColumn, expand1: 0, expand2: 2},
+            ];
+        }
+        function test_exclusive_expansion(data) {
+            var item1 = findChild(data.test, "listItem" + data.expand1);
+            var item2 = findChild(data.test, "listItem" + data.expand2);
+            verify(item1);
+            verify(item2);
+
+            expand(item1, true);
+            compare(data.test.ViewItems.expandedIndices.length, 1, "More items expanded");
+            compare(data.test.ViewItems.expandedIndices[0], data.expand1, "More items expanded");
+            // expand the other one
+            expand(item2, true);
+            compare(data.test.ViewItems.expandedIndices.length, 1, "More items expanded");
+            compare(data.test.ViewItems.expandedIndices[0], data.expand2, "More items expanded");
+        }
+
+        function test_multiple_expanded_data() {
+            return [
+                {tag: "ListView", test: listView, expand1: 0, expand2: 2},
+                {tag: "Flickable", test: flickableColumn, expand1: 0, expand2: 2},
+            ];
+        }
+        function test_multiple_expanded(data) {
+            var item1 = findChild(data.test, "listItem" + data.expand1);
+            var item2 = findChild(data.test, "listItem" + data.expand2);
+            verify(item1);
+            verify(item2);
+
+            data.test.ViewItems.expansionFlags = 0;
+            expand(item1, true);
+            expand(item2, true);
+            compare(data.test.ViewItems.expandedIndices.length, 2, "Different amount of items expanded");
+        }
+
+        function test_locked_while_expanded_data() {
+            return [
+                {tag: "ListView, locked", test: listView, expand: 0, flags: 0, xfail: true},
+                {tag: "Flickable, locked", test: flickableColumn, expand: 0, flags: 0, xfail: true},
+                {tag: "ListView, unlocked", test: listView, expand: 0, flags: ViewItems.UnlockExpanded, xfail: false},
+                {tag: "Flickable, unlocked", test: flickableColumn, expand: 0, flags: ViewItems.UnlockExpanded, xfail: false},
+            ];
+        }
+        function test_locked_while_expanded(data) {
+            var item = findChild(data.test, "listItem" + data.expand);
+            verify(item);
+
+            data.test.ViewItems.expansionFlags = data.flags;
+            expand(item, true);
+            setupSpy(item, "contentMovementEnded");
+            swipeNoWait(item, centerOf(item).x, centerOf(item).y, units.gu(10), 0);
+            if (data.xfail) {
+                expectFailContinue(data.tag, "No panel swipe is allowed");
+            }
+            spyWait();
+        }
+
+        function test_colapse_on_external_click_data() {
+            return [
+                {tag: "ListView", test: listView, expand1: 1, clickOn: 0},
+                {tag: "Flickable", test: flickableColumn, expand1: 1, clickOn: 0},
+            ];
+        }
+        function test_colapse_on_external_click(data) {
+            var item = findChild(data.test, "listItem" + data.expand1);
+            var clickItem = findChild(data.test, "listItem" + data.clickOn);
+            verify(item);
+            verify(clickItem);
+            var collapsedHeight = item.height;
+
+            data.test.ViewItems.expansionFlags = ViewItems.CollapseOnOutsidePress;
+            expand(item, true);
+            mouseClick(clickItem, centerOf(clickItem).x, centerOf(clickItem).y);
+            tryCompareFunction(function() { return item.height; }, collapsedHeight, 500);
+        }
+    }
+}

=== modified file 'tests/unit_x11/tst_components/tst_listitem_extras.qml'
--- tests/unit_x11/tst_components/tst_listitem_extras.qml	2015-08-31 07:50:45 +0000
+++ tests/unit_x11/tst_components/tst_listitem_extras.qml	2015-09-04 10:38:07 +0000
@@ -82,7 +82,7 @@
         }
     }
 
-    ListItemTestCase {
+    ListItemTestCase13 {
         name: "ListItemExtras"
         SignalSpy {
             id: clickSpy