Merge lp:~bzoltan/ubuntu-ui-toolkit/new_list_item into lp:ubuntu-ui-toolkit

[Zoltan Balogh]

New List Item

New List Item

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1247
http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-ci/2148/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/4811/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/3520/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-amd64-ci/94/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-armhf-ci/94/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/6063/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/3826/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/2148/rebuild

review: Needs Fixing (continuous-integration)

[lp:~bzoltan/ubuntu-ui-toolkit/new_list_item]

1248. By Zoltan Balogh on 2014-09-15

Fix changelog

1249. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/10-viewitem

1250. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/20-divider

1251. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/30-options

1252. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/35-options-panel-swipe

1253. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/40-visualize-options

1254. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/45-selected-option-rebinds

1255. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/50-custom-delegates

1256. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/55-snap-options

1257. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/60-action-value-type

1258. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/65-last-divider-invisible

1259. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/67-fix-disabled-listitem

1260. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/70-ubuntulistview-integration

1261. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/80-selection-mode

1262. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/84-pressandhold

1263. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/86-exposing-status-and-connectedItem

1264. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/88-expose-panelColor

1265. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/90-update-gallery

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1248
http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-ci/2149/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/4814/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/3522/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-amd64-ci/95/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-armhf-ci/95/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/6066/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/3828/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/2149/rebuild

review: Needs Fixing (continuous-integration)

[lp:~bzoltan/ubuntu-ui-toolkit/new_list_item]

1266. By Zoltan Balogh on 2014-09-15

Updated lp:~zsombi/ubuntu-ui-toolkit/10-viewitem

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1247
http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-ci/2150/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/4816
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/3523
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-amd64-ci/96
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-armhf-ci/96
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-armhf-ci/96/artifact/work/output/*zip*/output.zip
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/4580
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/6068
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/6068/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/13195
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-utopic/2919
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/3829
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/3829/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/2150/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1266
http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-ci/2151/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/4819
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/3525/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-amd64-ci/97/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-armhf-ci/97
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-ui-toolkit-utopic-armhf-ci/97/artifact/work/output/*zip*/output.zip
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/4583
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/6071
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/6071/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/13201
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/3831/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-ui-toolkit-ci/2151/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

1266. By Zoltan Balogh on 2014-09-15

Updated lp:~zsombi/ubuntu-ui-toolkit/10-viewitem

1265. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/90-update-gallery

1264. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/88-expose-panelColor

1263. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/86-exposing-status-and-connectedItem

1262. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/84-pressandhold

1261. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/80-selection-mode

1260. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/70-ubuntulistview-integration

1259. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/67-fix-disabled-listitem

1258. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/65-last-divider-invisible

1257. By Zoltan Balogh on 2014-09-15

lp:~zsombi/ubuntu-ui-toolkit/60-action-value-type

=== modified file 'components.api'
--- components.api	2014-09-05 05:49:46 +0000
+++ components.api	2014-09-15 11:00:03 +0000
@@ -673,6 +673,7 @@
 UbuntuListView 1.1
 UbuntuListView
     property PullToRefresh pullToRefresh
+    property ListItemOptions leadingOptions
 UbuntuNumberAnimation 0.1 1.0
 NumberAnimation
 PerformanceOverlay 0.1 1.0
@@ -814,6 +815,42 @@
     name: "UCInverseMouse"
     prototype: "UCMouse"
     exports: ["InverseMouse 0.1", "InverseMouse 1.0"]
+    name: "UCListItem"
+    prototype: "UCStyledItemBase"
+    exports: ["ListItem 1.1"]
+    Property { name: "contentItem"; type: "UCListItemContent"; isReadonly: true; isPointer: true }
+    Property { name: "divider"; type: "UCListItemDivider"; isReadonly: true; isPointer: true }
+    Property { name: "leadingOptions"; type: "UCListItemOptions"; isPointer: true }
+    Property { name: "trailingOptions"; type: "UCListItemOptions"; isPointer: true }
+    Property { name: "pressed"; type: "bool"; isReadonly: true }
+    Property { name: "selectable"; type: "bool" }
+    Property { name: "selected"; type: "bool" }
+    Property { name: "data"; type: "QObject"; isList: true; isReadonly: true }
+    Property { name: "children"; type: "QQuickItem"; isList: true; isReadonly: true }
+    Signal { name: "clicked" }
+    Signal { name: "pressAndHold" }
+    name: "UCListItemContent"
+    prototype: "QQuickItem"
+    Property { name: "color"; type: "QColor" }
+    Property { name: "pressedColor"; type: "QColor" }
+    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: "UCListItemOptions"
+    prototype: "QObject"
+    exports: ["ListItemOptions 1.1"]
+    name: "Status"
+    Property { name: "delegate"; type: "QQmlComponent"; isPointer: true }
+    Property { name: "options"; type: "QObject"; isList: true; isReadonly: true }
+    Property { name: "panelItem"; type: "QQuickItem"; isReadonly: true; isPointer: true }
+    Property { name: "status"; type: "Status"; isReadonly: true }
+    Property { name: "connectedItem"; type: "UCListItem"; isReadonly: true; isPointer: true }
+    Property { name: "panelColor"; type: "QColor" }
+    Property { name: "iconColor"; type: "QColor" }
     name: "UCMouse"
     prototype: "QObject"
     exports: ["Mouse 0.1", "Mouse 1.0"]

=== modified file 'debian/changelog'
--- debian/changelog	2014-09-08 17:53:18 +0000
+++ debian/changelog	2014-09-15 11:00:03 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 ubuntu-ui-toolkit (1.1.1239+14.10.20140908-0ubuntu1) utopic; urgency=medium
 
   [ Zsombor Egri ]
@@ -45,6 +46,34 @@
 
  -- Ubuntu daily release <[e-mail]>  Mon, 08 Sep 2014 17:53:18 +0000
 
+=======
+ubuntu-ui-toolkit (1.1.1247+14.10.20140904-0ubuntu2) UNRELEASED; urgency=medium
+
+  [ Zsombor Egri ]
+  * New ListItem component 
+  * Sheet header button space reservation made button presence 
+    dependent. Fixes: LP: #1356636
+  * Tweaks for ListItem dividers. Header margins and font weight
+    updated.
+  * Exclude UbuntuColors dumped erroneously by qmlplugindump as it
+    would be a C++ type.
+  * Organizer audible reminder wasn't updated when Alarm sound 
+    changed.
+
+  [ Zoltán Balogh ]
+  * Updated test plan execution for RTM images and for new phablet
+    tools. 
+
+  [ Christian Dywan ]
+  * Specify /sbin when calling initctl just like autopilot does.
+
+  [ Leo Arias ]
+  * On autopilot tests launched by upstart, use the local modules
+    if running from a branch.
+
+ -- Zoltán Balogh <[e-mail]>  Mon, 15 Sep 2014 10:50:49 +0300
+
+>>>>>>> MERGE-SOURCE
 ubuntu-ui-toolkit (1.1.1227+14.10.20140904-0ubuntu1) utopic; urgency=medium
 
   [ Zsombor Egri ]

=== modified file 'examples/ubuntu-ui-toolkit-gallery/ListItems.qml'
--- examples/ubuntu-ui-toolkit-gallery/ListItems.qml	2014-07-18 12:12:05 +0000
+++ examples/ubuntu-ui-toolkit-gallery/ListItems.qml	2014-09-15 11:00:03 +0000
@@ -22,6 +22,39 @@
     objectName: "listItemsTemplate"
 
     ListItemsSection {
+        title: i18n.tr("ListItem - without layout")
+        className: "ListItem"
+        clip: true
+        delegate: Toolkit.ListItem {
+            leadingOptions: Toolkit.ListItemOptions {
+                Toolkit.Action {
+                    iconName: "delete"
+                }
+            }
+            trailingOptions: Toolkit.ListItemOptions {
+                Toolkit.Action {
+                    iconName: "edit"
+                }
+                Toolkit.Action {
+                    iconName: "contact"
+                }
+                Toolkit.Action {
+                    iconName: "email"
+                }
+            }
+
+            Toolkit.Label {
+                anchors {
+                    top: parent.top
+                    bottom: parent.bottom
+                }
+                verticalAlignment: Text.AlignVCenter
+                text: "Plain ListItem #" + modelData
+            }
+        }
+    }
+
+    ListItemsSection {
         title: i18n.tr("Standard")
         className: "Standard"
         delegate: ListItem.Standard {

=== modified file 'export_modules_dir.sh'
--- export_modules_dir.sh	2014-07-14 17:34:44 +0000
+++ export_modules_dir.sh	2014-09-15 11:00:03 +0000
@@ -18,3 +18,6 @@
 export QML_IMPORT_PATH=$PWD/modules
 export QML2_IMPORT_PATH=$PWD/modules
 export UBUNTU_UI_TOOLKIT_THEMES_PATH=$PWD/modules
+/sbin/initctl set-env --global QML_IMPORT_PATH=$PWD/modules
+/sbin/initctl set-env --global QML2_IMPORT_PATH=$PWD/modules
+/sbin/initctl set-env --global UBUNTU_UI_TOOLKIT_THEMES_PATH=$PWD/modules

=== added file 'modules/Ubuntu/Components/ListItemPanel.qml'
--- modules/Ubuntu/Components/ListItemPanel.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/ListItemPanel.qml	2014-09-15 11:00:03 +0000
@@ -0,0 +1,143 @@
+/*
+ * 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.1
+
+/*
+  This component is the holder of the ListItem options.
+  */
+Item {
+    id: panel
+    width: optionsRow.childrenRect.width
+
+    readonly property Item contentItem: parent ? parent.contentItem : null
+
+    /*
+      Index of the ListItem, if the ListItem is inside a ListView or has been
+      created using a Repeater.
+      */
+    property int listItemIndex: -1
+
+    /*
+      Specifies whether the panel is used to visualize leading or trailing options.
+      */
+    property bool leadingPanel: false
+    /*
+      The delegate to be used to visualize the options
+      */
+    property Component delegate
+
+    /*
+      Options
+      */
+    property var optionList
+
+    /*
+      Panel and icon colors
+      */
+    property color panelColor
+    property color iconColor
+
+    /*
+      Emitted when action is triggered
+      */
+    signal selected()
+
+    // fire selected action when parent is removed
+    onParentChanged: {
+        if (!parent && selectedAction) {
+            selectedAction.triggered(listItemIndex >= 0 ? listItemIndex : null);
+            selectedAction = null;
+        }
+    }
+    property Action selectedAction: null
+
+    anchors {
+        left: contentItem ? (leadingPanel ? undefined : contentItem.right) : undefined
+        right: contentItem ? (leadingPanel ? contentItem.left : undefined) : undefined
+        top: contentItem ? contentItem.top : undefined
+        bottom: contentItem ? contentItem.bottom : undefined
+    }
+
+    Rectangle {
+        anchors.fill: parent
+        // FIXME: use Palette colors instead when available
+        color: (panel.panelColor != "#000000") ? panel.panelColor : (leadingPanel ? UbuntuColors.red : "#00000000")
+    }
+
+    Row {
+        id: optionsRow
+        anchors {
+            left: parent.left
+            top: parent.top
+            bottom: parent.bottom
+            leftMargin: spacing
+        }
+
+        property real maxItemWidth: panel.parent ? (panel.parent.width / panel.optionList.length) : 0
+
+        Repeater {
+            model: panel.optionList
+            AbstractButton {
+                action: modelData
+                width: (!visible || !enabled) ?
+                           0 : MathUtils.clamp(delegateLoader.item ? delegateLoader.item.width : 0, height, optionsRow.maxItemWidth)
+                anchors {
+                    top: parent.top
+                    bottom: parent.bottom
+                }
+
+                function trigger() {
+                    // save the action as we trigger when the rebound animation is over
+                    // to make sure we properly clean up the blockade of teh Flickables
+                    panel.selectedAction = action;
+                    panel.selected();
+                }
+
+                Loader {
+                    id: delegateLoader
+                    height: parent.height
+                    sourceComponent: panel.delegate ? panel.delegate : defaultDelegate
+                    property Action option: modelData
+                    property int index: index
+                    onItemChanged: {
+                        // this is needed only for testing purposes
+                        if (item && item.objectName === "") {
+                            item.objectName = "list_option_" + index
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Component {
+        id: defaultDelegate
+        Item {
+            width: height
+            Icon {
+                width: units.gu(2.5)
+                height: width
+                name: option.iconName
+                // FIXME: use Palette colors instead when available
+                color: (panel.iconColor != "#000000") ?
+                           panel.iconColor : (panel.leadingPanel ? "white" : UbuntuColors.lightGrey)
+                anchors.centerIn: parent
+            }
+        }
+    }
+}

=== added file 'modules/Ubuntu/Components/ListItemSelectablePanel.qml'
--- modules/Ubuntu/Components/ListItemSelectablePanel.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/ListItemSelectablePanel.qml	2014-09-15 11:00:03 +0000
@@ -0,0 +1,49 @@
+/*
+ * 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.1
+
+/*
+  This component is the holder of the ListItem selection checkbox.
+  */
+Rectangle {
+    id: panel
+    width: height
+
+    /*
+      Internally used to link to the list item's content
+      */
+    readonly property Item contentItem: parent ? parent.contentItem : null
+
+    /*
+      Exposed checked property linked to the listItem's selected
+      */
+    property alias checked: checkbox.checked
+
+    color: checked ? contentItem.pressedColor : contentItem.color
+
+    anchors {
+        right: contentItem ? contentItem.left : undefined
+        top: contentItem ? contentItem.top : undefined
+        bottom: contentItem ? contentItem.bottom : undefined
+    }
+
+    CheckBox {
+        id: checkbox
+        anchors.centerIn: parent
+    }
+}

=== modified file 'modules/Ubuntu/Components/ListItems/Empty.qml'
--- modules/Ubuntu/Components/ListItems/Empty.qml	2014-08-08 14:30:27 +0000
+++ modules/Ubuntu/Components/ListItems/Empty.qml	2014-09-15 11:00:03 +0000
@@ -307,7 +307,11 @@
 
     ThinDivider {
         id: bottomDividerLine
-        anchors.bottom: parent.bottom
+        anchors {
+            bottom: parent.bottom
+            leftMargin: units.gu(2)
+            rightMargin: units.gu(2)
+        }
         visible: showDivider && !priv.removed
     }
 

=== modified file 'modules/Ubuntu/Components/ListItems/Header.qml'
--- modules/Ubuntu/Components/ListItems/Header.qml	2014-04-20 19:25:12 +0000
+++ modules/Ubuntu/Components/ListItems/Header.qml	2014-09-15 11:00:03 +0000
@@ -60,11 +60,12 @@
     LabelVisual {
         id: label
         fontSize: "medium"
+        font.weight: Text.Normal
         anchors {
             verticalCenter: parent.verticalCenter
             left: parent.left
             right: parent.right
-            margins: units.gu(1)
+            margins: units.gu(2)
         }
     }
 
@@ -73,6 +74,8 @@
             left: parent.left
             right: parent.right
             bottom: parent.bottom
+            leftMargin: units.gu(2)
+            rightMargin: units.gu(2)
         }
     }
 }

=== modified file 'modules/Ubuntu/Components/ListItems/ThinDivider.qml'
--- modules/Ubuntu/Components/ListItems/ThinDivider.qml	2014-08-27 09:26:59 +0000
+++ modules/Ubuntu/Components/ListItems/ThinDivider.qml	2014-09-15 11:00:03 +0000
@@ -49,8 +49,6 @@
     anchors {
         left: (parent) ? parent.left : null
         right: (parent) ? parent.right : null
-        leftMargin: units.gu(2)
-        rightMargin: units.gu(2)
     }
     height: (visible) ? units.dp(2) : 0
     // a private property to catch theme background color change

=== modified file 'modules/Ubuntu/Components/Themes/Ambiance/SheetForegroundStyle.qml'
--- modules/Ubuntu/Components/Themes/Ambiance/SheetForegroundStyle.qml	2014-04-23 08:50:20 +0000
+++ modules/Ubuntu/Components/Themes/Ambiance/SheetForegroundStyle.qml	2014-09-15 11:00:03 +0000
@@ -60,7 +60,7 @@
                 top: parent.top
                 bottom: parent.bottom
             }
-            width: visuals.buttonContainerWidth
+            width: styledItem.leftButton ? visuals.buttonContainerWidth : 0
             Component.onCompleted: header.updateButton(styledItem.leftButton, leftButtonContainer)
         }
 
@@ -71,7 +71,7 @@
                 top: parent.top
                 bottom: parent.bottom
             }
-            width: visuals.buttonContainerWidth
+            width: styledItem.rightButton ? visuals.buttonContainerWidth : 0
             Component.onCompleted: header.updateButton(styledItem.rightButton, rightButtonContainer)
         }
 

=== modified file 'modules/Ubuntu/Components/UbuntuListView11.qdoc'
--- modules/Ubuntu/Components/UbuntuListView11.qdoc	2014-05-22 07:05:47 +0000
+++ modules/Ubuntu/Components/UbuntuListView11.qdoc	2014-09-15 11:00:03 +0000
@@ -36,3 +36,45 @@
   }
   \endqml
   */
+
+/*!
+ * \qmlproperty ListItemOptions UbuntuListView::leadingOptions
+ * The property holds the default leading options defined by the UbuntuListView.
+ * The option list can be overridden either by specifying a different \l ListItemOptions
+ * instance to the property or doing the same in \l ListItem itself. The default
+ * option list contains a single delete action, which removes the model data from
+ * the triggered index.
+ * \qml
+ * UbuntuListView {
+ *     width: units.gu(30)
+ *     height: units.gu(24)
+ *     leadingOptions: ListItemOptions {
+ *         Action {
+ *             iconName: "edit"
+ *             onTriggered: console.log("edit triggered on item index", value)
+ *         }
+ *     }
+ *     model: 10
+ *     delegate: ListItem {
+ *     }
+ * }
+ * \endqml
+ * And its equivalent:
+ * \qml
+ * UbuntuListView {
+ *     width: units.gu(30)
+ *     height: units.gu(24)
+ *     model: 10
+ *     delegate: ListItem {
+ *         leadingOptions: ListItemOptions {
+ *             Action {
+ *                 iconName: "edit"
+ *                 onTriggered: console.log("edit triggered on item index", value)
+ *             }
+ *         }
+ *     }
+ * }
+ * \endqml
+ * \note Setting \c leadingOptions on \l ListItem itself has precedence over the
+ * UbuntuListView property.
+ */

=== modified file 'modules/Ubuntu/Components/UbuntuListView11.qml'
--- modules/Ubuntu/Components/UbuntuListView11.qml	2014-06-04 07:54:35 +0000
+++ modules/Ubuntu/Components/UbuntuListView11.qml	2014-09-15 11:00:03 +0000
@@ -15,16 +15,47 @@
  */
 
 import QtQuick 2.2
+import Ubuntu.Components 1.1
 
 // documentation in UbuntuListView11.qdoc
 UbuntuListView {
-
+    id: listView
     /*!
       \internal
       \qmlproperty PullToRefresh pullToRefresh
       */
     property alias pullToRefresh: refreshItem
 
+    /*!
+      \internal
+      \qmlproperty ListItemOptions leadingOptions
+      Use binding so we can set it to each ListItem as binding!
+      */
+    property ListItemOptions leadingOptions: stockLeadingOption
+    ListItemOptions {
+        id: stockLeadingOption
+        options: Action {
+            iconName: "delete"
+            onTriggered: {
+                // delete the index from model if possible
+                if (Object.prototype.toString.call(listView.model) === "[object Number]") {
+                    // the model is a number, decrement it
+                    listView.model = listView.count - 1;
+                } else if (Object.prototype.toString.call(listView.model) === "[object Array]") {
+                    // the model is an array, remove the item from index
+                    var array = listView.model;
+                    array.splice(value, 1);
+                    listView.model = array;
+                } else {
+                    // we can only have an object
+                    if (listView.model.hasOwnProperty("remove")) {
+                        listView.model.remove(value, 1);
+                    }
+                }
+            }
+        }
+    }
+
     PullToRefresh {
         objectName: "listview_pulltorefresh"
         id: refreshItem

=== modified file 'modules/Ubuntu/Components/plugin/plugin.cpp'
--- modules/Ubuntu/Components/plugin/plugin.cpp	2014-09-05 05:05:54 +0000
+++ modules/Ubuntu/Components/plugin/plugin.cpp	2014-09-15 11:00:03 +0000
@@ -50,6 +50,9 @@
 #include "ucinversemouse.h"
 #include "sortfiltermodel.h"
 #include "ucstyleditembase.h"
+#include "uclistitem.h"
+#include "uclistitem_p.h"
+#include "uclistitemoptions.h"
 
 #include <sys/types.h>
 #include <unistd.h>
@@ -157,6 +160,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
+    qmlRegisterType<UCListItem, 1>(uri, 1, 1, "ListItem");
+    qmlRegisterType<UCListItemContent>();
+    qmlRegisterType<UCListItemDivider>();
+    qmlRegisterType<UCListItemOptions, 1>(uri, 1, 1, "ListItemOptions");
 }
 
 void UbuntuComponentsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'modules/Ubuntu/Components/plugin/plugin.pro'
--- modules/Ubuntu/Components/plugin/plugin.pro	2014-09-02 09:39:09 +0000
+++ modules/Ubuntu/Components/plugin/plugin.pro	2014-09-15 11:00:03 +0000
@@ -65,7 +65,12 @@
     ucmouse.h \
     unixsignalhandler_p.h \
     ucstyleditembase.h \
-    ucstyleditembase_p.h
+    ucstyleditembase_p.h \
+    uclistitem.h \
+    uclistitem_p.h \
+    uclistitemoptions.h \
+    uclistitemoptions_p.h \
+    propertychange_p.h
 
 SOURCES += plugin.cpp \
     uctheme.cpp \
@@ -99,7 +104,10 @@
     ucurihandler.cpp \
     ucmousefilters.cpp \
     unixsignalhandler_p.cpp \
-    ucstyleditembase.cpp
+    ucstyleditembase.cpp \
+    uclistitem.cpp \
+    uclistitemoptions.cpp \
+    propertychange_p.cpp
 
 # adapters
 SOURCES += adapters/alarmsadapter_organizer.cpp

=== added file 'modules/Ubuntu/Components/plugin/propertychange_p.cpp'
--- modules/Ubuntu/Components/plugin/propertychange_p.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/propertychange_p.cpp	2014-09-15 11:00:03 +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-09-15 11:00:03 +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-06-10 11:47:09 +0000
+++ modules/Ubuntu/Components/plugin/quickutils.cpp	2014-09-15 11:00:03 +0000
@@ -135,6 +135,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-06-10 11:47:09 +0000
+++ modules/Ubuntu/Components/plugin/quickutils.h	2014-09-15 11:00:03 +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:

=== 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-09-15 11:00:03 +0000
@@ -0,0 +1,1116 @@
+/*
+ * 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 "uclistitemoptions.h"
+#include "uclistitemoptions_p.h"
+#include "ucubuntuanimation.h"
+#include "propertychange_p.h"
+#include "i18n.h"
+#include "quickutils.h"
+#include "plugin.h"
+#include "ucmouse.h"
+#include <QtQml/QQmlInfo>
+#include <QtQuick/private/qquickitem_p.h>
+#include <QtQuick/private/qquickflickable_p.h>
+#include <QtQuick/private/qquickpositioners_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
+
+
+#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;
+}
+/******************************************************************************
+ * Divider
+ */
+UCListItemDivider::UCListItemDivider(QObject *parent)
+    : QObject(parent)
+    , m_visible(true)
+    , m_lastItem(false)
+    , 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().gu(2);
+    }
+    if (!m_rightMarginChanged) {
+        m_rightMargin = UCUnits::instance().gu(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 *paintNode, const QRectF &rect)
+{
+    if (m_visible && !m_lastItem && (m_gradient.size() > 0)) {
+        QSGRectangleNode *rectNode = static_cast<QSGRectangleNode *>(paintNode);
+        if (!rectNode) {
+            rectNode = m_listItem->sceneGraphContext()->createRectangleNode();
+        }
+        rectNode->setRect(QRectF(m_leftMargin, rect.height() - m_thickness,
+                                 rect.width() - m_leftMargin - m_rightMargin, m_thickness));
+        rectNode->setGradientStops(m_gradient);
+        rectNode->update();
+        return rectNode;
+    } else {
+        delete paintNode;
+        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();
+}
+
+/******************************************************************************
+ * ListItemContent
+ */
+UCListItemContent::UCListItemContent(QQuickItem *parent)
+    : QQuickItem(parent)
+    , m_color(Qt::transparent)
+    , m_pressedColor(Qt::yellow)
+    , m_item(0)
+{
+    setFlag(QQuickItem::ItemHasContents);
+    // catch theme palette changes
+    connect(&UCTheme::instance(), &UCTheme::paletteChanged, this, &UCListItemContent::updateColors);
+    updateColors();
+}
+
+UCListItemContent::~UCListItemContent()
+{
+}
+
+void UCListItemContent::setColor(const QColor &color)
+{
+    if (m_color == color) {
+        return;
+    }
+    m_color = color;
+    update();
+    Q_EMIT colorChanged();
+}
+
+void UCListItemContent::setPressedColor(const QColor &color)
+{
+    if (m_pressedColor == color) {
+        return;
+    }
+    m_pressedColor = color;
+    // no more theme change watch
+    disconnect(&UCTheme::instance(), &UCTheme::paletteChanged, this, &UCListItemContent::updateColors);
+    update();
+    Q_EMIT pressedColorChanged();
+}
+
+void UCListItemContent::updateColors()
+{
+    m_pressedColor = getPaletteColor("selected", "background");
+    update();
+}
+
+
+void UCListItemContent::itemChange(ItemChange change, const ItemChangeData &data)
+{
+    if (change == ItemParentHasChanged) {
+        m_item = qobject_cast<UCListItem*>(data.item);
+    }
+    QQuickItem::itemChange(change, data);
+}
+
+QSGNode *UCListItemContent::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
+{
+    Q_UNUSED(data);
+
+    UCListItemPrivate *dd = UCListItemPrivate::get(m_item);
+    bool pressed = (dd && dd->pressed);
+    bool selected = (dd && dd->selectable && dd->selected);
+    QColor color = (pressed || selected) ? m_pressedColor : m_color;
+
+    delete oldNode;
+    if (width() <= 0 || height() <= 0 || (color.alpha() == 0)) {
+        return 0;
+    }
+
+    QSGRectangleNode *rectNode = QQuickItemPrivate::get(this)->sceneGraphContext()->createRectangleNode();
+    rectNode->setColor(color);
+    rectNode->setRect(boundingRect());
+    rectNode->update();
+    return rectNode;
+}
+
+
+/******************************************************************************
+ * ListItemBasePrivate
+ */
+UCListItemPrivate::UCListItemPrivate()
+    : UCStyledItemBasePrivate()
+    , pressed(false)
+    , moved(false)
+    , ready(false)
+    , selectable(false)
+    , selected(false)
+    , index(-1)
+    , xAxisMoveThresholdGU(1.5)
+    , reboundAnimation(0)
+    , flickableInteractive(0)
+    , disabledOpacity(0)
+    , contentItem(new UCListItemContent)
+    , divider(new UCListItemDivider)
+    , leadingOptions(0)
+    , trailingOptions(0)
+    , selectionPanel(0)
+{
+}
+UCListItemPrivate::~UCListItemPrivate()
+{
+    delete flickableInteractive;
+    delete disabledOpacity;
+}
+
+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, &UCListItemContent::childrenChanged,
+                     q, &UCListItem::childrenChanged);
+    q->setFlag(QQuickItem::ItemHasContents);
+    // turn activeFocusOnPress on
+    activeFocusOnPress = true;
+    setFocusable();
+
+    // watch size change and set implicit size;
+    QObject::connect(&UCUnits::instance(), SIGNAL(gridUnitChanged()), q, SLOT(_q_updateSize()));
+    _q_updateSize();
+
+    // watch enabledChanged()
+    QObject::connect(q, SIGNAL(enabledChanged()), q, SLOT(_q_dimmDisabled()), Qt::DirectConnection);
+
+    // create rebound animation
+    UCUbuntuAnimation animationCodes;
+    reboundAnimation = new QQuickPropertyAnimation(q);
+    reboundAnimation->setEasing(animationCodes.StandardEasing());
+    reboundAnimation->setDuration(animationCodes.SnapDuration());
+    reboundAnimation->setTargetObject(contentItem);
+    reboundAnimation->setProperty("x");
+    reboundAnimation->setAlwaysRunToEnd(true);
+}
+
+void UCListItemPrivate::setFocusable()
+{
+    // alsways accept mouse events
+    Q_Q(UCListItem);
+    q->setAcceptedMouseButtons(Qt::LeftButton | Qt::MiddleButton | Qt::RightButton);
+    q->setFiltersChildMouseEvents(true);
+}
+
+void UCListItemPrivate::_q_dimmDisabled()
+{
+    Q_Q(UCListItem);
+    if (q->isEnabled()) {
+        PropertyChange::restore(disabledOpacity);
+    } else if (opacity() != 0.5) {
+        // this is the first time we need to create the property change
+        if (!disabledOpacity) {
+            disabledOpacity = new PropertyChange(q, "opacity");
+        }
+        PropertyChange::setValue(disabledOpacity, 0.5);
+    }
+}
+
+void UCListItemPrivate::_q_rebound()
+{
+    setPressed(false);
+    // initiate rebinding only if there were options tugged
+    Q_Q(UCListItem);
+    if (!UCListItemOptionsPrivate::isConnectedTo(leadingOptions, q) && !UCListItemOptionsPrivate::isConnectedTo(trailingOptions, q)) {
+        return;
+    }
+    setMoved(false);
+    //connect rebound completion so we can disconnect
+    QObject::connect(reboundAnimation, SIGNAL(stopped()), q, SLOT(_q_completeRebinding()));
+    // then rebound to zero
+    reboundTo(0);
+}
+void UCListItemPrivate::_q_completeRebinding()
+{
+    Q_Q(UCListItem);
+    // disconnect animation, otherwise snapping will disconnect the panel
+    QObject::disconnect(reboundAnimation, SIGNAL(stopped()), q, SLOT(_q_completeRebinding()));
+    // restore flickable's interactive and cleanup
+    PropertyChange::restore(flickableInteractive);
+    // disconnect options
+    grabPanel(leadingOptions, false);
+    grabPanel(trailingOptions, false);
+}
+
+void UCListItemPrivate::_q_updateIndex(QObject *ownerItem)
+{
+    Q_Q(UCListItem);
+    if (!ownerItem) {
+        ownerItem = q->sender();
+    }
+    Q_ASSERT(ownerItem);
+    // update the index as well
+    QQmlContext *context = qmlContext(q);
+    if (context) {
+        QVariant indexProperty = context->contextProperty("index");
+        index = indexProperty.isValid() ? indexProperty.toInt() : -1;
+    }
+    divider->m_lastItem = ready && index == (ownerItem->property("count").toInt() - 1);
+}
+
+void UCListItemPrivate::_q_updateSelected()
+{
+    Q_Q(UCListItem);
+    bool checked = selectionPanel->property("checked").toBool();
+    q->setSelected(checked);
+    contentItem->update();
+}
+
+// the function performs a cleanup on mouse release without any rebound animation
+void UCListItemPrivate::cleanup()
+{
+    setPressed(false);
+    setMoved(false);
+    _q_completeRebinding();
+}
+
+void UCListItemPrivate::reboundTo(qreal x)
+{
+    reboundAnimation->setFrom(contentItem->x());
+    reboundAnimation->setTo(x);
+    reboundAnimation->restart();
+}
+
+// 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));
+}
+
+// set pressed flag and update contentItem
+void UCListItemPrivate::setPressed(bool pressed)
+{
+    if (this->pressed != pressed) {
+        this->pressed = pressed;
+        suppressClick = false;
+        contentItem->update();
+        Q_Q(UCListItem);
+        Q_EMIT q->pressedChanged();
+    }
+}
+// toggles the moved flag and installs/removes event filter
+void UCListItemPrivate::setMoved(bool moved)
+{
+    suppressClick = moved;
+    if (this->moved == moved) {
+        return;
+    }
+    this->moved = moved;
+    Q_Q(UCListItem);
+    QQuickWindow *window = q->window();
+    if (!window) {
+        return;
+    }
+    if (moved) {
+        window->installEventFilter(q);
+    } else {
+        window->removeEventFilter(q);
+    }
+}
+
+// sets the moved flag but also grabs the panels from the leading/trailing options
+bool UCListItemPrivate::grabPanel(UCListItemOptions *optionsList, bool isMoved)
+{
+    Q_Q(UCListItem);
+    if (isMoved) {
+        bool grab = UCListItemOptionsPrivate::connectToListItem(optionsList, q, (optionsList == leadingOptions));
+        if (grab) {
+            PropertyChange::setValue(flickableInteractive, false);
+        }
+        return grab;
+    } else {
+        UCListItemOptionsPrivate::disconnectFromListItem(optionsList);
+        return false;
+    }
+}
+
+
+// connects/disconnects from the Flickable anchestor to get notified when to do rebound
+void UCListItemPrivate::listenToRebind(bool listen)
+{
+    if (flickable.isNull()) {
+        return;
+    }
+    Q_Q(UCListItem);
+    if (listen) {
+        QObject::connect(flickable.data(), SIGNAL(movementStarted()), q, SLOT(_q_rebound()));
+    } else {
+        QObject::disconnect(flickable.data(), SIGNAL(movementStarted()), q, SLOT(_q_rebound()));
+    }
+}
+
+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();
+}
+
+void UCListItemPrivate::clampX(qreal &x, qreal dx)
+{
+    UCListItemOptionsPrivate *leading = UCListItemOptionsPrivate::get(leadingOptions);
+    UCListItemOptionsPrivate *trailing = UCListItemOptionsPrivate::get(trailingOptions);
+    x += dx;
+    // min cannot be less than the trailing's panel width
+    qreal min = (trailing && trailing->panelItem) ? -trailing->panelItem->width() : 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() : 0;
+    x = CLAMP(x, min, max);
+}
+
+void UCListItemPrivate::autoLeadingOptions()
+{
+    Q_Q(UCListItem);
+    if (flickable && flickable->property("leadingOptions").isValid() && !leadingOptions) {
+        QQmlProperty prop(flickable, "leadingOptions", qmlContext(flickable));
+        QQmlAbstractBinding *binding = QQmlPropertyPrivate::binding(prop);
+        // set the value first, then bind
+        q->setLeadingOptions(prop.read().value<UCListItemOptions*>());
+        if (binding) {
+            // set the binding to our leadingOptions property
+            QQmlProperty leadingOptionsProperty(q, "leadingOptions", qmlContext(q));
+            QQmlAbstractBinding *oldBinding = QQmlPropertyPrivate::setBinding(leadingOptionsProperty, binding);
+            if (oldBinding && (oldBinding != binding)) {
+                oldBinding->destroy();
+            }
+        }
+    }
+}
+
+QQuickItem *UCListItemPrivate::createSelectionPanel()
+{
+    Q_Q(UCListItem);
+    if (!selectionPanel) {
+        QUrl panelDocument = UbuntuComponentsPlugin::pluginUrl().
+                resolved(QUrl::fromLocalFile("ListItemSelectablePanel.qml"));
+        QQmlComponent component(qmlEngine(q), panelDocument);
+        if (!component.isError()) {
+            selectionPanel = qobject_cast<QQuickItem*>(component.beginCreate(qmlContext(q)));
+            if (selectionPanel) {
+                QQml_setParent_noEvent(selectionPanel, q);
+                selectionPanel->setParentItem(q);
+                selectionPanel->setVisible(false);
+                selectionPanel->setProperty("checked", selected);
+                // complete component creation
+                component.completeCreate();
+            }
+        } else {
+            qmlInfo(q) << component.errorString();
+        }
+    }
+    return selectionPanel;
+}
+void UCListItemPrivate::toggleSelectionMode()
+{
+    if (!createSelectionPanel()) {
+        return;
+    }
+    Q_Q(UCListItem);
+    if (selectable) {
+        // move and dimm content item
+        selectionPanel->setVisible(true);
+        reboundTo(selectionPanel->width());
+        QObject::connect(selectionPanel, SIGNAL(checkedChanged()), q, SLOT(_q_updateSelected()));
+    } else {
+        // remove content item dimming and destroy selection panel as well
+        reboundTo(0.0);
+        selectionPanel->setVisible(false);
+        QObject::disconnect(selectionPanel, SIGNAL(checkedChanged()), q, SLOT(_q_updateSelected()));
+    }
+    _q_updateSelected();
+}
+
+/*!
+ * \qmltype ListItem
+ * \instantiates UCListItem
+ * \inqmlmodule Ubuntu.Components 1.1
+ * \ingroup ubuntu
+ * \brief The ListItem element provides Ubuntu design standards for list or grid
+ * views.
+ *
+ * The component is dedicated to be used in designs with static or dynamic lists
+ * (i.e. list views where each item's layout differs or in lists where the content
+ * is determined by a given model, thus each element has the same layout). The
+ * element does not define any specific layout, components can be placed in any
+ * ways on it. However, when used in list views, the content must be carefully
+ * chosen to in order to keep the kinetic behavior and the highest FPS possible.
+ *
+ * \c contentItem is an essential part of the component. Beside the fact that it
+ * holds all components and resources declared as child to ListItem, it can also
+ * configure the color of the background when in normal mode or when pressed. Being
+ * an item, all other properties can be accessed or altered, with the exception
+ * of some:
+ * \list A
+ * \li do not alter \c x, \c y, \c width or \c height properties as those are
+ *      controlled by the ListItem itself when leading or trailing options are
+ *      revealed and thus will destroy your logic
+ * \li never anchor left or right anchor lines as it will block revealing the options.
+ * \endlist
+ *
+ * Each ListItem has a thin divider shown on the bottom of the component. This
+ * divider can be configured through the \l 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. In other
+ * circumstances declaring a \c count property in the ListItem's parent item
+ * or Flickable can help applying the last item detection logic.
+ * \qml
+ * Column {
+ *     width: units.gu(40)
+ *     // bring count to Column from Repeater
+ *     property alias count: repeater.count
+ *     Repeater {
+ *         model: 10
+ *         ListItem {
+ *             Label {
+ *                 anchors.fill: parent
+ *                 horizontalCenter: Text.AlignHCenter
+ *                 verticalCenter: Text.AlignVCenter
+ *                 text: "Item #" + modelData
+ *             }
+ *         }
+ *     }
+ * }
+ * \endqml
+ *
+ * ListItem can handle options that can ge tugged from front ot right of the item.
+ * These options are Action elements visualized in panels attached to the front
+ * or to the end 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 options are configured through the \l leadingOptions as well as \l
+ * trailingOptions properties.
+ * \qml
+ * ListItem {
+ *     id: listItem
+ *     leadingOptions: ListItemOptions {
+ *         Action {
+ *             iconName: "delete"
+ *             onTriggered: listItem.destroy()
+ *         }
+ *     }
+ *     trailingOptions: ListItemOptions {
+ *         Action {
+ *             iconName: "search"
+ *             onTriggered: {
+ *                 // do some search
+ *             }
+ *         }
+ *     }
+ * }
+ * \endqml
+ * \note A ListItem cannot use the same ListItemOption instance for both leading or
+ * trailing options. If it is desired to have the same action present in both leading
+ * and trailing options, one of the ListItemOption options list can use the other's
+ * list. In the following example the list item can be deleted through both option
+ * leading and trailing options:
+ * \qml
+ * ListItem {
+ *     id: listItem
+ *     leadingOptions: ListItemOptions {
+ *         Action {
+ *             iconName: "delete"
+ *             onTriggered: listItem.destroy()
+ *         }
+ *     }
+ *     trailingOptions: ListItemOptions {
+ *         options: leadingOptions.options
+ *     }
+ * }
+ * \endqml
+ * \sa ListItemOptions
+ */
+
+/*!
+ * \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 tugged 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()
+{
+}
+
+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!
+     */
+    QQuickItem *countOwner = (d->flickable && d->flickable->property("count").isValid()) ?
+                d->flickable :
+                (d->parentItem && d->parentItem->property("count").isValid()) ? d->parentItem : 0;
+    if (countOwner) {
+        QObject::connect(countOwner, SIGNAL(countChanged()),
+                         this, SLOT(_q_updateIndex()), Qt::DirectConnection);
+        d->_q_updateIndex(countOwner);
+    }
+
+    // check if the parent ListView has leadingOptions defined, if yes, use it!
+    d->autoLeadingOptions();
+}
+
+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());
+        }
+
+        if (d->flickable) {
+            // create the flickableInteractive property change now
+            d->flickableInteractive = new PropertyChange(d->flickable, "interactive");
+            // connect to flickable to get width changes
+            QObject::connect(d->flickable, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()));
+        } else if (data.item) {
+            QObject::connect(data.item, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()));
+        } else {
+            // in case we had a flickableInteractive property change active, destroy it
+            if (d->flickableInteractive) {
+                delete d->flickableInteractive;
+                d->flickableInteractive = 0;
+            }
+            // mar as not ready, so no action should be performed which depends on readyness
+            d->ready = false;
+        }
+
+        // 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);
+    if (width() <= 0 || height() <= 0 || !d->divider) {
+        delete oldNode;
+        return 0;
+    }
+    // paint divider
+    return d->divider->paint(oldNode, boundingRect());
+}
+
+void UCListItem::mousePressEvent(QMouseEvent *event)
+{
+    UCStyledItemBase::mousePressEvent(event);
+    Q_D(UCListItem);
+    if (d->selectable || (!d->flickable.isNull() && d->flickable->isMoving())) {
+        // while moving, we cannot select or tug any items
+        return;
+    }
+    d->setPressed(true);
+    d->lastPos = d->pressedPos = event->localPos();
+    // connect the Flickable to know when to rebound
+    d->listenToRebind(true);
+    // start pressandhold timer
+    d->pressAndHoldTimer.start(DefaultPressAndHoldDelay, this);
+    // 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);
+    if (d->selectable) {
+        // no move is allowed while selectable mode is on
+        return;
+    }
+    d->pressAndHoldTimer.stop();
+    // set released
+    if (d->pressed) {
+        // disconnect the flickable
+        d->listenToRebind(false);
+
+        if (!d->suppressClick) {
+            Q_EMIT clicked();
+            d->_q_rebound();
+        } else {
+            // snap
+            qreal snapPosition = 0.0;
+            if (d->contentItem->x() < 0) {
+                snapPosition = UCListItemOptionsPrivate::snap(d->trailingOptions);
+            } else if (d->contentItem->x() > 0) {
+                snapPosition = UCListItemOptionsPrivate::snap(d->leadingOptions);
+            }
+            if (d->contentItem->x() == 0.0) {
+                // do a cleanup, no need to rebound, the item has been dragged back to 0
+                d->cleanup();
+            } else if (snapPosition == 0.0){
+                d->_q_rebound();
+            } else {
+                d->reboundTo(snapPosition);
+            }
+        }
+    }
+    d->setPressed(false);
+}
+
+void UCListItem::mouseMoveEvent(QMouseEvent *event)
+{
+    Q_D(UCListItem);
+    UCStyledItemBase::mouseMoveEvent(event);
+
+    if (d->selectable) {
+        // no move is allowed while selectable mode is on
+        return;
+    }
+
+    // accept the tugging only if the move is within the threshold
+    bool leadingAttached = UCListItemOptionsPrivate::isConnectedTo(d->leadingOptions, this);
+    bool trailingAttached = UCListItemOptionsPrivate::isConnectedTo(d->trailingOptions, 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();
+            // connect both panels
+            leadingAttached = d->grabPanel(d->leadingOptions, true);
+            trailingAttached = d->grabPanel(d->trailingOptions, true);
+            // stop pressAndHold timer as we started to drag
+            d->pressAndHoldTimer.stop();
+        }
+    }
+
+    if (leadingAttached || trailingAttached) {
+        qreal x = d->contentItem->x();
+        qreal dx = event->localPos().x() - d->lastPos.x();
+        d->lastPos = event->localPos();
+
+        if (dx) {
+            // clamp X into allowed dragging area
+            d->clampX(x, dx);
+            // block flickable
+            d->setMoved(true);
+            d->contentItem->setX(x);
+        }
+    }
+}
+
+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);
+}
+
+void UCListItem::timerEvent(QTimerEvent *event)
+{
+    Q_D(UCListItem);
+    if (isEnabled() && (event->timerId() == d->pressAndHoldTimer.timerId())) {
+        d->pressAndHoldTimer.stop();
+        d->suppressClick = true;
+        Q_EMIT pressAndHold();
+    } else {
+        QQuickItem::timerEvent(event);
+    }
+}
+
+/*!
+ * \qmlproperty ListItemOptions ListItem::leadingOptions
+ *
+ * The property holds the options and its configuration to be revealed when swiped
+ * from left to right.
+ *
+ * \sa trailingOptions
+ */
+UCListItemOptions *UCListItem::leadingOptions() const
+{
+    Q_D(const UCListItem);
+    return d->leadingOptions;
+}
+void UCListItem::setLeadingOptions(UCListItemOptions *options)
+{
+    Q_D(UCListItem);
+    if (d->leadingOptions == options) {
+        return;
+    }
+    d->leadingOptions = options;
+    if (d->leadingOptions == d->trailingOptions && d->leadingOptions) {
+        qmlInfo(this) << UbuntuI18n::tr("leadingOptions and trailingOptions cannot share the same object!");
+    }
+    Q_EMIT leadingOptionsChanged();
+}
+
+/*!
+ * \qmlproperty ListItemOptions ListItem::trailingOptions
+ *
+ * The property holds the options and its configuration to be revealed when swiped
+ * from right to left.
+ *
+ * \sa leadingOptions
+ */
+UCListItemOptions *UCListItem::trailingOptions() const
+{
+    Q_D(const UCListItem);
+    return d->trailingOptions;
+}
+void UCListItem::setTrailingOptions(UCListItemOptions *options)
+{
+    Q_D(UCListItem);
+    if (d->trailingOptions == options) {
+        return;
+    }
+    d->trailingOptions = options;
+    if (d->leadingOptions == d->trailingOptions && d->trailingOptions) {
+        qmlInfo(this) << UbuntuI18n::tr("leadingOptions and trailingOptions cannot share the same object!");
+    }
+    Q_EMIT trailingOptionsChanged();
+}
+
+/*!
+ * \qmlpropertygroup ::ListItem::contentItem
+ * \qmlproperty color ListItem::contentItem.color
+ * \qmlproperty color ListItem::contentItem.pressedColor
+ *
+ * contentItem holds the components placed on a ListItem. \c color configures
+ * the color of the normal contentItem, and \c pressedColor configures the color
+ * when pressed.
+ */
+UCListItemContent* 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
+ *
+ * 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 tugged (swiped left or right to reveal the options),
+ * it is not moved together with the content.
+ *
+ * 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::selectable
+ * The property drives whether a list item is selectable or not. When set, the item
+ * will show a check box on the leading side hanving the content item pushed towards
+ * trailing side and dimmed. The checkbox which will reflect and drive the \l selected
+ * state.
+ * Defaults to false.
+ * \note it is recommended to be used with UbuntuListView which can drive all the
+ * ListItem's selectable.
+ */
+bool UCListItem::selectable() const
+{
+    Q_D(const UCListItem);
+    return d->selectable;
+}
+void UCListItem::setSelectable(bool selectable)
+{
+    Q_D(UCListItem);
+    if (d->selectable == selectable) {
+        return;
+    }
+    d->selectable = selectable;
+    d->toggleSelectionMode();
+    Q_EMIT selectableChanged();
+}
+
+/*!
+ * \qmlproperty bool ListItem::selected
+ * The property drives whether a list item is selected or not. While selected, the
+ * ListItem is dimmed and cannot be tugged. The default value is false.
+ */
+bool UCListItem::selected() const
+{
+    Q_D(const UCListItem);
+    return d->selected;
+}
+void UCListItem::setSelected(bool selected)
+{
+    Q_D(UCListItem);
+    if (d->selected == selected) {
+        return;
+    }
+    d->selected = selected;
+    // update panel as well
+    if (d->selectionPanel) {
+        d->selectionPanel->setProperty("checked", d->selected);
+    }
+    Q_EMIT selectedChanged();
+}
+
+
+/*!
+ * \qmlproperty list<Object> ListItem::data
+ * \default
+ * Overloaded default property containing all the children and resources.
+ */
+QQmlListProperty<QObject> UCListItem::data()
+{
+    Q_D(UCListItem);
+    return QQuickItemPrivate::get(d->contentItem)->data();
+}
+
+/*!
+ * \qmlproperty list<Item> ListItem::children
+ * Overloaded default property containing all the visible children of the item.
+ */
+QQmlListProperty<QQuickItem> UCListItem::children()
+{
+    Q_D(UCListItem);
+    return QQuickItemPrivate::get(d->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-09-15 11:00:03 +0000
@@ -0,0 +1,92 @@
+/*
+ * 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 UCListItemOptions;
+class UCListItemPrivate;
+class UCListItem : public UCStyledItemBase
+{
+    Q_OBJECT
+    Q_PROPERTY(UCListItemContent *contentItem READ contentItem CONSTANT)
+    Q_PROPERTY(UCListItemDivider *divider READ divider CONSTANT)
+    Q_PROPERTY(UCListItemOptions *leadingOptions READ leadingOptions WRITE setLeadingOptions NOTIFY leadingOptionsChanged DESIGNABLE false)
+    Q_PROPERTY(UCListItemOptions *trailingOptions READ trailingOptions WRITE setTrailingOptions NOTIFY trailingOptionsChanged DESIGNABLE false)
+    Q_PROPERTY(bool pressed READ pressed NOTIFY pressedChanged)
+    Q_PROPERTY(bool selectable READ selectable WRITE setSelectable NOTIFY selectableChanged)
+    Q_PROPERTY(bool selected READ selected WRITE setSelected NOTIFY selectedChanged)
+    Q_PROPERTY(QQmlListProperty<QObject> data READ data DESIGNABLE false)
+    Q_PROPERTY(QQmlListProperty<QQuickItem> children READ children NOTIFY childrenChanged DESIGNABLE false)
+    Q_CLASSINFO("DefaultProperty", "data")
+public:
+    explicit UCListItem(QQuickItem *parent = 0);
+    ~UCListItem();
+
+    UCListItemContent *contentItem() const;
+    UCListItemDivider *divider() const;
+    UCListItemOptions *leadingOptions() const;
+    void setLeadingOptions(UCListItemOptions *options);
+    UCListItemOptions *trailingOptions() const;
+    void setTrailingOptions(UCListItemOptions *options);
+    bool pressed() const;
+    bool selectable() const;
+    void setSelectable(bool selectable);
+    bool selected() const;
+    void setSelected(bool selected);
+
+protected:
+    void componentComplete();
+    void itemChange(ItemChange change, const ItemChangeData &data);
+    QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data);
+    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
+    void mousePressEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+    void mouseMoveEvent(QMouseEvent *event);
+    bool eventFilter(QObject *, QEvent *);
+    void timerEvent(QTimerEvent *event);
+
+Q_SIGNALS:
+    void leadingOptionsChanged();
+    void trailingOptionsChanged();
+    void pressedChanged();
+    void selectableChanged();
+    void selectedChanged();
+    void childrenChanged();
+
+    void clicked();
+    void pressAndHold();
+
+public Q_SLOTS:
+
+private:
+    Q_DECLARE_PRIVATE(UCListItem)
+    QQmlListProperty<QObject> data();
+    QQmlListProperty<QQuickItem> children();
+    Q_PRIVATE_SLOT(d_func(), void _q_dimmDisabled())
+    Q_PRIVATE_SLOT(d_func(), void _q_rebound())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateSize())
+    Q_PRIVATE_SLOT(d_func(), void _q_completeRebinding())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateIndex(QObject *ownerItem = 0))
+    Q_PRIVATE_SLOT(d_func(), void _q_updateSelected())
+};
+
+#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-09-15 11:00:03 +0000
@@ -0,0 +1,177 @@
+/*
+ * 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 <QtCore/QBasicTimer>
+#include <QtQuick/private/qquickrectangle_p.h>
+
+class QQuickFlickable;
+class QQuickPropertyAnimation;
+class UCListItemContent;
+class UCListItemDivider;
+class UCListItemOptions;
+class PropertyChange;
+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();
+    }
+
+    // override setFocusable()
+    void setFocusable();
+
+    void _q_dimmDisabled();
+    void _q_rebound();
+    void _q_updateSize();
+    void _q_completeRebinding();
+    void _q_updateIndex(QObject *ownerItem = 0);
+    void _q_updateSelected();
+    void cleanup();
+    void reboundTo(qreal x);
+    void setPressed(bool pressed);
+    void setMoved(bool moved);
+    bool grabPanel(UCListItemOptions *optionList, bool isMoved);
+    void listenToRebind(bool listen);
+    void resize();
+    void update();
+    void clampX(qreal &x, qreal dx);
+    void autoLeadingOptions();
+    QQuickItem *createSelectionPanel();
+    void toggleSelectionMode();
+
+    bool pressed:1;
+    bool moved:1;
+    bool suppressClick:1;
+    bool ready:1;
+    bool selectable:1;
+    bool selected:1;
+    int index;
+    qreal xAxisMoveThresholdGU;
+    QBasicTimer pressAndHoldTimer;
+    QPointF lastPos;
+    QPointF pressedPos;
+    QPointer<QQuickFlickable> flickable;
+    QQuickPropertyAnimation *reboundAnimation;
+    PropertyChange *flickableInteractive;
+    PropertyChange *disabledOpacity;
+    UCListItemContent *contentItem;
+    UCListItemDivider *divider;
+    UCListItemOptions *leadingOptions;
+    UCListItemOptions *trailingOptions;
+    QQuickItem *selectionPanel;
+};
+
+class UCListItemContent : public QQuickItem
+{
+    Q_OBJECT
+    Q_PROPERTY(QColor color MEMBER m_color WRITE setColor NOTIFY colorChanged)
+    Q_PROPERTY(QColor pressedColor MEMBER m_pressedColor WRITE setPressedColor NOTIFY pressedColorChanged)
+public:
+    explicit UCListItemContent(QQuickItem *parent = 0);
+    ~UCListItemContent();
+
+    void setColor(const QColor &color);
+    void setPressedColor(const QColor &color);
+
+Q_SIGNALS:
+    void colorChanged();
+    void pressedColorChanged();
+
+protected:
+    void itemChange(ItemChange change, const ItemChangeData &data);
+    QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data);
+
+private Q_SLOTS:
+    void updateColors();
+
+private:
+    QColor m_color;
+    QColor m_pressedColor;
+    UCListItem *m_item;
+    bool m_pressedColorChanged:1;
+};
+
+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 *paintNode, 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_lastItem: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(UCListItemContent)
+QML_DECLARE_TYPE(UCListItemDivider)
+
+#endif // UCVIEWITEM_P_H

=== added file 'modules/Ubuntu/Components/plugin/uclistitemoptions.cpp'
--- modules/Ubuntu/Components/plugin/uclistitemoptions.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemoptions.cpp	2014-09-15 11:00:03 +0000
@@ -0,0 +1,526 @@
+/*
+ * 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 "uclistitemoptions.h"
+#include "uclistitemoptions_p.h"
+#include "uclistitem_p.h"
+#include "quickutils.h"
+#include "i18n.h"
+#include "plugin.h"
+#include <QtQml/QQmlInfo>
+#include <QtQuick/private/qquickitem_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
+
+
+UCListItemOptionsPrivate::UCListItemOptionsPrivate()
+    : QObjectPrivate()
+    , optionsFailure(false)
+    , panelColorChanged(false)
+    , iconColorChanged(false)
+    , status(UCListItemOptions::Disconnected)
+    , delegate(0)
+    , panelItem(0)
+    , panelColor(Qt::transparent)
+    , iconColor(Qt::transparent)
+    , optionSlotWidth(0.0)
+    , offsetDragged(0.0)
+    , optionsVisible(0)
+{
+}
+UCListItemOptionsPrivate::~UCListItemOptionsPrivate()
+{
+}
+
+void UCListItemOptionsPrivate::_q_handlePanelDrag()
+{
+    UCListItem *listItem = qobject_cast<UCListItem*>(panelItem->parentItem());
+    if (!listItem) {
+        return;
+    }
+
+    Q_Q(UCListItemOptions);
+    offsetDragged = (status == UCListItemOptions::LeadingOptions) ? panelItem->width() + panelItem->x() :
+                         listItem->width() - panelItem->x();
+    if (offsetDragged < 0.0) {
+        offsetDragged = 0.0;
+    }
+    if (optionSlotWidth > 0.0) {
+        optionsVisible = (int)trunc(offsetDragged / optionSlotWidth);
+    }
+}
+
+void UCListItemOptionsPrivate::_q_handlePanelWidth()
+{
+    optionSlotWidth = panelItem->width() / options.count();
+    _q_handlePanelDrag();
+}
+
+void UCListItemOptionsPrivate::funcAppend(QQmlListProperty<QObject> *list, QObject *option)
+{
+    UCListItemOptions *_this = static_cast<UCListItemOptions*>(list->object);
+    UCListItemOptionsPrivate *plist = UCListItemOptionsPrivate::get(_this);
+    if (!QuickUtils::inherits(option, "Action")) {
+        qmlInfo(_this) << UbuntuI18n::instance().tr(QString("Option at index %1 is not an Action or a derivate of it.").arg(plist->options.size()));
+        plist->optionsFailure = true;
+        plist->options.clear();
+        return;
+    }
+    if (!plist->optionsFailure) {
+        plist->options.append(option);
+    }
+}
+int UCListItemOptionsPrivate::funcCount(QQmlListProperty<QObject> *list)
+{
+    UCListItemOptions *_this = static_cast<UCListItemOptions*>(list->object);
+    UCListItemOptionsPrivate *plist = UCListItemOptionsPrivate::get(_this);
+    return plist->options.size();
+}
+QObject *UCListItemOptionsPrivate::funcAt(QQmlListProperty<QObject> *list, int index)
+{
+    UCListItemOptions *_this = static_cast<UCListItemOptions*>(list->object);
+    UCListItemOptionsPrivate *plist = UCListItemOptionsPrivate::get(_this);
+    return plist->options.at(index);
+}
+void UCListItemOptionsPrivate::funcClear(QQmlListProperty<QObject> *list)
+{
+    UCListItemOptions *_this = static_cast<UCListItemOptions*>(list->object);
+    UCListItemOptionsPrivate *plist = UCListItemOptionsPrivate::get(_this);
+    plist->optionsFailure = false;
+    return plist->options.clear();
+}
+
+bool UCListItemOptionsPrivate::connectToListItem(UCListItemOptions *options, UCListItem *listItem, bool leading)
+{
+    UCListItemOptionsPrivate *_this = get(options);
+    if (!_this || !_this->createPanelItem() || isConnectedTo(options, listItem)) {
+        return isConnectedTo(options, listItem);
+    }
+    // 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
+    if (_this->panelItem->parentItem()) {
+        // set the requesting listItem as queuedItem
+        _this->queuedItem = listItem;
+        return false;
+    }
+    _this->panelItem->setProperty("listItemIndex", UCListItemPrivate::get(listItem)->index);
+    _this->panelItem->setProperty("leadingPanel", leading);
+    _this->panelItem->setParentItem(listItem);
+    _this->offsetDragged = 0.0;
+    QObject::connect(_this->panelItem, SIGNAL(selected()), _this->panelItem->parentItem(), SLOT(_q_rebound()));
+    _this->status = (leading) ? UCListItemOptions::LeadingOptions : UCListItemOptions::TrailingOptions;
+    Q_EMIT options->statusChanged();
+    Q_EMIT options->connectedItemChanged();
+    return true;
+}
+
+void UCListItemOptionsPrivate::disconnectFromListItem(UCListItemOptions *options)
+{
+    UCListItemOptionsPrivate *_this = get(options);
+    if (!_this || !_this->panelItem || !_this->panelItem->parentItem()) {
+        return;
+    }
+
+    QObject::disconnect(_this->panelItem, SIGNAL(selected()), _this->panelItem->parentItem(), SLOT(_q_rebound()));
+    _this->panelItem->setParentItem(0);
+    _this->status = UCListItemOptions::Disconnected;
+    Q_EMIT options->statusChanged();
+    Q_EMIT options->connectedItemChanged();
+    // if there was a queuedItem, make it grab the options list
+    if (_this->queuedItem) {
+        UCListItemPrivate::get(_this->queuedItem.data())->grabPanel(options, true);
+        // remove item from queue
+        _this->queuedItem.clear();
+    }
+}
+
+bool UCListItemOptionsPrivate::isConnectedTo(UCListItemOptions *options, UCListItem *listItem)
+{
+    UCListItemOptionsPrivate *_this = get(options);
+    return _this && _this->panelItem &&
+            (_this->status != UCListItemOptions::Disconnected) &&
+            (_this->panelItem->parentItem() == listItem);
+}
+
+qreal UCListItemOptionsPrivate::snap(UCListItemOptions *options)
+{
+    UCListItemOptionsPrivate *_this = get(options);
+    if (!_this || !_this->panelItem) {
+        return 0.0;
+    }
+    qreal ratio = _this->offsetDragged / _this->optionSlotWidth;
+    int visible = _this->optionsVisible;
+    if (ratio > 0.0 && (ratio - trunc(ratio)) > 0.5) {
+        visible++;
+    }
+    return visible * _this->optionSlotWidth * (_this->status == UCListItemOptions::LeadingOptions ? 1 : -1);
+}
+
+
+QQuickItem *UCListItemOptionsPrivate::createPanelItem()
+{
+    if (panelItem) {
+        return panelItem;
+    }
+    Q_Q(UCListItemOptions);
+    QUrl panelDocument = UbuntuComponentsPlugin::pluginUrl().
+            resolved(QUrl::fromLocalFile("ListItemPanel.qml"));
+    QQmlComponent component(qmlEngine(q), panelDocument);
+    if (!component.isError()) {
+        panelItem = qobject_cast<QQuickItem*>(component.beginCreate(qmlContext(q)));
+        if (panelItem) {
+            QQml_setParent_noEvent(panelItem, q);
+            if (delegate) {
+                panelItem->setProperty("delegate", QVariant::fromValue(delegate));
+            }
+            panelItem->setProperty("optionList", QVariant::fromValue(options));
+            component.completeCreate();
+            if (panelColorChanged) {
+                updateColor("panelColor", panelColor);
+            }
+            if (iconColorChanged) {
+                updateColor("iconColor", iconColor);
+            }
+            Q_EMIT q->panelItemChanged();
+
+            // calculate option's slot size
+            optionSlotWidth = panelItem->width() / options.count();
+            offsetDragged = 0.0;
+            optionsVisible = 0;
+            // connect to panel to catch dragging
+            QObject::connect(panelItem, SIGNAL(widthChanged()), q, SLOT(_q_handlePanelWidth()));
+            QObject::connect(panelItem, SIGNAL(xChanged()), q, SLOT(_q_handlePanelDrag()));
+        }
+    } else {
+        qmlInfo(q) << component.errorString();
+    }
+    return panelItem;
+}
+
+void UCListItemOptionsPrivate::updateColor(const char *property, const QColor &color)
+{
+    if (!panelItem) {
+        return;
+    }
+    Q_Q(UCListItemOptions);
+    // get this property binding
+    QQmlProperty myColor(q, property, qmlContext(q));
+    QQmlBinding *binding = static_cast<QQmlBinding*>(QQmlPropertyPrivate::binding(myColor));
+    if (!binding) {
+        // this is a simple value assignment, so only override panel's color
+        panelItem->setProperty(property, QVariant::fromValue(color));
+    } else {
+        // transfer the binding to panelItem
+        // get panel item's color binding
+        QQmlProperty colorProperty(panelItem, property, qmlContext(panelItem));
+        QQmlAbstractBinding *prevBinding = QQmlPropertyPrivate::binding(colorProperty);
+        if (prevBinding != binding) {
+            // clear the previous binding
+            prevBinding = QQmlPropertyPrivate::setBinding(colorProperty, 0);
+            if (prevBinding) {
+                prevBinding->destroy();
+            }
+            // do the "alias"
+            binding->retargetBinding(panelItem, colorProperty.index());
+        }
+    }
+}
+
+/*!
+ * \qmltype ListItemOptions
+ * \instantiates UCListItemOptions
+ * \inherits QtQObject
+ * \inqmlmodule Ubuntu.Components 1.1
+ * \ingroup ubuntu
+ * \brief Provides configuration for options to be added to a ListItem.
+ *
+ * ListItem accepts options that can be configured to appear when tugged to left
+ * or right. There is no limitation on how many options can be displayed on both
+ * sides, this depends on the space available. However design guides say that it
+ * can be a maximum of one option on the left (leadng) and a maximum of 3 options
+ * on the right (trailing) side of a ListItem.
+ *
+ * The options are Action instances or elements derived from Action. The default
+ * visualization of the options can be overridden using the \l delegate property,
+ * and the default implementation uses the \c name property of the Action.
+ *
+ * The leading and trailing options are placed on \l panelItem, which is created
+ * the first time the options are accessed. The colors of the panel is taken from
+ * the theme's palette.
+ *
+ * When tugged, panels reveal the options one by one. In case an option is revealed
+ * more than 50%, the option will be snapped and revealed completely. This is also
+ * valid for the case when the option is visible less than 50%, in which case the
+ * option is hidden. Options can be triggered by tapping.
+ *
+ * \note You cannot use the same ListItemOptions for leading and for trailing options
+ * the same time as when the item content is tugged, both options' panels will be
+ * bound to the list item, and teh same item cannot be bount to both edges. However
+ * the same set of actions can be used for both options either by using a shared
+ * set or by using the others' list. Example:
+ * \qml
+ * ListItem {
+ *     leadingOptions: ListItemOptions {
+ *         Action {
+ *             iconName: "edit"
+ *         }
+ *         Action {
+ *             iconName: "delete"
+ *         }
+ *     }
+ *     trailingOptions: ListItemOptions {
+ *         options: leadingOptions.options
+ *     }
+ * }
+ * \endqml
+ *
+ * \section3 Notes on performance
+ * When used with views, or when the amount of items of same kind to be created
+ * is huge, it is recommended to use cached actions as well as cached ListItemOption
+ * instances. In this way we can reduce the creation time of the items:
+ * \qml
+ * import QtQuick 2.2
+ * import Ubuntu.Components 1.1
+ *
+ * MainView {
+ *     width: units.gu(40)
+ *     height: units.gu(71)
+ *
+ *     UbuntuListView {
+ *         anchors.fill: parent
+ *         model: 10000
+ *         ListItemOptions {
+ *             id: commonOptions
+ *             Action {
+ *                 iconName: "search"
+ *             }
+ *             Action {
+ *                 iconName: "edit"
+ *             }
+ *             Action {
+ *                 iconName: "copy"
+ *             }
+ *         }
+ *         delegate: ListItem {
+ *             trailingOptions: commonOptions
+ *         }
+ *     }
+ * }
+ * \endqml
+ */
+
+UCListItemOptions::UCListItemOptions(QObject *parent)
+    : QObject(*(new UCListItemOptionsPrivate), parent)
+{
+}
+UCListItemOptions::~UCListItemOptions()
+{
+}
+
+
+/*!
+ * \qmlproperty Component ListItemOptions::delegate
+ * Custom delegate which overrides the default one used by the ListItem. If the
+ * value is null, the default delegate will be used.
+ *
+ * ListItemOptions provides the \c option context property which contains the
+ * Action instance currently visualized. Using this property delegates can access
+ * the information to be visualized. The trigger is handled by the \l panelItem
+ * therefore only visualization is needed by the custom delegates. The other
+ * context property exposed to delegates is the \c index, which specifies the
+ * index of the option visualized.
+ *
+ * The delegate height is set automatically by the panelItem, and the width value
+ * is clamped between height and the maximum width of the list item divided by the
+ * number of options in the list.
+ * \qml
+ * import QtQuick 2.2
+ * import Ubuntu.Components 1.1
+ *
+ * MainView {
+ *     width: units.gu(40)
+ *     height: units.gu(71)
+ *
+ *     UbuntuListView {
+ *         anchors.fill: parent
+ *         model: 50
+ *         delegate: ListItem {
+ *             trailingOptions: optionsList
+ *         }
+ *         ListItemOptions {
+ *             id: optionsList
+ *             delegate: Column {
+ *                 width: height + units.gu(2)
+ *                 Icon {
+ *                     name: option.iconName
+ *                     width: units.gu(3)
+ *                     height: width
+ *                     color: "blue"
+ *                     anchors.horizontalCenter: parent.horizontalCenter
+ *                 }
+ *                 Label {
+ *                     text: option.text + "#" + index
+ *                     width: parent.width
+ *                     horizontalAlignment: Text.AlignHCenter
+ *                 }
+ *             }
+ *             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 *UCListItemOptions::delegate() const
+{
+    Q_D(const UCListItemOptions);
+    return d->delegate;
+}
+void UCListItemOptions::setDelegate(QQmlComponent *delegate)
+{
+    Q_D(UCListItemOptions);
+    if (d->delegate == delegate) {
+        return;
+    }
+    d->delegate = delegate;
+    if (d->panelItem) {
+        // update panel's delegate as well
+        d->panelItem->setProperty("delegate", QVariant::fromValue(delegate));
+    }
+    Q_EMIT delegateChanged();
+}
+
+/*!
+ * \qmlproperty list<Action> ListItemOptions::options
+ * \default
+ * The property holds the options to be displayed. It can hold instances cached or
+ * declared in place. An example of cached options:
+ * \qml
+ * ListItemOptions {
+ *     id: cacedOptions
+ *     options: [
+ *         copyAction, searchAction, cutAction
+ *     ]
+ * }
+ * \endqml
+ */
+QQmlListProperty<QObject> UCListItemOptions::options()
+{
+    Q_D(UCListItemOptions);
+    return QQmlListProperty<QObject>(this, &(d->options),
+                                     &UCListItemOptionsPrivate::funcAppend,
+                                     &UCListItemOptionsPrivate::funcCount,
+                                     &UCListItemOptionsPrivate::funcAt,
+                                     &UCListItemOptionsPrivate::funcClear);
+}
+
+/*!
+ * \qmlproperty Item ListItemOptions::panelItem
+ * The property presents the Item holding the visualized options. The panel is
+ * created when used the first time.
+ */
+QQuickItem *UCListItemOptions::panelItem() const
+{
+    Q_D(const UCListItemOptions);
+    return d->panelItem;
+}
+
+/*!
+ * \qmlproperty enum ListItemOptions::status
+ * \readonly
+ * The property holds the status of the ListItemOptions, whether is connected
+ * as leading or as trailing option list to a \l ListItem. Possible valueas are:
+ * \list A
+ *  \li \b \c Disconnected - default, the options list is not connected to any \l ListItem
+ *  \li \b \c LeadingOptions - the options list is connected as leading list
+ *  \li \b \c TrailingOptions - the options list is connected as trailing list
+ * \endlist
+ * \sa connectedItem
+ */
+UCListItemOptions::Status UCListItemOptions::status() const
+{
+    Q_D(const UCListItemOptions);
+    return d->status;
+}
+
+/*!
+ * \qmlproperty ListItem ListItemOptions::connectedItem
+ * \readonly
+ * The property holds the \l ListItem the options list is connected to. It is
+ * null by default and when the status is \c Disconnected.
+ * \sa status
+ */
+UCListItem *UCListItemOptions::connectedItem() const
+{
+    Q_D(const UCListItemOptions);
+    return d->panelItem ? qobject_cast<UCListItem*>(d->panelItem->parentItem()) : 0;
+}
+
+/*!
+ * \qmlproperty color ListItemOptions::panelColor
+ * The property overrides the default colouring of the \l panelItem.
+ */
+QColor UCListItemOptions::panelColor() const
+{
+    Q_D(const UCListItemOptions);
+    return d->panelColor;
+}
+void UCListItemOptions::setPanelColor(const QColor &color)
+{
+    Q_D(UCListItemOptions);
+    if (d->panelColor == color) {
+        return;
+    }
+    d->panelColor = color;
+    d->panelColorChanged = true;
+    // update panelItem's color
+    d->updateColor("panelColor", d->panelColor);
+    Q_EMIT panelColorChanged();
+}
+
+/*!
+ * \qmlproperty color ListItemOptions::iconColor
+ * The property overrides the default colouring of the icons in the default
+ * options visualization.
+ */
+QColor UCListItemOptions::iconColor() const
+{
+    Q_D(const UCListItemOptions);
+    return d->iconColor;
+}
+void UCListItemOptions::setIconColor(const QColor &color)
+{
+    Q_D(UCListItemOptions);
+    if (d->iconColor == color) {
+        return;
+    }
+    d->iconColor = color;
+    d->iconColorChanged = true;
+    // update panelItem's color
+    d->updateColor("iconColor", d->iconColor);
+    Q_EMIT iconColorChanged();
+}
+
+#include "moc_uclistitemoptions.cpp"

=== added file 'modules/Ubuntu/Components/plugin/uclistitemoptions.h'
--- modules/Ubuntu/Components/plugin/uclistitemoptions.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemoptions.h	2014-09-15 11:00:03 +0000
@@ -0,0 +1,75 @@
+/*
+ * 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 UCLISTITEMOPTIONS_H
+#define UCLISTITEMOPTIONS_H
+
+#include <QtCore/QObject>
+#include "uclistitem_p.h"
+
+class QQmlComponent;
+class UCListItemOptionsPrivate;
+class QQmlBinding;
+class UCListItemOptions : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate NOTIFY delegateChanged)
+    Q_PROPERTY(QQmlListProperty<QObject> options READ options CONSTANT)
+    Q_PROPERTY(QQuickItem *panelItem READ panelItem NOTIFY panelItemChanged)
+    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
+    Q_PROPERTY(UCListItem *connectedItem READ connectedItem NOTIFY connectedItemChanged)
+    Q_PROPERTY(QColor panelColor READ panelColor WRITE setPanelColor NOTIFY panelColorChanged)
+    Q_PROPERTY(QColor iconColor READ iconColor WRITE setIconColor NOTIFY iconColorChanged)
+    Q_CLASSINFO("DefaultProperty", "options")
+    Q_ENUMS(Status)
+public:
+    enum Status {
+        Disconnected = 0,
+        LeadingOptions,
+        TrailingOptions
+    };
+
+    explicit UCListItemOptions(QObject *parent = 0);
+    ~UCListItemOptions();
+
+    QQmlComponent *delegate() const;
+    void setDelegate(QQmlComponent *delegate);
+    QQmlListProperty<QObject> options();
+    QQuickItem *panelItem() const;
+    Status status() const;
+    UCListItem *connectedItem() const;
+    QColor panelColor() const;
+    void setPanelColor(const QColor &color);
+    QColor iconColor() const;
+    void setIconColor(const QColor &color);
+
+Q_SIGNALS:
+    void delegateChanged();
+    void panelItemChanged();
+    void statusChanged();
+    void connectedItemChanged();
+    void panelColorChanged();
+    void iconColorChanged();
+
+public Q_SLOTS:
+
+private:
+    Q_DECLARE_PRIVATE(UCListItemOptions)
+    Q_PRIVATE_SLOT(d_func(), void _q_handlePanelDrag())
+    Q_PRIVATE_SLOT(d_func(), void _q_handlePanelWidth())
+};
+
+#endif // UCLISTITEMOPTIONS_H

=== added file 'modules/Ubuntu/Components/plugin/uclistitemoptions_p.h'
--- modules/Ubuntu/Components/plugin/uclistitemoptions_p.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/uclistitemoptions_p.h	2014-09-15 11:00:03 +0000
@@ -0,0 +1,66 @@
+/*
+ * 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 UCLISTITEMOPTIONS_P_H
+#define UCLISTITEMOPTIONS_P_H
+
+#include "uclistitemoptions.h"
+#include "QtCore/private/qobject_p.h"
+
+class UCListItem;
+class UCListItemOptionsPrivate : public QObjectPrivate {
+    Q_DECLARE_PUBLIC(UCListItemOptions)
+public:
+    UCListItemOptionsPrivate();
+    ~UCListItemOptionsPrivate();
+    static UCListItemOptionsPrivate* get(UCListItemOptions *options)
+    {
+        return options ? options->d_func() : 0;
+    }
+
+    bool optionsFailure:1;
+    bool panelColorChanged:1;
+    bool iconColorChanged:1;
+    UCListItemOptions::Status status;
+    QQmlComponent *delegate;
+    QQuickItem *panelItem;
+    QColor panelColor;
+    QColor iconColor;
+    QList<QObject*> options;
+    QPointer<UCListItem> queuedItem;
+    qreal optionSlotWidth;
+    qreal offsetDragged;
+    int optionsVisible;
+
+    void _q_handlePanelDrag();
+    void _q_handlePanelWidth();
+
+    // options list property functions
+    static void funcAppend(QQmlListProperty<QObject>*, QObject*);
+    static int funcCount(QQmlListProperty<QObject>*);
+    static QObject *funcAt(QQmlListProperty<QObject>*, int);
+    static void funcClear(QQmlListProperty<QObject>*);
+
+    static bool connectToListItem(UCListItemOptions *options, UCListItem *listItem, bool leading);
+    static void disconnectFromListItem(UCListItemOptions *options);
+    static bool isConnectedTo(UCListItemOptions *options, UCListItem *listItem);
+    static qreal snap(UCListItemOptions *options);
+
+    QQuickItem *createPanelItem();
+    void updateColor(const char *property, const QColor &color);
+};
+
+#endif // UCLISTITEMOPTIONS_P_H

=== modified file 'modules/Ubuntu/Components/qmldir'
--- modules/Ubuntu/Components/qmldir	2014-09-03 08:17:24 +0000
+++ modules/Ubuntu/Components/qmldir	2014-09-15 11:00:03 +0000
@@ -106,3 +106,5 @@
 Icon 1.1 Icon11.qml
 StyledItem 1.1 StyledItem.qml
 singleton UbuntuColors 1.1 11/UbuntuColors.qml
+internal ListItemPanel ListItemPanel.qml
+internal ListItemSelectablePanel ListItemSelectablePanel.qml

=== modified file 'tests/autopilot/ubuntuuitoolkit/environment.py'
--- tests/autopilot/ubuntuuitoolkit/environment.py	2014-03-10 18:53:37 +0000
+++ tests/autopilot/ubuntuuitoolkit/environment.py	2014-09-15 11:00:03 +0000
@@ -23,42 +23,46 @@
 logger = logging.getLogger(__name__)
 
 
-def is_initctl_env_var_set(variable):
+def is_initctl_env_var_set(variable, global_=False):
     """Check True if an initctl environment variable is set.
 
     :param variable: The name of the variable to check.
+    :param global: if True, the method will operate on the global environment
+        table. Default is False.
     :return: True if the variable is set. False otherwise.
 
     """
     try:
-        get_initctl_env_var(variable)
+        get_initctl_env_var(variable, global_)
         return True
     except subprocess.CalledProcessError:
         return False
 
 
-def get_initctl_env_var(variable):
+def get_initctl_env_var(variable, global_=False):
     """Return the value of an initctl environment variable."""
+    command = ['/sbin/initctl', 'get-env', variable]
+    if global_:
+        command += ['--global']
     output = subprocess.check_output(
-        ['/sbin/initctl', 'get-env', variable],
-        stderr=subprocess.STDOUT,
-        universal_newlines=True)
+        command, stderr=subprocess.STDOUT, universal_newlines=True)
     return output.rstrip()
 
 
 @autopilot_logging.log_action(logger.info)
-def set_initctl_env_var(variable, value):
+def set_initctl_env_var(variable, value, global_=False):
     """Set the value of an initctl environment variable."""
-    subprocess.call(
-        ['/sbin/initctl', 'set-env', '%s=%s' % (variable, value)],
-        stderr=subprocess.STDOUT,
-        universal_newlines=True)
+    command = ['/sbin/initctl', 'set-env', '%s=%s' % (variable, value)]
+    if global_:
+        command += ['--global']
+    subprocess.call(command, stderr=subprocess.STDOUT, universal_newlines=True)
 
 
 @autopilot_logging.log_action(logger.info)
-def unset_initctl_env_var(variable):
+def unset_initctl_env_var(variable, global_=False):
     """Remove an initctl environment variable."""
+    command = ['/sbin/initctl', 'unset-env', variable]
+    if global_:
+        command += ['--global']
     subprocess.call(
-        ['/sbin/initctl', 'unset-env', variable],
-        stderr=subprocess.STDOUT,
-        universal_newlines=True)
+        command, stderr=subprocess.STDOUT, universal_newlines=True)

=== modified file 'tests/autopilot/ubuntuuitoolkit/fixture_setup.py'
--- tests/autopilot/ubuntuuitoolkit/fixture_setup.py	2014-07-22 07:44:40 +0000
+++ tests/autopilot/ubuntuuitoolkit/fixture_setup.py	2014-09-15 11:00:03 +0000
@@ -115,24 +115,36 @@
 class InitctlEnvironmentVariable(fixtures.Fixture):
     """Set the value of initctl environment variables."""
 
-    def __init__(self, **kwargs):
+    def __init__(self, global_=False, **kwargs):
         super(InitctlEnvironmentVariable, self).__init__()
+        # Added one level of indirection to be able to spy the calls to
+        # environment during tests.
+        self.environment = environment
         self.variables = kwargs
+        self.global_ = global_
 
     def setUp(self):
         super(InitctlEnvironmentVariable, self).setUp()
         for variable, value in self.variables.items():
             self._add_variable_cleanup(variable)
-            environment.set_initctl_env_var(variable, value)
+            self.environment.set_initctl_env_var(
+                variable, value, global_=self.global_)
 
     def _add_variable_cleanup(self, variable):
-        if environment.is_initctl_env_var_set(variable):
-            original_value = environment.get_initctl_env_var(variable)
+        if self.environment.is_initctl_env_var_set(
+                variable, global_=self.global_):
+            original_value = self.environment.get_initctl_env_var(
+                variable, global_=self.global_)
             self.addCleanup(
-                environment.set_initctl_env_var, variable,
-                original_value)
+                self.environment.set_initctl_env_var,
+                variable,
+                original_value,
+                global_=self.global_)
         else:
-            self.addCleanup(environment.unset_initctl_env_var, variable)
+            self.addCleanup(
+                self.environment.unset_initctl_env_var,
+                variable,
+                global_=self.global_)
 
 
 class FakeHome(fixtures.Fixture):

=== modified file 'tests/autopilot/ubuntuuitoolkit/tests/__init__.py'
--- tests/autopilot/ubuntuuitoolkit/tests/__init__.py	2014-07-24 21:28:05 +0000
+++ tests/autopilot/ubuntuuitoolkit/tests/__init__.py	2014-09-15 11:00:03 +0000
@@ -87,6 +87,9 @@
             qml_file_contents=self.test_qml)
         self.useFixture(fake_application)
 
+        local_modules_path = _get_module_include_path()
+        if os.path.exists(local_modules_path):
+            self.use_local_modules(local_modules_path)
         desktop_file_name = os.path.basename(
             fake_application.desktop_file_path)
         application_name, _ = os.path.splitext(desktop_file_name)
@@ -94,6 +97,17 @@
             application_name,
             emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase)
 
+    def use_local_modules(self, local_modules_path):
+        env_vars = [
+            'QML_IMPORT_PATH',
+            'QML2_IMPORT_PATH',
+            'UBUNTU_UI_TOOLKIT_THEMES_PATH'
+        ]
+        kwargs = {'global_': True}
+        for env in env_vars:
+            kwargs[env] = local_modules_path
+        self.useFixture(fixture_setup.InitctlEnvironmentVariable(**kwargs))
+
 
 class QMLStringAppTestCase(UbuntuUIToolkitWithFakeAppRunningTestCase):
     """Base test case for self tests that define the QML on an string."""

=== modified file 'tests/autopilot/ubuntuuitoolkit/tests/test_environment.py'
--- tests/autopilot/ubuntuuitoolkit/tests/test_environment.py	2014-03-13 17:54:38 +0000
+++ tests/autopilot/ubuntuuitoolkit/tests/test_environment.py	2014-09-15 11:00:03 +0000
@@ -30,7 +30,7 @@
 
     def test_is_environment_variable_set_with_set_variable(self):
         """Test that is_initctl_env_var_set returns True for existing vars."""
-        variable = 'Testvariabletoset'
+        variable = 'Test variable to set {}'.format(uuid.uuid1())
         self.addCleanup(environment.unset_initctl_env_var, variable)
 
         environment.set_initctl_env_var(variable, 'dummy')
@@ -39,7 +39,7 @@
 
     def test_get_environment_variable(self):
         """Test that get_initctl_env_var returns the right value."""
-        variable = 'Testvariabletoget'
+        variable = 'Test variable to get {}'.format(uuid.uuid1())
         self.addCleanup(environment.unset_initctl_env_var, variable)
         environment.set_initctl_env_var(variable, 'test value')
 
@@ -48,7 +48,7 @@
 
     def test_unset_environment_variable(self):
         """Test that unset_initctl_env_var removes the variable."""
-        variable = 'Testvariabletoget'
+        variable = 'Test variable to unset {}'.format(uuid.uuid1())
         environment.set_initctl_env_var(variable, 'dummy')
 
         environment.unset_initctl_env_var(variable)
@@ -57,8 +57,33 @@
 
     def test_unset_environment_variable_with_unset_variable(self):
         """Test that unset_initctl_env_var does nothing with unset var."""
-        variable = 'I do not exist'
+        variable = 'I do not exist {}'.format(uuid.uuid1())
 
         environment.unset_initctl_env_var(variable)
 
         self.assertFalse(environment.is_initctl_env_var_set(variable))
+
+    def test_is_global_environment_variable_set_with_unset_variable(self):
+        """Test is_initctl_env_var_set returns False for unset global vars."""
+        variable = 'I do not exist global {}'.format(uuid.uuid1())
+
+        self.assertFalse(environment.is_initctl_env_var_set(
+            variable, global_=True))
+
+    def test_get_global_environment_variable(self):
+        """Test that get_initctl_env_var returns the right global value."""
+        variable = 'Test variable to get {}'.format(uuid.uuid1())
+        self.addCleanup(
+            environment.unset_initctl_env_var, variable, global_=True)
+        environment.set_initctl_env_var(variable, 'test value', global_=True)
+
+        self.assertEqual(
+            'test value',
+            environment.get_initctl_env_var(variable, global_=True))
+
+    def test_unset_global_environment_variable(self):
+        """Test that unset_initctl_env_var removes the global variable."""
+        variable = 'Test variable to unset {}'.format(uuid.uuid1())
+
+        environment.set_initctl_env_var(variable, 'dummy', global_=True)
+        environment.unset_initctl_env_var(variable, global_=True)

=== modified file 'tests/autopilot/ubuntuuitoolkit/tests/test_fixture_setup.py'
--- tests/autopilot/ubuntuuitoolkit/tests/test_fixture_setup.py	2014-06-26 04:28:38 +0000
+++ tests/autopilot/ubuntuuitoolkit/tests/test_fixture_setup.py	2014-09-15 11:00:03 +0000
@@ -23,6 +23,7 @@
 except ImportError:
     # Python 2 add-on: python-mock.
     import mock
+import testscenarios
 import testtools
 from autopilot import (
     display,
@@ -241,6 +242,95 @@
             environment.get_initctl_env_var('testenvvarforfixture'))
 
 
+class InitctlGlobalEnvironmentVariableTestCase(
+        testscenarios.TestWithScenarios):
+
+    scenarios = [
+        ('global unset variable', {
+            'is_variable_set': False,
+            'variable_value': 'dummy',
+            'global_value': 'value',
+            'expected_calls': [
+                mock.call.is_initctl_env_var_set(
+                    'testenvvarforfixture', global_='value'),
+                mock.call.set_initctl_env_var(
+                    'testenvvarforfixture', 'new test value', global_='value'),
+                mock.call.unset_initctl_env_var(
+                    'testenvvarforfixture', global_='value')
+            ]
+        }),
+        ('global set variable', {
+            'is_variable_set': True,
+            'variable_value': 'original_value',
+            'global_value': 'value',
+            'expected_calls': [
+                mock.call.is_initctl_env_var_set(
+                    'testenvvarforfixture', global_='value'),
+                mock.call.get_initctl_env_var(
+                    'testenvvarforfixture', global_='value'),
+                mock.call.set_initctl_env_var(
+                    'testenvvarforfixture', 'new test value', global_='value'),
+                mock.call.set_initctl_env_var(
+                    'testenvvarforfixture', 'original_value', global_='value')
+            ]
+        }),
+        ('default unset variable', {
+            'is_variable_set': False,
+            'variable_value': 'dummy',
+            'global_value': 'default',
+            'expected_calls': [
+                mock.call.is_initctl_env_var_set(
+                    'testenvvarforfixture', global_=False),
+                mock.call.set_initctl_env_var(
+                    'testenvvarforfixture', 'new test value', global_=False),
+                mock.call.unset_initctl_env_var(
+                    'testenvvarforfixture', global_=False)
+            ]
+        }),
+        ('global set variable', {
+            'is_variable_set': True,
+            'variable_value': 'original_value',
+            'global_value': 'default',
+            'expected_calls': [
+                mock.call.is_initctl_env_var_set(
+                    'testenvvarforfixture', global_=False),
+                mock.call.get_initctl_env_var(
+                    'testenvvarforfixture', global_=False),
+                mock.call.set_initctl_env_var(
+                    'testenvvarforfixture', 'new test value', global_=False),
+                mock.call.set_initctl_env_var(
+                    'testenvvarforfixture', 'original_value', global_=False)
+            ]
+        }),
+    ]
+
+    def test_use_initctl_environment_variable_with_global_unset_variable(self):
+        if self.global_value == 'default':
+            initctl_env_var = fixture_setup.InitctlEnvironmentVariable(
+                testenvvarforfixture='new test value')
+        else:
+            initctl_env_var = fixture_setup.InitctlEnvironmentVariable(
+                testenvvarforfixture='new test value',
+                global_=self.global_value)
+
+        mock_env = mock.Mock()
+        initctl_env_var.environment = mock_env
+        mock_env.is_initctl_env_var_set.return_value = self.is_variable_set
+        mock_env.get_initctl_env_var.return_value = self.variable_value
+
+        def inner_test():
+            class TestWithInitctlEnvVar(testtools.TestCase):
+                def test_it(self):
+                    self.useFixture(initctl_env_var)
+
+            return TestWithInitctlEnvVar('test_it')
+
+        inner_test().run()
+
+        self.assertEquals(
+            self.expected_calls, mock_env.mock_calls)
+
+
 class FakeHomeTestCase(testtools.TestCase):
 
     def test_fake_home_fixture_patches_initctl_env_var(self):

=== added directory 'tests/resources/listitems'
=== added file 'tests/resources/listitems/InUListView.qml'
--- tests/resources/listitems/InUListView.qml	1970-01-01 00:00:00 +0000
+++ tests/resources/listitems/InUListView.qml	2014-09-15 11:00:03 +0000
@@ -0,0 +1,63 @@
+/*
+ * 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.1
+
+MainView {
+    id: main
+    width: units.gu(50)
+    height: units.gu(100)
+
+    Page {
+        title: "UbuntuListView"
+
+        UbuntuListView {
+            anchors.fill: parent
+
+            ListItemOptions {
+                id: stockOptions
+                Action {
+                    iconName: "edit"
+                }
+                Action {
+                    iconName: "share"
+                }
+                Action {
+                    iconName: "attachment"
+                }
+            }
+
+            model: ListModel {
+                Component.onCompleted: {
+                    for (var i = 0; i < 20; i++)
+                        append({data: "List item mode #" + i})
+                }
+            }
+
+            delegate: ListItem {
+                trailingOptions: stockOptions
+
+                Label {
+                    anchors.fill: parent
+                    horizontalAlignment: Text.AlignHCenter
+                    verticalAlignment: Text.AlignVCenter
+                    text: modelData + " @index " + index
+                }
+            }
+        }
+    }
+}

=== 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-09-15 11:00:03 +0000
@@ -0,0 +1,186 @@
+/*
+ * 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.1
+
+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)
+    }
+
+    ListItemOptions {
+        id: leading
+        objectName: "StockLeading"
+        Action {
+            iconName: "delete"
+            onTriggered: { print(iconName, "triggered", value)
+                leading.panelColor = Qt.binding(function() {
+                    return (leading.status == ListItemOptions.LeadingOptions) ? UbuntuColors.blue : UbuntuColors.lightGrey;
+                })
+                leading.iconColor = Qt.binding(function() {
+                    return (leading.status == ListItemOptions.LeadingOptions) ? "white" : UbuntuColors.red;
+                })
+            }
+        }
+        Action {
+            iconName: "alarm-clock"
+            enabled: false
+            onTriggered: print(iconName, "triggered")
+        }
+        Action {
+            iconName: "camcorder"
+            onTriggered: print(iconName, "triggered", value)
+        }
+        Action {
+            iconName: "stock_website"
+            onTriggered: print(iconName, "triggered", value)
+        }
+    }
+
+    property bool selectable: false
+    Column {
+        anchors {
+            left: parent.left
+            right: parent.right
+        }
+
+        Button {
+            text: "Selectable " + (selectable ? "OFF" : "ON")
+            onClicked: selectable = !selectable
+        }
+
+        ListItem {
+            id: testItem
+            objectName: "single"
+            selectable: main.selectable
+            onClicked: {
+                print("click")
+                main.override = !main.override
+            }
+            onPressAndHold: print("pressAndHold", objectName)
+            Label {
+                anchors.fill: parent
+                text: units.gridUnit + "PX/unit"
+            }
+            leadingOptions: ListItemOptions {
+                objectName: "InlineLeading"
+                options: [stock]
+                delegate: Column {
+                    width: height + units.gu(2)
+                    Icon {
+                        width: units.gu(3)
+                        height: width
+                        name: option.iconName
+                        color: "blue"
+                        anchors.horizontalCenter: parent.horizontalCenter
+                    }
+                    Label {
+                        text: option.text + index
+                        width: parent.width
+                        horizontalAlignment: Text.AlignHCenter
+                    }
+                }
+            }
+            trailingOptions: leading
+        }
+
+        ListView {
+            id: view
+            clip: true
+            width: parent.width
+            height: units.gu(36)
+            model: 10
+            pressDelay: 0
+            delegate: ListItem {
+                objectName: "ListItem" + index
+                id: listItem
+                selectable: main.selectable
+                selected: true
+                onClicked: print(" clicked")
+                leadingOptions: leading
+                Label {
+                    text: modelData + " item"
+                }
+                states: State {
+                    name: "override"
+                    when: main.override
+                    PropertyChanges {
+                        target: listItem.contentItem
+                        pressedColor: "brown"
+                    }
+                }
+            }
+        }
+        Flickable {
+            id: flicker
+            width: parent.width
+            height: units.gu(36)
+            clip: true
+            contentHeight: column.childrenRect.height
+            Column {
+                id: column
+                width: view.width
+                property alias count: repeater.count
+                Repeater {
+                    id: repeater
+                    model: 10
+                    ListItem {
+                        objectName: "InFlickable"+index
+                        selectable: main.selectable
+                        leadingOptions: ListItemOptions {
+                            id: optionData
+                            panelColor: "pink"
+                            Action {
+                                iconName: "edit"
+                                onTriggered: print(iconName, "triggered", value)
+                            }
+                            Action {
+                                iconName: "delete"
+                                onTriggered: print(iconName, "triggered", value)
+                            }
+                        }
+                        trailingOptions: ListItemOptions {
+                            panelColor: leadingOptions.panelColor
+                            options: leadingOptions.options
+                        }
+
+                        contentItem {
+                            color: UbuntuColors.red
+                            pressedColor: "lime"
+                        }
+                        divider.colorFrom: UbuntuColors.green
+
+                        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-09-15 11:00:03 +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-09-15 11:00:03 +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
+    property alias count: repeater.count
+    Repeater {
+        id: repeater
+        model: 5000
+        ListItem {
+        }
+    }
+}

=== added file 'tests/unit/tst_performance/ListItemWithInlineOptionsList.qml'
--- tests/unit/tst_performance/ListItemWithInlineOptionsList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemWithInlineOptionsList.qml	2014-09-15 11:00:03 +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/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.1
+
+Column {
+    width: 800
+    height: 600
+
+    Repeater {
+        model: 5000
+        ListItem {
+            trailingOptions: ListItemOptions {
+                Action {}
+                Action {}
+                Action {}
+            }
+            leadingOptions: ListItemOptions {
+                Action {}
+                Action {}
+                Action {}
+            }
+        }
+    }
+}

=== added file 'tests/unit/tst_performance/ListItemWithLeadingOptionsList.qml'
--- tests/unit/tst_performance/ListItemWithLeadingOptionsList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemWithLeadingOptionsList.qml	2014-09-15 11:00:03 +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.1
+
+Column {
+    width: 800
+    height: 600
+    property ListItemOptions leadingOptions: options1
+    ListItemOptions {
+        id: options1
+        Action {}
+    }
+    ListItemOptions {
+        id: options2
+        Action {}
+        Action {}
+        Action {}
+    }
+
+    Repeater {
+        model: 5000
+        ListItem {
+            trailingOptions: options1
+        }
+    }
+}

=== added file 'tests/unit/tst_performance/ListItemWithOptionsList.qml'
--- tests/unit/tst_performance/ListItemWithOptionsList.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_performance/ListItemWithOptionsList.qml	2014-09-15 11:00:03 +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.1
+
+Column {
+    width: 800
+    height: 600
+    ListItemOptions {
+        id: options1
+        Action {}
+    }
+    ListItemOptions {
+        id: options2
+        Action {}
+        Action {}
+        Action {}
+    }
+
+    Repeater {
+        model: 5000
+        ListItem {
+            trailingOptions: options1
+            leadingOptions: options2
+        }
+    }
+}

=== 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-09-15 11:00:03 +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-09-15 11:00:03 +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-09-15 11:00:03 +0000
@@ -74,16 +74,16 @@
         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 options") << "ListItemWithOptionsList.qml" << QUrl();
+        QTest::newRow("list with new ListItem using default leadingOptions") << "ListItemWithLeadingOptionsList.qml" << QUrl();
+        QTest::newRow("list with new ListItem with inline options") << "ListItemWithInlineOptionsList.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-09-15 11:00:03 +0000
@@ -19,4 +19,11 @@
     TextWithImport.qml \
     TextWithImportGrid.qml \
     TextWithImportPopupsGrid.qml \
-    TextWithImportPopups.qml
+    TextWithImportPopups.qml \
+    ItemList.qml \
+    ListItemList.qml \
+    ListItemWithOptionsList.qml \
+    ListItemWithInlineOptionsList.qml \
+    ListItemsEmptyList.qml \
+    ListItemsBaseList.qml \
+    ListItemWithLeadingOptionsList.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-09-15 11:00:03 +0000
@@ -0,0 +1,569 @@
+/*
+ * 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.1
+
+Item {
+    id: main
+    width: units.gu(40)
+    height: units.gu(71)
+
+    Action {
+        id: stockAction
+        iconName: "starred"
+        property var param
+        onTriggered: param = value
+    }
+    ListItemOptions {
+        id: leading
+        Action {
+            iconName: "delete"
+            property var param
+            onTriggered: param = value
+        }
+        Action {
+            iconName: "edit"
+            property var param
+            onTriggered: param = value
+        }
+        Action {
+            iconName: "camcorder"
+            property var param
+            onTriggered: param = value
+        }
+    }
+    ListItemOptions {
+        id: trailing
+        panelColor: leading.panelColor
+        iconColor: leading.iconColor
+        options: [
+            stockAction,
+        ]
+        delegate: Item {
+            objectName: "custom_delegate"
+        }
+    }
+    ListItemOptions {
+        id: wrongOption
+        Action {
+            id: goodAction
+            iconName: "starred"
+        }
+        QtObject {
+            id: badAction
+        }
+        Action {
+            iconName: "starred"
+        }
+    }
+    ListItemOptions {
+        id: optionsDefault
+        property int optionCount: options.length
+    }
+
+    Column {
+        width: parent.width
+        ListItem {
+            id: defaults
+            width: parent.width
+        }
+        ListItem {
+            id: testItem
+            width: parent.width
+            contentItem.color: "blue"
+            leadingOptions: leading
+            trailingOptions: ListItemOptions {
+                options: leading.options
+            }
+
+            Item {
+                id: bodyItem
+                anchors.fill: parent
+            }
+        }
+        ListView {
+            id: listView
+            width: parent.width
+            height: units.gu(24)
+            clip: true
+            model: 10
+            delegate: ListItem {
+                objectName: "listItem" + index
+                width: parent.width
+                leadingOptions: leading
+                trailingOptions: trailing
+            }
+        }
+    }
+
+    UbuntuTestCase {
+        name: "ListItemAPI"
+        when: windowShown
+
+        SignalSpy {
+            id: pressedSpy
+            signalName: "pressedChanged"
+            target: testItem
+        }
+
+        SignalSpy {
+            id: clickSpy
+            signalName: "clicked"
+            target: testItem;
+        }
+
+        SignalSpy {
+            id: actionSpy
+            signalName: "triggered"
+        }
+
+        SignalSpy {
+            id: xChangeSpy
+            signalName: "xChanged"
+        }
+
+        function waitReboundCompletion(item) {
+            var prevX;
+            tryCompareFunction(function() { var b = prevX == item.contentItem.x; prevX = item.contentItem.x; return b; }, true, 1000);
+        }
+
+        function initTestCase() {
+            TestExtras.registerTouchDevice();
+            waitForRendering(main);
+        }
+
+        function cleanup() {
+            testItem.selected = false;
+            testItem.selectable = false;
+            waitForRendering(testItem, 200);
+            pressedSpy.clear();
+            clickSpy.clear();
+            actionSpy.clear();
+            xChangeSpy.clear();
+            listView.interactive = true;
+            // tap on the first item to make sure we are rebounding all
+            mouseClick(defaults, 0, 0);
+            // make sure all events are processed
+            wait(200);
+        }
+
+        function test_0_defaults() {
+            verify(defaults.contentItem !== null, "Defaults is null");
+            compare(defaults.contentItem.color, "#000000", "Transparent by default");
+            compare(defaults.contentItem.pressedColor, Theme.palette.selected.background, "Theme.palette.selected.background color by default")
+            compare(defaults.pressed, false, "Not pressed buy default");
+            compare(defaults.divider.visible, true, "divider is visible by default");
+            compare(defaults.divider.leftMargin, units.gu(2), "divider's left margin is 2GU");
+            compare(defaults.divider.rightMargin, units.gu(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(optionsDefault.delegate, null, "ListItemOptions has no delegate set by default.");
+            compare(optionsDefault.options.length, 0, "ListItemOptions has no options set.");
+            compare(optionsDefault.panelItem, null, "There is no panelItem created by default.");
+            compare(optionsDefault.status, ListItemOptions.Disconnected, "optiosn list is disconnected by default");
+            compare(optionsDefault.connectedItem, null, "No item is connected by default");
+            compare(optionsDefault.panelColor, "#000000", "default panelColor must be black");
+        }
+
+        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);
+        }
+        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));
+        }
+
+        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;
+        }
+
+        // ListItemOptions tests
+        function test_valid_options_data() {
+            return [
+                {tag: "Inline Actions", object: leading, expected: 3, xfail: false},
+                {tag: "Stock Actions", object: trailing, expected: 1, xfail: false},
+                {tag: "Wrong Actions", object: wrongOption, expected: 3, xfail: true},
+                {tag: "Wrong Actions", object: wrongOption, expected: 0, xfail: false},
+            ];
+        }
+        function test_valid_options(data) {
+            if (data.xfail) {
+                expectFailContinue(data.tag, "expected to fail");
+            }
+            compare(data.object.options.length, data.expected, data.tag + ": expected options differ.");
+        }
+
+        function test_touch_tug_options_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_touch_tug_options(data) {
+            listView.positionViewAtBeginning();
+            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));
+            }
+            waitForRendering(data.item, 400);
+            if (data.positiveDirection) {
+                verify(data.item.contentItem.x > 0, data.tag + " options did not show up");
+            } else {
+                verify(data.item.contentItem.x < 0, data.tag + " options did not show up");
+            }
+
+            // dismiss
+            if (data.mouse) {
+                mouseClick(main, 1, 1);
+            } else {
+                TestExtras.touchClick(0, main, Qt.point(1, 1));
+            }
+            waitForRendering(data.item, 400);
+        }
+
+        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.contentItem, 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.contentItem, mouse: false},
+            ];
+        }
+        function test_rebound_when_pressed_outside_or_clicked(data) {
+            listView.positionViewAtBeginning();
+            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));
+            }
+            waitForRendering(data.item, 400);
+            verify(data.item.contentItem.x != 0, "The component wasn't tugged!");
+            // dismiss
+            if (data.mouse) {
+                mouseClick(data.clickOn, centerOf(data.clickOn).x, centerOf(data.clickOn).y);
+            } else {
+                TestExtras.touchClick(0, data.clickOn, centerOf(data.clickOn));
+            }
+            waitForRendering(data.item, 400);
+            tryCompareFunction(function(){ return data.item.contentItem.x; }, 0, 1000);
+        }
+
+        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();
+            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));
+            }
+            waitForRendering(data.item, 800);
+            compare(listView.interactive, false, "The ListView is still interactive!");
+            // dismiss
+            if (data.mouse) {
+                mouseClick(data.clickOn, centerOf(data.clickOn).x, centerOf(data.clickOn).y);
+            } else {
+                TestExtras.touchClick(0, data.clickOn, centerOf(data.clickOn));
+            }
+            waitForRendering(data.item, 400);
+            tryCompareFunction(function(){ return listView.interactive; }, true, 1000);
+        }
+
+        function test_selecting_option_rebounds_data() {
+            var item0 = findChild(listView, "listItem0");
+            return [
+                {tag: "With mouse", item: item0, pos: centerOf(item0), dx: units.gu(20), options: item0.leadingOptions, select: "list_option_0", mouse: true},
+                {tag: "With touch", item: item0, pos: centerOf(item0), dx: units.gu(20), options: item0.leadingOptions, select: "list_option_0", mouse: false},
+            ]
+        }
+        function test_selecting_option_rebounds(data) {
+            listView.positionViewAtBeginning();
+            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));
+            }
+            waitForRendering(data.item, 800);
+            var selectedOption = findChild(data.options.panelItem, data.select);
+            verify(selectedOption, "Cannot select option " + data.select);
+            // dismiss
+            if (data.mouse) {
+                mouseClick(selectedOption, centerOf(selectedOption).x, centerOf(selectedOption).y);
+            } else {
+                TestExtras.touchClick(0, selectedOption, centerOf(selectedOption));
+            }
+            waitForRendering(data.item, 400);
+            tryCompareFunction(function(){ return data.item.contentItem.x; }, 0, 1000);
+        }
+
+        function test_custom_trailing_delegate() {
+            listView.positionViewAtBeginning();
+            var item = findChild(listView, "listItem0");
+            flick(item, centerOf(item).x, centerOf(item).y, -units.gu(20), 0);
+            verify(trailing.panelItem, "Panel is not visible");
+            var custom = findChild(trailing.panelItem, "custom_delegate");
+            verify(custom, "Custom delegate not in use");
+            // cleanup
+            mouseClick(main, 0, 0);
+        }
+
+        // execute as last so we make sure we have the panel created
+        function test_snap_data() {
+            verify(testItem.leadingOptions.panelItem, "Panel had not been created!");
+            var option = findChild(testItem.leadingOptions.panelItem, "list_option_0");
+            verify(option, "Options not accessible");
+            var optionSize = option.width;
+            return [
+                {tag: "Snap back leading, mouse", item: testItem.contentItem, dx: optionSize / 2 - 10, list: testItem.leadingOptions, snap: false, mouse: true},
+                {tag: "Snap back leading, touch", item: testItem.contentItem, dx: optionSize / 2 - 10, list: testItem.leadingOptions, snap: false, mouse: false},
+                {tag: "Snap in leading, mouse", item: testItem.contentItem, dx: optionSize / 2 + 10, list: testItem.leadingOptions, snap: true, mouse: true},
+                {tag: "Snap in leading, touch", item: testItem.contentItem, dx: optionSize / 2 + 10, list: testItem.leadingOptions, snap: true, mouse: false},
+
+                {tag: "Snap back trailing, mouse", item: testItem.contentItem, dx: -(optionSize / 2 - 10), list: testItem.trailingOptions, snap: false, mouse: true},
+                {tag: "Snap back trailing, touch", item: testItem.contentItem, dx: -(optionSize / 2 - 10), list: testItem.trailingOptions, snap: false, mouse: false},
+                {tag: "Snap in trailing, mouse", item: testItem.contentItem, dx: -(optionSize / 2 + 10), list: testItem.trailingOptions, snap: true, mouse: true},
+                {tag: "Snap in trailing, touch", item: testItem.contentItem, dx: -(optionSize / 2 + 10), list: testItem.trailingOptions, snap: true, mouse: false},
+            ];
+        }
+        function test_snap(data) {
+            if (data.mouse) {
+                flick(data.item, centerOf(data.item).x, centerOf(data.item).y, data.dx, 0);
+            } else {
+                TestExtras.touchDrag(0, data.item, centerOf(data.item), Qt.point(data.dx, 0));
+            }
+
+            waitForRendering(data.item, 800);
+            if (data.snap) {
+                verify(data.item.x != 0, "Not snapped to be visible");
+            } else {
+                verify(data.item.x == 0, "Not snapped back");
+            }
+
+            // cleanup
+            if (data.mouse) {
+                mouseClick(data.item, centerOf(data.item).x, centerOf(data.item).y);
+            } else {
+                TestExtras.touchClick(0, data.item, centerOf(data.item));
+            }
+            waitForRendering(data.item, 800);
+        }
+
+        function test_verify_action_value_data() {
+            return [
+                {tag: "Undefined", item: testItem, result: undefined},
+                {tag: "Index 0", item: findChild(listView, "listItem0"), result: 0},
+                {tag: "Index 1", item: findChild(listView, "listItem1"), result: 1},
+                {tag: "Index 2", item: findChild(listView, "listItem2"), result: 2},
+                {tag: "Index 3", item: findChild(listView, "listItem3"), result: 3},
+            ];
+        }
+        function test_verify_action_value(data) {
+            var option = findChild(data.item.leadingOptions.panelItem, "list_option_0");
+            verify(option, "Options panel cannot be reached");
+            // we test the last action, as we tug the first action on leading, which means teh alst will be accessible
+            var len = data.item.leadingOptions.options.length;
+            var action = data.item.leadingOptions.options[len - 1];
+            actionSpy.target = action;
+            actionSpy.clear();
+            // tug options in
+            flick(data.item.contentItem, centerOf(data.item.contentItem).x, centerOf(data.item.contentItem).y, option.width, 0);
+            waitForRendering(data.item.contentItem, 800);
+
+            // select the option
+            mouseClick(data.item, centerOf(option).x, centerOf(option).y);
+            waitForRendering(data.item.contentItem, 800);
+
+            // check the action param
+            actionSpy.wait();
+            compare(action.param, data.result, "Action parameter differs");
+        }
+
+        SignalSpy {
+            id: panelItemSpy
+            signalName: "onXChanged"
+        }
+
+        function test_disabled_item_locked_data() {
+            var item0 = findChild(listView, "listItem0");
+            return [
+                // drag same amount as height is
+                {tag: "Simple item, leading", item: testItem, enabled: false, dx: testItem.height},
+                {tag: "Simple item, trailing", item: testItem, enabled: false, dx: -testItem.height},
+                {tag: "ListView item, leading", item: item0, enabled: false, dx: item0.height},
+                {tag: "ListView item, trailing", item: item0, enabled: false, dx: -item0.height},
+            ];
+        }
+        function test_disabled_item_locked(data) {
+            var oldEnabled = data.item.enabled;
+            panelItemSpy.clear();
+            panelItemSpy.target = data.item;
+            data.item.enabled = false;
+            // tug
+            flick(data.item.contentItem, centerOf(data.item.contentItem).x, centerOf(data.item.contentItem).y, data.dx, 0);
+            compare(panelItemSpy.count, 0, "Item had been tugged despite being disabled!");
+            // check opacity
+            fuzzyCompare(data.item.opacity, 0.5, 0.1, "Disabled item must be 50% transparent");
+            //cleanup
+            data.item.enabled = oldEnabled;
+        }
+
+        function test_toggle_selectable_data() {
+            return [
+                {tag: "When not selected", selected: false},
+                {tag: "When selected", selected: true},
+            ]
+        }
+        function test_toggle_selectable(data) {
+            xChangeSpy.target = testItem.contentItem;
+            testItem.selectable = true;
+            waitForRendering(testItem.contentItem, 800);
+            testItem.selected = data.selected;
+            xChangeSpy.wait();
+        }
+
+        function test_no_tug_when_selectable() {
+            xChangeSpy.target = null;
+            testItem.selectable = true;
+            // wait till animation to selection mode ends
+            waitReboundCompletion(testItem);
+
+            // try to tug leading
+            xChangeSpy.target = testItem.contentItem;
+            xChangeSpy.clear();
+            compare(xChangeSpy.count, 0, "Wrong signal count!");
+            flick(testItem.contentItem, centerOf(testItem.contentItem).x, centerOf(testItem.contentItem).y, testItem.contentItem.width / 2, 0);
+            compare(xChangeSpy.count, 0, "No tug allowed when in selection mode");
+        }
+
+        SignalSpy {
+            id: pressAndHoldSpy
+            signalName: "pressAndHold"
+        }
+        function test_pressandhold_suppress_click() {
+            var center = centerOf(testItem);
+            pressAndHoldSpy.target = testItem;
+            clickSpy.target = testItem;
+            clickSpy.clear();
+            mouseLongPress(testItem, center.x, center.y);
+            mouseRelease(testItem, center.x, center.y);
+            pressAndHoldSpy.wait();
+            compare(clickSpy.count, 0, "Click must be suppressed when long pressed");
+        }
+
+        function test_listitemoptions_status_data() {
+            var drag = testItem.contentItem.width / 2;
+            return [
+                {tag:"Leading", item: testItem, dx: drag, list: testItem.leadingOptions, expectedStatus: ListItemOptions.LeadingOptions},
+                {tag:"Trailing", item: testItem, dx: -drag, list: testItem.trailingOptions, expectedStatus: ListItemOptions.TrailingOptions},
+            ];
+        }
+        function test_listitemoptions_status(data) {
+            var testItem = data.item.contentItem;
+            flick(testItem, centerOf(testItem).x, centerOf(testItem).y, data.dx, 0);
+            waitForRendering(testItem, 800);
+            compare(data.list.status, data.expectedStatus, "Status on the option list differs.");
+            compare(data.list.connectedItem, data.item, "connectedItem is not the tugged item.");
+        }
+
+        function test_panelColor_change() {
+            // change panel color for the leading and observe the trailing panelItem color change
+            leading.panelColor = UbuntuColors.blue;
+            compare(leading.panelItem.panelColor, UbuntuColors.blue, "leading panelItem color differs");
+            compare(trailing.panelItem.panelColor, UbuntuColors.blue, "trailing panelItem color has not been set");
+        }
+        function test_iconColor_change() {
+            // change panel color for the leading and observe the trailing panelItem color change
+            leading.iconColor = UbuntuColors.green;
+            compare(leading.panelItem.iconColor, UbuntuColors.green, "leading panelItem color differs");
+            compare(trailing.panelItem.iconColor, UbuntuColors.green, "trailing panelItem color has not been set");
+        }
+    }
+}

=== added file 'tests/unit_x11/tst_components/tst_listitem_ubuntulistview.qml'
--- tests/unit_x11/tst_components/tst_listitem_ubuntulistview.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_components/tst_listitem_ubuntulistview.qml	2014-09-15 11:00:03 +0000
@@ -0,0 +1,159 @@
+/*
+ * 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.1
+
+Item {
+    id: main
+    width: units.gu(40)
+    height: units.gu(71)
+
+    Column {
+        anchors.fill: parent
+        UbuntuListView {
+            id: listView
+            clip: true
+            width: parent.width
+            height: parent.height / 3
+            delegate: ListItem {
+                objectName: "listItem" + index
+            }
+        }
+        // override default leading
+        UbuntuListView {
+            id: customListView1
+            clip: true
+            width: parent.width
+            height: parent.height / 3
+            model: numberModel
+            leadingOptions: ListItemOptions {
+                Action {
+                    iconName: "edit"
+                }
+            }
+            delegate: ListItem {
+                objectName: "listItem" + index
+            }
+        }
+        // inline option list takes precedence (overrides UbuntuListView's default)
+        UbuntuListView {
+            id: customListView2
+            clip: true
+            width: parent.width
+            height: parent.height / 3
+            model: numberModel
+            delegate: ListItem {
+                objectName: "listItem" + index
+                leadingOptions: ListItemOptions {
+                    Action {
+                        iconName: "edit"
+                    }
+                }
+            }
+        }
+    }
+
+    property int numberModel: 10
+    property var arrayModel: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    property ListModel objectModel: ListModel {
+        function fill() {
+            clear();
+            for (var i = 0; i < 10; i++) {
+                append({data: "ListElement #" + i})
+            }
+        }
+    }
+
+    UbuntuTestCase {
+        name: "ListItem with UbuntuListView"
+        when: windowShown
+
+        SignalSpy {
+            id: actionSpy
+            signalName: "triggered";
+        }
+
+        function init() {
+            numberModel = 10;
+            arrayModel = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+            objectModel.fill();
+        }
+        function cleanup() {
+            listView.model = undefined;
+            actionSpy.target = null;
+            actionSpy.clear();
+        }
+
+        function test_leading_option_is_delete_alone() {
+            // set a model to the listView
+            listView.model = numberModel;
+            waitForRendering(listView, 800);
+            var listItem = findChild(listView, "listItem0");
+            verify(listItem, "Cannot get list item at index 0");
+            // tug the leadingOptions in
+            flick(listItem.contentItem, centerOf(listItem.contentItem).x, centerOf(listItem.contentItem).y, listItem.contentItem.width / 2, 0);
+            // leading options panel must be created
+            verify(listItem.leadingOptions.panelItem, "Panel of LeadingOptions cannot be reached!");
+            compare(listItem.leadingOptions.options.length, 1, "More options in the default leadingOptions than it should be!");
+            compare(listItem.leadingOptions.options[0].iconName, "delete", "The default leading option is not 'delete'");
+        }
+
+        function test_delete_item_data() {
+            return [
+                {tag: "Number model", model: numberModel, index: 3, resultModelSize: 9 },
+                {tag: "Array model", model: arrayModel, index: 4, resultModelSize: 9 },
+                {tag: "Object model", model: objectModel, index: 2, resultModelSize: 9 },
+            ];
+        }
+        function test_delete_item(data) {
+            listView.model = data.model;
+            waitForRendering(listView, 800);
+            // navigate to teh list item
+            listView.positionViewAtIndex(data.index, ListView.Contain);
+            // perform delete by tugging the leading panel in
+            var listItem = findChild(listView, "listItem" + data.index);
+            verify(listItem, "Cannot get list item at index " + data.index);
+            flick(listItem.contentItem, centerOf(listItem.contentItem).x, centerOf(listItem.contentItem).y, listItem.contentItem.width / 2, 0);
+
+            // watch action triggers
+            actionSpy.target = listItem.leadingOptions.options[0];
+            // select the option on the leadingOptions
+            var option = findChild(listItem.leadingOptions.panelItem, "list_option_0");
+            verify(option, "Option cannot be reached");
+            mouseClick(listItem, centerOf(option).x, centerOf(option).y);
+            actionSpy.wait();
+
+            // check model size by comparing the listview count
+            compare(listView.count, data.resultModelSize, "Item had not been deleted!");
+        }
+
+        function test_default_optionlist_override_data() {
+            return [
+                {tag: "Default leadingOption overridden", view: customListView1},
+                {tag: "Inline leadingOption has precedence over default", view: customListView2},
+            ];
+        }
+        function test_default_optionlist_override(data) {
+            var listItem = findChild(data.view, "listItem0");
+            verify(listItem, "Cannot get list item at index 0");
+            compare(listItem.leadingOptions.options.length, 1, "More than 1 option in the leadingOptions list");
+            compare(listItem.leadingOptions.options[0].iconName, "edit", "Default UbuntuListItem option not overridden!");
+        }
+    }
+}

=== modified file 'tests/unit_x11/tst_components/tst_ubuntulistview11.qml'
--- tests/unit_x11/tst_components/tst_ubuntulistview11.qml	2014-06-26 15:59:10 +0000
+++ tests/unit_x11/tst_components/tst_ubuntulistview11.qml	2014-09-15 11:00:03 +0000
@@ -91,6 +91,7 @@
         function test_0_defaults() {
             verify(ubuntuListView.hasOwnProperty("pullToRefresh"), "PullToRefresh is missing");
             compare(ubuntuListView.pullToRefresh.enabled, false, "PullToRefresh functionality is disabled by default");
+            verify(ubuntuListView.leadingOptions, "LeadingOptions is not defined!");
         }
 
         function test_pullToRefresh_manual_refresh() {