Merge lp:~osomon/unity-2d/dnd-reorder-apps into lp:unity-2d/3.0

[Olivier Tilloy]

[launcher] Implement the ability to re-order applications via drag’n’drop.

This branch implements the ability to re-order applications in the launcher via drag’n’drop.

Known issues/shortcomings:

 - When dropping an application at the top of the list, or when dragging the topmost application down the list, the list is somehow shifted down by the value of the 'spacing' property. I filed http://bugreports.qt.nokia.com/browse/QTBUG-17622. I spent quite some time looking for a workaround, fresh ideas are welcome.

 - The position of the tiles of the other applications (all of them but the one being dragged) is not animated. This is because the list view positions the items itself, and animations are ignored. A possible workaround is to re-parent the tiles to the mouse area, but that introduces a lot of tricky bugs on which I already spent quite some time, so I left it out for the moment, this can be improved later.

[Olivier Tilloy (osomon)]

Note: a possible workaround for the first point mentioned above is to set the value of 'spacing' to 0, and compensate for this by adding top and bottom margins to the launcher tiles.

[Ugo Riboni (uriboni)]

When you start dragging a tile, please make sure to check that between the moment the mouse button is pressed and the moment the drag actually starts we didn't move the pointer to another tile. If this happens, just don't start the drag.

In other words, start the drag only if the pointer remains inside the same tile during the 800ms of wait that are hardcoded into Qt for pressAndHold.

[Ugo Riboni (uriboni)]

When you drag a tile, if it's dragged outside of the margins of the launcher, it disappears.
So I suggest a 2-parts solution to this:
- first don't allow the tile to move horizontally, only vertically, even if the user moves the mouse horizontally.
- second, try using QWidget::grabKey when the drag is started to get all mouse events to your window, including the mouse release event. This way even if the mouse cursor gets outside of the launcher window while dragging and the mouse button is released the tile will be dropped in its new position.
This should allow also the other tiles to re-position themselves when the mouse is outside of the launcher window when dragging.

review: Needs Fixing

[Ugo Riboni (uriboni)]

When you drag a tile and go over the autoscroll areas, the autoscroll is not triggered.
This makes it impossible to drag a tile all the way to the top/bottom in one single drag'n'drop action if the launcher has more items than they fit in the screen.

I think this happens because when forwarding mouse events from the toplevel MouseArea you don't check if there's one of the autoscroll areas below, and don't forward the events to it.

[Ugo Riboni (uriboni)]

As you mentioned in the MR description, there's this know issue where the list is shifted down a certain amount of pixels in some conditions.
If this was only a cosmetic problem we could fix it later. However it's also a functional issue since if it's done many times it causes the bottom tile to "slide off" of the list.
The tile become effectively unreachable because the autoscroll doesn't take into account this bogus extra space and therefore you can't scroll to this last tile anymore and interact with it.

A workaround is to make the autoscroll calculations take this extra space into account (since thankfully we know when it's added).

(please keep this fix for last after everything else mentioned here is fixed)

review: Needs Fixing

[Ugo Riboni (uriboni)]

The mousewheel can't be used for scrolling anymore. This was a quite useful feature, so if it's possible to get it back somehow it would be good.

I understand that since it was implemented by the Flickable and we disable it, this might have to be reimplemented manually.

Please report a bug for this so we can take care of this later on.

review: Needs Fixing

[Ugo Riboni (uriboni)]

15 + /* id (desktop file path) of the application being dragged */
16 + property string currentId: ""
17 + /* list index of the application being dragged */
18 + property int currentIndex

21 + /* list index of the application underneath the cursor */
22 + property int index: main.indexAt(listCoordinates.x, listCoordinates.y)

I think it's not clear to someone reading the code without going back to these comments what the 3 properties above are for.

currentId should probably be called draggedDesktopFileName or something like that, so that it tells you both it's related to dnd and it's actually a desktop file and not just an opaque id.

currentIndex could probably be renamed draggedTileIndex for the same reason.

And index should probably be tileIndexAtMouse or something like that, but "index" alone is definitely not descriptive enough.

review: Needs Fixing

[Ugo Riboni (uriboni)]

24 + onPressAndHold: {
25 + var id = items.get(currentIndex = index).desktop_file
26 + if (id != undefined) currentId = id
27 + }

items.get(currentIndex = index) saves you one line of code, but it makes the entire thing much less clear. In general assignements should be on their own separate line for clarity (relying on the fact that the "value" of an assignement is implicitly the assigned operand is clever but rather obscure).

Also when you rename currentIndex rename var id in a matching way since you're already there.

review: Needs Fixing

[Ugo Riboni (uriboni)]

166 +void
167 +LauncherApplicationsList::move(int from, int to)
168 +{
169 + LauncherApplication* firstApplication = m_applications[qMin(from, to)];
170 + LauncherApplication* secondApplication = m_applications[qMax(from, to)];

Can you please add a short comment to explain why you need qMin and qMax ? Took me a while to understand it myself.

192 + firstGconfPriority.setValue(QVariant(double(firstApplication->priority())));

Can't we just change the LauncherApplication::priorty to be a double so we don't have to do these casts whenever we need to read/store the priorities ?

review: Needs Fixing

[Ugo Riboni (uriboni)]

208 + Q_INVOKABLE void move(int from, int to);

Making it a slot is probably a better option, as it makes it more reusable and doesn't cost us anything.

[Ugo Riboni (uriboni)]

260 + // "move" is not a member of QAbstractListModel, cannot be invoked directly
261 + QMetaObject::invokeMethod(model, "move",
262 + Q_ARG(int, from - offset),
263 + Q_ARG(int, to - offset));

I understand what you're doing here, and my deep love of metaprogramming makes me like it ;)

However it kind of breaks the idea that the ListAggregatorModel can be used to aggregate *consistently* anything that's QAbstractListModel. In this case you get a totally different behavior if you're moving items from one underlying model or the other.
One option could be to make it somehow possible to ask the aggregator to tell us which model an item is in, and then do the move operation on that model directly.

[Ugo Riboni (uriboni)]

314 + /* Move one item from one position to another position.
315 + The item must remain in the same model. */
316 + Q_INVOKABLE void move(int from, int to);
317 +

Same thing about Q_INVOKABLE versus slots as mentioned above.

review: Needs Fixing

[lp:~osomon/unity-2d/dnd-reorder-apps]

409. By Olivier Tilloy on 2011-02-23

Do not start dragging an application if the mouse cursor has moved too much since the mouse press event.

410. By Olivier Tilloy on 2011-02-23

Move the tile being dragged along the vertical axis only.

411. By Olivier Tilloy on 2011-02-23

Drop the tile being dragged when the mouse cursor exits the launcher.

412. By Olivier Tilloy on 2011-02-23

Fix autoscrolling that had been broken by the use of hoverEnabled to constrain
the tile being dragged to the original position of the mouse press event.

413. By Olivier Tilloy on 2011-02-23

Work around http://bugreports.qt.nokia.com/browse/QTBUG-17622 by setting the spacing of the ListView to 0
and compensating with some vertical padding in the tiles.

414. By Olivier Tilloy on 2011-02-23

Encapsulate all the elements that need to be animated into an item called 'looseItem'.

415. By Olivier Tilloy on 2011-02-23

Fix indentations.

416. By Olivier Tilloy on 2011-02-23

Ensure the tiles in the shelf are always above those in 'main'.

417. By Olivier Tilloy on 2011-02-23

Re-enable flicking on the list view.
There are bugs.

[Olivier Tilloy (osomon)]

I addressed most of the points you raised above, and will shortly submit a new merge request to get those changes in. See my comments on the points I didn’t address or addressed only partially:

> try using QWidget::grabKey when the drag is started to get all
> mouse events to your window […]

As discussed and agreed, this won’t be implemented for now.

> Can you please add a short comment to explain why you need qMin and qMax ?

That looks pretty obvious to me, the pointers to the LauncherApplications are called firstApplication and secondApplication for a reason, an additional comment would just state the obvious.

> Can't we just change the LauncherApplication::priorty to be a double […]

We could, but priorities really are integers, so it’s better to keep our interfaces clean and work around the issues internally, in the implementation. On top of that this code is going to go away very soon, changing the interface could potentially introduce regressions for no real benefit.

> One option could be to make it somehow possible to ask the aggregator
> to tell us which model an item is in, and then do the move operation
> on that model directly.

That is exactly what I’m doing here: modelAtIndex(from) tells us which model an item is in and we invoke the move() method on this model.
The reason I need to do that the metaprogramming-way, as the comment states it, is that "move" is not a member of the QAbstractListModel interface. I could modify the ListAggregatorModel class to store instances of an interface that inherits QAbstractListModel and adds to it a "move" method, but that sounds a bit overkill, don’t you think?
The metaprogramming way is flexible enough that if the method doesn’t exist on the model, the call will simply be ignored.

[Olivier Tilloy (osomon)]

New merge request: https://code.launchpad.net/~osomon/unity-2d/dnd-reorder-apps/+merge/51720.

=== modified file 'launcher/Launcher.qml'
--- launcher/Launcher.qml	2011-02-18 14:02:46 +0000
+++ launcher/Launcher.qml	2011-02-23 21:55:46 +0000
@@ -18,6 +18,7 @@
         anchors.top: parent.top
         anchors.bottom: shelf.top
         width: parent.width
+        z: 1 /* for dnd to remain on top of looseItems */
 
         paddingTop: 5
         paddingBottom: 5
@@ -27,6 +28,79 @@
         model: ListAggregatorModel {
             id: items
         }
+
+        // FIXME: dragging the list to flick it exhibits unpleasant visual
+        // artifacts, and its contentY sometimes remains blocked at a position
+        // too far off the boundaries of the list.
+        MouseArea {
+            /* Handle drag’n’drop to re-order applications. */
+            id: dnd
+            anchors.fill: parent
+
+            /* id (desktop file path) of the application being dragged */
+            property string currentId: ""
+            /* list index of the application being dragged */
+            property int currentIndex
+            /* absolute mouse coordinates in the list */
+            property variant listCoordinates: mapToItem(main.contentItem, mouseX, mouseY)
+            /* list index of the application underneath the cursor */
+            property int index: main.indexAt(listCoordinates.x, listCoordinates.y)
+
+            onPressed: {
+                /* index is not valid yet because the mouse area is not
+                   sensitive to hovering (if it were, it would eat hover events
+                   for other mouse areas below, which is not desired). */
+                var coord = mapToItem(main.contentItem, mouse.x, mouse.y)
+                currentIndex = main.indexAt(coord.x, coord.y)
+            }
+            onPressAndHold: {
+                if (index != currentIndex) {
+                    /* The item under the cursor changed since the press. */
+                    return
+                }
+                parent.interactive = false
+                var id = items.get(currentIndex).desktop_file
+                if (id != undefined) currentId = id
+            }
+            function drop() {
+                currentId = ""
+                parent.interactive = true
+            }
+            onReleased: drop()
+            onExited: drop()
+            onMousePositionChanged: {
+                if (currentId != "" && index != -1 && index != currentIndex) {
+                    /* Workaround a bug in QML whereby moving an item down in
+                       the list results in its visual representation being
+                       shifted too far down by one index
+                       (http://bugreports.qt.nokia.com/browse/QTBUG-15841).
+                       Since the bug happens only when moving an item *down*,
+                       and since moving an item one index down is strictly
+                       equivalent to moving the item below one index up, we
+                       achieve the same result by tricking the list model into
+                       thinking that the mirror operation was performed.
+                       Note: this bug will be fixed in Qt 4.7.2, at which point
+                       this workaround can go away. */
+                    if (index > currentIndex) {
+                        items.move(index, currentIndex, 1)
+                    } else {
+                        /* This should be the only code path here, if it wasn’t
+                           for the bug explained and worked around above. */
+                        items.move(currentIndex, index, 1)
+                    }
+                    currentIndex = index
+                }
+            }
+            onClicked: {
+                /* Forward the click to the launcher item below. */
+                var point = mapToItem(main.contentItem, mouse.x, mouse.y)
+                var item = main.contentItem.childAt(point.x, point.y)
+                /* FIXME: the coordinates of the mouse event forwarded are
+                   incorrect. Luckily, it’s acceptable as they are not used in
+                   the handler anyway. */
+                if (item && typeof(item.clicked) == "function") item.clicked(mouse)
+            }
+        }
     }
 
     LauncherList {
@@ -34,6 +108,8 @@
         anchors.bottom: parent.bottom;
         height: tileSize * count + spacing * Math.max(0, count - 1)
         width: parent.width
+        /* Ensure the tiles in the shelf are always above those in 'main'. */
+        itemZ: 1
 
         model: ListAggregatorModel {
             id: shelfItems

=== modified file 'launcher/LauncherItem.qml'
--- launcher/LauncherItem.qml	2011-02-18 14:02:46 +0000
+++ launcher/LauncherItem.qml	2011-02-23 21:55:46 +0000
@@ -34,9 +34,14 @@
     objectName: "launcherItem"
 
     anchors.horizontalCenter: parent.horizontalCenter
-    height: tileSize
+    /* Manually add some padding to compensate for the spacing
+       of the ListView being set to 0 to work around
+       http://bugreports.qt.nokia.com/browse/QTBUG-17622. */
+    property int padding: 5
+    height: tileSize + padding
 
     property int tileSize
+    property string desktopFile: ""
     property alias icon: icon.source
     property bool running: false
     property bool active: false
@@ -70,230 +75,263 @@
     signal entered
     signal exited
 
-    /* This is the arrow shown at the right of the tile when the application is
-       the active one */
-    Image {
-        anchors.right: parent.right
-        anchors.verticalCenter: parent.verticalCenter
-        source: "image://blended/%1color=%2alpha=%3"
-              .arg(engineBaseUrl + "artwork/launcher_arrow_rtl.png")
-              .arg("lightgrey")
-              .arg(1.0)
-
-        /* This extra shift is necessary (as is for the pips below)
-           since we are vertically centering in a parent with even height, so
-           there's one pixel offset that need to be assigned arbitrarily.
-           Unity chose to add it, QML to subtract it. So we adjust for that. */
-        transform: Translate { y: 1 }
-
-        visible: active
-    }
-
-    /* This is the area on the left of the tile where the pips/arrow end up.
-
-       I'd rather use a Column here, but the pip images have an halo
-       around them, so they are pretty tall and would mess up the column.
-       As a workaround I center all of them, then shift up or down
-       depending on the index. */
-    Repeater {
-        model: item.pips
-        delegate: Image {
-            /* FIXME: It seems that when the image is created (or re-used) by the Repeater
-               for a moment it doesn't have any parent, and therefore warnings are
-               printed for the following two anchor assignements. This fixes the
-               problem, but I'm not sure if it should happen in the first place. */
-            anchors.left: (parent) ? parent.left : undefined
-            anchors.verticalCenter: (parent) ? parent.verticalCenter : undefined
-
-            source: "image://blended/%1color=%2alpha=%3"
-                    .arg(pipSource).arg("lightgrey").arg(1.0)
-
-            transform: Translate { y: getPipOffset(index) + 1 }
-        }
-    }
-
-    /* This is the for centering the actual tile in the launcher */
     Item {
-        id: tile
-        anchors.centerIn: parent
-        width: item.tileSize
+        /* The actual item, reparented so its y coordinate can be animated. */
+        id: looseItem
+        parent: launcher
+        width: item.width
         height: item.height
+        x: item.x
+        /* item.parent is the delegate, and its parent is the LauncherList */
+        y: item.parent.parent.y - item.parent.parent.contentY + item.y
+        z: item.parent.parent.itemZ
 
-        /* This is the image providing the background image. The
-           color blended with this image is obtained from the color of the icon when it's
-           loaded.
-           While the application is launching, this will fade out and in. */
+        /* This is the arrow shown at the right of the tile when the application is
+           the active one */
         Image {
-            id: tileBackground
-            property color color: defaultBackgroundColor
-            anchors.fill: parent
-
-            SequentialAnimation on opacity {
-                NumberAnimation { to: 0.0; duration: 1000; easing.type: Easing.InOutQuad }
-                NumberAnimation { to: 1.0; duration: 1000; easing.type: Easing.InOutQuad }
-
-                loops: Animation.Infinite
-                alwaysRunToEnd: true
-                running: launching
-            }
-
-            sourceSize.width: item.tileSize
-            sourceSize.height: item.tileSize
+            anchors.right: parent.right
+            anchors.verticalCenter: parent.verticalCenter
             source: "image://blended/%1color=%2alpha=%3"
-                    .arg(engineBaseUrl + "artwork/round_corner_54x54.png")
-                    .arg(color.toString().replace("#", ""))
-                    .arg(1.0)
+                  .arg(engineBaseUrl + "artwork/launcher_arrow_rtl.png")
+                  .arg("lightgrey")
+                  .arg(1.0)
+
+            /* This extra shift is necessary (as is for the pips below)
+               since we are vertically centering in a parent with even height, so
+               there's one pixel offset that need to be assigned arbitrarily.
+               Unity chose to add it, QML to subtract it. So we adjust for that. */
+            transform: Translate { y: 1 }
+
+            visible: active && (looseItem.state != "beingDragged")
         }
 
-        /* This image appears only while launching, and pulses in and out in counterpoint
-           to the background, so that the outline of the tile is always visible. */
-        Image {
-            id: tileOutline
-            anchors.fill: parent
-
-            sourceSize.width: item.tileSize
-            sourceSize.height: item.tileSize
-            source: "artwork/round_outline_54x54.png"
-
-            opacity: 0
-
-            SequentialAnimation on opacity {
-                NumberAnimation { to: 1.0; duration: 1000; easing.type: Easing.InOutQuad }
-                NumberAnimation { to: 0.0; duration: 1000; easing.type: Easing.InOutQuad }
-
-                loops: Animation.Infinite
-                alwaysRunToEnd: true
-                running: launching
+        /* This is the area on the left of the tile where the pips/arrow end up.
+
+           I'd rather use a Column here, but the pip images have an halo
+           around them, so they are pretty tall and would mess up the column.
+           As a workaround I center all of them, then shift up or down
+           depending on the index. */
+        Repeater {
+            model: item.pips
+            delegate: Image {
+                /* FIXME: It seems that when the image is created (or re-used) by the Repeater
+                   for a moment it doesn't have any parent, and therefore warnings are
+                   printed for the following two anchor assignements. This fixes the
+                   problem, but I'm not sure if it should happen in the first place. */
+                anchors.left: (parent) ? parent.left : undefined
+                anchors.verticalCenter: (parent) ? parent.verticalCenter : undefined
+
+                source: "image://blended/%1color=%2alpha=%3"
+                        .arg(pipSource).arg("lightgrey").arg(1.0)
+
+                transform: Translate { y: getPipOffset(index) + 1 }
+
+                visible: looseItem.state != "beingDragged"
             }
         }
 
-        /* This is just the main icon of the tile */
-        Image {
-            id: icon
+        /* This is the for centering the actual tile in the launcher */
+        Item {
+            id: tile
+            width: item.tileSize
+            height: item.tileSize
             anchors.centerIn: parent
 
-            sourceSize.width: 48
-            sourceSize.height: 48
-
-            /* Whenever one of the parameters used in calculating the background color of
-               the icon changes, recalculate its value */
-            onWidthChanged: updateColors()
-            onHeightChanged: updateColors()
-            onSourceChanged: updateColors()
-
-            function updateColors() {
-                if (!item.backgroundFromIcon) return;
-
-                var colors = launcherView.getColorsFromIcon(icon.source, icon.sourceSize)
-                if (colors && colors.length > 0) tileBackground.color = colors[0]
-            }
-        }
-
-        /* This just adds some shiny effect to the tile */
-        Image {
-            id: tileShine
-            anchors.fill: parent
-
-            source: "artwork/round_shine_54x54.png"
-            sourceSize.width: item.tileSize
-            sourceSize.height: item.tileSize
-        }
-
-        Rectangle {
-            id: counter
-            height: 16 - border.width
-            width: 32
-            // Using anchors the item will be 1 pixel off with respect to Unity
-            y: 1
-            x: 1
-            radius: height / 2 - 1
-            border.width: 2
-            border.color: "white"
-            color: "#595959"
-            visible: launcherItem.counterVisible
-
-            Text {
+            /* This is the image providing the background image. The
+               color blended with this image is obtained from the color of the icon when it's
+               loaded.
+               While the application is launching, this will fade out and in. */
+            Image {
+                id: tileBackground
+                property color color: defaultBackgroundColor
+                anchors.fill: parent
+
+                SequentialAnimation on opacity {
+                    NumberAnimation { to: 0.0; duration: 1000; easing.type: Easing.InOutQuad }
+                    NumberAnimation { to: 1.0; duration: 1000; easing.type: Easing.InOutQuad }
+
+                    loops: Animation.Infinite
+                    alwaysRunToEnd: true
+                    running: launching
+                }
+
+                sourceSize.width: item.tileSize
+                sourceSize.height: item.tileSize
+                source: "image://blended/%1color=%2alpha=%3"
+                        .arg(engineBaseUrl + "artwork/round_corner_54x54.png")
+                        .arg(color.toString().replace("#", ""))
+                        .arg(1.0)
+            }
+
+            /* This image appears only while launching, and pulses in and out in counterpoint
+               to the background, so that the outline of the tile is always visible. */
+            Image {
+                id: tileOutline
+                anchors.fill: parent
+
+                sourceSize.width: item.tileSize
+                sourceSize.height: item.tileSize
+                source: "artwork/round_outline_54x54.png"
+
+                opacity: 0
+
+                SequentialAnimation on opacity {
+                    NumberAnimation { to: 1.0; duration: 1000; easing.type: Easing.InOutQuad }
+                    NumberAnimation { to: 0.0; duration: 1000; easing.type: Easing.InOutQuad }
+
+                    loops: Animation.Infinite
+                    alwaysRunToEnd: true
+                    running: launching
+                }
+            }
+
+            /* This is just the main icon of the tile */
+            Image {
+                id: icon
                 anchors.centerIn: parent
-                font.pixelSize: parent.height - 3
-                width: parent.width - 5
-                elide: Text.ElideRight
-                horizontalAlignment: Text.AlignHCenter
-                color: "white"
-                text: launcherItem.counter
-            }
-        }
-
-        Image {
-            id: progressBar
-            source: "artwork/progress_bar_trough.png"
-            anchors.verticalCenter: parent.verticalCenter
-            anchors.left: parent.left
-            width: tile.width
-            state: launcherItem.progressBarVisible ? "" : "hidden"
-
-            Image {
-                id: progressFill
-                source: "artwork/progress_bar_fill.png"
+
+                sourceSize.width: 48
+                sourceSize.height: 48
+
+                /* Whenever one of the parameters used in calculating the background color of
+                   the icon changes, recalculate its value */
+                onWidthChanged: updateColors()
+                onHeightChanged: updateColors()
+                onSourceChanged: updateColors()
+
+                function updateColors() {
+                    if (!item.backgroundFromIcon) return;
+
+                    var colors = launcherView.getColorsFromIcon(icon.source, icon.sourceSize)
+                    if (colors && colors.length > 0) tileBackground.color = colors[0]
+                }
+            }
+
+            /* This just adds some shiny effect to the tile */
+            Image {
+                id: tileShine
+                anchors.fill: parent
+
+                source: "artwork/round_shine_54x54.png"
+                sourceSize.width: item.tileSize
+                sourceSize.height: item.tileSize
+            }
+
+            Rectangle {
+                id: counter
+                height: 16 - border.width
+                width: 32
+                // Using anchors the item will be 1 pixel off with respect to Unity
+                y: 1
+                x: 1
+                radius: height / 2 - 1
+                border.width: 2
+                border.color: "white"
+                color: "#595959"
+                visible: launcherItem.counterVisible
+
+                Text {
+                    anchors.centerIn: parent
+                    font.pixelSize: parent.height - 3
+                    width: parent.width - 5
+                    elide: Text.ElideRight
+                    horizontalAlignment: Text.AlignHCenter
+                    color: "white"
+                    text: launcherItem.counter
+                }
+            }
+
+            Image {
+                id: progressBar
+                source: "artwork/progress_bar_trough.png"
                 anchors.verticalCenter: parent.verticalCenter
-                x: 6
-                width: sourceSize.width * launcherItem.progress
+                anchors.left: parent.left
+                width: tile.width
+                state: launcherItem.progressBarVisible ? "" : "hidden"
+
+                Image {
+                    id: progressFill
+                    source: "artwork/progress_bar_fill.png"
+                    anchors.verticalCenter: parent.verticalCenter
+                    x: 6
+                    width: sourceSize.width * launcherItem.progress
+
+                    Behavior on width {
+                       NumberAnimation { duration: 200; easing.type: Easing.InOutSine }
+                    }
+                }
 
                 Behavior on width {
-                   NumberAnimation { duration: 200; easing.type: Easing.InOutSine }
-                }
-            }
-
-            Behavior on width {
-                NumberAnimation { duration: 200; easing.type: Easing.InOutSine }
-            }
-
-            states: State {
-                name: "hidden"
-                PropertyChanges {
-                    target: progressBar
-                    width: 0
-                }
-                // This, combined with anchors.left: parent.left in the default state
-                // makes the bar seem to come in from the left and go away at the right
-                AnchorChanges {
-                    target: progressBar
-                    anchors.left: undefined
-                    anchors.right: tile.right
-                }
-            }
-        }
-
-        Image {
-            id: emblemIcon
-            anchors.left: parent.left
-            anchors.top: parent.top
-            visible: launcherItem.emblemVisible && !counter.visible
-        }
-
-
-        /* The entire tile will "shake" when the window is marked as "urgent", to attract
-           the user's attention */
-        SequentialAnimation {
-            running: urgent
-            alwaysRunToEnd: true
-
+                    NumberAnimation { duration: 200; easing.type: Easing.InOutSine }
+                }
+
+                states: State {
+                    name: "hidden"
+                    PropertyChanges {
+                        target: progressBar
+                        width: 0
+                    }
+                    // This, combined with anchors.left: parent.left in the default state
+                    // makes the bar seem to come in from the left and go away at the right
+                    AnchorChanges {
+                        target: progressBar
+                        anchors.left: undefined
+                        anchors.right: tile.right
+                    }
+                }
+            }
+
+            Image {
+                id: emblemIcon
+                anchors.left: parent.left
+                anchors.top: parent.top
+                visible: launcherItem.emblemVisible && !counter.visible
+            }
+
+
+            /* The entire tile will "shake" when the window is marked as "urgent", to attract
+               the user's attention */
             SequentialAnimation {
-                loops: 30
-                NumberAnimation { target: tile; property: "rotation"; to: 15; duration: 150 }
-                NumberAnimation { target: tile; property: "rotation"; to: -15; duration: 150 }
-            }
-            NumberAnimation { target: tile; property: "rotation"; to: 0; duration: 75 }
-        }
-    }
-
-    MouseArea {
-        id: mouse
-        anchors.fill: parent
-
-        hoverEnabled: true
-        acceptedButtons: Qt.LeftButton | Qt.RightButton
-        onClicked: item.clicked(mouse)
-        onEntered: item.entered()
-        onExited: item.exited()
+                running: urgent
+                alwaysRunToEnd: true
+
+                SequentialAnimation {
+                    loops: 30
+                    NumberAnimation { target: tile; property: "rotation"; to: 15; duration: 150 }
+                    NumberAnimation { target: tile; property: "rotation"; to: -15; duration: 150 }
+                }
+                NumberAnimation { target: tile; property: "rotation"; to: 0; duration: 75 }
+            }
+
+            MouseArea {
+                id: mouse
+                anchors.fill: parent
+
+                hoverEnabled: true
+                acceptedButtons: Qt.LeftButton | Qt.RightButton
+                onClicked: item.clicked(mouse)
+                onEntered: item.entered()
+                onExited: item.exited()
+            }
+        }
+
+        states: State {
+            name: "beingDragged"
+            when: (dnd.currentId != "") && (dnd.currentId == item.desktopFile)
+            PropertyChanges {
+                target: looseItem
+                /* item.parent is the delegate, and its parent is the LauncherList */
+                y: dnd.listCoordinates.y - item.parent.parent.contentY - tile.height / 2
+                /* When dragging an item, stack it on top of all its siblings */
+                z: 1
+            }
+        }
+        Behavior on y {
+            enabled: (looseItem.state != "beingDragged") && !item.parent.parent.moving && !item.parent.parent.autoScrolling
+            NumberAnimation {
+                duration: 400
+                easing.type: Easing.OutBack
+            }
+        }
     }
 }

=== modified file 'launcher/LauncherList.qml'
--- launcher/LauncherList.qml	2011-02-21 10:23:45 +0000
+++ launcher/LauncherList.qml	2011-02-23 21:55:46 +0000
@@ -4,18 +4,27 @@
 
 AutoScrollingListView {
     id: list
-    spacing: 5
+
+    /* The spacing is explicitly set to 0 and compensated for
+       by adding some padding to the tiles because of
+       http://bugreports.qt.nokia.com/browse/QTBUG-17622. */
+    spacing: 0
+
     property int tileSize: 54
 
     /* Keep a reference to the currently visible contextual menu */
     property variant visibleMenu
 
+    /* A hint for items to determine the value of their 'z' property */
+    property real itemZ: 0
+
     delegate: LauncherItem {
         id: launcherItem
 
         width: list.width
         tileSize: list.tileSize
 
+        desktopFile: item.desktop_file ? item.desktop_file : ""
         icon: "image://icons/" + item.icon
         running: item.running
         active: item.active
@@ -87,6 +96,12 @@
             onAutoScrollingChanged: if (list.autoScrolling) item.menu.hide()
         }
 
+        Connections {
+            target: dnd
+            /* Hide the tooltip/menu when dragging an application. */
+            onCurrentIdChanged: if (dnd.currentId != "") item.menu.hide()
+        }
+
         function setIconGeometry() {
             if (running) {
                 item.setIconGeometry(x + panel.x, y + panel.y, width, height)

=== modified file 'launcher/UnityApplications/launcherapplicationslist.cpp'
--- launcher/UnityApplications/launcherapplicationslist.cpp	2011-02-21 10:29:10 +0000
+++ launcher/UnityApplications/launcherapplicationslist.cpp	2011-02-23 21:55:46 +0000
@@ -356,3 +356,38 @@
     return QVariant::fromValue(m_applications.at(index.row()));
 }
 
+
+void
+LauncherApplicationsList::move(int from, int to)
+{
+    LauncherApplication* firstApplication = m_applications[qMin(from, to)];
+    LauncherApplication* secondApplication = m_applications[qMax(from, to)];
+
+    QModelIndex parent;
+    /* When moving an item down, the destination index needs to be incremented
+       by one, as explained in the documentation:
+       http://doc.qt.nokia.com/qabstractitemmodel.html#beginMoveRows */
+    beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));
+    m_applications.move(from, to);
+    endMoveRows();
+
+    if (firstApplication->sticky() && secondApplication->sticky()) {
+        /* Update priorities only if both applications are favorites. */
+        int firstPriority = firstApplication->priority();
+        int secondPriority = secondApplication->priority();
+        /* Since we are guaranteed that this sort of move only happens between
+           two consecutive applications, all we need to do is swap their
+           priorities. */
+        firstApplication->setPriority(secondPriority);
+        secondApplication->setPriority(firstPriority);
+
+        GConfItemQmlWrapper firstGconfPriority;
+        firstGconfPriority.setKey(FAVORITES_KEY + favoriteFromDesktopFilePath(firstApplication->desktop_file()) + "/priority");
+        firstGconfPriority.setValue(QVariant(double(firstApplication->priority())));
+
+        GConfItemQmlWrapper secondGconfPriority;
+        secondGconfPriority.setKey(FAVORITES_KEY + favoriteFromDesktopFilePath(secondApplication->desktop_file()) + "/priority");
+        secondGconfPriority.setValue(QVariant(double(secondApplication->priority())));
+    }
+}
+

=== modified file 'launcher/UnityApplications/launcherapplicationslist.h'
--- launcher/UnityApplications/launcherapplicationslist.h	2011-02-21 10:29:10 +0000
+++ launcher/UnityApplications/launcherapplicationslist.h	2011-02-23 21:55:46 +0000
@@ -41,6 +41,8 @@
     QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
     int rowCount(const QModelIndex & parent = QModelIndex()) const;
 
+    Q_INVOKABLE void move(int from, int to);
+
     Q_INVOKABLE void insertFavoriteApplication(QString desktop_file);
     Q_INVOKABLE void insertWebFavorite(const QUrl& url);
 

=== modified file 'launcher/UnityApplications/listaggregatormodel.cpp'
--- launcher/UnityApplications/listaggregatormodel.cpp	2011-01-06 23:06:59 +0000
+++ launcher/UnityApplications/listaggregatormodel.cpp	2011-02-23 21:55:46 +0000
@@ -19,6 +19,8 @@
 
 #include "listaggregatormodel.h"
 
+#include <QDebug>
+
 ListAggregatorModel::ListAggregatorModel(QObject* parent) :
     QAbstractListModel(parent)
 {
@@ -60,6 +62,8 @@
             SLOT(onRowsInserted(const QModelIndex&, int, int)));
     connect(model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
             SLOT(onRowsRemoved(const QModelIndex&, int, int)));
+    connect(model, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)),
+            SLOT(onRowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)));
 }
 
 void
@@ -77,10 +81,27 @@
     {
         endRemoveRows();
     }
-    QObject::disconnect(model, SIGNAL(rowsInserted(const QModelIndex&, int, int)),
-                        this, SLOT(onRowsInserted(const QModelIndex&, int, int)));
-    QObject::disconnect(model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
-                        this, SLOT(onRowsRemoved(const QModelIndex&, int, int)));
+    disconnect(model, SIGNAL(rowsInserted(const QModelIndex&, int, int)),
+               this, SLOT(onRowsInserted(const QModelIndex&, int, int)));
+    disconnect(model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
+               this, SLOT(onRowsRemoved(const QModelIndex&, int, int)));
+    disconnect(model, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)),
+               this, SLOT(onRowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)));
+}
+
+void
+ListAggregatorModel::move(int from, int to)
+{
+    QAbstractListModel* model = modelAtIndex(from);
+    if (modelAtIndex(to) != model) {
+        qWarning() << "cannot move an item from one model to another";
+        return;
+    }
+    int offset = computeOffset(model);
+    // "move" is not a member of QAbstractListModel, cannot be invoked directly
+    QMetaObject::invokeMethod(model, "move",
+                              Q_ARG(int, from - offset),
+                              Q_ARG(int, to - offset));
 }
 
 int
@@ -95,6 +116,20 @@
     return offset;
 }
 
+QAbstractListModel*
+ListAggregatorModel::modelAtIndex(int index) const
+{
+    int offset = index;
+    Q_FOREACH(QAbstractListModel* model, m_models) {
+        int size = model->rowCount();
+        if (offset < size) {
+            return model;
+        }
+        offset -= size;
+    }
+    return NULL;
+}
+
 void
 ListAggregatorModel::onRowsInserted(const QModelIndex& parent, int first, int last)
 {
@@ -113,6 +148,17 @@
     endRemoveRows();
 }
 
+void
+ListAggregatorModel::onRowsMoved(const QModelIndex& sourceParent, int sourceStart, int sourceEnd,
+                                 const QModelIndex& destinationParent, int destinationRow)
+{
+    QAbstractListModel* model = static_cast<QAbstractListModel*>(sender());
+    int offset = computeOffset(model);
+    beginMoveRows(sourceParent, sourceStart + offset, sourceEnd + offset,
+                  destinationParent, destinationRow + offset);
+    endMoveRows();
+}
+
 int
 ListAggregatorModel::rowCount(const QModelIndex& parent) const
 {

=== modified file 'launcher/UnityApplications/listaggregatormodel.h'
--- launcher/UnityApplications/listaggregatormodel.h	2011-01-06 23:06:59 +0000
+++ launcher/UnityApplications/listaggregatormodel.h	2011-02-23 21:55:46 +0000
@@ -41,6 +41,10 @@
        to a QAbstractListModel */
     Q_INVOKABLE void appendModel(const QVariant& model);
 
+    /* Move one item from one position to another position.
+       The item must remain in the same model. */
+    Q_INVOKABLE void move(int from, int to);
+
 protected:
     QList<QAbstractListModel*> m_models;
 
@@ -50,9 +54,11 @@
 private slots:
     void onRowsInserted(const QModelIndex& parent, int first, int last);
     void onRowsRemoved(const QModelIndex& parent, int first, int last);
+    void onRowsMoved(const QModelIndex&, int, int, const QModelIndex&, int);
 
 private:
     int computeOffset(QAbstractListModel* model) const;
+    QAbstractListModel* modelAtIndex(int index) const;
 };
 
 #endif // LISTAGGREGATORMODEL_H