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

[Zsombor Egri]

New ListItem component base. Support for leading/trailing actions. Exported in Ubuntu.Components 1.2 UNSTABLE release.

[Tim Peeters (tpeeters)]

67- branch (already reviewed) + staging sync.

Let's get it landed :)

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-autolanding/738/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-autolanding/45/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-autolanding/45
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-autolanding/45/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-autolanding/45/console

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1279
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1306/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/455
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/39/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/39
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/39/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/39/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/402
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/455
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/455/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16408

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1280
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1309/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/461
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/42/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/42
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/42/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/42/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/407
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/461
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/461/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16416

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1281
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1311/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/472
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/44
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/44
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/44/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/44
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/418
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/472
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/472/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16437

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'components.api'
--- components.api	2014-12-03 05:54:13 +0000
+++ components.api	2014-12-03 06:10:30 +0000
@@ -864,6 +864,63 @@
     name: "UCInverseMouse"
     prototype: "UCMouse"
     exports: ["InverseMouse 0.1", "InverseMouse 1.0"]
+    name: "UCListItem"
+    prototype: "UCStyledItemBase"
+    exports: ["ListItem 1.2"]
+    Property { name: "contentItem"; type: "QQuickItem"; isReadonly: true; isPointer: true }
+    Property { name: "divider"; type: "UCListItemDivider"; isReadonly: true; isPointer: true }
+    Property { name: "leadingActions"; type: "UCListItemActions"; isPointer: true }
+    Property { name: "trailingActions"; type: "UCListItemActions"; isPointer: true }
+    Property { name: "pressed"; type: "bool"; isReadonly: true }
+    Property { name: "swipeOvershoot"; type: "double" }
+    Property { name: "contentMoving"; type: "bool"; isReadonly: true }
+    Property { name: "color"; type: "QColor" }
+    Property { name: "highlightColor"; type: "QColor" }
+    Property { name: "listItemData"; type: "QObject"; isList: true; isReadonly: true }
+    Property { name: "listItemChildren"; type: "QQuickItem"; isList: true; isReadonly: true }
+    Property { name: "style"; type: "QQmlComponent"; isPointer: true }
+    Property { name: "__styleInstance"; type: "QQuickItem"; isReadonly: true; isPointer: true }
+    Signal { name: "clicked" }
+    Signal { name: "contentMovementStarted" }
+    Signal { name: "contentMovementEnded" }
+    name: "UCListItemActions"
+    prototype: "QObject"
+    exports: ["ListItemActions 1.2"]
+    name: "Status"
+    Property { name: "delegate"; type: "QQmlComponent"; isPointer: true }
+    Property { name: "actions"; type: "UCAction"; isList: true; isReadonly: true }
+    Property { name: "data"; type: "QObject"; isList: true; isReadonly: true }
+    Signal {
+    name: "statusChanged"
+    Parameter { name: "status"; type: "Status" }
+    name: "UCListItemActionsAttached"
+    prototype: "QObject"
+    Property { name: "container"; type: "UCListItemActions"; isReadonly: true; isPointer: true }
+    Property { name: "visibleActions"; type: "UCAction"; isList: true; isReadonly: true }
+    Property { name: "listItem"; type: "UCListItem"; isReadonly: true; isPointer: true }
+    Property { name: "listItemIndex"; type: "int"; isReadonly: true }
+    Property { name: "offset"; type: "double"; isReadonly: true }
+    Property { name: "status"; type: "UCListItemActions::Status"; isReadonly: true }
+    Property { name: "swiping"; type: "bool"; isReadonly: true }
+    Method {
+    name: "snapToPosition"
+    Parameter { name: "position"; type: "double" }
+    Component { name: "UCListItemAttached"; prototype: "QObject" }
+    name: "UCListItemDivider"
+    prototype: "QObject"
+    Property { name: "visible"; type: "bool" }
+    Property { name: "leftMargin"; type: "double" }
+    Property { name: "rightMargin"; type: "double" }
+    Property { name: "colorFrom"; type: "QColor" }
+    Property { name: "colorTo"; type: "QColor" }
+    name: "UCListItemStyle"
+    prototype: "QQuickItem"
+    exports: ["Ubuntu.Components.Styles/ListItemStyle 1.2"]
+    Property { name: "actionsDelegate"; type: "QQmlComponent"; isPointer: true }
+    Property { name: "selectionDelegate"; type: "QQmlComponent"; isPointer: true }
+    Property { name: "dragHandlerDelegate"; type: "QQmlComponent"; isPointer: true }
+    Property { name: "snapAnimation"; type: "QQuickPropertyAnimation"; isPointer: true }
+    Property { name: "swipeOvershoot"; type: "double" }
     name: "UCMouse"
     prototype: "QObject"
     exports: ["Mouse 0.1", "Mouse 1.0"]
 
=== modified file 'documentation/overview.qdoc'
--- documentation/overview.qdoc	2014-06-18 06:36:00 +0000
+++ documentation/overview.qdoc	2014-12-03 06:10:30 +0000
@@ -113,4 +113,9 @@
          import Ubuntu Test 1.0
      \endcode
      \annotatedlist ubuntu-test
+
+     \part Unstable QML Types
+     The following section lists components which will be part of future releases.
+     Their interface is unstable and thus should not be used in production applications.
+     \annotatedlist unstable-ubuntu-listitems
  */
 
=== added file 'modules/Ubuntu/Components/Themes/Ambiance/ListItemPanel.qml'
--- modules/Ubuntu/Components/Themes/Ambiance/ListItemPanel.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Themes/Ambiance/ListItemPanel.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.2
+import Ubuntu.Components 1.2
+
+/*
+  This component is the holder of the ListItem actions.
+  */
+Item {
+
+    // styling properties
+    /*
+      Color of the background.
+      */
+    // FIXME: use Palette colors instead when available
+    property color backgroundColor: (leading ? UbuntuColors.red : "white")
+
+    /*
+      Color used in coloring the icons.
+      */
+    // FIXME: use Palette colors instead when available
+    property color foregroundColor: leading ? "white" : UbuntuColors.darkGrey
+
+    /*
+      Specifies the width of the component visualizing the action.
+      */
+    property real visualizedActionWidth: units.gu(2.5)
+
+    // panel implementation
+    id: panel
+    width: Math.max(
+               actionsRow.childrenRect.width,
+               ListItemActions.visibleActions.length * MathUtils.clamp(visualizedActionWidth, height, actionsRow.maxItemWidth))
+
+    // used for module/autopilot testing
+    objectName: "ListItemPanel" + (leading ? "Leading" : "Trailing")
+
+    /*
+      Property holding the ListItem's contentItem instance
+      */
+    readonly property Item contentItem: parent ? parent.contentItem : null
+
+    /*
+      Specifies whether the panel is used to visualize leading or trailing actions.
+      */
+    readonly property bool leading: panel.ListItemActions.status == panel.ListItemActions.Leading
+
+    anchors {
+        left: contentItem ? (leading ? undefined : contentItem.right) : undefined
+        right: contentItem ? (leading ? contentItem.left : undefined) : undefined
+        top: contentItem ? contentItem.top : undefined
+        bottom: contentItem ? contentItem.bottom : undefined
+    }
+
+    Rectangle {
+        objectName: "panel_background"
+        anchors {
+            fill: parent
+            // add 4 times the overshoot margins to cover the background when tugged
+            leftMargin: (leading && panel.ListItemActions.listItem) ? -units.gu(4 * panel.ListItemActions.listItem.swipeOvershoot) : 0
+            rightMargin: (!leading && panel.ListItemActions.listItem) ? -units.gu(4 * panel.ListItemActions.listItem.swipeOvershoot) : 0
+        }
+        color: panel.backgroundColor
+    }
+
+    // handle action triggering
+    ListItemActions.onStatusChanged: {
+        if (ListItemActions.status === ListItemActions.Disconnected && actionsRow.selectedAction) {
+            actionsRow.selectedAction.trigger(actionsRow.listItemIndex >= 0 ? actionsRow.listItemIndex : null);
+            actionsRow.selectedAction = null;
+        }
+    }
+
+    // track drag direction, so we know in which direction we should snap
+    property real prevX: 0.0
+    property bool leftToRight: false
+    onXChanged: {
+        leftToRight = prevX < x;
+        prevX = x;
+    }
+    // default snapping!
+    ListItemActions.onSwipingChanged: {
+        if (ListItemActions.swiping) {
+            // the dragging got started, set prevX
+            prevX = panel.x;
+            return;
+        }
+        if (!visible) {
+            return;
+        }
+        // snap in if the offset is bigger than the overshoot and the direction of the drag is to reveal the panel
+        var snapPos = (ListItemActions.offset > ListItemActions.listItem.swipeOvershoot &&
+                       (leftToRight && leading || !leftToRight && !leading)) ? panel.width : 0.0;
+        ListItemActions.snapToPosition(snapPos);
+    }
+
+    Row {
+        id: actionsRow
+        anchors {
+            left: parent.left
+            top: parent.top
+            bottom: parent.bottom
+            leftMargin: spacing
+        }
+
+        property real maxItemWidth: panel.parent ? (panel.parent.width / panel.ListItemActions.visibleActions.length) : 0
+
+        property Action selectedAction
+        property int listItemIndex
+
+        Repeater {
+            model: panel.ListItemActions.visibleActions
+            AbstractButton {
+                id: actionButton
+                action: modelData
+                enabled: action.enabled
+                opacity: action.enabled ? 1.0 : 0.5
+                width: MathUtils.clamp(delegateLoader.item ? delegateLoader.item.width : 0, height, actionsRow.maxItemWidth)
+                anchors {
+                    top: parent.top
+                    bottom: parent.bottom
+                }
+                function trigger() {
+                    actionsRow.selectedAction = modelData;
+                    actionsRow.listItemIndex = panel.ListItemActions.listItemIndex;
+                    panel.ListItemActions.snapToPosition(0.0);
+                }
+
+                Rectangle {
+                    anchors.fill: parent
+                    color: Theme.palette.selected.background
+                    visible: pressed
+                }
+
+                Loader {
+                    id: delegateLoader
+                    height: parent.height
+                    sourceComponent: panel.ListItemActions.container.delegate ? panel.ListItemActions.container.delegate : defaultDelegate
+                    property Action action: modelData
+                    property int index: index
+                    property bool pressed: actionButton.pressed
+                    onItemChanged: {
+                        // use action's objectName to identify the visualized action
+                        if (item && item.objectName === "") {
+                            item.objectName = modelData.objectName;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Component {
+        id: defaultDelegate
+        Item {
+            width: height
+            Icon {
+                width: panel.visualizedActionWidth
+                height: width
+                name: action.iconName
+                color: panel.foregroundColor
+                anchors.centerIn: parent
+            }
+        }
+    }
+}
 
=== added file 'modules/Ubuntu/Components/Themes/Ambiance/ListItemStyle.qml'
--- modules/Ubuntu/Components/Themes/Ambiance/ListItemStyle.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Themes/Ambiance/ListItemStyle.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3
+import Ubuntu.Components.Styles 1.2 as Styles
+import Ubuntu.Components 1.2
+
+Styles.ListItemStyle {
+
+    swipeOvershoot: units.gu(2)
+    actionsDelegate: ListItemPanel{}
+
+    snapAnimation: PropertyAnimation {
+        property: "x"
+        easing {
+            type: Easing.OutElastic
+            period: 0.5
+        }
+        duration: UbuntuAnimation.BriskDuration
+        alwaysRunToEnd: true
+    }
+
+}
 
=== modified file 'modules/Ubuntu/Components/Themes/Ambiance/qmldir'
--- modules/Ubuntu/Components/Themes/Ambiance/qmldir	2014-11-25 15:20:11 +0000
+++ modules/Ubuntu/Components/Themes/Ambiance/qmldir	2014-12-03 06:10:30 +0000
@@ -54,3 +54,7 @@
 internal TextSelectionEndCursorStyle TextSelectionEndCursorStyle.qml
 internal OverflowPanel OverflowPanel.qml
 internal HeadDividerStyle HeadDividerStyle.qml
+
+#version 1.2
+ListItemPanel 1.2 ListItemPanel.qml
+ListItemStyle 1.2 ListItemStyle.qml
 
=== modified file 'modules/Ubuntu/Components/plugin/plugin.cpp'
--- modules/Ubuntu/Components/plugin/plugin.cpp	2014-12-03 05:54:13 +0000
+++ modules/Ubuntu/Components/plugin/plugin.cpp	2014-12-03 06:10:30 +0000
@@ -52,6 +52,10 @@
 #include "ucaction.h"
 #include "ucactioncontext.h"
 #include "ucactionmanager.h"
+#include "uclistitem.h"
+#include "uclistitem_p.h"
+#include "uclistitemactions.h"
+#include "uclistitemstyle.h"
 
 #include <sys/types.h>
 #include <unistd.h>
@@ -162,6 +166,11 @@
     qmlRegisterType<QSortFilterProxyModelQML>(uri, 1, 1, "SortFilterModel");
     qmlRegisterUncreatableType<FilterBehavior>(uri, 1, 1, "FilterBehavior", "Not instantiable");
     qmlRegisterUncreatableType<SortBehavior>(uri, 1, 1, "SortBehavior", "Not instantiable");
+
+    // ListItem and related types, released to 1.2
+    qmlRegisterType<UCListItem, 2>(uri, 1, 2, "ListItem");
+    qmlRegisterType<UCListItemDivider>();
+    qmlRegisterType<UCListItemActions, 2>(uri, 1, 2, "ListItemActions");
 }
 
 void UbuntuComponentsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
@@ -169,6 +178,10 @@
     // initialize baseURL
     m_baseUrl = QUrl(baseUrl().toString() + '/');
 
+    // register internal styles
+    const char *styleUri = "Ubuntu.Components.Styles";
+    qmlRegisterType<UCListItemStyle, 2>(styleUri, 1, 2, "ListItemStyle");
+
     QQmlExtensionPlugin::initializeEngine(engine, uri);
     QQmlContext* context = engine->rootContext();
 
 
=== modified file 'modules/Ubuntu/Components/plugin/plugin.pro'
--- modules/Ubuntu/Components/plugin/plugin.pro	2014-12-03 05:54:13 +0000
+++ modules/Ubuntu/Components/plugin/plugin.pro	2014-12-03 06:10:30 +0000
@@ -66,7 +66,13 @@
     ucaction.h \
     ucactioncontext.h \
     ucactionmanager.h \
-    adapters/actionsproxy_p.h
+    adapters/actionsproxy_p.h \
+    uclistitem.h \
+    uclistitem_p.h \
+    uclistitemactions.h \
+    uclistitemactions_p.h \
+    propertychange_p.h \
+    uclistitemstyle.h
 
 SOURCES += plugin.cpp \
     uctheme.cpp \
@@ -102,7 +108,13 @@
     ucaction.cpp \
     ucactioncontext.cpp \
     ucactionmanager.cpp \
-    adapters/actionsproxy_p.cpp
+    adapters/actionsproxy_p.cpp \
+    uclistitem.cpp \
+    uclistitemactions.cpp \
+    uclistitemactionsattached.cpp \
+    uclistitemattached.cpp \
+    propertychange_p.cpp \
+    uclistitemstyle.cpp
 
 # adapters
 SOURCES += adapters/alarmsadapter_organizer.cpp
 
=== added file 'modules/Ubuntu/Components/plugin/propertychange_p.cpp'
--- modules/Ubuntu/Components/plugin/propertychange_p.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/propertychange_p.cpp	2014-12-03 06:10:30 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "propertychange_p.h"
+
+#include <QtQml/private/qqmlabstractbinding_p.h>
+#define foreach Q_FOREACH //workaround to fix private includes
+#include <QtQml/private/qqmlbinding_p.h>     // for QmlBinding
+#undef foreach
+
+/*
+ * The class is used to save properties and their bindings while the property is
+ * altered temporarily.
+ */
+PropertyChange::PropertyChange(QObject *item, const char *property)
+    : m_backedUp(false)
+    , qmlProperty(item, property, qmlContext(item))
+{
+}
+PropertyChange::~PropertyChange()
+{
+    restore(this);
+}
+
+/*
+ * Sets a value to the property. Will back up the original values if it wasn't yet.
+ * This function can be called many times, it will not destroy the backed up value/binding.
+ */
+void PropertyChange::setValue(PropertyChange *change, const QVariant &value)
+{
+    if (!change) {
+        return;
+    }
+    if (!change->m_backedUp) {
+        change->backup.first = QQmlPropertyPrivate::setBinding(change->qmlProperty, 0);
+        change->backup.second = change->qmlProperty.read();
+        change->m_backedUp = true;
+    }
+    change->qmlProperty.write(value);
+}
+
+/*
+ * Restore backed up value or binding.
+ */
+void PropertyChange::restore(PropertyChange *change)
+{
+    if (!change) {
+        return;
+    }
+    if (change->m_backedUp) {
+        // if there was a binding, restore it
+        if (change->backup.first) {
+            QQmlAbstractBinding *prevBinding = QQmlPropertyPrivate::setBinding(change->qmlProperty, change->backup.first);
+            if (prevBinding && prevBinding != change->backup.first) {
+                prevBinding->destroy();
+            }
+        } else {
+            // there was no binding, restore previous value
+            change->qmlProperty.write(change->backup.second);
+        }
+        change->m_backedUp = false;
+    }
+}
 
=== added file 'modules/Ubuntu/Components/plugin/propertychange_p.h'
--- modules/Ubuntu/Components/plugin/propertychange_p.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/propertychange_p.h	2014-12-03 06:10:30 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PROPERTYCHANGE_P_H
+#define PROPERTYCHANGE_P_H
+
+#include <QtCore/QVariant>
+#include <QtCore/QObject>
+#include <QtQml/QQmlProperty>
+
+class QQmlAbstractBinding;
+class PropertyChange
+{
+public:
+    PropertyChange(QObject *item, const char *property);
+    ~PropertyChange();
+
+    static void setValue(PropertyChange* change, const QVariant &value);
+    static void restore(PropertyChange* change);
+private:
+    bool m_backedUp;
+    QQmlProperty qmlProperty;
+    QPair<QQmlAbstractBinding*, QVariant> backup;
+};
+
+#endif // PROPERTYCHANGE_P_H
 
=== modified file 'modules/Ubuntu/Components/plugin/quickutils.cpp'
--- modules/Ubuntu/Components/plugin/quickutils.cpp	2014-11-04 16:14:07 +0000
+++ modules/Ubuntu/Components/plugin/quickutils.cpp	2014-12-03 06:10:30 +0000
@@ -138,6 +138,29 @@
     return result.left(result.indexOf("_QML"));
 }
 
+/*!
+ * \internal
+ * The function checks whether an item inherits a given class name.
+ */
+bool QuickUtils::inherits(QObject *object, const QString &fromClass)
+{
+    if (!object || fromClass.isEmpty()) {
+        return false;
+    }
+    const QMetaObject *mo = object->metaObject();
+    QString className;
+    while (mo) {
+        className = mo->className();
+        className = className.left(className.indexOf("_QML"));
+        if (className == fromClass) {
+            return true;
+        }
+        mo = mo->superClass();
+    }
+    return false;
+}
+
+
 
 /*!
  * \internal
 
=== modified file 'modules/Ubuntu/Components/plugin/quickutils.h'
--- modules/Ubuntu/Components/plugin/quickutils.h	2014-11-04 16:14:07 +0000
+++ modules/Ubuntu/Components/plugin/quickutils.h	2014-12-03 06:10:30 +0000
@@ -44,6 +44,7 @@
     bool touchScreenAvailable() const;
 
     Q_INVOKABLE static QString className(QObject *item);
+    Q_REVISION(1) Q_INVOKABLE static bool inherits(QObject *object, const QString &fromClass);
     QObject* createQmlObject(const QUrl &url, QQmlEngine *engine);
 
 Q_SIGNALS:
 
=== modified file 'modules/Ubuntu/Components/plugin/ucaction.h'
--- modules/Ubuntu/Components/plugin/ucaction.h	2014-09-01 06:56:39 +0000
+++ modules/Ubuntu/Components/plugin/ucaction.h	2014-12-03 06:10:30 +0000
@@ -87,6 +87,8 @@
     Type m_parameterType;
 
     friend class UCActionContext;
+    friend class UCListItemActionsAttached;
+    friend class UCListItemActionsPrivate;
 
     bool isValidType(QVariant::Type valueType);
     void generateName();
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitem.cpp'
--- modules/Ubuntu/Components/plugin/uclistitem.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitem.cpp	2014-12-03 06:10:30 +0000
@@ -0,0 +1,1260 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ucunits.h"
+#include "uctheme.h"
+#include "uclistitem.h"
+#include "uclistitem_p.h"
+#include "uclistitemactions.h"
+#include "uclistitemactions_p.h"
+#include "ucubuntuanimation.h"
+#include "propertychange_p.h"
+#include "i18n.h"
+#include "quickutils.h"
+#include <QtQml/QQmlInfo>
+#include <QtQuick/private/qquickitem_p.h>
+#include <QtQuick/private/qquickflickable_p.h>
+#include <QtQuick/private/qquickpositioners_p.h>
+#include <QtQuick/private/qquickanimation_p.h>
+#include <QtQuick/private/qquickmousearea_p.h>
+#include "uclistitemstyle.h"
+
+#define MIN(x, y)           ((x < y) ? x : y)
+#define MAX(x, y)           ((x > y) ? x : y)
+#define CLAMP(v, min, max)  (min <= max) ? MAX(min, MIN(v, max)) : MAX(max, MIN(v, min))
+
+QColor getPaletteColor(const char *profile, const char *color)
+{
+    QColor result;
+    QObject *palette = UCTheme::instance().palette();
+    if (palette) {
+        QObject *paletteProfile = palette->property(profile).value<QObject*>();
+        if (paletteProfile) {
+            result = paletteProfile->property(color).value<QColor>();
+        }
+    }
+    return result;
+}
+/******************************************************************************
+ * SnapAnimator
+ *
+ * The class handles the animation executed when the ListItemAction panel is
+ * swiped. The animation is executed from the swipe position the mouse/touch is
+ * released to the desired position given in snap(). The action panel is assumed
+ * to be anchored to the ListItem.contentItem left or right, depending on which
+ * action list is swiped in. Therefore the animator only changes the ListItem.contentItem
+ * x coordinate.
+ * The animation is defined by the style.
+ */
+UCListItemSnapAnimator::UCListItemSnapAnimator(UCListItem *item)
+    : QObject(item)
+    , item(item)
+{
+}
+UCListItemSnapAnimator::~UCListItemSnapAnimator()
+{
+    // make sure we cannot animate anymore, for safety
+    item = 0;
+}
+
+/*
+ * Snap the ListItem.contentItem in or out, depending on the position specified
+ * in "to" parameter. If the position is 0, a snap out will be executed - see
+ * snapOut(). In any other cases a snap in action will be performed - see snapIn().
+ */
+bool UCListItemSnapAnimator::snap(qreal to)
+{
+    if (!item) {
+        return false;
+    }
+    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
+    QQuickPropertyAnimation *snap = getDefaultAnimation();
+    if (!snap) {
+        // no animation, so we simply position the component
+        listItem->contentItem->setX(to);
+        return false;
+    }
+    snap->setTargetObject(listItem->contentItem);
+    if (to == 0.0) {
+        QObject::connect(snap, &QQuickAbstractAnimation::stopped,
+                         this, &UCListItemSnapAnimator::snapOut);
+    } else {
+        QObject::connect(snap, &QQuickAbstractAnimation::stopped,
+                         this, &UCListItemSnapAnimator::snapIn);
+    }
+    if (snap->properties().isEmpty() && snap->property().isEmpty()) {
+        snap->setProperty("x");
+    }
+    snap->setFrom(listItem->contentItem->property(snap->property().toLocal8Bit().constData()));
+    snap->setTo(to);
+    snap->setAlwaysRunToEnd(true);
+    listItem->setContentMoving(true);
+    snap->start();
+    return true;
+}
+
+/*
+ * The function completes a running snap animation.
+ */
+void UCListItemSnapAnimator::complete()
+{
+    QQuickPropertyAnimation *snap = getDefaultAnimation();
+    if (snap && snap->isRunning()) {
+        snap->complete();
+    }
+}
+
+/*
+ * Snap out is performed when the ListItem.contentItem returns back to its original
+ * X coordinates (0). At this point both leading and trailing action panels will
+ * be disconnected, ascending Flickables will get unlocked (interactive value restored
+ * to the state before they were locked) and ListItem.contentMoving will be reset.
+ */
+void UCListItemSnapAnimator::snapOut()
+{
+    if (senderSignalIndex() >= 0) {
+        // disconnect animation, otherwise snapping will disconnect the panel
+        QQuickAbstractAnimation *snap = getDefaultAnimation();
+        QObject::disconnect(snap, 0, 0, 0);
+    }
+    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
+    if (listItem->attachedProperties) {
+        // restore flickable's interactive and cleanup
+        listItem->attachedProperties->disableInteractive(item, false);
+        // no need to listen flickables any longer
+        listItem->listenToRebind(false);
+    }
+    // disconnect actions
+    listItem->grabPanel(listItem->leadingActions, false);
+    listItem->grabPanel(listItem->trailingActions, false);
+    // set contentMoved to false
+    listItem->setContentMoving(false);
+}
+
+/*
+ * Snap in only resets the ListItem.contentMoving property, but will keep leading/trailing
+ * actions connected as well as all ascendant Flickables locked (interactive = false).
+ */
+void UCListItemSnapAnimator::snapIn()
+{
+    if (senderSignalIndex() >= 0) {
+        // disconnect animation
+        QQuickAbstractAnimation *snap = getDefaultAnimation();
+        QObject::disconnect(snap, 0, 0, 0);
+    }
+    // turn content moving off
+    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
+    listItem->setContentMoving(false);
+}
+
+/*
+ * Returns the animation specified by the style.
+ */
+QQuickPropertyAnimation *UCListItemSnapAnimator::getDefaultAnimation()
+{
+    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
+    listItem->initStyleItem();
+    return listItem->styleItem ? listItem->styleItem->m_snapAnimation : 0;
+}
+
+/******************************************************************************
+ * Divider
+ */
+UCListItemDivider::UCListItemDivider(QObject *parent)
+    : QObject(parent)
+    , m_visible(true)
+    , m_leftMarginChanged(false)
+    , m_rightMarginChanged(false)
+    , m_colorFromChanged(false)
+    , m_colorToChanged(false)
+    , m_thickness(0)
+    , m_leftMargin(0)
+    , m_rightMargin(0)
+    , m_listItem(0)
+{
+    connect(&UCUnits::instance(), &UCUnits::gridUnitChanged, this, &UCListItemDivider::unitsChanged);
+    connect(&UCTheme::instance(), &UCTheme::paletteChanged, this, &UCListItemDivider::paletteChanged);
+    unitsChanged();
+    paletteChanged();
+}
+UCListItemDivider::~UCListItemDivider()
+{
+}
+
+void UCListItemDivider::init(UCListItem *listItem)
+{
+    QQml_setParent_noEvent(this, listItem);
+    m_listItem = UCListItemPrivate::get(listItem);
+}
+
+void UCListItemDivider::unitsChanged()
+{
+    m_thickness = UCUnits::instance().dp(2);
+    if (!m_leftMarginChanged) {
+        m_leftMargin = UCUnits::instance().dp(2);
+    }
+    if (!m_rightMarginChanged) {
+        m_rightMargin = UCUnits::instance().dp(2);
+    }
+    if (m_listItem) {
+        m_listItem->update();
+    }
+}
+
+void UCListItemDivider::paletteChanged()
+{
+    QColor background = getPaletteColor("normal", "background");
+    if (!background.isValid()) {
+        return;
+    }
+    // FIXME: we need a palette value for divider colors, till then base on the background
+    // luminance
+    if (!m_colorFromChanged || !m_colorToChanged) {
+        qreal luminance = (background.red()*212 + background.green()*715 + background.blue()*73)/1000.0/255.0;
+        bool lightBackground = (luminance > 0.85);
+        if (!m_colorFromChanged) {
+            m_colorFrom = lightBackground ? QColor("#26000000") : QColor("#26FFFFFF");
+        }
+        if (!m_colorToChanged) {
+            m_colorTo = lightBackground ? QColor("#14FFFFFF") : QColor("#14000000");
+        }
+        updateGradient();
+    }
+}
+
+void UCListItemDivider::updateGradient()
+{
+    m_gradient.clear();
+    m_gradient.append(QGradientStop(0.0, m_colorFrom));
+    m_gradient.append(QGradientStop(0.49, m_colorFrom));
+    m_gradient.append(QGradientStop(0.5, m_colorTo));
+    m_gradient.append(QGradientStop(1.0, m_colorTo));
+    if (m_listItem) {
+        m_listItem->update();
+    }
+}
+
+QSGNode *UCListItemDivider::paint(QSGNode *node, const QRectF &rect)
+{
+    QSGRectangleNode *dividerNode = static_cast<QSGRectangleNode*>(node);
+    bool lastItem = m_listItem->countOwner ? (m_listItem->index() == (m_listItem->countOwner->property("count").toInt() - 1)): false;
+    if (m_visible && !lastItem && (m_gradient.size() > 0) && ((m_colorFrom.alphaF() >= (1.0f / 255.0f)) || (m_colorTo.alphaF() >= (1.0f / 255.0f)))) {
+        if (!dividerNode) {
+            dividerNode = m_listItem->sceneGraphContext()->createRectangleNode();
+        }
+        QRectF divider(m_leftMargin, rect.height() - m_thickness, rect.width() - m_leftMargin - m_rightMargin, m_thickness);
+        dividerNode->setRect(divider);
+        dividerNode->setGradientStops(m_gradient);
+        dividerNode->update();
+        return dividerNode;
+    } else if (node) {
+        // delete the node
+        delete node;
+    }
+    return 0;
+}
+
+void UCListItemDivider::setVisible(bool visible)
+{
+    if (m_visible == visible) {
+        return;
+    }
+    m_visible = visible;
+    m_listItem->resize();
+    m_listItem->update();
+    Q_EMIT visibleChanged();
+}
+
+void UCListItemDivider::setLeftMargin(qreal leftMargin)
+{
+    if (m_leftMargin == leftMargin) {
+        return;
+    }
+    m_leftMargin = leftMargin;
+    m_leftMarginChanged = true;
+    m_listItem->update();
+    Q_EMIT leftMarginChanged();
+}
+
+void UCListItemDivider::setRightMargin(qreal rightMargin)
+{
+    if (m_rightMargin == rightMargin) {
+        return;
+    }
+    m_rightMargin = rightMargin;
+    m_rightMarginChanged = true;
+    m_listItem->update();
+    Q_EMIT rightMarginChanged();
+}
+
+void UCListItemDivider::setColorFrom(const QColor &color)
+{
+    if (m_colorFrom == color) {
+        return;
+    }
+    m_colorFrom = color;
+    m_colorFromChanged = true;
+    updateGradient();
+    Q_EMIT colorFromChanged();
+}
+
+void UCListItemDivider::setColorTo(const QColor &color)
+{
+    if (m_colorTo == color) {
+        return;
+    }
+    m_colorTo = color;
+    m_colorToChanged = true;
+    updateGradient();
+    Q_EMIT colorToChanged();
+}
+
+/******************************************************************************
+ * ListItemPrivate
+ */
+UCListItemPrivate::UCListItemPrivate()
+    : UCStyledItemBasePrivate()
+    , pressed(false)
+    , contentMoved(false)
+    , highlightColorChanged(false)
+    , swiped(false)
+    , suppressClick(false)
+    , ready(false)
+    , customStyle(false)
+    , customColor(false)
+    , customOvershoot(false)
+    , flicked(false)
+    , xAxisMoveThresholdGU(1.5)
+    , overshoot(0)
+    , color(Qt::transparent)
+    , highlightColor(Qt::transparent)
+    , attachedProperties(0)
+    , contentItem(new QQuickItem)
+    , divider(new UCListItemDivider)
+    , leadingActions(0)
+    , trailingActions(0)
+    , animator(0)
+    , styleComponent(0)
+    , styleItem(0)
+{
+}
+UCListItemPrivate::~UCListItemPrivate()
+{
+}
+
+void UCListItemPrivate::init()
+{
+    Q_Q(UCListItem);
+    contentItem->setObjectName("ListItemHolder");
+    QQml_setParent_noEvent(contentItem, q);
+    contentItem->setParentItem(q);
+    divider->init(q);
+    // content will be redirected to the contentItem, therefore we must report
+    // children changes as it would come from the main component
+    QObject::connect(contentItem, &QQuickItem::childrenChanged,
+                     q, &UCListItem::listItemChildrenChanged);
+    q->setFlag(QQuickItem::ItemHasContents);
+    // turn activeFocusOnPress on
+    q->setActiveFocusOnPress(true);
+
+    // catch theme changes
+    QObject::connect(&UCTheme::instance(), SIGNAL(nameChanged()), q, SLOT(_q_updateThemedData()));
+    _q_updateThemedData();
+
+    // watch size change and set implicit size;
+    QObject::connect(&UCUnits::instance(), SIGNAL(gridUnitChanged()), q, SLOT(_q_updateSize()));
+    _q_updateSize();
+}
+
+void UCListItemPrivate::_q_updateThemedData()
+{
+    // update colors, panels
+    if (!customColor) {
+        Q_Q(UCListItem);
+        highlightColor = getPaletteColor("selected", "background");
+        q->update();
+    }
+    loadStyle(true);
+}
+
+void UCListItemPrivate::_q_rebound()
+{
+    setPressed(false);
+    // initiate rebinding only if there were actions tugged
+    Q_Q(UCListItem);
+    if (!UCListItemActionsPrivate::isConnectedTo(leadingActions, q) &&
+        !UCListItemActionsPrivate::isConnectedTo(trailingActions, q)) {
+        return;
+    }
+    setSwiped(false);
+    // rebound to zero
+    animator->snap(0);
+}
+
+void UCListItemPrivate::_q_updateIndex()
+{
+    Q_Q(UCListItem);
+    q->update();
+}
+
+/*!
+ * \qmlproperty Component ListItem::style
+ * Holds the style of the component defining the components visualizing the leading/
+ * trailing actions, selection and dragging mode handlers as well as different
+ * animations. The component does not assume any visuals present in the style,
+ * and will load its content only when requested.
+ * \sa ListItemStyle
+ */
+QQmlComponent *UCListItemPrivate::style() const
+{
+    return styleComponent;
+}
+void UCListItemPrivate::setStyle(QQmlComponent *delegate)
+{
+    if (styleComponent == delegate) {
+        return;
+    }
+    Q_Q(UCListItem);
+    // make sure we're rebound before we change the panel component
+    promptRebound();
+    if (styleItem) {
+        delete styleItem;
+        styleItem = 0;
+        Q_EMIT q->__styleInstanceChanged();
+    }
+    delete styleComponent;
+    customStyle = (delegate == 0);
+    styleComponent = delegate;
+    loadStyle(false);
+    Q_EMIT q->styleChanged();
+}
+
+// update themed components
+bool UCListItemPrivate::loadStyle(bool reload)
+{
+    if (!ready) {
+        return false;
+    }
+    if (!customStyle) {
+        Q_Q(UCListItem);
+        if (reload && styleItem) {
+            delete styleItem;
+            styleItem = 0;
+            Q_EMIT q->__styleInstanceChanged();
+        }
+        delete styleComponent;
+        styleComponent = UCTheme::instance().createStyleComponent("ListItemStyle.qml", q);
+    }
+    return (styleComponent != NULL);
+}
+// creates the style item
+void UCListItemPrivate::initStyleItem()
+{
+    if (!styleItem && !loadStyle(false)) {
+        return;
+    }
+    Q_Q(UCListItem);
+    QObject *object = styleComponent->beginCreate(qmlContext(q));
+    styleItem = qobject_cast<UCListItemStyle*>(object);
+    if (!styleItem) {
+        delete object;
+        styleComponent->completeCreate();
+        return;
+    }
+    QQml_setParent_noEvent(styleItem, q);
+    styleComponent->completeCreate();
+    Q_EMIT q->__styleInstanceChanged();
+
+    // get the overshoot value from the style!
+    if (!customOvershoot) {
+        overshoot = styleItem->m_swipeOvershoot;
+        Q_EMIT q->swipeOvershootChanged();
+    }
+}
+
+/*!
+ * \qmlproperty Item ListItem::__styleInstance
+ * \internal
+ */
+QQuickItem *UCListItemPrivate::styleInstance() const
+{
+    return styleItem;
+}
+
+// rebound without animation
+void UCListItemPrivate::promptRebound()
+{
+    setPressed(false);
+    setSwiped(false);
+    if (animator) {
+        animator->snapOut();
+    }
+}
+
+// set pressed flag and update background
+// called when units size changes
+void UCListItemPrivate::_q_updateSize()
+{
+    Q_Q(UCListItem);
+    QQuickItem *owner = flickable ? flickable : parentItem;
+    q->setImplicitWidth(owner ? owner->width() : UCUnits::instance().gu(40));
+    q->setImplicitHeight(UCUnits::instance().gu(7));
+}
+
+// returns the index of the list item when used in model driven views,
+// and the child index in other cases
+int UCListItemPrivate::index()
+{
+    Q_Q(UCListItem);
+    // is there an index context property?
+    QQmlContext *context = qmlContext(q);
+    QVariant index = context->contextProperty("index");
+    return index.isValid() ?
+                index.toInt() :
+                (parentItem ? QQuickItemPrivate::get(parentItem)->childItems.indexOf(q) : -1);
+}
+
+// returns true if the highlight is possible
+bool UCListItemPrivate::canHighlight(QMouseEvent *event)
+{
+    // localPos is a position relative to ListItem which will give us a child from
+    // from the original coordinates; therefore we must map the position to the contentItem
+   Q_Q(UCListItem);
+   QPointF myPos = q->mapToItem(contentItem, event->localPos());
+   QQuickItem *child = contentItem->childAt(myPos.x(), myPos.y());
+   bool activeComponent = child && (child->acceptedMouseButtons() & event->button()) && !qobject_cast<QQuickText*>(child);
+   // do highlight if not pressed above the active component, and the component has either
+   // action, leading or trailing actions list or at least an active child component declared
+   QQuickMouseArea *ma = q->findChild<QQuickMouseArea*>();
+   bool activeMouseArea = ma && ma->isEnabled();
+   return !activeComponent && (leadingActions || trailingActions || activeMouseArea);
+}
+
+// set pressed flag and update contentItem
+void UCListItemPrivate::setPressed(bool pressed)
+{
+    if (this->pressed != pressed) {
+        this->pressed = pressed;
+        suppressClick = false;
+        Q_Q(UCListItem);
+        q->update();
+        Q_EMIT q->pressedChanged();
+    }
+}
+// toggles the tugged flag and installs/removes event filter
+void UCListItemPrivate::setSwiped(bool swiped)
+{
+    suppressClick = swiped;
+    if (this->swiped == swiped) {
+        return;
+    }
+    this->swiped = swiped;
+    Q_Q(UCListItem);
+    QQuickWindow *window = q->window();
+    if (swiped) {
+        window->installEventFilter(q);
+    } else {
+        window->removeEventFilter(q);
+    }
+}
+
+// grabs the panels from the leading/trailing actions and disables all ascending flickables
+bool UCListItemPrivate::grabPanel(UCListItemActions *actionsList, bool isTugged)
+{
+    Q_Q(UCListItem);
+    if (isTugged) {
+        bool grab = UCListItemActionsPrivate::connectToListItem(actionsList, q, (actionsList == leadingActions));
+        if (attachedProperties) {
+            attachedProperties->disableInteractive(q, true);
+        }
+        return grab;
+    } else {
+        UCListItemActionsPrivate::disconnectFromListItem(actionsList);
+        return false;
+    }
+}
+
+
+// connects/disconnects from the Flickable anchestor to get notified when to do rebound
+void UCListItemPrivate::listenToRebind(bool listen)
+{
+    if (attachedProperties) {
+        Q_Q(UCListItem);
+        attachedProperties->listenToRebind(q, listen);
+    }
+}
+
+void UCListItemPrivate::resize()
+{
+    Q_Q(UCListItem);
+    QRectF rect(q->boundingRect());
+    if (divider && divider->m_visible) {
+        rect.setHeight(rect.height() - divider->m_thickness);
+    }
+    contentItem->setSize(rect.size());
+}
+
+void UCListItemPrivate::update()
+{
+    if (!ready) {
+        return;
+    }
+    Q_Q(UCListItem);
+    q->update();
+}
+
+// clamps the X value and moves the contentItem to the new X value
+void UCListItemPrivate::clampAndMoveX(qreal &x, qreal dx)
+{
+    UCListItemActionsPrivate *leading = UCListItemActionsPrivate::get(leadingActions);
+    UCListItemActionsPrivate *trailing = UCListItemActionsPrivate::get(trailingActions);
+    x += dx;
+    // min cannot be less than the trailing's panel width
+    qreal min = (trailing && trailing->panelItem) ? -trailing->panelItem->width() - overshoot: 0;
+    // max cannot be bigger than 0 or the leading's width in case we have leading panel
+    qreal max = (leading && leading->panelItem) ? leading->panelItem->width() + overshoot: 0;
+    x = CLAMP(x, min, max);
+}
+
+/*!
+ * \qmltype ListItem
+ * \instantiates UCListItem
+ * \inqmlmodule Ubuntu.Components 1.2
+ * \ingroup unstable-ubuntu-listitems
+ * \since Ubuntu.Components 1.2
+ * \brief The ListItem element provides Ubuntu design standards for list or grid
+ * views.
+ * The ListItem component was designed to be used in a list view. It does not
+ * define any specific layout, but while its contents can be freely chosen by
+ * the developer, care must be taken to keep the contents light in order to ensure
+ * good performance when used in long list views.
+ *
+ * The component provides two color properties which configures the item's background
+ * when normal or pressed. This can be configured through \l color and \l highlightColor
+ * properties.
+ *
+ * \c contentItem holds all components and resources declared as child to ListItem.
+ * Being an Item, all properties can be accessed or altered. However, make sure you
+ * never change \c x, \c y, \c width, \c height or \c anchors properties as those are
+ * controlled by the ListItem itself when leading or trailing actions are revealed
+ * and thus might cause the component to misbehave.
+ *
+ * Each ListItem has a thin divider shown on the bottom of the component. This
+ * divider can be configured through the \c divider grouped property, which can
+ * configure its margins from the edges of the ListItem as well as its visibility.
+ * When used in \c ListView or \l UbuntuListView, the last list item will not
+ * show the divider no matter of the visible property value set.
+ *
+ * ListItem can handle actions that can get tugged from front to back of the item.
+ * These actions are Action elements visualized in panels attached to the front
+ * or to the back of the item, and are revealed by swiping the item horizontally.
+ * The tug is started only after the mouse/touch move had passed a given threshold.
+ * These actions are configured through the \l leadingActions as well as \l
+ * trailingActions properties.
+ * \qml
+ * ListItem {
+ *     id: listItem
+ *     leadingActions: ListItemActions {
+ *         actions: [
+ *             Action {
+ *                 iconName: "delete"
+ *                 onTriggered: listItem.destroy()
+ *             }
+ *         ]
+ *     }
+ *     trailingActions: ListItemActions {
+ *         actions: [
+ *             Action {
+ *                 iconName: "search"
+ *                 onTriggered: {
+ *                     // do some search
+ *                 }
+ *             }
+ *         ]
+ *     }
+ * }
+ * \endqml
+ * \note When a list item is tugged, it automatically connects both leading and
+ * trailing actions to the list item. This implies that a ListItem cannot use
+ * the same ListItemActions instance for both leading and trailing actions. If
+ * it is desired to have the same action present in both leading and trailing
+ * actions, one of the ListItemActions actions list can use the other's list. In
+ * the following example the list item can be deleted through both leading and
+ * trailing actions:
+ * \qml
+ * ListItem {
+ *     id: listItem
+ *     leadingActions: ListItemActions {
+ *         actions: [
+ *             Action {
+ *                 iconName: "delete"
+ *                 onTriggered: listItem.destroy()
+ *             }
+ *         ]
+ *     }
+ *     trailingActions: ListItemActions {
+ *         actions: leadingActions.actions
+ *     }
+ * }
+ * \endqml
+ * \sa ListItemActions
+ *
+ * The component is styled using the \l ListItemStyle style interface.
+ */
+
+/*!
+ * \qmlsignal ListItem::clicked()
+ *
+ * The signal is emitted when the component gets released while the \l pressed property
+ * is set. The signal is not emitted if the ListItem content is swiped or when used in
+ * Flickable (or ListView, GridView) and the Flickable gets moved.
+ */
+UCListItem::UCListItem(QQuickItem *parent)
+    : UCStyledItemBase(*(new UCListItemPrivate), parent)
+{
+    Q_D(UCListItem);
+    d->init();
+}
+
+UCListItem::~UCListItem()
+{
+}
+
+UCListItemAttached *UCListItem::qmlAttachedProperties(QObject *owner)
+{
+    return new UCListItemAttached(owner);
+}
+
+void UCListItem::componentComplete()
+{
+    UCStyledItemBase::componentComplete();
+    Q_D(UCListItem);
+    d->ready = true;
+    /* We only deal with ListView, as for other cases we would need to check the children
+     * changes, which would have an enormous impact on performance in case of huge amount
+     * of items. However, if the parent item, or Flickable declares a "count" property,
+     * the ListItem will take use of it!
+     */
+    d->countOwner = (d->flickable && d->flickable->property("count").isValid()) ?
+                d->flickable :
+                (d->parentItem && d->parentItem->property("count").isValid()) ? d->parentItem : 0;
+    if (d->countOwner) {
+        QObject::connect(d->countOwner.data(), SIGNAL(countChanged()),
+                         this, SLOT(_q_updateIndex()), Qt::DirectConnection);
+        update();
+    }
+}
+
+void UCListItem::itemChange(ItemChange change, const ItemChangeData &data)
+{
+    UCStyledItemBase::itemChange(change, data);
+    if (change == ItemParentHasChanged) {
+        Q_D(UCListItem);
+        // make sure we are not connected to the previous Flickable
+        d->listenToRebind(false);
+        // check if we are in a positioner, and if that positioner is in a Flickable
+        QQuickBasePositioner *positioner = qobject_cast<QQuickBasePositioner*>(data.item);
+        if (positioner && positioner->parentItem()) {
+            d->flickable = qobject_cast<QQuickFlickable*>(positioner->parentItem()->parentItem());
+        } else if (data.item && data.item->parentItem()){
+            // check if we are in a Flickable then
+            d->flickable = qobject_cast<QQuickFlickable*>(data.item->parentItem());
+        }
+
+        // attach ListItem properties to the flickable or to the parent item
+        if (d->flickable) {
+            // connect to flickable to get width changes
+            d->attachedProperties = static_cast<UCListItemAttached*>(qmlAttachedPropertiesObject<UCListItem>(d->flickable));
+        } else if (data.item) {
+            d->attachedProperties = static_cast<UCListItemAttached*>(qmlAttachedPropertiesObject<UCListItem>(data.item));
+        } else {
+            // mark as not ready, so no action should be performed which depends on readyness
+            d->ready = false;
+            // about to be deleted or reparented, disable attached
+            d->attachedProperties = 0;
+        }
+
+        if (data.item) {
+            QObject::connect(d->flickable ? d->flickable : data.item, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()));
+        }
+
+        // update size
+        d->_q_updateSize();
+    }
+}
+
+void UCListItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+{
+    UCStyledItemBase::geometryChanged(newGeometry, oldGeometry);
+    // resize contentItem item
+    Q_D(UCListItem);
+    d->resize();
+}
+
+QSGNode *UCListItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
+{
+    Q_UNUSED(data);
+
+    Q_D(UCListItem);
+    QColor color = d->pressed ? d->highlightColor : d->color;
+
+    if (width() <= 0 || height() <= 0) {
+        delete oldNode;
+        return 0;
+    }
+
+    QSGRectangleNode *rectNode = 0;
+    rectNode = static_cast<QSGRectangleNode*>(oldNode);
+    if (!rectNode) {
+        rectNode = QQuickItemPrivate::get(this)->sceneGraphContext()->createRectangleNode();
+    }
+    if (color.alphaF() >= (1.0f / 255.0f)) {
+        rectNode->setColor(color);
+        // cover only the area of the contentItem
+        rectNode->setRect(d->contentItem->boundingRect());
+        rectNode->setGradientStops(QGradientStops());
+        rectNode->setAntialiasing(true);
+        rectNode->setAntialiasing(false);
+        rectNode->update();
+    } else {
+        // delete node, this will delete the divider node as well
+        delete rectNode;
+        rectNode = 0;
+    }
+    oldNode = rectNode;
+    QSGNode *dividerNode = oldNode ? oldNode->childAtIndex(0) : 0;
+    if (d->divider && d->divider->m_visible) {
+        QSGNode *newNode = d->divider->paint(dividerNode, boundingRect());
+        if (newNode != dividerNode && oldNode) {
+            if (dividerNode) {
+                oldNode->removeChildNode(dividerNode);
+            }
+            if (newNode) {
+                oldNode->appendChildNode(newNode);
+            }
+        }
+        if (!oldNode) {
+            oldNode = newNode;
+        }
+    } else if (dividerNode) {
+        // the divider painter node may be still added as child, so remove it
+        oldNode->removeChildNode(dividerNode);
+    }
+    return oldNode;
+}
+
+void UCListItem::mousePressEvent(QMouseEvent *event)
+{
+    UCStyledItemBase::mousePressEvent(event);
+    Q_D(UCListItem);
+    if (d->attachedProperties && d->attachedProperties->isMoving()) {
+        // while moving, we cannot select any items
+        return;
+    }
+    if (event->button() == Qt::LeftButton && d->canHighlight(event)) {
+        d->setPressed(true);
+        d->lastPos = d->pressedPos = event->localPos();
+        // connect the Flickable to know when to rebound
+        d->listenToRebind(true);
+        // if it was moved, grab the panels
+        if (d->swiped) {
+            d->grabPanel(d->leadingActions, true);
+            d->grabPanel(d->trailingActions, true);
+        }
+    }
+    // accept the event so we get the rest of the events as well
+    event->setAccepted(true);
+}
+
+void UCListItem::mouseReleaseEvent(QMouseEvent *event)
+{
+    UCStyledItemBase::mouseReleaseEvent(event);
+    Q_D(UCListItem);
+    // set released
+    if (d->pressed) {
+        d->listenToRebind(false);
+        if (d->attachedProperties) {
+            d->attachedProperties->disableInteractive(this, false);
+        }
+
+        if (!d->suppressClick) {
+            Q_EMIT clicked();
+            d->_q_rebound();
+        }
+    }
+    d->setPressed(false);
+}
+
+void UCListItem::mouseMoveEvent(QMouseEvent *event)
+{
+    Q_D(UCListItem);
+    UCStyledItemBase::mouseMoveEvent(event);
+
+    // accept the tugging only if the move is within the threshold
+    bool leadingAttached = UCListItemActionsPrivate::isConnectedTo(d->leadingActions, this);
+    bool trailingAttached = UCListItemActionsPrivate::isConnectedTo(d->trailingActions, this);
+    if (d->pressed && !(leadingAttached || trailingAttached)) {
+        // check if we can initiate the drag at all
+        // only X direction matters, if Y-direction leaves the threshold, but X not, the tug is not valid
+        qreal threshold = UCUnits::instance().gu(d->xAxisMoveThresholdGU);
+        qreal mouseX = event->localPos().x();
+        qreal pressedX = d->pressedPos.x();
+
+        if ((mouseX < (pressedX - threshold)) || (mouseX > (pressedX + threshold))) {
+            // the press went out of the threshold area, enable move, if the direction allows it
+            d->lastPos = event->localPos();
+            // tries to connect both panels so we do no longer need to take care which
+            // got connected ad which not; this may fail in case of shared ListItemActions,
+            // as then the panel is shared between the list items, and the panel might be
+            // still in use in other panels. See UCListItemActionsPrivate::connectToListItem
+            leadingAttached = d->grabPanel(d->leadingActions, true);
+            trailingAttached = d->grabPanel(d->trailingActions, true);
+            // create animator if not created yet
+            if (!d->animator) {
+                d->animator = new UCListItemSnapAnimator(this);
+            }
+        }
+    }
+
+    if (leadingAttached || trailingAttached) {
+        qreal x = d->contentItem->x();
+        qreal dx = event->localPos().x() - d->lastPos.x();
+        d->lastPos = event->localPos();
+
+        if (dx) {
+            d->setContentMoving(true);
+            // clamp X into allowed dragging area
+            d->clampAndMoveX(x, dx);
+            // block flickable
+            d->setSwiped(true);
+            d->contentItem->setX(x);
+            // decide which panel is visible by checking the contentItem's X coordinates
+            if (d->contentItem->x() > 0) {
+                if (leadingAttached) {
+                    UCListItemActionsPrivate::get(d->leadingActions)->panelItem->setVisible(true);
+                }
+                if (trailingAttached) {
+                    UCListItemActionsPrivate::get(d->trailingActions)->panelItem->setVisible(false);
+                }
+            } else if (d->contentItem->x() < 0) {
+                // trailing revealed
+                if (leadingAttached) {
+                    UCListItemActionsPrivate::get(d->leadingActions)->panelItem->setVisible(false);
+                }
+                if (trailingAttached) {
+                    UCListItemActionsPrivate::get(d->trailingActions)->panelItem->setVisible(true);
+                }
+            }
+        }
+    }
+}
+
+bool UCListItem::childMouseEventFilter(QQuickItem *child, QEvent *event)
+{
+    QEvent::Type type = event->type();
+    if (type == QEvent::MouseButtonPress) {
+        // suppress click event if pressed over an active area, except Text, which can also handle
+        // mouse clicks when content is an URL
+        QMouseEvent *mouse = static_cast<QMouseEvent*>(event);
+        if (child->isEnabled() && (child->acceptedMouseButtons() & mouse->button()) && !qobject_cast<QQuickText*>(child)) {
+            Q_D(UCListItem);
+            d->suppressClick = true;
+            // listen for flickable to be able to rebind if movement started there!
+            d->listenToRebind(true);
+        }
+    } else if (type == QEvent::MouseButtonRelease) {
+        Q_D(UCListItem);
+        d->suppressClick = false;
+    }
+    return UCStyledItemBase::childMouseEventFilter(child, event);
+}
+
+bool UCListItem::eventFilter(QObject *target, QEvent *event)
+{
+    QPointF myPos;
+    // only filter press events, and rebound when pressed outside
+    if (event->type() == QEvent::MouseButtonPress) {
+        QMouseEvent *mouse = static_cast<QMouseEvent*>(event);
+        QQuickWindow *window = qobject_cast<QQuickWindow*>(target);
+        if (window) {
+            myPos = window->contentItem()->mapToItem(this, mouse->localPos());
+        }
+    } else if (event->type() == QEvent::TouchBegin) {
+        QTouchEvent *touch = static_cast<QTouchEvent*>(event);
+        QQuickWindow *window = qobject_cast<QQuickWindow*>(target);
+        if (window) {
+            myPos = window->contentItem()->mapToItem(this, touch->touchPoints()[0].pos());
+        }
+    }
+    if (!myPos.isNull() && !contains(myPos)) {
+        Q_D(UCListItem);
+        d->_q_rebound();
+        // only accept event, but let it be handled by the underlying or surrounding Flickables
+        event->accept();
+    }
+    return UCStyledItemBase::eventFilter(target, event);
+}
+
+/*!
+ * \qmlproperty ListItemActions ListItem::leadingActions
+ *
+ * The property holds the actions and its configuration to be revealed when swiped
+ * from left to right.
+ *
+ * \sa trailingActions
+ */
+UCListItemActions *UCListItem::leadingActions() const
+{
+    Q_D(const UCListItem);
+    return d->leadingActions;
+}
+void UCListItem::setLeadingActions(UCListItemActions *actions)
+{
+    Q_D(UCListItem);
+    if (d->leadingActions == actions) {
+        return;
+    }
+    // snap out before we change the actions
+    d->promptRebound();
+    // then delete panelItem
+    if (d->leadingActions) {
+        UCListItemActionsPrivate *list = UCListItemActionsPrivate::get(d->leadingActions);
+        delete list->panelItem;
+        list->panelItem = 0;
+    }
+    d->leadingActions = actions;
+    if (d->leadingActions == d->trailingActions && d->leadingActions) {
+        qmlInfo(this) << UbuntuI18n::tr("leadingActions and trailingActions cannot share the same object!");
+    }
+    Q_EMIT leadingActionsChanged();
+}
+
+/*!
+ * \qmlproperty ListItemActions ListItem::trailingActions
+ *
+ * The property holds the actions and its configuration to be revealed when swiped
+ * from right to left.
+ *
+ * \sa leadingActions
+ */
+UCListItemActions *UCListItem::trailingActions() const
+{
+    Q_D(const UCListItem);
+    return d->trailingActions;
+}
+void UCListItem::setTrailingActions(UCListItemActions *actions)
+{
+    Q_D(UCListItem);
+    if (d->trailingActions == actions) {
+        return;
+    }
+    // snap out before we change the actions
+    d->promptRebound();
+    // then delete panelItem
+    if (d->trailingActions) {
+        UCListItemActionsPrivate *list = UCListItemActionsPrivate::get(d->trailingActions);
+        delete list->panelItem;
+        list->panelItem = 0;
+    }
+    d->trailingActions = actions;
+    if (d->leadingActions == d->trailingActions && d->trailingActions) {
+        qmlInfo(this) << UbuntuI18n::tr("leadingActions and trailingActions cannot share the same object!");
+    }
+    Q_EMIT trailingActionsChanged();
+}
+
+/*!
+ * \qmlproperty Item ListItem::contentItem
+ *
+ * contentItem holds the components placed on a ListItem.
+ */
+QQuickItem* UCListItem::contentItem() const
+{
+    Q_D(const UCListItem);
+    return d->contentItem;
+}
+
+/*!
+ * \qmlpropertygroup ::ListItem::divider
+ * \qmlproperty bool ListItem::divider.visible
+ * \qmlproperty real ListItem::divider.leftMargin
+ * \qmlproperty real ListItem::divider.rightMargin
+ * \qmlproperty real ListItem::divider.colorFrom
+ * \qmlproperty real ListItem::divider.colorTo
+ *
+ * This grouped property configures the thin divider shown in the bottom of the
+ * component. Configures the visibility and the margins from the left and right
+ * of the ListItem. When swiped left or right to reveal the actions, it is not
+ * moved together with the content. \c colorFrom and \c colorTo configure
+ * the starting and ending colors of the divider.
+ *
+ * When \c visible is true, the ListItem's content size gets thinner with the
+ * divider's \c thickness.
+ *
+ * The default values for the properties are:
+ * \list
+ * \li \c visible: true
+ * \li \c leftMargin: 2 GU
+ * \li \c rightMargin: 2 GU
+ * \endlist
+ */
+UCListItemDivider* UCListItem::divider() const
+{
+    Q_D(const UCListItem);
+    return d->divider;
+}
+
+/*!
+ * \qmlproperty bool ListItem::pressed
+ * True when the item is pressed. The items stays pressed when the mouse or touch
+ * is moved horizontally. When in Flickable (or ListView), the item gets un-pressed
+ * (false) when the mouse or touch is moved towards the vertical direction causing
+ * the flickable to move.
+ */
+bool UCListItem::pressed() const
+{
+    Q_D(const UCListItem);
+    return d->pressed;
+}
+
+/*!
+ * \qmlproperty bool ListItem::contentMoving
+ * \readonly
+ * The property describes whether the content is moving or not. The content is
+ * moved when swiped or when snapping in or out, and lasts till the snapping
+ * animation completes.
+ */
+
+/*!
+ * \qmlsignal ListItem::contentMovementStarted()
+ * The signal is emitted when the content movement has started.
+ */
+
+/*!
+ * \qmlsignal ListItem::contentMovementEnded()
+ * The signal is emitted when the content movement has ended.
+ */
+bool UCListItemPrivate::contentMoving() const
+{
+    return contentMoved;
+}
+void UCListItemPrivate::setContentMoving(bool moved)
+{
+    if (contentMoved == moved) {
+        return;
+    }
+    contentMoved = moved;
+    Q_Q(UCListItem);
+    if (contentMoved) {
+        Q_EMIT q->contentMovementStarted();
+    } else {
+        Q_EMIT q->contentMovementEnded();
+    }
+    Q_EMIT q->contentMovingChanged();
+
+}
+
+/*!
+ * \qmlproperty color ListItem::color
+ * Configures the color of the normal background. The default value is transparent.
+ */
+QColor UCListItem::color() const
+{
+    Q_D(const UCListItem);
+    return d->color;
+}
+void UCListItem::setColor(const QColor &color)
+{
+    Q_D(UCListItem);
+    if (d->color == color) {
+        return;
+    }
+    d->color = color;
+    update();
+    Q_EMIT colorChanged();
+}
+
+/*!
+ * \qmlproperty color ListItem::highlightColor
+ * Configures the color when pressed. Defaults to the theme palette's background color.
+ */
+QColor UCListItem::highlightColor() const
+{
+    Q_D(const UCListItem);
+    return d->highlightColor;
+}
+void UCListItem::setHighlightColor(const QColor &color)
+{
+    Q_D(UCListItem);
+    if (d->highlightColor == color) {
+        return;
+    }
+    d->highlightColor = color;
+    // no more theme change watch
+    d->customColor = true;
+    update();
+    Q_EMIT highlightColorChanged();
+}
+
+/*!
+ * \qmlproperty real ListItem::swipeOvershoot
+ * The property configures the overshoot value on swiping. Its default value is
+ * configured by the \l {ListItemStyle}{style}. Any positive value overrides the
+ * default value, and any negative value resets it back to the default.
+ */
+qreal UCListItemPrivate::swipeOvershoot() const
+{
+    return overshoot;
+}
+void UCListItemPrivate::setSwipeOvershoot(qreal overshoot)
+{
+    // same value should be guarded only if the style hasn't been loaded yet
+    // swipeOvershoot can be set to 0 prior the style is loaded.
+    if (this->overshoot == overshoot && styleItem) {
+        return;
+    }
+    customOvershoot = (overshoot >= 0.0);
+    this->overshoot = (overshoot < 0.0) ?
+                // reset, use style to get the overshoot value
+                (styleItem ? styleItem->m_swipeOvershoot : 0.0) :
+                overshoot;
+    update();
+    Q_Q(UCListItem);
+    Q_EMIT q->swipeOvershootChanged();
+}
+
+/*!
+ * \qmlproperty list<Object> ListItem::listItemData
+ * \default
+ * \internal
+ * Overloaded default property containing all the children and resources.
+ */
+QQmlListProperty<QObject> UCListItemPrivate::data()
+{
+    return QQuickItemPrivate::get(contentItem)->data();
+}
+
+/*!
+ * \qmlproperty list<Item> ListItem::listItemChildren
+ * \internal
+ * Overloaded default property containing all the visible children of the item.
+ */
+QQmlListProperty<QQuickItem> UCListItemPrivate::children()
+{
+    return QQuickItemPrivate::get(contentItem)->children();
+}
+
+#include "moc_uclistitem.cpp"
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitem.h'
--- modules/Ubuntu/Components/plugin/uclistitem.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitem.h	2014-12-03 06:10:30 +0000
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UCLISTITEM_H
+#define UCLISTITEM_H
+
+#include <QtQuick/QQuickItem>
+#include "ucstyleditembase.h"
+
+class UCListItemContent;
+class UCListItemDivider;
+class UCListItemActions;
+class UCListItemAttached;
+class QQuickPropertyAnimation;
+class UCListItemPrivate;
+class UCListItem : public UCStyledItemBase
+{
+    Q_OBJECT
+    Q_PROPERTY(QQuickItem *contentItem READ contentItem CONSTANT)
+    Q_PROPERTY(UCListItemDivider *divider READ divider CONSTANT)
+    Q_PROPERTY(UCListItemActions *leadingActions READ leadingActions WRITE setLeadingActions NOTIFY leadingActionsChanged DESIGNABLE false)
+    Q_PROPERTY(UCListItemActions *trailingActions READ trailingActions WRITE setTrailingActions NOTIFY trailingActionsChanged DESIGNABLE false)
+    Q_PROPERTY(bool pressed READ pressed NOTIFY pressedChanged)
+    Q_PRIVATE_PROPERTY(UCListItem::d_func(), qreal swipeOvershoot READ swipeOvershoot WRITE setSwipeOvershoot NOTIFY swipeOvershootChanged)
+    Q_PRIVATE_PROPERTY(UCListItem::d_func(), bool contentMoving READ contentMoving NOTIFY contentMovingChanged)
+    Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
+    Q_PROPERTY(QColor highlightColor READ highlightColor WRITE setHighlightColor NOTIFY highlightColorChanged)
+    Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQmlListProperty<QObject> listItemData READ data DESIGNABLE false)
+    Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQmlListProperty<QQuickItem> listItemChildren READ children NOTIFY listItemChildrenChanged DESIGNABLE false)
+    // FIXME move these to StyledItemBase with subtheming
+    Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQmlComponent *style READ style WRITE setStyle NOTIFY styleChanged)
+    Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQuickItem *__styleInstance READ styleInstance NOTIFY __styleInstanceChanged)
+    Q_CLASSINFO("DefaultProperty", "listItemData")
+public:
+    explicit UCListItem(QQuickItem *parent = 0);
+    ~UCListItem();
+
+    static UCListItemAttached *qmlAttachedProperties(QObject *owner);
+
+    QQuickItem *contentItem() const;
+    UCListItemDivider *divider() const;
+    UCListItemActions *leadingActions() const;
+    void setLeadingActions(UCListItemActions *options);
+    UCListItemActions *trailingActions() const;
+    void setTrailingActions(UCListItemActions *options);
+    bool pressed() const;
+    QColor color() const;
+    void setColor(const QColor &color);
+    QColor highlightColor() const;
+    void setHighlightColor(const QColor &color);
+
+protected:
+    void componentComplete();
+    QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data);
+    void itemChange(ItemChange change, const ItemChangeData &data);
+    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
+    void mousePressEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+    void mouseMoveEvent(QMouseEvent *event);
+    bool childMouseEventFilter(QQuickItem *child, QEvent *event);
+    bool eventFilter(QObject *, QEvent *);
+
+Q_SIGNALS:
+    void leadingActionsChanged();
+    void trailingActionsChanged();
+    void pressedChanged();
+    void swipeOvershootChanged();
+    void contentMovingChanged();
+    void colorChanged();
+    void highlightColorChanged();
+    void listItemChildrenChanged();
+
+    void clicked();
+
+    void styleChanged();
+    void __styleInstanceChanged();
+
+    void contentMovementStarted();
+    void contentMovementEnded();
+
+public Q_SLOTS:
+
+private:
+    Q_DECLARE_PRIVATE(UCListItem)
+    Q_PRIVATE_SLOT(d_func(), void _q_updateThemedData())
+    Q_PRIVATE_SLOT(d_func(), void _q_rebound())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateSize())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateIndex())
+};
+
+QML_DECLARE_TYPEINFO(UCListItem, QML_HAS_ATTACHED_PROPERTIES)
+
+class UCListItemAttachedPrivate;
+class UCListItemAttached : public QObject
+{
+    Q_OBJECT
+public:
+    explicit UCListItemAttached(QObject *owner);
+    ~UCListItemAttached();
+
+    bool listenToRebind(UCListItem *item, bool listen);
+    void disableInteractive(UCListItem *item, bool disable);
+    bool isMoving();
+    bool isBoundTo(UCListItem *item);
+
+private Q_SLOTS:
+    void unbindItem();
+private:
+    Q_DECLARE_PRIVATE(UCListItemAttached)
+    QScopedPointer<UCListItemAttachedPrivate> d_ptr;
+};
+
+#endif // UCLISTITEM_H
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitem_p.h'
--- modules/Ubuntu/Components/plugin/uclistitem_p.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitem_p.h	2014-12-03 06:10:30 +0000
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UCVIEWITEM_P_H
+#define UCVIEWITEM_P_H
+
+#include "uclistitem.h"
+#include "ucstyleditembase_p.h"
+#include <QtCore/QPointer>
+#include <QtQuick/private/qquickrectangle_p.h>
+
+class QQuickFlickable;
+class QQuickPropertyAnimation;
+class UCListItemContent;
+class UCListItemDivider;
+class UCListItemActions;
+class UCListItemSnapAnimator;
+class UCListItemStyle;
+class UCListItemPrivate : public UCStyledItemBasePrivate
+{
+    Q_DECLARE_PUBLIC(UCListItem)
+public:
+    UCListItemPrivate();
+    virtual ~UCListItemPrivate();
+    void init();
+
+    static inline UCListItemPrivate *get(UCListItem *that)
+    {
+        Q_ASSERT(that);
+        return that->d_func();
+    }
+
+    void _q_updateThemedData();
+    void _q_rebound();
+    void promptRebound();
+    void _q_updateSize();
+    void _q_updateIndex();
+    int index();
+    bool canHighlight(QMouseEvent *event);
+    void setPressed(bool pressed);
+    void setSwiped(bool tugged);
+    bool grabPanel(UCListItemActions *optionList, bool isTugged);
+    void listenToRebind(bool listen);
+    void resize();
+    void update();
+    void clampAndMoveX(qreal &x, qreal dx);
+
+    bool pressed:1;
+    bool contentMoved:1;
+    bool highlightColorChanged:1;
+    bool swiped:1;
+    bool suppressClick:1;
+    bool ready:1;
+    bool customStyle:1;
+    bool customColor:1;
+    bool customOvershoot:1;
+    bool flicked:1;
+    qreal xAxisMoveThresholdGU;
+    qreal overshoot;
+    QPointF lastPos;
+    QPointF pressedPos;
+    QColor color;
+    QColor highlightColor;
+    QPointer<QQuickItem> countOwner;
+    QPointer<QQuickFlickable> flickable;
+    QPointer<UCListItemAttached> attachedProperties;
+    QQuickItem *contentItem;
+    UCListItemDivider *divider;
+    UCListItemActions *leadingActions;
+    UCListItemActions *trailingActions;
+    UCListItemSnapAnimator *animator;
+
+    // FIXME move these to StyledItemBase togehther with subtheming.
+    QQmlComponent *styleComponent;
+    UCListItemStyle *styleItem;
+
+    // getters/setters
+    qreal swipeOvershoot() const;
+    void setSwipeOvershoot(qreal overshoot);
+    QQmlListProperty<QObject> data();
+    QQmlListProperty<QQuickItem> children();
+    bool contentMoving() const;
+    void setContentMoving(bool moved);
+    QQmlComponent *style() const;
+    void setStyle(QQmlComponent *delegate);
+    bool loadStyle(bool reload);
+    void initStyleItem();
+    QQuickItem *styleInstance() const;
+};
+
+class PropertyChange;
+class UCListItemAttachedPrivate
+{
+    Q_DECLARE_PUBLIC(UCListItemAttached)
+public:
+    UCListItemAttachedPrivate(UCListItemAttached *qq);
+    ~UCListItemAttachedPrivate();
+
+    void clearFlickablesList();
+    void buildFlickablesList();
+    void clearChangesList();
+    void buildChangesList(const QVariant &newValue);
+
+    UCListItemAttached *q_ptr;
+    bool globalDisabled;
+    QList< QPointer<QQuickFlickable> > flickables;
+    QList< PropertyChange* > changes;
+    QPointer<UCListItem> boundItem;
+    QPointer<UCListItem> disablerItem;
+};
+
+class UCListItemDivider : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool visible MEMBER m_visible WRITE setVisible NOTIFY visibleChanged)
+    Q_PROPERTY(qreal leftMargin MEMBER m_leftMargin WRITE setLeftMargin NOTIFY leftMarginChanged)
+    Q_PROPERTY(qreal rightMargin MEMBER m_rightMargin WRITE setRightMargin NOTIFY rightMarginChanged)
+    Q_PROPERTY(QColor colorFrom MEMBER m_colorFrom WRITE setColorFrom NOTIFY colorFromChanged)
+    Q_PROPERTY(QColor colorTo MEMBER m_colorTo WRITE setColorTo NOTIFY colorToChanged)
+public:
+    explicit UCListItemDivider(QObject *parent = 0);
+    ~UCListItemDivider();
+    void init(UCListItem *listItem);
+
+Q_SIGNALS:
+    void visibleChanged();
+    void leftMarginChanged();
+    void rightMarginChanged();
+    void colorFromChanged();
+    void colorToChanged();
+
+protected:
+    QSGNode *paint(QSGNode *node, const QRectF &rect);
+
+private Q_SLOTS:
+    void unitsChanged();
+    void paletteChanged();
+
+private:
+    void updateGradient();
+    void setVisible(bool visible);
+    void setLeftMargin(qreal leftMargin);
+    void setRightMargin(qreal rightMargin);
+    void setColorFrom(const QColor &color);
+    void setColorTo(const QColor &color);
+
+    bool m_visible:1;
+    bool m_leftMarginChanged:1;
+    bool m_rightMarginChanged:1;
+    bool m_colorFromChanged:1;
+    bool m_colorToChanged:1;
+    qreal m_thickness;
+    qreal m_leftMargin;
+    qreal m_rightMargin;
+    QColor m_colorFrom;
+    QColor m_colorTo;
+    QGradientStops m_gradient;
+    UCListItemPrivate *m_listItem;
+    friend class UCListItem;
+    friend class UCListItemPrivate;
+};
+
+QColor getPaletteColor(const char *profile, const char *color);
+
+QML_DECLARE_TYPE(UCListItemDivider)
+
+class QQuickPropertyAnimation;
+class UCListItemSnapAnimator : public QObject
+{
+    Q_OBJECT
+public:
+    UCListItemSnapAnimator(UCListItem *item);
+    ~UCListItemSnapAnimator();
+
+    bool snap(qreal to);
+    void complete();
+
+public Q_SLOTS:
+    void snapOut();
+    void snapIn();
+
+    QQuickPropertyAnimation *getDefaultAnimation();
+
+private:
+    bool active;
+    UCListItem *item;
+};
+
+#endif // UCVIEWITEM_P_H
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitemactions.cpp'
--- modules/Ubuntu/Components/plugin/uclistitemactions.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemactions.cpp	2014-12-03 06:10:30 +0000
@@ -0,0 +1,541 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uclistitemactions.h"
+#include "uclistitemactions_p.h"
+#include "uclistitem_p.h"
+#include "quickutils.h"
+#include "i18n.h"
+#include "plugin.h"
+#include <QtQml/QQmlInfo>
+#include "ucaction.h"
+#include "ucunits.h"
+#include "uclistitemstyle.h"
+
+UCListItemActionsPrivate::UCListItemActionsPrivate()
+    : QObjectPrivate()
+    , status(UCListItemActions::Disconnected)
+    , offsetDragged(0)
+    , optionSlotWidth(0.0)
+    , delegate(0)
+    , panelDelegate(0)
+    , panelItem(0)
+{
+}
+UCListItemActionsPrivate::~UCListItemActionsPrivate()
+{
+}
+
+void UCListItemActionsPrivate::_q_updateDraggedOffset()
+{
+    UCListItem *listItem = qobject_cast<UCListItem*>(panelItem->parentItem());
+    if (!listItem) {
+        return;
+    }
+
+    Q_Q(UCListItemActions);
+    offsetDragged = (status == UCListItemActions::Leading) ? panelItem->width() + panelItem->x() :
+                         listItem->width() - panelItem->x();
+    if (offsetDragged < 0.0) {
+        offsetDragged = 0.0;
+    }
+}
+
+UCListItemActionsAttached *UCListItemActionsPrivate::attachedObject()
+{
+    if (!panelItem) {
+        return 0;
+    }
+    return static_cast<UCListItemActionsAttached*>(
+                qmlAttachedPropertiesObject<UCListItemActions>(panelItem, false));
+}
+
+/*
+ * Connects a ListItem to the ListItemActions' panel and returns true upon successful connection.
+ * Connection may fail if there is a different ListItem connected. In this case the new ListItem
+ * will be queued and automatically connected when the previous ListItem disconnects.
+ * The panel is only re-created when a different Component is used to create it.
+ * FIXME - despite each ListItem uses the same document to create the panel, theming engine
+ * provides different Component objects for each, due to not caching the components created.
+ * This must be fixed to optimize memory usage.
+ */
+bool UCListItemActionsPrivate::connectToListItem(UCListItemActions *actions, UCListItem *listItem, bool leading)
+{
+    UCListItemActionsPrivate *_this = get(actions);
+    if (!_this) {
+        return false;
+    }
+    // do we have a panel created already?
+    if (_this->panelItem) {
+        if (isConnectedTo(actions, listItem)) {
+            return true;
+        }
+        if (_this->panelItem->parentItem() && _this->panelItem->parentItem() != listItem) {
+            // set the requesting listItem as queuedItem
+            _this->queuedItem = listItem;
+            return false;
+        }
+    }
+    // no parent set or panelItem yet, proceed with panel creation
+    UCListItemPrivate *pItem = UCListItemPrivate::get(listItem);
+    pItem->initStyleItem();
+    if (!pItem->styleItem || (pItem->styleItem && !_this->createPanelItem(pItem->styleItem->m_actionsDelegate))) {
+        return false;
+    }
+
+    // check if the panel is still connected to a ListItem
+    // this may happen if there is a swipe over an other item while the previous
+    // one is rebounding
+    _this->panelItem->setParentItem(listItem);
+    if (_this->attachedObject()) {
+        _this->attachedObject()->connectListItem(listItem, true);
+    }
+    _this->offsetDragged = 0.0;
+    _this->status = leading ? UCListItemActions::Leading : UCListItemActions::Trailing;
+    Q_EMIT actions->statusChanged(_this->status);
+    return true;
+}
+
+void UCListItemActionsPrivate::disconnectFromListItem(UCListItemActions *actions)
+{
+    UCListItemActionsPrivate *_this = get(actions);
+    if (!_this || !_this->panelItem || !_this->panelItem->parentItem()) {
+        return;
+    }
+
+    if (_this->attachedObject()) {
+        _this->attachedObject()->connectListItem(static_cast<UCListItem*>(_this->panelItem->parentItem()), false);
+    }
+    _this->panelItem->setParentItem(0);
+    _this->status = UCListItemActions::Disconnected;
+    Q_EMIT actions->statusChanged(_this->status);
+    // if there was a queuedItem, make it grab the actions list
+    if (_this->queuedItem) {
+        UCListItemPrivate::get(_this->queuedItem.data())->grabPanel(actions, true);
+        // remove item from queue
+        _this->queuedItem.clear();
+    }
+}
+
+bool UCListItemActionsPrivate::isConnectedTo(UCListItemActions *actions, UCListItem *listItem)
+{
+    UCListItemActionsPrivate *_this = get(actions);
+    return _this && _this->panelItem &&
+            (_this->status != UCListItemActions::Disconnected) &&
+            (_this->panelItem->parentItem() == listItem);
+}
+
+QQuickItem *UCListItemActionsPrivate::createPanelItem(QQmlComponent *panel)
+{
+    if (panelItem && panelDelegate == panel) {
+        return panelItem;
+    }
+    // delete the panel if the next item's actionsDelegate differs from the
+    // one this panel was created from
+    if (panelDelegate != panel) {
+        delete panelItem;
+        panelItem = 0;
+    }
+
+    Q_Q(UCListItemActions);
+    if (!panel) {
+        qmlInfo(q) << UbuntuI18n::instance().tr("actionsDelegate not set!");
+        return 0;
+    }
+
+    panelDelegate = panel;
+    if (!panelDelegate->isError()) {
+        panelItem = qobject_cast<QQuickItem*>(panelDelegate->beginCreate(qmlContext(q)));
+        if (panelItem) {
+            QQml_setParent_noEvent(panelItem, q);
+            // add panelItem to data so we can access it in case is needed (i.e. tests)
+            data.append(panelItem);
+            // create attached property!
+            UCListItemActionsAttached *attached = static_cast<UCListItemActionsAttached*>(
+                        qmlAttachedPropertiesObject<UCListItemActions>(panelItem));
+            if (!attached->container()) {
+                attached->setList(q);
+            } else {
+                // container is set, but we need to emit the signal again so we get the
+                // attached props updated for those cases when the attached property is
+                // created before the statement above
+                Q_EMIT attached->containerChanged();
+            }
+            panelDelegate->completeCreate();
+
+            // calculate option's slot size
+            offsetDragged = 0.0;
+            // connect to panel to catch dragging
+            QObject::connect(panelItem, SIGNAL(xChanged()), q, SLOT(_q_updateDraggedOffset()));
+        }
+    } else {
+        qmlInfo(q) << panelDelegate->errorString();
+    }
+
+    return panelItem;
+}
+
+/*!
+ * \qmltype ListItemActions
+ * \instantiates UCListItemActions
+ * \inherits QtQObject
+ * \inqmlmodule Ubuntu.Components 1.2
+ * \since Ubuntu.Components 1.2
+ * \ingroup unstable-ubuntu-listitems
+ * \brief Provides configuration for actions to be added to a ListItem.
+ *
+ * ListItem accepts actions that can be configured to appear when swiped to left
+ * or right. The API does not limit the number of actions to be assigned for leading
+ * or trailing actions, however the design constrains are allowing a maximum of
+ * 1 action on leading- and a maximum of 3 actions on trailing side of the ListItem.
+ *
+ * The \l actions are Action instances or elements derived from Action. The default
+ * visualization of the actions can be overridden using the \l delegate property,
+ * and the default implementation uses the \c name property of the Action.
+ *
+ * The leading and trailing actions are placed on a panel item, which is created
+ * the first time the actions are accessed. The colors of the panel is taken from
+ * the theme's palette.
+ *
+ * When swiped, panels reveal the actions one by one. In case an action is revealed
+ * more than 50%, the action will be snapped and revealed completely. This is also
+ * valid for the case when the action is visible less than 50%, in which case the
+ * action is hidden. Actions can be triggered by tapping.
+ *
+ * \note You can use the same ListItemActions for leading and for trailing actions
+ * the same time only if the instance is used by different groups of list items,
+ * where one group uses it as leading and other group as trailing. In any other
+ * circumstances use separate ListItemActions for leading and trailing actions.
+ * \qml
+ * import QtQuick 2.2
+ * import Ubuntu.Components 1.2
+ * MainView {
+ *     width: units.gu(40)
+ *     height: units.gu(71)
+ *
+ *     ListItemActions {
+ *         id: sharedActions
+ *         actions: [
+ *             Action {
+ *                 iconName: "search"
+ *             },
+ *             Action {
+ *                 iconName: "edit"
+ *             },
+ *             Action {
+ *                 iconName: "copy"
+ *             }
+ *         ]
+ *     }
+ *
+ *     Column {
+ *         ListItem {
+ *             leadingActions: sharedActions
+ *         }
+ *         UbuntuListView {
+ *             anchors.fill: parent
+ *             model: 10000
+ *             delegate: ListItem {
+ *                 trailingActions: sharedActions
+ *             }
+ *         }
+ *     }
+ * }
+ * \endqml
+ *
+ * \section3 Using with ListViews
+ * ListItemActions instances can be shared between ListItem instances within the
+ * same view. When shared, the memory footprint of the view will be lot smaller,
+ * as there will be no individual panel created for each list's actions visualization.
+ * Depending on how long the initialization of the component used in \l {ListItemStyle::actionsDelegate}
+ * {actionsDelegate} takes, creation time will be also reduced to one time per view.
+ * However, this implies that swiping a new ListItem content while another one is
+ * swiped will result in showing the newly swiped item's panel delayed, as the
+ * panel can be shown only after the previous item's snapping is completed. Depending
+ * on the \l {ListItemStyle::snapAnimation}{snapAnimation} duration, this may take some time, and the
+ * response time of the UI can become unacceptable.
+ *
+ * Having individual ListItemActions instances increases the memory footprint,
+ * however the UI will be more responsive as swiping individual ListItems will
+ * not have to wait till the previous ListItem's panel is snapped out (rebound).
+ * On the other hand, memory consumption will increase significantly due to
+ * separate panel creation, and performance may decrease with up to 40%, depending
+ * on what way are the actions declared, within the ListItemActions or as shared
+ * actions.
+ *
+ * The example above illustrates how to share ListItemActions between ListItem
+ * delegates, which can be the worst-performant but most lightwaight memory consumer
+ * setup. The following example illustrates the worst case:
+ * \qml
+ * import QtQuick 2.2
+ * import Ubuntu.Components 1.2
+ * MainView {
+ *     width: units.gu(40)
+ *     height: units.gu(71)
+ *
+ *     UbuntuListView {
+ *         anchors.fill: parent
+ *         model: 10000
+ *         delegate: ListItem {
+ *             leadingActions: ListItemActions {
+ *                 actions: [
+ *                     Action {
+ *                         iconName: "delete"
+ *                     }
+ *                 ]
+ *             }
+ *             trailingActions: ListItemActions {
+ *                 actions: [
+ *                     Action {
+ *                         iconName: "search"
+ *                     },
+ *                     Action {
+ *                         iconName: "edit"
+ *                     },
+ *                     Action {
+ *                         iconName: "copy"
+ *                     }
+ *                 ]
+ *             }
+ *         }
+ *     }
+ * }
+ * \endqml
+ *
+ * This example can be optimized by sharing the action arrays between the items:
+ * \qml
+ * import QtQuick 2.2
+ * import Ubuntu.Components 1.2
+ * MainView {
+ *     width: units.gu(40)
+ *     height: units.gu(71)
+ *
+ *     property list<Action> leading: [
+ *         Action {
+ *             iconName: "delete"
+ *         }
+ *     ]
+ *     property list<Action> trailing: [
+ *         Action {
+ *             iconName: "search"
+ *         },
+ *         Action {
+ *             iconName: "edit"
+ *         },
+ *         Action {
+ *             iconName: "copy"
+ *         }
+ *     ]
+ *
+ *     UbuntuListView {
+ *         anchors.fill: parent
+ *         model: 10000
+ *         delegate: ListItem {
+ *             leadingActions: ListItemActions {
+ *                 actions: leading
+ *             }
+ *             trailingActions: ListItemActions {
+ *                 actions: trailing
+ *             }
+ *         }
+ *     }
+ * }
+ * \endqml
+ *
+ * \section3 Action parameter types
+ * Actions handled by the ListItem are all triggered with the ListItem's index
+ * as parameter. This index can either be the model index when used with ListView,
+ * or the child index from the parentItem's childItems list. Actions can use this
+ * parameter to identify the instance of the ListItem on which it was executed,
+ * in which case ListItem will change the type from \c Actions.None to \c Actions.Integer
+ * when it is triggered.
+ *
+ * \section3 Attached properties
+ * ListItemActions provides a set of attached properties to the panels visualizing
+ * the actions. These properties can be used by implementations visualizing the
+ * actions.
+ */
+
+UCListItemActions::UCListItemActions(QObject *parent)
+    : QObject(*(new UCListItemActionsPrivate), parent)
+{
+}
+UCListItemActions::~UCListItemActions()
+{
+}
+
+UCListItemActionsAttached *UCListItemActions::qmlAttachedProperties(QObject *owner)
+{
+    /*
+     * Detect the attachee, whether is it a child item of the panelItem. The panelItem
+     * itself cannot be detected, as the object can be attached during the call of
+     * component.beginCreate().
+     */
+    UCListItemActionsAttached *attached = new UCListItemActionsAttached(owner);
+    QQuickItem *item = qobject_cast<QQuickItem*>(owner);
+    while (item) {
+        // has item our attached property?
+        UCListItemActionsAttached *itemAttached = static_cast<UCListItemActionsAttached*>(
+                    qmlAttachedPropertiesObject<UCListItemActions>(item, false));
+        if (itemAttached) {
+            attached->setList(itemAttached->container());
+            break;
+        }
+        item = item->parentItem();
+    }
+    return attached;
+}
+
+/*!
+ * \qmlproperty Component ListItemActions::delegate
+ * The property holds the custom delegate to visualize the actions listed in the
+ * ListItemActions. When set to null, the default delegate specified by the \l
+ * {ListItemStyle::actionsDelegate}{actionsDelegate} will be used.
+ *
+ * ListItemActions provides the \c action context property which contains the
+ * Action instance currently visualized. Using this property delegates can access
+ * the information to be visualized. The action is triggered by the panel item
+ * holding the visualized action, therefore only visualization is needed by the
+ * custom delegate. The other context property exposed to delegates is the \c
+ * index, which specifies the index of the action visualized.
+ *
+ * Specifying a custom delegate will not override the triggering logic of the
+ * action, that will be still handled by the panel itself. However custom delegates
+ * may still need to distinguish the pressed/released state visually. This can
+ * be achieved using the \c pressed context property, which informs the delegate
+ * about the pressed state of the action.
+ *
+ * The delegate height is set automatically by the panel item, only the width must
+ * be specified which will be clamped between height and the maximum width of the
+ * list item divided by the number of actions in the list.
+ * \qml
+ * import QtQuick 2.2
+ * import Ubuntu.Components 1.2
+ *
+ * MainView {
+ *     width: units.gu(40)
+ *     height: units.gu(71)
+ *
+ *     UbuntuListView {
+ *         anchors.fill: parent
+ *         model: 50
+ *         delegate: ListItem {
+ *             trailingActions: actionsList
+ *         }
+ *         ListItemActions {
+ *             id: actionsList
+ *             delegate: Column {
+ *                 width: height + units.gu(2)
+ *                 Icon {
+ *                     name: action.iconName
+ *                     width: units.gu(3)
+ *                     height: width
+ *                     color: pressed ? "blue" : "lightblue"
+ *                     anchors.horizontalCenter: parent.horizontalCenter
+ *                 }
+ *                 Label {
+ *                     text: action.text + "#" + index
+ *                     width: parent.width
+ *                     horizontalAlignment: Text.AlignHCenter
+ *                 }
+ *             }
+ *             actions: Action {
+ *                 iconName: "starred"
+ *                 text: "Star"
+ *             }
+ *         }
+ *     }
+ * }
+ * \endqml
+ * \note Putting a Rectangle in the delegate can be used to override the color
+ * of the panel.
+ *
+ * Defaults to null.
+ */
+QQmlComponent *UCListItemActions::delegate() const
+{
+    Q_D(const UCListItemActions);
+    return d->delegate;
+}
+void UCListItemActions::setDelegate(QQmlComponent *delegate)
+{
+    Q_D(UCListItemActions);
+    if (d->delegate == delegate) {
+        return;
+    }
+    d->delegate = delegate;
+    Q_EMIT delegateChanged();
+}
+
+/*!
+ * \qmlproperty list<Action> ListItemActions::actions
+ * The property holds the actions to be displayed. It can hold instances cached or
+ * declared in place. An example of cached actions:
+ * \qml
+ * ListItemActions {
+ *     id: cachedActions
+ *     actions: [
+ *         copyAction, searchAction, cutAction
+ *     ]
+ * }
+ * \endqml
+ */
+int UCListItemActionsPrivate::actions_count(QQmlListProperty<UCAction> *p)
+{
+    return reinterpret_cast<QList<UCAction *> *>(p->data)->count();
+}
+void UCListItemActionsPrivate::actions_append(QQmlListProperty<UCAction> *p, UCAction *v)
+{
+    // check action type before adding it
+    if (v->m_parameterType == UCAction::None) {
+        v->setProperty("parameterType", UCAction::Integer);
+    }
+    reinterpret_cast<QList<UCAction *> *>(p->data)->append(v);
+}
+UCAction *UCListItemActionsPrivate::actions_at(QQmlListProperty<UCAction> *p, int i)
+{
+    return reinterpret_cast<QList<UCAction *> *>(p->data)->at(i);
+}
+
+void UCListItemActionsPrivate::actions_clear(QQmlListProperty<UCAction> *p)
+{
+    reinterpret_cast<QList<UCAction *> *>(p->data)->clear();
+}
+
+QQmlListProperty<UCAction> UCListItemActions::actions()
+{
+    Q_D(UCListItemActions);
+    return QQmlListProperty<UCAction>(this, &d->actions,
+                                      UCListItemActionsPrivate::actions_append,
+                                      UCListItemActionsPrivate::actions_count,
+                                      UCListItemActionsPrivate::actions_at,
+                                      UCListItemActionsPrivate::actions_clear
+                                      );
+}
+
+/*!
+ * \internal
+ * \qmlproperty list<QtObject> ListItemActions::data
+ * \default
+ * The property holds any additional content added to the ListItemActions.
+ */
+QQmlListProperty<QObject> UCListItemActions::data()
+{
+    Q_D(UCListItemActions);
+    return QQmlListProperty<QObject>(this, d->data);
+}
+
+#include "moc_uclistitemactions.cpp"
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitemactions.h'
--- modules/Ubuntu/Components/plugin/uclistitemactions.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemactions.h	2014-12-03 06:10:30 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UCLISTITEMACTIONS_H
+#define UCLISTITEMACTIONS_H
+
+#include <QtCore/QObject>
+#include "uclistitem_p.h"
+
+class QQmlComponent;
+class UCAction;
+class UCListItemActionsAttached;
+class UCListItemActionsPrivate;
+class UCListItemActions : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate NOTIFY delegateChanged)
+    Q_PROPERTY(QQmlListProperty<UCAction> actions READ actions CONSTANT)
+    Q_PROPERTY(QQmlListProperty<QObject> data READ data)
+    Q_CLASSINFO("DefaultProperty", "data")
+    Q_ENUMS(Status)
+public:
+    enum Status {
+        Disconnected,
+        Leading,
+        Trailing
+    };
+    explicit UCListItemActions(QObject *parent = 0);
+    ~UCListItemActions();
+
+    static UCListItemActionsAttached *qmlAttachedProperties(QObject *owner);
+
+    QQmlComponent *delegate() const;
+    void setDelegate(QQmlComponent *delegate);
+    QQmlListProperty<UCAction> actions();
+    QQmlListProperty<QObject> data();
+
+Q_SIGNALS:
+    void delegateChanged();
+    void statusChanged(Status status);
+
+private:
+    Q_DECLARE_PRIVATE(UCListItemActions)
+    Q_PRIVATE_SLOT(d_func(), void _q_updateDraggedOffset())
+};
+
+class UCListItemActionsAttached : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(UCListItemActions *container READ container NOTIFY containerChanged)
+    Q_PROPERTY(QQmlListProperty<UCAction> visibleActions READ visibleActions NOTIFY visibleActionsChanged)
+    Q_PROPERTY(UCListItem *listItem READ listItem NOTIFY listItemChanged)
+    Q_PROPERTY(int listItemIndex READ listItemIndex NOTIFY listItemIndexChanged)
+    Q_PROPERTY(qreal offset READ offset NOTIFY offsetChanged)
+    Q_PROPERTY(UCListItemActions::Status status READ status NOTIFY statusChanged)
+    Q_PROPERTY(bool swiping READ swiping NOTIFY swipingChanged)
+public:
+    UCListItemActionsAttached(QObject *parent = 0);
+    ~UCListItemActionsAttached();
+    void setList(UCListItemActions *list);
+    void connectListItem(UCListItem *item, bool connect);
+
+    UCListItemActions *container() const
+    {
+        return m_container.data();
+    }
+    QQmlListProperty<UCAction> visibleActions();
+    UCListItem *listItem();
+    int listItemIndex();
+    bool swiping();
+    qreal offset();
+    UCListItemActions::Status status();
+
+
+public Q_SLOTS:
+    void snapToPosition(qreal position);
+
+Q_SIGNALS:
+    void containerChanged();
+    void visibleActionsChanged();
+    void listItemChanged();
+    void listItemIndexChanged();
+    void offsetChanged();
+    void statusChanged();
+    void swipingChanged();
+
+private:
+    QPointer<UCListItemActions> m_container;
+    QList<UCAction*> m_visibleActions;
+    bool m_swiping;
+    friend class UCListItemAction;
+
+private Q_SLOTS:
+    void updateVisibleActions();
+    void updateSwipeState();
+};
+
+QML_DECLARE_TYPEINFO(UCListItemActions, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // UCLISTITEMACTIONS_H
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitemactions_p.h'
--- modules/Ubuntu/Components/plugin/uclistitemactions_p.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemactions_p.h	2014-12-03 06:10:30 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UCLISTITEMACTIONS_P_H
+#define UCLISTITEMACTIONS_P_H
+
+#include "uclistitemactions.h"
+#include "QtCore/private/qobject_p.h"
+#include <QtQml/QQmlListProperty>
+
+class UCListItem;
+class UCListItemActionsPrivate : public QObjectPrivate {
+    Q_DECLARE_PUBLIC(UCListItemActions)
+public:
+    UCListItemActionsPrivate();
+    ~UCListItemActionsPrivate();
+    static UCListItemActionsPrivate* get(UCListItemActions *actions)
+    {
+        return actions ? actions->d_func() : 0;
+    }
+
+    UCListItemActions::Status status;
+    qreal offsetDragged;
+    qreal optionSlotWidth;
+
+    QQmlComponent *delegate;
+    QQmlComponent *panelDelegate;
+    QQuickItem *panelItem;
+    QList<UCAction*> actions;
+    QList<QObject*> data;
+    QPointer<UCListItem> queuedItem;
+
+    void _q_updateDraggedOffset();
+    UCListItemActionsAttached *attachedObject();
+
+    static bool connectToListItem(UCListItemActions *options, UCListItem *listItem, bool leading);
+    static void disconnectFromListItem(UCListItemActions *options);
+    static bool isConnectedTo(UCListItemActions *options, UCListItem *listItem);
+
+    static int actions_count(QQmlListProperty<UCAction> *p);
+    static void actions_append(QQmlListProperty<UCAction> *p, UCAction *v);
+    static UCAction *actions_at(QQmlListProperty<UCAction>*, int);
+    static void actions_clear(QQmlListProperty<UCAction>*);
+
+    QQuickItem *createPanelItem(QQmlComponent *delegate);
+};
+
+#endif // UCLISTITEMACTIONS_P_H
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitemactionsattached.cpp'
--- modules/Ubuntu/Components/plugin/uclistitemactionsattached.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemactionsattached.cpp	2014-12-03 06:10:30 +0000
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uclistitem.h"
+#include "uclistitem_p.h"
+#include "uclistitemactions.h"
+#include "uclistitemactions_p.h"
+#include "ucunits.h"
+#include "ucaction.h"
+
+UCListItemActionsAttached::UCListItemActionsAttached(QObject *parent)
+    : QObject(parent)
+    , m_swiping(false)
+{
+}
+
+UCListItemActionsAttached::~UCListItemActionsAttached()
+{
+}
+
+/*!
+ * \qmlattachedproperty ListItemActions ListItemActions::container
+ * \readonly
+ * The property holds the instance of the \l ListItemActions the ListItem's actions
+ * panel is visualizing.
+ */
+void UCListItemActionsAttached::setList(UCListItemActions *list)
+{
+    if (list == m_container) {
+        return;
+    }
+    m_container = list;
+    if (!m_container.isNull()) {
+        // connect statusChanged() to update status, listItem, listItemIndex and overshoot values
+        QObject::connect(m_container.data(), &UCListItemActions::statusChanged,
+                         this, &UCListItemActionsAttached::statusChanged);
+        QObject::connect(m_container.data(), &UCListItemActions::statusChanged,
+                         this, &UCListItemActionsAttached::listItemChanged);
+        QObject::connect(m_container.data(), &UCListItemActions::statusChanged,
+                         this, &UCListItemActionsAttached::listItemIndexChanged);
+
+        UCListItemActionsPrivate *actions = UCListItemActionsPrivate::get(m_container.data());
+        // connect panel's xChanged to update the dragged offset
+        QObject::connect(actions->panelItem, &QQuickItem::xChanged,
+                         this, &UCListItemActionsAttached::offsetChanged);
+
+        // connect actions to get updates about visible changes
+        Q_FOREACH(UCAction *action, UCListItemActionsPrivate::get(m_container)->actions) {
+            QObject::connect(action, &UCAction::visibleChanged,
+                             this, &UCListItemActionsAttached::updateVisibleActions);
+        }
+        updateVisibleActions();
+    }
+    Q_EMIT containerChanged();
+    Q_EMIT visibleActionsChanged();
+}
+
+void UCListItemActionsAttached::connectListItem(UCListItem *item, bool connect)
+{
+    if (!item) {
+        return;
+    }
+    if (connect) {
+        QObject::connect(item, &UCListItem::pressedChanged,
+                         this, &UCListItemActionsAttached::updateSwipeState);
+        QObject::connect(item, &UCListItem::contentMovingChanged,
+                         this, &UCListItemActionsAttached::updateSwipeState);
+    } else {
+        QObject::disconnect(item, &UCListItem::pressedChanged,
+                            this, &UCListItemActionsAttached::updateSwipeState);
+        QObject::disconnect(item, &UCListItem::contentMovingChanged,
+                            this, &UCListItemActionsAttached::updateSwipeState);
+    }
+}
+
+// private slot to update visible actions
+void UCListItemActionsAttached::updateVisibleActions()
+{
+    m_visibleActions.clear();
+    if (!m_container.isNull()) {
+        Q_FOREACH(UCAction *action, UCListItemActionsPrivate::get(m_container)->actions) {
+            if (action->m_visible) {
+                m_visibleActions << action;
+            }
+        }
+    }
+    Q_EMIT visibleActionsChanged();
+}
+
+// private slot updating swipe state
+void UCListItemActionsAttached::updateSwipeState()
+{
+    if (m_container.isNull()) {
+        return;
+    }
+    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
+    if (!panelItem || !panelItem->parentItem()) {
+        return;
+    }
+    UCListItem *item = static_cast<UCListItem*>(panelItem->parentItem());
+    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
+    bool swiped = listItem->pressed && listItem->contentMoved;
+    if (swiped != m_swiping) {
+        m_swiping = swiped;
+        Q_EMIT swipingChanged();
+    }
+}
+
+/*!
+ * \qmlattachedproperty list<Action> ListItemActions::visibleActions
+ * Holds the list of visible actions. This is a convenience property to help action
+ * visualization panel implementations to consider only visible actions.
+ */
+QQmlListProperty<UCAction> UCListItemActionsAttached::visibleActions()
+{
+    return QQmlListProperty<UCAction>(this, m_visibleActions);
+}
+
+/*!
+ * \qmlattachedproperty ListItem ListItemActions::listItem
+ * \readonly
+ * The property reports the connected \l ListItem to the list of actions.
+ */
+UCListItem *UCListItemActionsAttached::listItem()
+{
+    if (m_container.isNull()) {
+        return NULL;
+    }
+    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
+    if (!panelItem) {
+        return NULL;
+    }
+    QQuickItem *listItem = panelItem->parentItem();
+    return static_cast<UCListItem*>(listItem);
+}
+
+/*!
+ * \qmlattachedproperty int ListItemActions::listItemIndex
+ * \readonly
+ * Holds the index of the \l ListItem within a view, if the \l ListItem is used
+ * in a model driven view. Otherwise it is set to -1.
+ */
+int UCListItemActionsAttached::listItemIndex() {
+    if (m_container.isNull()) {
+        return -1;
+    }
+    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
+    if (!panelItem) {
+        return -1;
+    }
+    QQuickItem *listItem = panelItem->parentItem();
+    return listItem ? UCListItemPrivate::get(static_cast<UCListItem*>(listItem))->index() : -1;
+}
+
+/*!
+ * \qmlattachedproperty bool ListItemActions::swiping
+ * \readonly
+ * The property notifies whether the panel is swiped or not. The property does
+ * not notify the rebounding.
+ */
+bool UCListItemActionsAttached::swiping()
+{
+    return m_swiping;
+}
+
+/*!
+ * \qmlattachedproperty real ListItemActions::offset
+ * The property returns the offset the panel item holding the visualized actions
+ * is visible. This can be used to do different animations on the panel and on
+ * the action visualizations.
+ */
+qreal UCListItemActionsAttached::offset()
+{
+    if (m_container.isNull()) {
+        return 0.0;
+    }
+    return UCListItemActionsPrivate::get(m_container)->offsetDragged;
+}
+
+/*!
+ * \qmlattachedproperty enum ListItemActions::status
+ * \readonly
+ * The property holds the status of the ListItemActions, whether is connected
+ * as leading or as trailing action list to a \l ListItem. Possible valueas are:
+ * \list A
+ *  \li \b Disconnected - default, the actions list is not connected to any \l ListItem
+ *  \li \b Leading - the actions list is connected as leading list
+ *  \li \b Trailing - the actions list is connected as trailing list
+ * \endlist
+ */
+UCListItemActions::Status UCListItemActionsAttached::status()
+{
+    if (m_container.isNull()) {
+        return UCListItemActions::Disconnected;
+    }
+    return UCListItemActionsPrivate::get(m_container)->status;
+}
+
+/*!
+ * \qmlattachedmethod void ListItemActions::snapToPosition(real position)
+ * The function can be used to perform custom snapping, or to execute rebounding
+ * and also disconnecting from the connected \l ListItem. This can be achieved by
+ * calling the function with 0.0 value.
+ */
+void UCListItemActionsAttached::snapToPosition(qreal position)
+{
+    //if it is disconnected, leave (this also includes the case when m_container is null)
+    if (status() == UCListItemActions::Disconnected) {
+        return;
+    }
+    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
+    if (!panelItem) {
+        // we don't have the panel created yet
+        return;
+    }
+    UCListItem *item = static_cast<UCListItem*>(panelItem->parentItem());
+    if (!item) {
+        // no ListItem attached
+        return;
+    }
+    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
+    position *= (status() == UCListItemActions::Leading) ? 1 : -1;
+    if (position == 0.0) {
+        listItem->_q_rebound();
+    } else {
+        if (listItem->animator) {
+            listItem->animator->snap(position);
+        } else {
+            listItem->contentItem->setX(position);
+        }
+    }
+}
+
+
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitemattached.cpp'
--- modules/Ubuntu/Components/plugin/uclistitemattached.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemattached.cpp	2014-12-03 06:10:30 +0000
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ucunits.h"
+#include "uctheme.h"
+#include "uclistitem.h"
+#include "uclistitem_p.h"
+#include "propertychange_p.h"
+#include <QtQuick/private/qquickflickable_p.h>
+
+/*
+ * The properties are attached to the ListItem's parent item or to its closest
+ * Flickable parent, when embedded in ListView or Flickable. There will be only
+ * one attached property per Flickable for all embedded child ListItems, enabling
+ * in this way the controlling of the interactive flag of the Flickable and all
+ * its ascendant Flickables.
+ */
+UCListItemAttachedPrivate::UCListItemAttachedPrivate(UCListItemAttached *qq)
+    : q_ptr(qq)
+    , globalDisabled(false)
+{
+}
+
+UCListItemAttachedPrivate::~UCListItemAttachedPrivate()
+{
+    clearChangesList();
+    clearFlickablesList();
+}
+
+// disconnect all flickables
+void UCListItemAttachedPrivate::clearFlickablesList()
+{
+    Q_Q(UCListItemAttached);
+    Q_FOREACH(const QPointer<QQuickFlickable> &flickable, flickables) {
+        if (flickable.data())
+        QObject::disconnect(flickable.data(), &QQuickFlickable::movementStarted,
+                            q, &UCListItemAttached::unbindItem);
+    }
+    flickables.clear();
+}
+
+// connect all flickables
+void UCListItemAttachedPrivate::buildFlickablesList()
+{
+    Q_Q(UCListItemAttached);
+    QQuickItem *item = qobject_cast<QQuickItem*>(q->parent());
+    if (!item) {
+        return;
+    }
+    clearFlickablesList();
+    while (item) {
+        QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(item);
+        if (flickable) {
+            QObject::connect(flickable, &QQuickFlickable::movementStarted,
+                             q, &UCListItemAttached::unbindItem);
+            flickables << flickable;
+        }
+        item = item->parentItem();
+    }
+}
+
+void UCListItemAttachedPrivate::clearChangesList()
+{
+    // clear property change objects
+    Q_Q(UCListItemAttached);
+    Q_FOREACH(PropertyChange *change, changes) {
+        // deleting PropertyChange will restore the saved property
+        // to its original binding/value
+        delete change;
+    }
+    changes.clear();
+}
+
+void UCListItemAttachedPrivate::buildChangesList(const QVariant &newValue)
+{
+    // collect all ascendant flickables
+    Q_Q(UCListItemAttached);
+    QQuickItem *item = qobject_cast<QQuickItem*>(q->parent());
+    if (!item) {
+        return;
+    }
+    clearChangesList();
+    while (item) {
+        QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(item);
+        if (flickable) {
+            PropertyChange *change = new PropertyChange(item, "interactive");
+            PropertyChange::setValue(change, newValue);
+            changes << change;
+        }
+        item = item->parentItem();
+    }
+}
+
+UCListItemAttached::UCListItemAttached(QObject *owner)
+    : QObject(owner)
+    , d_ptr(new UCListItemAttachedPrivate(this))
+{
+}
+
+UCListItemAttached::~UCListItemAttached()
+{
+}
+
+// register item to be rebound
+bool UCListItemAttached::listenToRebind(UCListItem *item, bool listen)
+{
+    // we cannot bind the item until we have an other one bound
+    bool result = false;
+    Q_D(UCListItemAttached);
+    if (listen) {
+        if (d->boundItem.isNull() || (d->boundItem == item)) {
+            d->boundItem = item;
+            // rebuild flickable list
+            d->buildFlickablesList();
+            result = true;
+        }
+    } else if (d->boundItem == item) {
+        d->boundItem.clear();
+        result = true;
+    }
+    return result;
+}
+
+// reports true if any of the ascendant flickables is moving
+bool UCListItemAttached::isMoving()
+{
+    Q_D(UCListItemAttached);
+    Q_FOREACH(const QPointer<QQuickFlickable> &flickable, d->flickables) {
+        if (flickable && flickable->isMoving()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// returns true if the given ListItem is bound to listen on moving changes
+bool UCListItemAttached::isBoundTo(UCListItem *item)
+{
+    Q_D(UCListItemAttached);
+    return d->boundItem == item;
+}
+
+/*
+ * Disable/enable interactive flag for the ascendant flickables. The item is used
+ * to detect whether the same item is trying to enable the flickables which disabled
+ * it before. The enabled/disabled states are not equivalent to the enabled/disabled
+ * state of the interactive flag.
+ * When disabled, always the last item disabling will be kept as active disabler,
+ * and only the active disabler can enable (restore) the interactive flag state.
+ */
+void UCListItemAttached::disableInteractive(UCListItem *item, bool disable)
+{
+    Q_D(UCListItemAttached);
+    if (disable) {
+        // disabling or re-disabling
+        d->disablerItem = item;
+        if (d->globalDisabled == disable) {
+            // was already disabled, leave
+            return;
+        }
+        d->globalDisabled = true;
+    } else if (d->globalDisabled && d->disablerItem == item) {
+        // the one disabled it will enable
+        d->globalDisabled = false;
+        d->disablerItem.clear();
+    } else {
+        // !disabled && (!globalDisabled || item != d->disablerItem)
+        return;
+    }
+    if (disable) {
+        // (re)build changes list with disabling the interactive value
+        d->buildChangesList(false);
+    } else {
+        d->clearChangesList();
+    }
+}
+
+void UCListItemAttached::unbindItem()
+{
+    Q_D(UCListItemAttached);
+    if (d->boundItem) {
+        // depending on content item's X coordinate, we either do animated or prompt rebind
+        if (d->boundItem->contentItem()->x() != 0.0) {
+            // content is not in origin, rebind
+            UCListItemPrivate::get(d->boundItem.data())->_q_rebound();
+        } else {
+            // do some cleanup
+            UCListItemPrivate::get(d->boundItem.data())->promptRebound();
+        }
+        d->boundItem.clear();
+    }
+    // clear binding list
+    d->clearFlickablesList();
+}
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitemstyle.cpp'
--- modules/Ubuntu/Components/plugin/uclistitemstyle.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemstyle.cpp	2014-12-03 06:10:30 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uclistitemstyle.h"
+
+/*!
+ * \qmltype ListItemStyle
+ * \instantiates UCListItemStyle
+ * \inqmlmodule Ubuntu.Components.Styles 1.2
+ * \ingroup style-api
+ * \since Ubuntu.Components.Styles 1.2
+ * \brief Style API for ListItem component.
+ *
+ * Style API for the ListItem component which provides actions, select and
+ * drag handler delegates, and snap animation via its properties.
+ * ListItem treats the style differently compared to the other components,
+ * as it:
+ * \list
+ *  \li - loads the style only when needed
+ *  \li - gets delegates and snap animation from the style properties
+ *  \li - ignores any other visuals defined in the style.
+ * \endlist
+ */
+UCListItemStyle::UCListItemStyle(QQuickItem *parent)
+    : QQuickItem(parent)
+    , m_actionsDelegate(0)
+    , m_selectionDelegate(0)
+    , m_dragHandlerDelegate(0)
+    , m_snapAnimation(0)
+    , m_swipeOvershoot(0)
+{
+}
+
+/*!
+ * \qmlproperty Component ListItemStyle::actionsDelegate
+ * Specifies the component visualizing the leading/trailing actions.
+ */
+
+/*!
+ * \qmlproperty Component ListItemStyle::selectionDelegate
+ * Holds the component handling the selection mode.
+ */
+
+/*!
+ * \qmlproperty Component ListItemStyle::dragHandlerDelegate
+ * Holds the component shown when dragging mode is enabled.
+ */
+
+/*!
+ * \qmlproperty PropertyAnimation ListItemStyle::snapAnimation
+ * Holds the animation used in animating when snapped in or out.
+ */
+
+/*!
+ * \qmlproperty real ListItemStyle::swipeOvershoot
+ * The property specifies the overshoot value of the ListItem.
+ */
 
=== added file 'modules/Ubuntu/Components/plugin/uclistitemstyle.h'
--- modules/Ubuntu/Components/plugin/uclistitemstyle.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemstyle.h	2014-12-03 06:10:30 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef UCLISTITEMSTYLE_H
+#define UCLISTITEMSTYLE_H
+
+#include <QtQuick/QQuickItem>
+
+class QQmlComponent;
+class QQuickPropertyAnimation;
+class UCListItemStyle : public QQuickItem
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlComponent *actionsDelegate MEMBER m_actionsDelegate NOTIFY actionsDelegateChanged)
+    Q_PROPERTY(QQmlComponent *selectionDelegate MEMBER m_selectionDelegate NOTIFY selectionDelegateChanged)
+    Q_PROPERTY(QQmlComponent *dragHandlerDelegate MEMBER m_dragHandlerDelegate NOTIFY dragHandlerDelegateChanged)
+    Q_PROPERTY(QQuickPropertyAnimation *snapAnimation MEMBER m_snapAnimation NOTIFY snapAnimationChanged)
+    Q_PROPERTY(qreal swipeOvershoot MEMBER m_swipeOvershoot NOTIFY swipeOvershootChanged)
+public:
+    explicit UCListItemStyle(QQuickItem *parent = 0);
+
+Q_SIGNALS:
+    void actionsDelegateChanged();
+    void selectionDelegateChanged();
+    void dragHandlerDelegateChanged();
+    void snapAnimationChanged();
+    void swipeOvershootChanged();
+
+private:
+    QQmlComponent *m_actionsDelegate;
+    QQmlComponent *m_selectionDelegate;
+    QQmlComponent *m_dragHandlerDelegate;
+    QQuickPropertyAnimation *m_snapAnimation;
+    qreal m_swipeOvershoot;
+
+    friend class UCListItemPrivate;
+    friend class UCListItemActionsPrivate;
+    friend class UCListItemSnapAnimator;
+};
+
+#endif // UCLISTITEMSTYLE_H
 
=== modified file 'modules/Ubuntu/Components/plugin/ucstyleditembase.cpp'
--- modules/Ubuntu/Components/plugin/ucstyleditembase.cpp	2014-09-02 12:49:00 +0000
+++ modules/Ubuntu/Components/plugin/ucstyleditembase.cpp	2014-12-03 06:10:30 +0000
@@ -186,13 +186,11 @@
         // therefore must check containment
         QPointF point = mapFromItem(child, mouse->localPos());
         if (contains(point)) {
-            QMouseEvent press(event->type(), point, mouse->windowPos(), mouse->screenPos(),
-                              mouse->button(), mouse->buttons(), mouse->modifiers());
-            mousePressEvent(&press);
+            requestFocus(Qt::MouseFocusReason);
         }
     }
     // let the event be passed to children
-    return false;
+    return QQuickItem::childMouseEventFilter(child, event);
 }
 
 #include "moc_ucstyleditembase.cpp"
 
=== modified file 'modules/Ubuntu/Test/UbuntuTestCase.qml'
--- modules/Ubuntu/Test/UbuntuTestCase.qml	2014-10-10 16:49:22 +0000
+++ modules/Ubuntu/Test/UbuntuTestCase.qml	2014-12-03 06:10:30 +0000
@@ -163,12 +163,9 @@
         if (pressTimeout !== undefined && pressTimeout > 0) {
             wait(pressTimeout);
         }
-        mouseMove(item, x, y, button, modifiers, delay);
-        for (var i = 1; i <= steps; i++) {
-            // mouse moves are all processed immediately, without delay in between events
-            mouseMove(item, x + i * ddx, y + i * ddy, -1, button);
-        }
-        mouseRelease(item, x + dx, y + dy, button, modifiers, delay);
+        // mouse moves are all processed immediately, without delay in between events
+        mouseMoveSlowly(item, x, y, dx, dy, steps, delay);
+        mouseRelease(item, x + dx, y + dy, button, modifiers);
         // empty event buffer
         wait(200);
     }
 
=== modified file 'tests/qmlapicheck.sh'
--- tests/qmlapicheck.sh	2014-10-30 10:44:19 +0000
+++ tests/qmlapicheck.sh	2014-12-03 06:10:30 +0000
@@ -33,7 +33,7 @@
     # https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1256999
     # https://bugreports.qt-project.org/browse/QTBUG-36243
     env UBUNTU_UI_TOOLKIT_THEMES_PATH=$SRCDIR/modules ALARM_BACKEND=memory \
-        qmlplugindump $i 0.1 $SRCDIR/modules 1>> $BLDDIR/plugins.qmltypes
+        qmlplugindump -noinstantiate $i 0.1 $SRCDIR/modules 1>> $BLDDIR/plugins.qmltypes
     test $? != 0 && ERRORS=1
 done
 test $ERRORS = 1 && echo Error: qmlplugindump failed && exit 1
 
=== added file 'tests/resources/listitems/ListItemTest.qml'
--- tests/resources/listitems/ListItemTest.qml	1970-01-01 00:00:00 +0000
+++ tests/resources/listitems/ListItemTest.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,201 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.2
+import Ubuntu.Components 1.2
+
+MainView {
+    id: main
+    width: units.gu(50)
+    height: units.gu(100)
+
+    property bool override: false
+
+    Action {
+        objectName: "stock"
+        id: stock
+        iconName: "starred"
+        text: "Staaaar"
+        onTriggered: print(iconName, "triggered", value)
+    }
+
+    ListItemActions {
+        id: leading
+        objectName: "StockLeading"
+        actions: [
+            Action {
+                iconName: "delete"
+                onTriggered: print(iconName, "triggered", value)
+            },
+            Action {
+                iconName: "alarm-clock"
+                enabled: false
+                onTriggered: print(iconName, "triggered", value)
+            },
+            Action {
+                iconName: "camcorder"
+                onTriggered: print(iconName, "triggered", value)
+            },
+            Action {
+                iconName: "stock_website"
+                onTriggered: print(iconName, "triggered", value)
+            },
+            Action {
+                iconName: "starred"
+                onTriggered: print(iconName, "triggered", value)
+            },
+            Action {
+                iconName: "go-home"
+                onTriggered: print(iconName, "triggered", value)
+            }
+        ]
+    }
+
+    property list<Action> leadingArray: [
+        Action {
+            iconName: "delete"
+        }
+    ]
+    property list<Action> trailingArray: [
+        Action {
+            iconName: "search"
+        },
+        Action {
+            iconName: "edit"
+        },
+        Action {
+            iconName: "email"
+        }
+    ]
+
+    Column {
+        anchors {
+            left: parent.left
+            right: parent.right
+        }
+
+        ListItem {
+            id: testItem
+            objectName: "single"
+            color: "lime"
+            onClicked: {
+                print("click")
+                main.override = !main.override
+            }
+            Label {
+                anchors.fill: parent
+                text: units.gridUnit + "PX/unit"
+            }
+            leadingActions: ListItemActions {
+                objectName: "InlineLeading"
+                actions: [stock]
+                delegate: Column {
+                    width: height + units.gu(2)
+                    anchors.verticalCenter: parent.verticalCenter
+                    Icon {
+                        width: units.gu(3)
+                        height: width
+                        name: action.iconName
+                        color: "blue"
+                        anchors.horizontalCenter: parent.horizontalCenter
+                    }
+                    Label {
+                        text: action.text + index
+                        width: parent.width
+                        horizontalAlignment: Text.AlignHCenter
+                    }
+                }
+            }
+            trailingActions: leading
+        }
+        ListItem {
+            Label {
+                anchors.fill: parent
+                text: "Another standalone ListItem"
+            }
+            leadingActions: testItem.leadingActions
+            trailingActions: ListItemActions {
+                actions: leading.actions
+            }
+        }
+
+        ListView {
+            id: view
+            clip: true
+            width: parent.width
+            height: units.gu(20)
+            model: 10
+            pressDelay: 0
+            delegate: ListItem {
+                objectName: "ListItem" + index
+                id: listItem
+                onClicked: print(" clicked")
+                leadingActions: leading
+                Label {
+                    text: modelData + " item"
+                }
+                states: State {
+                    name: "override"
+                    when: main.override
+                    PropertyChanges {
+                        target: listItem
+                        highlightColor: "brown"
+                    }
+                }
+            }
+        }
+        Flickable {
+            id: flicker
+            width: parent.width
+            height: units.gu(20)
+            clip: true
+            contentHeight: column.childrenRect.height
+            ListItemActions {
+                id: trailing
+                actions: leading.actions
+            }
+
+            Column {
+                id: column
+                width: view.width
+                property alias count: repeater.count
+                Repeater {
+                    id: repeater
+                    model: 10
+                    ListItem {
+                        objectName: "InFlickable"+index
+                        color: "red"
+                        highlightColor: "lime"
+                        divider.colorFrom: UbuntuColors.green
+                        swipeOvershoot: units.gu(10)
+
+                        leadingActions: ListItemActions {
+                            actions: leadingArray
+                        }
+                        trailingActions: ListItemActions {
+                            actions: trailingArray
+                        }
+
+                        Label {
+                            text: modelData + " Flickable item"
+                        }
+                        onClicked: divider.visible = !divider.visible
+                    }
+                }
+            }
+        }
+    }
+}
 
=== added file 'tests/unit/tst_performance/ItemList.qml'
--- tests/unit/tst_performance/ItemList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ItemList.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.1
+
+Column {
+    width: 800
+    height: 600
+    Repeater {
+        model: 5000
+        Item {
+            width: parent.width
+            height: units.gu(6)
+        }
+    }
+}
 
=== added file 'tests/unit/tst_performance/ListItemList.qml'
--- tests/unit/tst_performance/ListItemList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemList.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.2
+
+Column {
+    width: 800
+    height: 600
+    property alias count: repeater.count
+    Repeater {
+        id: repeater
+        model: 5000
+        ListItem {
+        }
+    }
+}
 
=== added file 'tests/unit/tst_performance/ListItemWithActionsList.qml'
--- tests/unit/tst_performance/ListItemWithActionsList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemWithActionsList.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.2
+
+Column {
+    width: 800
+    height: 600
+    ListItemActions {
+        id: actions1
+        actions: [Action {}]
+    }
+    ListItemActions {
+        id: actions2
+        actions: [
+            Action {},
+            Action {},
+            Action {}
+        ]
+    }
+
+    Repeater {
+        model: 5000
+        ListItem {
+            trailingActions: actions1
+            leadingActions: actions2
+        }
+    }
+}
 
=== added file 'tests/unit/tst_performance/ListItemWithInlineActionsList.qml'
--- tests/unit/tst_performance/ListItemWithInlineActionsList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemWithInlineActionsList.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.2
+
+Column {
+    width: 800
+    height: 600
+
+    Repeater {
+        model: 5000
+        ListItem {
+            trailingActions: ListItemActions {
+                actions: [
+                    Action {}
+                ]
+            }
+            leadingActions: ListItemActions {
+                actions: [
+                    Action {},
+                    Action {},
+                    Action {}
+                ]
+            }
+        }
+    }
+}
 
=== added file 'tests/unit/tst_performance/ListItemsBaseList.qml'
--- tests/unit/tst_performance/ListItemsBaseList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemsBaseList.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.1
+import Ubuntu.Components.ListItems 1.0 as ListItems
+
+Column {
+    width: 800
+    height: 600
+    Repeater {
+        model: 5000
+        ListItems.Base {
+        }
+    }
+}
 
=== added file 'tests/unit/tst_performance/ListItemsEmptyList.qml'
--- tests/unit/tst_performance/ListItemsEmptyList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemsEmptyList.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.1
+import Ubuntu.Components.ListItems 1.0 as ListItems
+
+Column {
+    width: 800
+    height: 600
+    Repeater {
+        model: 5000
+        ListItems.Empty {
+        }
+    }
+}
 
=== modified file 'tests/unit/tst_performance/tst_performance.cpp'
--- tests/unit/tst_performance/tst_performance.cpp	2013-06-27 15:35:23 +0000
+++ tests/unit/tst_performance/tst_performance.cpp	2014-12-03 06:10:30 +0000
@@ -74,16 +74,15 @@
         QTest::newRow("grid with Label") << "LabelGrid.qml" << QUrl();
         QTest::newRow("grid with UbuntuShape") << "UbuntuShapeGrid.qml" << QUrl();
         QTest::newRow("grid with UbuntuShapePair") << "PairOfUbuntuShapeGrid.qml" << QUrl();
-        QTest::newRow("grid with ButtonStyle") << "ButtonStyleGrid.qml" << QUrl();
         QTest::newRow("grid with Button") << "ButtonGrid.qml" << QUrl();
-//        QTest::newRow("grid with CheckBoxStyle") << "CheckBoxStyleGrid.qml" << QUrl();
-//        QTest::newRow("grid with CheckBox") << "CheckBoxGrid.qml" << QUrl();
-//        QTest::newRow("grid with SwitchStyle") << "SwitchStyleGrid.qml" << QUrl();
-//        QTest::newRow("grid with Switch") << "SwitchGrid.qml" << QUrl();
-//        QTest::newRow("grid with SwitchStyle") << "SwitchStyleGrid.qml" << QUrl();
-//        QTest::newRow("grid with Switch") << "SwitchGrid.qml" << QUrl();
-        QTest::newRow("grid with SliderStyle") << "SliderStyleGrid.qml" << QUrl();
         QTest::newRow("grid with Slider") << "SliderGrid.qml" << QUrl();
+        QTest::newRow("list with QtQuick Item") << "ItemList.qml" << QUrl();
+        QTest::newRow("list with new ListItem") << "ListItemList.qml" << QUrl();
+        QTest::newRow("list with new ListItem with actions") << "ListItemWithActionsList.qml" << QUrl();
+        QTest::newRow("list with new ListItem with inline actions") << "ListItemWithInlineActionsList.qml" << QUrl();
+        QTest::newRow("list with ListItems.Empty (equivalent to the new ListItem") << "ListItemsEmptyList.qml" << QUrl();
+        // disable this test as it takes >20 seconds. Kept still for measurements to be done during development
+//        QTest::newRow("list with ListItems.Base (one icon, one label and one chevron)") << "ListItemsBaseList.qml" << QUrl();
     }
 
     void benchmark_GridOfComponents()
 
=== modified file 'tests/unit/tst_performance/tst_performance.pro'
--- tests/unit/tst_performance/tst_performance.pro	2013-06-27 15:20:12 +0000
+++ tests/unit/tst_performance/tst_performance.pro	2014-12-03 06:10:30 +0000
@@ -19,4 +19,10 @@
     TextWithImport.qml \
     TextWithImportGrid.qml \
     TextWithImportPopupsGrid.qml \
-    TextWithImportPopups.qml
+    TextWithImportPopups.qml \
+    ItemList.qml \
+    ListItemList.qml \
+    ListItemsEmptyList.qml \
+    ListItemsBaseList.qml \
+    ListItemWithInlineActionsList.qml \
+    ListItemWithActionsList.qml
 
=== added file 'tests/unit_x11/tst_components/tst_listitem.qml'
--- tests/unit_x11/tst_components/tst_listitem.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_components/tst_listitem.qml	2014-12-03 06:10:30 +0000
@@ -0,0 +1,570 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.Test 1.0
+import Ubuntu.Components 1.2
+
+Item {
+    id: main
+    width: units.gu(40)
+    height: units.gu(71)
+
+    Action {
+        id: stockAction
+        iconName: "starred"
+        objectName: "stockAction"
+    }
+    ListItemActions {
+        id: leading
+        actions: [
+            Action {
+                iconName: "starred"
+                objectName: "leading_1"
+            },
+            Action {
+                iconName: "edit"
+                objectName: "leading_2"
+            },
+            Action {
+                iconName: "camcorder"
+                objectName: "leading_3"
+            }
+        ]
+    }
+    ListItemActions {
+        id: trailing
+        actions: [
+            stockAction,
+        ]
+    }
+    ListItemActions {
+        id: actionsDefault
+    }
+
+    Component {
+        id: customDelegate
+        Rectangle {
+            width: units.gu(10)
+            color: "green"
+            objectName: "custom_delegate"
+        }
+    }
+
+    Column {
+        width: parent.width
+        ListItem {
+            id: defaults
+            width: parent.width
+        }
+        ListItem {
+            id: testItem
+            width: parent.width
+            color: "blue"
+            leadingActions: leading
+            trailingActions: trailing
+            Item {
+                id: bodyItem
+                anchors.fill: parent
+            }
+        }
+        ListView {
+            id: listView
+            width: parent.width
+            height: units.gu(28)
+            clip: true
+            model: 10
+            delegate: ListItem {
+                objectName: "listItem" + index
+                color: "lightgray"
+                width: parent.width
+                leadingActions: leading
+                trailingActions: trailing
+            }
+        }
+    }
+
+    UbuntuTestCase {
+        name: "ListItemAPI"
+        when: windowShown
+
+        SignalSpy {
+            id: movingSpy
+            signalName: "contentMovementEnded"
+        }
+
+        SignalSpy {
+            id: pressedSpy
+            signalName: "pressedChanged"
+            target: testItem
+        }
+
+        SignalSpy {
+            id: clickSpy
+            signalName: "clicked"
+            target: testItem;
+        }
+
+        SignalSpy {
+            id: actionSpy
+            signalName: "onTriggered"
+        }
+        SignalSpy {
+            id: interactiveSpy
+            signalName: "interactiveChanged"
+        }
+
+        function panelItem(item, leading) {
+            return findInvisibleChild(item, (leading ? "ListItemPanelLeading" : "ListItemPanelTrailing"));
+        }
+
+        function rebound(item, watchTarget) {
+            if (watchTarget === undefined) {
+                watchTarget = item;
+            }
+
+            movingSpy.target = null;
+            movingSpy.target = watchTarget;
+            movingSpy.clear();
+            mouseClick(item, centerOf(item).x, centerOf(item).y);
+            if (watchTarget.contentMoving) {
+                movingSpy.wait();
+            }
+            movingSpy.target = null;
+        }
+
+        function initTestCase() {
+            TestExtras.registerTouchDevice();
+            waitForRendering(main);
+        }
+
+        function cleanup() {
+            movingSpy.clear();
+            pressedSpy.clear();
+            clickSpy.clear();
+            actionSpy.clear();
+            interactiveSpy.clear();
+            listView.interactive = true;
+            // make sure we collapse
+            mouseClick(defaults, 0, 0)
+            movingSpy.target = null;
+            movingSpy.clear();
+            interactiveSpy.target = null;
+            interactiveSpy.clear();
+            trailing.delegate = null;
+            listView.positionViewAtBeginning();
+        }
+
+        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.pressed, false, "Not pressed buy default");
+            compare(defaults.swipeOvershoot, 0.0, "No overshoot till the style is loaded!");
+            compare(defaults.divider.visible, true, "divider is visible by default");
+            compare(defaults.divider.leftMargin, units.dp(2), "divider's left margin is 2GU");
+            compare(defaults.divider.rightMargin, units.dp(2), "divider's right margin is 2GU");
+            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.contentMoving, false, "default is not moving");
+            compare(defaults.style, null, "Style is loaded upon first use.");
+            compare(defaults.__styleInstance, null, "__styleInstance must be null.");
+
+            compare(actionsDefault.delegate, null, "ListItemActions has no delegate set by default.");
+            compare(actionsDefault.actions.length, 0, "ListItemActions has no actions set.");
+        }
+
+        function test_children_in_content_item() {
+            compare(bodyItem.parent, testItem.contentItem, "Content is not in the right holder!");
+        }
+
+        function test_pressedChanged_on_click() {
+            mousePress(testItem, testItem.width / 2, testItem.height / 2);
+            pressedSpy.wait();
+            mouseRelease(testItem, testItem.width / 2, testItem.height / 2);
+        }
+        function test_pressedChanged_on_tap() {
+            TestExtras.touchPress(0, testItem, centerOf(testItem));
+            pressedSpy.wait();
+            TestExtras.touchRelease(0, testItem, centerOf(testItem));
+            // local cleanup, wait few msecs to suppress double tap
+            wait(400);
+        }
+
+        function test_clicked_on_mouse() {
+            mouseClick(testItem, testItem.width / 2, testItem.height / 2);
+            clickSpy.wait();
+        }
+        function test_clicked_on_tap() {
+            TestExtras.touchClick(0, testItem, centerOf(testItem));
+            clickSpy.wait();
+        }
+
+        function test_mouse_click_on_listitem() {
+            var listItem = findChild(listView, "listItem0");
+            verify(listItem, "Cannot find listItem0");
+
+            mousePress(listItem, listItem.width / 2, 0);
+            compare(listItem.pressed, true, "Item is not pressed?");
+            // do 5 moves to be able to sense it
+            var dy = 0;
+            for (var i = 1; i <= 5; i++) {
+                dy += i * 10;
+                mouseMove(listItem, listItem.width / 2, dy);
+            }
+            compare(listItem.pressed, false, "Item is pressed still!");
+            mouseRelease(listItem, listItem.width / 2, dy);
+            // dismiss
+            rebound(listItem);
+        }
+        function test_touch_click_on_listitem() {
+            var listItem = findChild(listView, "listItem0");
+            verify(listItem, "Cannot find listItem0");
+
+            TestExtras.touchPress(0, listItem, Qt.point(listItem.width / 2, 5));
+            compare(listItem.pressed, true, "Item is not pressed?");
+            // do 5 moves to be able to sense it
+            var dy = 0;
+            for (var i = 1; i <= 5; i++) {
+                dy += i * 10;
+                TestExtras.touchMove(0, listItem, Qt.point(listItem.width / 2, dy));
+            }
+            compare(listItem.pressed, false, "Item is pressed still!");
+            // cleanup, wait few milliseconds to avoid dbl-click collision
+            TestExtras.touchRelease(0, listItem, Qt.point(listItem.width / 2, dy));
+            // dismiss
+            rebound(listItem);
+        }
+
+        function test_background_height_change_on_divider_visible() {
+            // make sure the testItem's divider is shown
+            testItem.divider.visible = true;
+            verify(testItem.contentItem.height < testItem.height, "ListItem's background height must be less than the item itself.");
+            testItem.divider.visible = false;
+            compare(testItem.contentItem.height, testItem.height, "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();
+            movingSpy.target = data.item;
+            if (data.mouse) {
+                flick(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            } else {
+                TestExtras.touchDrag(0, data.item, data.pos, Qt.point(data.dx, 0));
+            }
+            movingSpy.wait();
+            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_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();
+            movingSpy.target = data.item;
+            if (data.mouse) {
+                flick(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            } else {
+                TestExtras.touchDrag(0, data.item, data.pos, Qt.point(data.dx, 0));
+            }
+            movingSpy.wait();
+            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();
+            compare(listView.interactive, true, "ListView is not interactive");
+            movingSpy.target = data.item;
+            interactiveSpy.target = listView;
+            if (data.mouse) {
+                flick(data.item, data.pos.x, data.pos.y, data.dx, data.dy);
+            } else {
+                TestExtras.touchDrag(0, data.item, data.pos, Qt.point(data.dx, data.dy));
+            }
+            movingSpy.wait();
+            // animation should no longer be running!
+            verify(!data.item.__styleInstance.snapAnimation.running, "Animation is still 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);
+            // animation should no longer be running!
+            verify(!data.item.__styleInstance.snapAnimation.running, "Animation is still running!");
+            fuzzyCompare(data.item.contentItem.x, 0.0, 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) {
+            movingSpy.target = data.item;
+            flick(data.item, centerOf(data.item).x, centerOf(data.item).y, data.leading ? units.gu(20) : -units.gu(20), 0);
+            movingSpy.wait();
+
+            // 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_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();
+            movingSpy.target = data.item;
+            if (data.mouse) {
+                flick(data.item, data.pos.x, data.pos.y, data.dx, 0);
+            } else {
+                TestExtras.touchDrag(0, data.item, data.pos, Qt.point(data.dx, 0));
+            }
+            movingSpy.wait();
+            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.clear();
+            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, 0.0, 0.1, "Content not snapped out");
+        }
+
+        function test_custom_trailing_delegate() {
+            trailing.delegate = customDelegate;
+            listView.positionViewAtBeginning();
+            var item = findChild(listView, "listItem0");
+            movingSpy.target = item;
+            flick(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(4), snapIn: true},
+                {tag: "Snap out trailing", item: listItem, dx: -units.gu(2), snapIn: false},
+                {tag: "Snap in trailing", item: listItem, dx: -units.gu(4), snapIn: true},
+            ];
+        }
+        function test_snap(data) {
+            movingSpy.target = data.item;
+            flick(data.item, centerOf(data.item).x, centerOf(data.item).y, data.dx, 0);
+            movingSpy.wait();
+            waitForRendering(data.item, 400);
+            movingSpy.clear();
+            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; }, 0.0, 1000, "Not snapped back");
+            }
+        }
+
+        function test_snap_gesture_data() {
+            var listItem = findChild(listView, "listItem0");
+            var front = Qt.point(units.gu(1), listItem.height / 2);
+            var rear = Qt.point(listItem.width - 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(2)], snapIn: false},
+                {tag: "Snap in, leading", item: listItem, grabPos: front, dx: [units.gu(10), -units.gu(1), units.gu(1)], 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)], snapIn: true},
+            ];
+        }
+        function test_snap_gesture(data) {
+            // performe the moves
+            movingSpy.target = data.item;
+            var pos = data.grabPos;
+            mousePress(data.item.contentItem, pos.x, pos.y);
+            for (var i in data.dx) {
+                var dx = data.dx[i];
+                mouseMoveSlowly(data.item.contentItem, pos.x, pos.y, dx, 0, 5, 100);
+                pos.x += dx;
+            }
+            mouseRelease(data.item.contentItem, 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, 0.0, 0.1, "Not snapped out!");
+            }
+        }
+
+        function test_overshoot_from_style() {
+            // scroll to the last ListView element and test on that, to make sure we don't have the style loaded for that component
+            listView.positionViewAtEnd();
+            var listItem = findChild(listView, "listItem" + (listView.count - 1));
+            verify(listItem, "Cannot get list item for testing");
+
+            compare(listItem.swipeOvershoot, 0.0, "No overshoot should be set yet!");
+            // now swipe
+            movingSpy.target = listItem;
+            flick(listItem.contentItem, centerOf(listItem).x, centerOf(listItem).y, units.gu(5), 0);
+            movingSpy.wait();
+            compare(listItem.swipeOvershoot, listItem.__styleInstance.swipeOvershoot, "Overshoot not taken from style");
+
+            // cleanup
+            rebound(listItem);
+        }
+
+        function test_custom_overshoot_data() {
+            // use different items to make sure the style doesn't update the overshoot values during the test
+            return [
+                {tag: "Positive value", index: listView.count - 1, value: units.gu(10), expected: units.gu(10)},
+                {tag: "Zero value", index: listView.count - 2, value: 0, expected: 0},
+                // synchronize the expected value with the one from Ambiance theme!
+                {tag: "Negative value", index: listView.count - 3, value: -1, expected: units.gu(2)},
+            ];
+        }
+        function test_custom_overshoot(data) {
+            // scroll to the last ListView element and test on that, to make sure we don't have the style loaded for that component
+            listView.positionViewAtEnd();
+            var listItem = findChild(listView, "listItem" + data.index);
+            verify(listItem, "Cannot get list item for testing");
+
+            compare(listItem.swipeOvershoot, 0.0, "No overshoot should be set yet!");
+            listItem.swipeOvershoot = data.value;
+            // now swipe
+            movingSpy.target = listItem;
+            flick(listItem.contentItem, centerOf(listItem).x, centerOf(listItem).y, units.gu(5), 0);
+            movingSpy.wait();
+            compare(listItem.swipeOvershoot, data.expected, "Overshoot differs from one set!");
+
+            // cleanup
+            rebound(listItem);
+        }
+
+        function test_verify_action_value_data() {
+            var item0 = findChild(listView, "listItem0");
+            var item1 = findChild(listView, "listItem1");
+            var item2 = findChild(listView, "listItem2");
+            var item3 = findChild(listView, "listItem3");
+            return [
+                // testItem is the child item @index 1 in the topmost Column.
+                {tag: "Standalone item, child index 1", item: testItem, result: 1},
+                {tag: "ListView, item index 0", item: item0, result: 0},
+                {tag: "ListView, item index 1", item: item1, result: 1},
+                {tag: "ListView, item index 2", item: item2, result: 2},
+                {tag: "ListView, item index 3", item: item3, result: 3},
+            ];
+        }
+        function test_verify_action_value(data) {
+            // tug actions in
+            movingSpy.target = data.item;
+            flick(data.item, centerOf(data.item).x, centerOf(data.item).y, units.gu(20), 0, 100, 10);
+            movingSpy.wait();
+            verify(data.item.contentItem.x != 0.0, "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.clear();
+            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");
+        }
+    }
+}