Merge lp:~nik90/ubuntu-clock-app/14-sync-listitem-actions-oct5 into lp:ubuntu-clock-app

[Nekhelesh Ramananthan]

Just a regular sync of ListItemWithActions.qml with upstream component.

Just a regular sync of ListItemWithActions.qml with upstream component.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:110
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/522/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-utopic-python3/700/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-clock-app-utopic-amd64-ci/169/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/522/rebuild

review: Needs Fixing (continuous-integration)

[Nekhelesh Ramananthan (nik90)]

#blocked on Jenkins. This requires a patch to the Jenkins environment since the xvfb package which is used to run the clock app tests takes input focus away from the clock app when it is launched. This is causing the AP tests to be pass. Francis and Nicholas have been informed. Once jenkins is fixed, we should be good to merge this branch.

review: Needs Fixing

[Riccardo Padovani (rpadovani)]

lgtm

review: Approve

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:111
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/543/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-utopic-python3/822/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/543/rebuild

review: Needs Fixing (continuous-integration)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:112
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/546/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-utopic-python3/830/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/546/rebuild

review: Needs Fixing (continuous-integration)

[lp:~nik90/ubuntu-clock-app/14-sync-listitem-actions-oct5]

114. By Nekhelesh Ramananthan on 2014-10-10

Updated debian changelog

[Nekhelesh Ramananthan (nik90)]

#unblocked Test failures fixed! Approving!

review: Approve

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:114
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/547/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic-python3/839
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic-python3/839/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-clock-app-ci/547/rebuild

review: Approve (continuous-integration)

=== modified file 'app/upstreamcomponents/ListItemWithActions.qml'
--- app/upstreamcomponents/ListItemWithActions.qml	2014-09-20 10:47:21 +0000
+++ app/upstreamcomponents/ListItemWithActions.qml	2014-10-10 10:19:22 +0000
@@ -34,63 +34,80 @@
     property alias internalAnchors: mainContents.anchors
     default property alias contents: mainContents.children
 
-    readonly property double actionWidth: units.gu(5)
+    readonly property double actionWidth: units.gu(4)
     readonly property double leftActionWidth: units.gu(10)
     readonly property double actionThreshold: actionWidth * 0.4
     readonly property double threshold: 0.4
     readonly property string swipeState: main.x == 0 ? "Normal" : main.x > 0 ? "LeftToRight" : "RightToLeft"
     readonly property alias swipping: mainItemMoving.running
+    readonly property bool _showActions: mouseArea.pressed || swipeState != "Normal" || swipping
+
+    /* internal */
+    property var _visibleRightSideActions: filterVisibleActions(rightSideActions)
 
     signal itemClicked(var mouse)
     signal itemPressAndHold(var mouse)
 
-    function returnToBoundsRTL()
+    function returnToBoundsRTL(direction)
     {
         var actionFullWidth = actionWidth + units.gu(2)
+
+        // go back to normal state if swipping reverse
+        if (direction === "LTR") {
+            updatePosition(0)
+            return
+        } else if (!triggerActionOnMouseRelease) {
+            updatePosition(-rightActionsView.width + units.gu(2))
+            return
+        }
+
         var xOffset = Math.abs(main.x)
-        var index = Math.min(Math.floor(xOffset / actionFullWidth), rightSideActions.length)
-
-        if (index < 1) {
-            main.x = 0
-        } else if (index === rightSideActions.length) {
-            main.x = -rightActionsView.width
-        } else {
-            main.x = -(actionFullWidth * index)
+        var index = Math.min(Math.floor(xOffset / actionFullWidth), _visibleRightSideActions.length)
+        var newX = 0
+      if (index === _visibleRightSideActions.length) {
+            newX = -(rightActionsView.width - units.gu(2))
+        } else if (index >= 1) {
+            newX = -(actionFullWidth * index)
         }
+        updatePosition(newX)
     }
 
-    function returnToBoundsLTR()
+    function returnToBoundsLTR(direction)
     {
         var finalX = leftActionWidth
-        if (main.x > (finalX * root.threshold))
-            main.x = finalX
-        else
-            main.x = 0
+        if ((direction === "RTL") || (main.x <= (finalX * root.threshold)))
+            finalX = 0
+        updatePosition(finalX)
     }
 
-    function returnToBounds()
+    function returnToBounds(direction)
     {
         if (main.x < 0) {
-            returnToBoundsRTL()
+            returnToBoundsRTL(direction)
         } else if (main.x > 0) {
-            returnToBoundsLTR()
+            returnToBoundsLTR(direction)
+        } else {
+            updatePosition(0)
         }
     }
 
-    function contains(item, point)
+    function contains(item, point, marginX)
     {
-        return (point.x >= item.x) && (point.x <= (item.x + item.width)) && (point.y >= item.y) && (point.y <= (item.y + item.height));
+        var itemStartX = item.x - marginX
+        var itemEndX = item.x + item.width + marginX
+        return (point.x >= itemStartX) && (point.x <= itemEndX) &&
+               (point.y >= item.y) && (point.y <= (item.y + item.height));
     }
 
     function getActionAt(point)
     {
-        if (contains(leftActionView, point)) {
+        if (contains(leftActionView, point, 0)) {
             return leftSideAction
-        } else if (contains(rightActionsView, point)) {
+        } else if (contains(rightActionsView, point, 0)) {
             var newPoint = root.mapToItem(rightActionsView, point.x, point.y)
             for (var i = 0; i < rightActionsRepeater.count; i++) {
                 var child = rightActionsRepeater.itemAt(i)
-                if (contains(child, newPoint)) {
+                if (contains(child, newPoint, units.gu(1))) {
                     return i
                 }
             }
@@ -100,15 +117,16 @@
 
     function updateActiveAction()
     {
-        if ((main.x <= -root.actionWidth) &&
-            (main.x > -rightActionsView.width)) {
+        if (triggerActionOnMouseRelease &&
+            (main.x <= -(root.actionWidth + units.gu(2))) &&
+            (main.x > -(rightActionsView.width - units.gu(2)))) {
             var actionFullWidth = actionWidth + units.gu(2)
             var xOffset = Math.abs(main.x)
-            var index = Math.min(Math.floor(xOffset / actionFullWidth), rightSideActions.length)
+            var index = Math.min(Math.floor(xOffset / actionFullWidth), _visibleRightSideActions.length)
             index = index - 1
             if (index > -1) {
                 root.activeItem = rightActionsRepeater.itemAt(index)
-                root.activeAction = root.rightSideActions[index]
+                root.activeAction = root._visibleRightSideActions[index]
             }
         } else {
             root.activeAction = null
@@ -117,7 +135,29 @@
 
     function resetSwipe()
     {
-        main.x = 0
+        updatePosition(0)
+    }
+
+    function filterVisibleActions(actions)
+    {
+        var visibleActions = []
+        for(var i = 0; i < actions.length; i++) {
+            var action = actions[i]
+            if (action.visible) {
+                visibleActions.push(action)
+            }
+        }
+        return visibleActions
+    }
+
+    function updatePosition(pos)
+    {
+        if (!root.triggerActionOnMouseRelease && (pos !== 0)) {
+            mouseArea.state = pos > 0 ? "RightToLeft" : "LeftToRight"
+        } else {
+            mouseArea.state = ""
+        }
+        main.x = pos
     }
 
     states: [
@@ -153,45 +193,49 @@
         }
         width: root.leftActionWidth + actionThreshold
         visible: leftSideAction
-        color: "red"
+        color: UbuntuColors.red
 
         Icon {
             anchors {
                 centerIn: parent
                 horizontalCenterOffset: actionThreshold / 2
             }
-            name: leftSideAction ? leftSideAction.iconName : ""
+            name: leftSideAction && _showActions ? leftSideAction.iconName : ""
             color: Theme.palette.selected.field
             height: units.gu(3)
             width: units.gu(3)
         }
     }
 
-    Item {
+    Rectangle {
        id: rightActionsView
 
        anchors {
            top: main.top
            left: main.right
-           leftMargin: units.gu(1)
            bottom: main.bottom
        }
-       visible: rightSideActions.length > 0
-       width: rightActionsRepeater.count > 0 ? rightActionsRepeater.count * (root.actionWidth + units.gu(2)) + actionThreshold : 0
+       visible: _visibleRightSideActions.length > 0
+       width: rightActionsRepeater.count > 0 ? rightActionsRepeater.count * (root.actionWidth + units.gu(2)) + root.actionThreshold + units.gu(2) : 0
+       color: "white"
        Row {
-           anchors.fill: parent
+           anchors{
+               top: parent.top
+               left: parent.left
+               leftMargin: units.gu(2)
+               right: parent.right
+               rightMargin: units.gu(2)
+               bottom: parent.bottom
+           }
            spacing: units.gu(2)
            Repeater {
                id: rightActionsRepeater
 
-               model: rightSideActions
+               model: _showActions ? _visibleRightSideActions : []
                Item {
                    property alias image: img
 
-                   anchors {
-                       top: parent.top
-                       bottom: parent.bottom
-                   }
+                   height: rightActionsView.height
                    width: root.actionWidth
 
                    Icon {
@@ -200,10 +244,10 @@
                        anchors.centerIn: parent
                        width: units.gu(3)
                        height: units.gu(3)
-                       name: iconName
-                       color: root.activeAction === modelData || !root.triggerActionOnMouseRelease ? UbuntuColors.lightAubergine : Theme.palette.selected.background
+                       name: modelData.iconName
+                       color: root.activeAction === modelData ? UbuntuColors.lightAubergine : UbuntuColors.lightGrey
                    }
-               }
+              }
            }
        }
     }
@@ -262,7 +306,6 @@
             }
         }
         Behavior on color {
-            enabled: (root.color != root.selectedColor)
            ColorAnimation {}
         }
     }
@@ -302,7 +345,10 @@
             value: 1.0
         }
         ScriptAction {
-            script: root.activeAction.triggered(root)
+            script: {
+                root.activeAction.triggered(root)
+                mouseArea.state = ""
+            }
         }
         PauseAnimation {
             duration: 500
@@ -318,24 +364,59 @@
     MouseArea {
         id: mouseArea
 
-        property bool locked: root.locked || ((root.leftSideAction === null) && (root.rightSideActions.count === 0))
+        property bool locked: root.locked || ((root.leftSideAction === null) && (root._visibleRightSideActions.count === 0))
         property bool manual: false
+        property string direction: "None"
+        property real lastX: -1
 
         anchors.fill: parent
         drag {
             target: locked ? null : main
             axis: Drag.XAxis
-            minimumX: rightActionsView.visible ? -(rightActionsView.width + root.actionThreshold) : 0
+            minimumX: rightActionsView.visible ? -(rightActionsView.width) : 0
             maximumX: leftActionView.visible ? leftActionView.width : 0
+            threshold: root.actionThreshold
+        }
+
+        states: [
+            State {
+                name: "LeftToRight"
+                PropertyChanges {
+                    target: mouseArea
+                    drag.maximumX: 0
+                }
+            },
+            State {
+                name: "RightToLeft"
+                PropertyChanges {
+                    target: mouseArea
+                    drag.minimumX: 0
+                }
+            }
+        ]
+
+        onMouseXChanged: {
+            var offset = (lastX - mouseX)
+            if (Math.abs(offset) <= root.actionThreshold) {
+                return
+            }
+            lastX = mouseX
+            direction = offset > 0 ? "RTL" : "LTR";
+        }
+
+        onPressed: {
+            lastX = mouse.x
         }
 
         onReleased: {
             if (root.triggerActionOnMouseRelease && root.activeAction) {
                 triggerAction.start()
             } else {
-                root.returnToBounds()
+                root.returnToBounds(direction)
                 root.activeAction = null
             }
+            lastX = -1
+            direction = "None"
         }
         onClicked: {
             if (main.x === 0) {
@@ -349,7 +430,7 @@
                 var actionIndex = getActionAt(Qt.point(mouse.x, mouse.y))
                 if (actionIndex !== -1) {
                     root.activeItem = rightActionsRepeater.itemAt(actionIndex)
-                    root.activeAction = root.rightSideActions[actionIndex]
+                    root.activeAction = root._visibleRightSideActions[actionIndex]
                     triggerAction.start()
                     return
                 }

=== modified file 'debian/changelog'
--- debian/changelog	2014-10-09 19:14:27 +0000
+++ debian/changelog	2014-10-10 10:19:22 +0000
@@ -9,6 +9,7 @@
   * Design tweak to always show the remaining time to an alarm for one-time alarms
     only. (LP: #1377538)
   * Tweaked bottom edge to show the time to the next active alarm (LP: #1290793)
+  * Synced ListItemWithActions with upstream
 
   [Akiva Shammai Avraham]
   * Improved the analog clock performance by updating the clock hands every second

=== modified file 'tests/unit/tst_alarm.qml'
--- tests/unit/tst_alarm.qml	2014-10-05 16:00:28 +0000
+++ tests/unit/tst_alarm.qml	2014-10-10 10:19:22 +0000
@@ -174,6 +174,21 @@
             }
         }
 
+        function _swipeToDeleteItem(item)
+        {
+            var startX = item.threshold
+            var startY = item.height / 2
+            var endX = item.width
+            var endY = startY
+            mousePress(item, startX, startY)
+            mouseMoveSlowly(item,
+                            startX, startY,
+                            endX - startX, endY - startY,
+                            10, 100)
+            mouseRelease(item, endX, endY)
+            mouseClick(item, startX, startY)
+        }
+
         function _deleteAlarm(label, repeat, time, status) {
             var alarmsList = findChild(alarmPage, "alarmListView")
             var oldCount = alarmsList.count
@@ -182,9 +197,7 @@
             var alarmObject = findChild(alarmsList, "alarm"+index)
 
             if (index !== -1) {
-                mouseDrag(alarmObject, alarmObject.width/4, alarmObject.height/2, units.gu(10), 0)
-                mouseRelease(alarmObject, alarmObject.width/4+units.gu(10), alarmObject.height/2)
-                mouseClick(alarmObject, units.gu(5), alarmObject.height/2)
+                _swipeToDeleteItem(alarmObject)
             }
 
             tryCompare(alarmsList, "count", oldCount-1, 10000, "Alarm count did not decrease after deleting the alarm")