Merge lp:~mzanetti/unity8/no-more-pinning into lp:unity8/rtm-14.09

[Michael Zanetti]

 * Are there any related MPs required for this MP to build/function as expected? Please list.

no

 * Did you perform an exploratory manual test run of your code change and any related functionality?

yes

 * Did you make sure that your branch does not contain spurious tags?

yes

 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
 * If you changed the UI, has there been a design review?

both N/A

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-10-06 15:56:08 +0000
+++ CMakeLists.txt	2014-10-14 12:55:09 +0000
@@ -58,6 +58,7 @@
 include(GNUInstallDirs)
 
 set(SHELL_APP_DIR ${CMAKE_INSTALL_DATADIR}/unity8)
+set(SHELL_PRIVATE_LIBDIR ${CMAKE_INSTALL_LIBDIR}/unity8)
 
 execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=plugindir_suffix unity-shell-api OUTPUT_VARIABLE SHELL_INSTALL_QML OUTPUT_STRIP_TRAILING_WHITESPACE)
 if(SHELL_INSTALL_QML STREQUAL "")
@@ -109,6 +110,7 @@
 
 # add subdirectories to build
 add_subdirectory(include)
+add_subdirectory(libs)
 add_subdirectory(src)
 add_subdirectory(tools)
 add_subdirectory(qml)

=== modified file 'debian/changelog'
--- debian/changelog	2014-10-09 14:05:55 +0000
+++ debian/changelog	2014-10-14 12:55:09 +0000
@@ -1,3 +1,30 @@
+unity8 (8.00+14.10.20141013.2-0ubuntu1) utopic; urgency=low
+
+  [ Michael Terry ]
+  * Don't show initial lockscreen during the edge demo. The user just
+    set up their phone with a password, it's pointless to ask them
+    again. (LP: #1358283)
+  * Distinguish between incoming calls and other dialer-app opens. (LP:
+    #1378218) (LP: #1378218)
+
+  [ Andrea Cimitan ]
+  * Fix flickable speed to be resolution independent, by subclassing
+    components (LP: #1348557)
+
+  [ Michał Sawicz ]
+  * Fix the ShellWithPin test and some functionality.
+
+  [ Albert Astals ]
+  * Move Base.qml to DashCategoryBase
+  * Fix first item positioning when m_clipItem->y() is not 0 (LP:
+    #1251597)
+  * Fix some small qml warnings
+
+  [ Daniel d'Andrada ]
+  * Add touch ownership logic on top of qt input handling
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 13 Oct 2014 15:43:03 +0000
+
 unity8 (8.00+14.10.20141009.4-0ubuntu1) utopic; urgency=low
 
   [ Michał Sawicz ]

=== modified file 'debian/control'
--- debian/control	2014-10-06 08:00:45 +0000
+++ debian/control	2014-10-14 12:55:09 +0000
@@ -86,7 +86,7 @@
          qmenumodel-qml (>= 0.2.8),
          qml-module-qtquick-xmllistmodel,
          qtdeclarative5-gsettings1.0,
-         qtdeclarative5-qtmir-plugin (>= 0.4.3),
+         qtdeclarative5-qtmir-plugin (>= 0.4.4),
          qtdeclarative5-ubuntu-telephony0.1,
          unity-launcher-impl-4,
          unity8-common (= ${source:Version}),

=== modified file 'debian/unity8-private.install'
--- debian/unity8-private.install	2014-09-05 12:25:51 +0000
+++ debian/unity8-private.install	2014-10-14 12:55:09 +0000
@@ -9,5 +9,6 @@
 usr/lib/*/unity8/qml/Ubuntu
 usr/lib/*/unity8/qml/Unity
 usr/lib/*/unity8/qml/Utils
+usr/lib/*/unity8/libUbuntuGestures*
 usr/share/accountsservice/interfaces
 usr/share/dbus-1/interfaces

=== added directory 'libs'
=== added file 'libs/CMakeLists.txt'
--- libs/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ libs/CMakeLists.txt	2014-10-14 12:55:09 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(UbuntuGestures)

=== added directory 'libs/UbuntuGestures'
=== added file 'libs/UbuntuGestures/CMakeLists.txt'
--- libs/UbuntuGestures/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/CMakeLists.txt	2014-10-14 12:55:09 +0000
@@ -0,0 +1,40 @@
+# in order to include Qt's private headers
+remove_definitions(-DQT_NO_KEYWORDS)
+
+set(UbuntuGestures_SOURCES
+    CandidateInactivityTimer.cpp
+    DebugHelpers.cpp
+    Timer.cpp
+    TouchOwnershipEvent.cpp
+    TouchRegistry.cpp
+    UnownedTouchEvent.cpp
+)
+
+add_definitions(-DUBUNTUGESTURES_LIBRARY)
+
+add_library(UbuntuGestures SHARED ${UbuntuGestures_SOURCES})
+
+qt5_use_modules(UbuntuGestures Core Quick)
+
+# So that Foo.cpp can #include "Foo.moc"
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+install(TARGETS UbuntuGestures
+        DESTINATION ${SHELL_PRIVATE_LIBDIR})
+
+
+# There's no cmake var for v8 include path :-/ so create one
+LIST(GET Qt5Core_INCLUDE_DIRS 0 QtCoreDir0)
+if(${Qt5Core_VERSION_STRING} VERSION_LESS "5.1.0")
+    SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/../QtV8/${Qt5Core_VERSION_STRING}/QtV8)
+else()
+    SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/QtV8/${Qt5Core_VERSION_STRING}/QtV8)
+endif()
+
+# DANGER! DANGER! Using Qt's private API!
+include_directories(
+    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
+    ${Qt5Quick_INCLUDE_DIRS}
+    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
+    ${Qt5V8_PRIVATE_INCLUDE_DIR}
+)

=== added file 'libs/UbuntuGestures/CandidateInactivityTimer.cpp'
--- libs/UbuntuGestures/CandidateInactivityTimer.cpp	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/CandidateInactivityTimer.cpp	2014-10-14 12:55:09 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "CandidateInactivityTimer.h"
+
+namespace UbuntuGestures {
+
+CandidateInactivityTimer::CandidateInactivityTimer(int touchId, QQuickItem *candidate,
+        AbstractTimerFactory &timerFactory, QObject *parent)
+    : QObject(parent)
+    , m_touchId(touchId)
+    , m_candidate(candidate)
+{
+    m_timer = timerFactory.createTimer(this);
+    connect(m_timer, &AbstractTimer::timeout,
+            this, &CandidateInactivityTimer::onTimeout);
+    m_timer->setInterval(durationMs);
+    m_timer->setSingleShot(true);
+    m_timer->start();
+}
+
+void CandidateInactivityTimer::onTimeout()
+{
+    qWarning("[TouchRegistry] Candidate for touch %d defaulted!", m_touchId);
+    Q_EMIT candidateDefaulted(m_touchId, m_candidate);
+}
+
+} // namespace UbuntuGestures

=== added file 'libs/UbuntuGestures/CandidateInactivityTimer.h'
--- libs/UbuntuGestures/CandidateInactivityTimer.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/CandidateInactivityTimer.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTUGESTURES_CANDIDATE_INACTIVITY_TIMER_H
+#define UBUNTUGESTURES_CANDIDATE_INACTIVITY_TIMER_H
+
+#include <QObject>
+
+class QQuickItem;
+
+#include "Timer.h"
+
+namespace UbuntuGestures {
+
+class UBUNTUGESTURES_EXPORT CandidateInactivityTimer : public QObject {
+    Q_OBJECT
+public:
+    CandidateInactivityTimer(int touchId, QQuickItem *candidate,
+                             AbstractTimerFactory &timerFactory,
+                             QObject *parent = nullptr);
+
+    const int durationMs = 350;
+
+Q_SIGNALS:
+    void candidateDefaulted(int touchId, QQuickItem *candidate);
+private Q_SLOTS:
+    void onTimeout();
+private:
+    AbstractTimer *m_timer;
+    int m_touchId;
+    QQuickItem *m_candidate;
+};
+
+} // namespace UbuntuGestures
+
+#endif // UBUNTUGESTURES_CANDIDATE_INACTIVITY_TIMER_H

=== added file 'libs/UbuntuGestures/DebugHelpers.cpp'
--- libs/UbuntuGestures/DebugHelpers.cpp	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/DebugHelpers.cpp	2014-10-14 12:55:09 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "DebugHelpers.h"
+#include <QTouchEvent>
+
+QString touchPointStateToString(Qt::TouchPointState state)
+{
+    switch (state) {
+    case Qt::TouchPointPressed:
+        return QString("pressed");
+    case Qt::TouchPointMoved:
+        return QString("moved");
+    case Qt::TouchPointStationary:
+        return QString("stationary");
+    case Qt::TouchPointReleased:
+        return QString("released");
+    default:
+        return QString("INVALID_STATE");
+    }
+}
+
+QString touchEventToString(const QTouchEvent *ev)
+{
+    QString message;
+
+    switch (ev->type()) {
+    case QEvent::TouchBegin:
+        message.append("TouchBegin ");
+        break;
+    case QEvent::TouchUpdate:
+        message.append("TouchUpdate ");
+        break;
+    case QEvent::TouchEnd:
+        message.append("TouchEnd ");
+        break;
+    case QEvent::TouchCancel:
+        message.append("TouchCancel ");
+        break;
+    default:
+        message.append("INVALID_TOUCH_EVENT_TYPE ");
+    }
+
+    foreach(const QTouchEvent::TouchPoint& touchPoint, ev->touchPoints()) {
+        message.append(
+            QString("(id:%1, state:%2, scenePos:(%3,%4)) ")
+                .arg(touchPoint.id())
+                .arg(touchPointStateToString(touchPoint.state()))
+                .arg(touchPoint.scenePos().x())
+                .arg(touchPoint.scenePos().y())
+            );
+    }
+
+    return message;
+}

=== added file 'libs/UbuntuGestures/DebugHelpers.h'
--- libs/UbuntuGestures/DebugHelpers.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/DebugHelpers.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTUGESTURES_DEBUG_HELPER_H
+#define UBUNTUGESTURES_DEBUG_HELPER_H
+
+#include <QString>
+
+#include "UbuntuGesturesGlobal.h"
+
+class QTouchEvent;
+
+UBUNTUGESTURES_EXPORT QString touchPointStateToString(Qt::TouchPointState state);
+UBUNTUGESTURES_EXPORT QString touchEventToString(const QTouchEvent *ev);
+
+#endif // UBUNTUGESTURES_DEBUG_HELPER_H

=== added file 'libs/UbuntuGestures/Pool.h'
--- libs/UbuntuGestures/Pool.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/Pool.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTUGESTURES_POOL_H
+#define UBUNTUGESTURES_POOL_H
+
+#include <QVector>
+
+#include "UbuntuGesturesGlobal.h"
+
+/*
+  An object pool.
+  Avoids unnecessary creations/initializations and deletions/destructions of items. Useful
+  in a scenario where items are created and destroyed very frequently but the total number
+  of items at any given time remains small. They're stored in a unordered fashion.
+
+  To be used in Pool, ItemType needs to have the following methods:
+
+  - ItemType();
+
+  A constructor that takes no parameters. An object contructed with it must return false if
+  isValid() is called.
+
+  - bool isValid() const;
+
+  Returns wheter the object holds a valid , "filled" state or is empty.
+  Used by Pool to check if the slot occupied by this object is actually available.
+
+  - void reset();
+
+  Resets the object to its initial, empty, state. After calling this method, isValid() must
+  return false.
+ */
+template <class ItemType> class Pool
+{
+public:
+    Pool() : m_lastUsedIndex(-1) {
+    }
+
+    class Iterator {
+    public:
+        Iterator() : index(-1), item(nullptr) {}
+        Iterator(int index, ItemType *item)
+            : index(index), item(item) {}
+
+        ItemType *operator->() const { return item; }
+        ItemType &operator*() const { return *item; }
+        ItemType &value() const { return *item; }
+
+        Iterator &operator= (const Iterator& other) {
+            index = other.index;
+            item = other.item;
+
+            // by convention, always return *this
+            return *this;
+        }
+
+        operator bool() const { return item != nullptr; }
+
+        int index;
+        ItemType *item;
+    };
+
+    Iterator &end() const { return Iterator(); }
+
+    ItemType &getEmptySlot() {
+        Q_ASSERT(m_lastUsedIndex < m_slots.size());
+
+        // Look for an in-between vacancy first
+        for (int i = 0; i < m_lastUsedIndex; ++i) {
+            ItemType &item = m_slots[i];
+            if (!item.isValid()) {
+                return item;
+            }
+        }
+
+        ++m_lastUsedIndex;
+        if (m_lastUsedIndex >= m_slots.size()) {
+            m_slots.resize(m_lastUsedIndex + 1);
+        }
+
+        return m_slots[m_lastUsedIndex];
+    }
+
+    void freeSlot(Iterator &iterator) {
+        m_slots[iterator.index].reset();
+        if (iterator.index == m_lastUsedIndex) {
+            do {
+                --m_lastUsedIndex;
+            } while (m_lastUsedIndex >= 0 && !m_slots.at(m_lastUsedIndex).isValid());
+        }
+    }
+
+    // Iterates through all valid items (i.e. the occupied slots)
+    // calling the given function, with the option of ending the loop early.
+    //
+    // bool Func(Iterator& item)
+    //
+    // Returning true means it wants to continue the "for" loop, false
+    // terminates the loop.
+    template<typename Func> void forEach(Func func) {
+        Iterator it;
+        for (it.index = 0; it.index <= m_lastUsedIndex; ++it.index) {
+            it.item = &m_slots[it.index];
+            if (!it.item->isValid())
+                continue;
+
+            if (!func(it))
+                break;
+        }
+    }
+
+    bool isEmpty() const { return m_lastUsedIndex == -1; }
+
+
+private:
+    QVector<ItemType> m_slots;
+    int m_lastUsedIndex;
+};
+
+#endif // UBUNTUGESTURES_POOL_H

=== added file 'libs/UbuntuGestures/Timer.cpp'
--- libs/UbuntuGestures/Timer.cpp	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/Timer.cpp	2014-10-14 12:55:09 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Timer.h"
+
+namespace UbuntuGestures {
+
+Timer::Timer(QObject *parent) : AbstractTimer(parent)
+{
+    m_timer.setSingleShot(false);
+    connect(&m_timer, &QTimer::timeout, this, &AbstractTimer::timeout);
+}
+
+int Timer::interval() const
+{
+    return m_timer.interval();
+}
+
+void Timer::setInterval(int msecs)
+{
+    m_timer.setInterval(msecs);
+}
+
+void Timer::start()
+{
+    m_timer.start();
+    AbstractTimer::start();
+}
+
+void Timer::stop()
+{
+    m_timer.stop();
+    AbstractTimer::stop();
+}
+
+bool Timer::isSingleShot() const
+{
+    return m_timer.isSingleShot();
+}
+
+void Timer::setSingleShot(bool value)
+{
+    m_timer.setSingleShot(value);
+}
+
+/////////////////////////////////// FakeTimer //////////////////////////////////
+
+FakeTimer::FakeTimer(QObject *parent)
+    : UbuntuGestures::AbstractTimer(parent)
+    , m_interval(0)
+    , m_singleShot(false)
+{
+}
+
+int FakeTimer::interval() const
+{
+    return m_interval;
+}
+
+void FakeTimer::setInterval(int msecs)
+{
+    m_interval = msecs;
+}
+
+bool FakeTimer::isSingleShot() const
+{
+    return m_singleShot;
+}
+
+void FakeTimer::setSingleShot(bool value)
+{
+    m_singleShot = value;
+}
+
+/////////////////////////////////// FakeTimerFactory //////////////////////////////////
+
+AbstractTimer *FakeTimerFactory::createTimer(QObject *parent)
+{
+    FakeTimer *fakeTimer = new FakeTimer(parent);
+
+    timers.append(fakeTimer);
+
+    return fakeTimer;
+}
+
+void FakeTimerFactory::makeRunningTimersTimeout()
+{
+    for (int i = 0; i < timers.count(); ++i) {
+        FakeTimer *timer = timers[i].data();
+        if (timer && timer->isRunning()) {
+            timer->emitTimeout();
+        }
+    }
+}
+
+} // namespace UbuntuGestures

=== added file 'libs/UbuntuGestures/Timer.h'
--- libs/UbuntuGestures/Timer.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/Timer.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTUGESTURES_TIMER_H
+#define UBUNTUGESTURES_TIMER_H
+
+#include "UbuntuGesturesGlobal.h"
+
+#include <QObject>
+#include <QPointer>
+#include <QTimer>
+
+namespace UbuntuGestures {
+
+/* Defines an interface for a Timer. Useful for tests. */
+class UBUNTUGESTURES_EXPORT AbstractTimer : public QObject
+{
+    Q_OBJECT
+public:
+    AbstractTimer(QObject *parent) : QObject(parent), m_isRunning(false) {}
+    virtual int interval() const = 0;
+    virtual void setInterval(int msecs) = 0;
+    virtual void start() { m_isRunning = true; }
+    virtual void stop() { m_isRunning = false; }
+    bool isRunning() const { return m_isRunning; }
+    virtual bool isSingleShot() const = 0;
+    virtual void setSingleShot(bool value) = 0;
+Q_SIGNALS:
+    void timeout();
+private:
+    bool m_isRunning;
+};
+
+/* Essentially a QTimer wrapper */
+class UBUNTUGESTURES_EXPORT Timer : public AbstractTimer
+{
+    Q_OBJECT
+public:
+    Timer(QObject *parent = nullptr);
+
+    int interval() const override;
+    void setInterval(int msecs) override;
+    void start() override;
+    void stop() override;
+    bool isSingleShot() const override;
+    void setSingleShot(bool value) override;
+private:
+    QTimer m_timer;
+};
+
+/* For tests */
+class UBUNTUGESTURES_EXPORT FakeTimer : public AbstractTimer
+{
+    Q_OBJECT
+public:
+    FakeTimer(QObject *parent = nullptr);
+
+    virtual void emitTimeout() { Q_EMIT timeout(); }
+
+    int interval() const override;
+    void setInterval(int msecs) override;
+    bool isSingleShot() const override;
+    void setSingleShot(bool value) override;
+private:
+    int m_interval;
+    bool m_singleShot;
+};
+
+class UBUNTUGESTURES_EXPORT AbstractTimerFactory
+{
+public:
+    virtual ~AbstractTimerFactory() {}
+    virtual AbstractTimer *createTimer(QObject *parent = nullptr) = 0;
+};
+
+class UBUNTUGESTURES_EXPORT TimerFactory : public AbstractTimerFactory
+{
+public:
+    AbstractTimer *createTimer(QObject *parent = nullptr) override { return new Timer(parent); }
+};
+
+class UBUNTUGESTURES_EXPORT FakeTimerFactory : public AbstractTimerFactory
+{
+public:
+    AbstractTimer *createTimer(QObject *parent = nullptr) override;
+    void makeRunningTimersTimeout();
+    QList<QPointer<FakeTimer>> timers;
+};
+
+} // namespace UbuntuGestures
+
+#endif // UBUNTUGESTURES_TIMER_H

=== added file 'libs/UbuntuGestures/TouchOwnershipEvent.cpp'
--- libs/UbuntuGestures/TouchOwnershipEvent.cpp	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/TouchOwnershipEvent.cpp	2014-10-14 12:55:09 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TouchOwnershipEvent.h"
+
+QEvent::Type TouchOwnershipEvent::m_touchOwnershipType = (QEvent::Type)-1;
+
+TouchOwnershipEvent::TouchOwnershipEvent(int touchId, bool gained)
+    : QEvent(touchOwnershipEventType())
+    , m_touchId(touchId)
+    , m_gained(gained)
+{
+}
+
+QEvent::Type TouchOwnershipEvent::touchOwnershipEventType()
+{
+    if (m_touchOwnershipType == (QEvent::Type)-1) {
+        m_touchOwnershipType = (QEvent::Type)registerEventType();
+    }
+
+    return m_touchOwnershipType;
+}

=== added file 'libs/UbuntuGestures/TouchOwnershipEvent.h'
--- libs/UbuntuGestures/TouchOwnershipEvent.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/TouchOwnershipEvent.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTU_TOUCHOWNERSHIPEVENT_H
+#define UBUNTU_TOUCHOWNERSHIPEVENT_H
+
+#include <QEvent>
+#include "UbuntuGesturesGlobal.h"
+
+/*
+   When an item get an ownership event for a touch it can grab/steal that touch
+   with a clean conscience.
+ */
+class UBUNTUGESTURES_EXPORT TouchOwnershipEvent : public QEvent
+{
+public:
+    TouchOwnershipEvent(int touchId, bool gained);
+
+    static Type touchOwnershipEventType();
+
+    /*
+      Whether ownership was gained (true) or lost (false)
+     */
+    bool gained() const { return m_gained; }
+
+    /*
+        Id of the touch whose ownership was granted.
+     */
+    int touchId() const { return m_touchId; }
+
+private:
+    static Type m_touchOwnershipType;
+    int m_touchId;
+    bool m_gained;
+};
+
+#endif // UBUNTU_TOUCHOWNERSHIPEVENT_H

=== added file 'libs/UbuntuGestures/TouchRegistry.cpp'
--- libs/UbuntuGestures/TouchRegistry.cpp	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/TouchRegistry.cpp	2014-10-14 12:55:09 +0000
@@ -0,0 +1,500 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TouchRegistry.h"
+
+#include <QCoreApplication>
+#include <QDebug>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-pedantic"
+#include <private/qquickitem_p.h>
+#pragma GCC diagnostic pop
+
+#include "CandidateInactivityTimer.h"
+#include "Timer.h"
+#include "TouchOwnershipEvent.h"
+#include "UnownedTouchEvent.h"
+
+#define TOUCHREGISTRY_DEBUG 0
+
+#if TOUCHREGISTRY_DEBUG
+    #include "DebugHelpers.h"
+    #define UG_DEBUG qDebug() << "[TouchRegistry]"
+#endif // TOUCHREGISTRY_DEBUG
+
+using namespace UbuntuGestures;
+
+TouchRegistry *TouchRegistry::m_instance = nullptr;
+
+TouchRegistry::TouchRegistry(QObject *parent)
+    : TouchRegistry(parent, new TimerFactory)
+{
+}
+
+TouchRegistry::TouchRegistry(QObject *parent, AbstractTimerFactory *timerFactory)
+    : QObject(parent)
+    , m_inDispatchLoop(false)
+    , m_timerFactory(timerFactory)
+{
+    if (m_instance == nullptr) {
+        m_instance = this;
+    } else {
+        qFatal("Cannot have more than one instance of TouchRegistry. It must be a singleton.");
+    }
+}
+
+TouchRegistry::~TouchRegistry()
+{
+    Q_ASSERT(m_instance != nullptr);
+    m_instance = nullptr;
+    delete m_timerFactory;
+}
+
+void TouchRegistry::update(const QTouchEvent *event)
+{
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "got" << qPrintable(touchEventToString(event));
+    #endif
+
+    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
+        if (touchPoint.state() == Qt::TouchPointPressed) {
+            TouchInfo &touchInfo = m_touchInfoPool.getEmptySlot();
+            touchInfo.init(touchPoint.id());
+        } else if (touchPoint.state() == Qt::TouchPointReleased) {
+            Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(touchPoint.id());
+
+            touchInfo->physicallyEnded = true;
+        }
+    }
+
+    deliverTouchUpdatesToUndecidedCandidatesAndWatchers(event);
+
+    freeEndedTouchInfos();
+}
+
+void TouchRegistry::deliverTouchUpdatesToUndecidedCandidatesAndWatchers(const QTouchEvent *event)
+{
+    // TODO: Look into how we could optimize this whole thing.
+    //       Although it's not really a problem as we should have at most two candidates
+    //       for each point and there should not be many active points at any given moment.
+    //       But having three nested for-loops does scare.
+
+    // TODO: Don't send it to the object that is already receiving the regular event
+    // because QQuickWindow is sending it to him (i.e., he's the touch owner from Qt's point of view)
+    // Problem is, we cannnot easily get this information.
+
+    const QList<QTouchEvent::TouchPoint> &updatedTouchPoints = event->touchPoints();
+
+    // Maps an item to the touches in this event he should be informed about.
+    // E.g.: a QTouchEvent might have three touches but a given item might be interested in only
+    // one of them. So he will get a UnownedTouchEvent from this QTouchEvent containing only that
+    // touch point.
+    QMap<QQuickItem*, QList<int>> touchIdsForItems;
+
+    // Build touchIdsForItems
+    m_touchInfoPool.forEach([&](Pool<TouchInfo>::Iterator &touchInfo) {
+        if (touchInfo->isOwned() && touchInfo->watchers.isEmpty())
+            return true;
+
+        for (int j = 0; j < updatedTouchPoints.count(); ++j) {
+            if (updatedTouchPoints[j].id() == touchInfo->id) {
+                if (!touchInfo->isOwned()) {
+                    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
+                        CandidateInfo &candidate = touchInfo->candidates[i];
+                        Q_ASSERT(!candidate.item.isNull());
+                        touchIdsForItems[candidate.item.data()].append(touchInfo->id);
+                    }
+                }
+
+                const QList<QPointer<QQuickItem>> &watchers = touchInfo->watchers;
+                for (int i = 0; i < watchers.count(); ++i) {
+                    if (!watchers[i].isNull()) {
+                        touchIdsForItems[watchers[i].data()].append(touchInfo->id);
+                    }
+                }
+
+                return true;
+            }
+        }
+
+        return true;
+    });
+
+    // TODO: Consider what happens if an item calls any of TouchRegistry's public methods
+    // from the event handler callback.
+    m_inDispatchLoop = true;
+    auto it = touchIdsForItems.constBegin();
+    while (it != touchIdsForItems.constEnd()) {
+        QQuickItem *item = it.key();
+        const QList<int> &touchIds = it.value();
+        dispatchPointsToItem(event, touchIds, item);
+        ++it;
+    };
+    m_inDispatchLoop = false;
+}
+
+void TouchRegistry::freeEndedTouchInfos()
+{
+    m_touchInfoPool.forEach([&](Pool<TouchInfo>::Iterator &touchInfo) {
+        if (touchInfo->ended()) {
+            m_touchInfoPool.freeSlot(touchInfo);
+        }
+        return true;
+    });
+}
+
+/*
+   Extracts the touches with the given touchIds from event and send them in a
+   UnownedTouchEvent to the given item
+ */
+void TouchRegistry::dispatchPointsToItem(const QTouchEvent *event, const QList<int> &touchIds,
+        QQuickItem *item)
+{
+    Qt::TouchPointStates touchPointStates = 0;
+    QList<QTouchEvent::TouchPoint> touchPoints;
+
+    const QList<QTouchEvent::TouchPoint> &allTouchPoints = event->touchPoints();
+
+    QTransform windowToCandidateTransform = QQuickItemPrivate::get(item)->windowToItemTransform();
+    QMatrix4x4 windowToCandidateMatrix(windowToCandidateTransform);
+
+    for (int i = 0; i < allTouchPoints.count(); ++i) {
+        const QTouchEvent::TouchPoint &originalTouchPoint = allTouchPoints[i];
+        if (touchIds.contains(originalTouchPoint.id())) {
+            QTouchEvent::TouchPoint touchPoint = originalTouchPoint;
+
+            translateTouchPointFromScreenToWindowCoords(touchPoint);
+
+            // Set the point's local coordinates to that of the item
+            touchPoint.setRect(windowToCandidateTransform.mapRect(touchPoint.sceneRect()));
+            touchPoint.setStartPos(windowToCandidateTransform.map(touchPoint.startScenePos()));
+            touchPoint.setLastPos(windowToCandidateTransform.map(touchPoint.lastScenePos()));
+            touchPoint.setVelocity(windowToCandidateMatrix.mapVector(touchPoint.velocity()).toVector2D());
+
+            touchPoints.append(touchPoint);
+            touchPointStates |= touchPoint.state();
+        }
+    }
+
+    QTouchEvent *eventForItem = new QTouchEvent(event->type(),
+                                                event->device(),
+                                                event->modifiers(),
+                                                touchPointStates,
+                                                touchPoints);
+    eventForItem->setWindow(event->window());
+    eventForItem->setTimestamp(event->timestamp());
+    eventForItem->setTarget(event->target());
+
+    UnownedTouchEvent unownedTouchEvent(eventForItem);
+
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "Sending unowned" << qPrintable(touchEventToString(eventForItem))
+        << "to" << item;
+    #endif
+
+    QCoreApplication::sendEvent(item, &unownedTouchEvent);
+}
+
+void TouchRegistry::translateTouchPointFromScreenToWindowCoords(QTouchEvent::TouchPoint &touchPoint)
+{
+    touchPoint.setScreenRect(touchPoint.sceneRect());
+    touchPoint.setStartScreenPos(touchPoint.startScenePos());
+    touchPoint.setLastScreenPos(touchPoint.lastScenePos());
+
+    touchPoint.setSceneRect(touchPoint.rect());
+    touchPoint.setStartScenePos(touchPoint.startPos());
+    touchPoint.setLastScenePos(touchPoint.lastPos());
+}
+
+bool TouchRegistry::eventFilter(QObject *watched, QEvent *event)
+{
+    Q_UNUSED(watched);
+
+    switch (event->type()) {
+    case QEvent::TouchBegin:
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd:
+    case QEvent::TouchCancel:
+        update(static_cast<QTouchEvent*>(event));
+        break;
+    default:
+        // do nothing
+        break;
+    }
+
+    // Do not filter out the event. i.e., let it be handled further as
+    // we're just monitoring events
+    return false;
+}
+
+void TouchRegistry::addCandidateOwnerForTouch(int id, QQuickItem *candidate)
+{
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "addCandidateOwnerForTouch id" << id << "candidate" << candidate;
+    #endif
+
+    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
+    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
+
+    if (touchInfo->isOwned()) {
+        qWarning("TouchRegistry: trying to add candidate owner for a touch that's already owned");
+        return;
+    }
+
+    // TODO: Check if candidate already exists
+
+    CandidateInfo candidateInfo;
+    candidateInfo.undecided = true;
+    candidateInfo.item = candidate;
+    candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,
+                                                                 *m_timerFactory,
+                                                                 this);
+    connect(candidateInfo.inactivityTimer, &CandidateInactivityTimer::candidateDefaulted,
+            this, &TouchRegistry::rejectCandidateOwnerForTouch);
+
+    touchInfo->candidates.append(candidateInfo);
+}
+
+void TouchRegistry::addTouchWatcher(int touchId, QQuickItem *watcher)
+{
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "addTouchWatcher id" << touchId << "watcher" << watcher;
+    #endif
+
+    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(touchId);
+    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
+
+    // TODO: Check if watcher already exists
+
+    touchInfo->watchers.append(watcher);
+}
+
+void TouchRegistry::removeCandidateOwnerForTouch(int id, QQuickItem *candidate)
+{
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "removeCandidateOwnerForTouch id" << id << "candidate" << candidate;
+    #endif
+
+    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
+    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
+
+    int indexRemoved = -1;
+
+    // TODO: check if the candidate is in fact the owner of the touch
+
+    for (int i = 0; i < touchInfo->candidates.count() && indexRemoved == -1; ++i) {
+        CandidateInfo &candidateInfo = touchInfo->candidates[i];
+        if (candidateInfo.item == candidate) {
+            Q_ASSERT(i > 0 || candidateInfo.undecided);
+            if (i == 0 && !candidateInfo.undecided) {
+                qCritical("TouchRegistry: touch owner is being removed.");
+            }
+            delete candidateInfo.inactivityTimer;
+            candidateInfo.inactivityTimer = nullptr;
+            touchInfo->candidates.removeAt(i);
+            indexRemoved = i;
+        }
+    }
+
+    if (indexRemoved == 0) {
+        // the top candidate has been removed. if the new top candidate
+        // wants the touch let him know he's now the owner.
+        if (touchInfo->isOwned()) {
+            touchInfo->notifyCandidatesOfOwnershipResolution();
+        }
+    }
+
+    if (!m_inDispatchLoop && touchInfo->ended()) {
+        m_touchInfoPool.freeSlot(touchInfo);
+    }
+}
+
+void TouchRegistry::requestTouchOwnership(int id, QQuickItem *candidate)
+{
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "requestTouchOwnership id " << id << "candidate" << candidate;
+    #endif
+
+    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
+    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
+
+    Q_ASSERT(!touchInfo->isOwned());
+
+    int candidateIndex = -1;
+    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
+        CandidateInfo &candidateInfo = touchInfo->candidates[i];
+        if (candidateInfo.item == candidate) {
+            candidateInfo.undecided = false;
+            delete candidateInfo.inactivityTimer;
+            candidateInfo.inactivityTimer = nullptr;
+            candidateIndex = i;
+            break;
+        }
+    }
+
+    // add it as a candidate if not present yet
+    if (candidateIndex < 0) {
+        CandidateInfo candidateInfo;
+        candidateInfo.undecided = false;
+        candidateInfo.item = candidate;
+        candidateInfo.inactivityTimer = nullptr;
+        touchInfo->candidates.append(candidateInfo);
+        // it's the last one
+        candidateIndex = touchInfo->candidates.count() - 1;
+    }
+
+    // If it's the top candidate it means it's now the owner. Let
+    // it know about it.
+    if (candidateIndex == 0) {
+        touchInfo->notifyCandidatesOfOwnershipResolution();
+    }
+}
+
+Pool<TouchRegistry::TouchInfo>::Iterator TouchRegistry::findTouchInfo(int id)
+{
+    Pool<TouchInfo>::Iterator touchInfo;
+
+    m_touchInfoPool.forEach([&](Pool<TouchInfo>::Iterator &someTouchInfo) -> bool {
+        if (someTouchInfo->id == id) {
+            touchInfo = someTouchInfo;
+            return false;
+        } else {
+            return true;
+        }
+    });
+
+    return touchInfo;
+}
+
+
+void TouchRegistry::rejectCandidateOwnerForTouch(int id, QQuickItem *candidate)
+{
+    // NB: It's technically possible that candidate is a dangling pointer at this point.
+    // Although that would most likely be due to a bug in our code.
+    // In any case, only dereference it after it's confirmed that it indeed exists.
+
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "rejectCandidateOwnerForTouch id" << id << "candidate" << (void*)candidate;
+    #endif
+
+    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
+    if (!touchInfo) {
+        #if TOUCHREGISTRY_DEBUG
+        UG_DEBUG << "Failed to find TouchInfo for id" << id;
+        #endif
+        return;
+    }
+
+    int rejectedCandidateIndex = -1;
+
+    // Check if the given candidate is valid and still undecided
+    for (int i = 0; i < touchInfo->candidates.count() && rejectedCandidateIndex == -1; ++i) {
+        CandidateInfo &candidateInfo = touchInfo->candidates[i];
+        if (candidateInfo.item == candidate) {
+            Q_ASSERT(i > 0 || candidateInfo.undecided);
+            if (i == 0 && !candidateInfo.undecided) {
+                qCritical() << "TouchRegistry: Can't reject item (" << (void*)candidate
+                    << ") as it already owns touch" << id;
+                return;
+            } else {
+                // we found the guy and it's all fine.
+                rejectedCandidateIndex = i;
+            }
+        }
+    }
+
+    // If we reached this point it's because the given candidate exists and is indeed undecided.
+
+    Q_ASSERT(rejectedCandidateIndex >= 0 && rejectedCandidateIndex < touchInfo->candidates.size());
+
+    {
+        TouchOwnershipEvent lostOwnershipEvent(id, false /*gained*/);
+        QCoreApplication::sendEvent(candidate, &lostOwnershipEvent);
+    }
+
+    touchInfo->candidates.removeAt(rejectedCandidateIndex);
+
+    if (rejectedCandidateIndex == 0) {
+        // the top candidate has been removed. if the new top candidate
+        // wants the touch let him know he's now the owner.
+        if (touchInfo->isOwned()) {
+            touchInfo->notifyCandidatesOfOwnershipResolution();
+        }
+    }
+}
+
+////////////////////////////////////// TouchRegistry::TouchInfo ////////////////////////////////////
+
+TouchRegistry::TouchInfo::TouchInfo(int id)
+{
+    init(id);
+}
+
+void TouchRegistry::TouchInfo::reset()
+{
+    id = -1;
+
+    for (int i = 0; i < candidates.count(); ++i) {
+        CandidateInfo &candidate = candidates[i];
+        delete candidate.inactivityTimer;
+        candidate.inactivityTimer.clear(); // shoundn't be needed but anyway...
+    }
+}
+
+void TouchRegistry::TouchInfo::init(int id)
+{
+    this->id = id;
+    physicallyEnded = false;
+    candidates.clear();
+    watchers.clear();
+}
+
+bool TouchRegistry::TouchInfo::isOwned() const
+{
+    return !candidates.isEmpty() && !candidates.first().undecided;
+}
+
+bool TouchRegistry::TouchInfo::ended() const
+{
+    Q_ASSERT(isValid());
+    return physicallyEnded && (isOwned() || candidates.isEmpty());
+}
+
+void TouchRegistry::TouchInfo::notifyCandidatesOfOwnershipResolution()
+{
+    Q_ASSERT(isOwned());
+
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "sending TouchOwnershipEvent(id =" << id
+        << " gained) to candidate" << candidates[0].item;
+    #endif
+
+    TouchOwnershipEvent gainedOwnershipEvent(id, true /*gained*/);
+    QCoreApplication::sendEvent(candidates[0].item, &gainedOwnershipEvent);
+
+
+    TouchOwnershipEvent lostOwnershipEvent(id, false /*gained*/);
+    for (int i = 1; i < candidates.count(); ++i) {
+        #if TOUCHREGISTRY_DEBUG
+        UG_DEBUG << "sending TouchWonershipEvent(id =" << id << " lost) to candidate"
+            << candidates[i].item;
+        #endif
+        QCoreApplication::sendEvent(candidates[i].item, &lostOwnershipEvent);
+    }
+}

=== added file 'libs/UbuntuGestures/TouchRegistry.h'
--- libs/UbuntuGestures/TouchRegistry.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/TouchRegistry.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UNITY_TOUCHREGISTRY_H
+#define UNITY_TOUCHREGISTRY_H
+
+#include <QQuickItem>
+#include <QObject>
+#include <QPointer>
+#include <QTouchEvent>
+#include <QVector>
+
+#include "UbuntuGesturesGlobal.h"
+#include "CandidateInactivityTimer.h"
+#include "Pool.h"
+
+namespace UbuntuGestures {
+    class AbstractTimerFactory;
+}
+
+/*
+  Where the ownership of touches is registered.
+
+  Singleton used for adding a touch point ownership model analogous to the one
+  described in the XInput 2.2 protocol[1] on top of the existing input dispatch logic in QQuickWindow.
+
+  It provides a much more flexible and powerful way of dealing with pointer ownership than the existing
+  mechanisms in Qt. Namely QQuickItem::grabTouchPoints, QuickItem::keepTouchGrab,
+  QQuickItem::setFiltersChildMouseEvents, QQuickItem::ungrabTouchPoints and QQuickItem::touchUngrabEvent.
+
+  Usage:
+
+  1- An item receives a a new touch point. If he's not sure whether he wants it yet, he calls:
+        TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, this);
+        touchEvent->ignore();
+     Ignoring the event is crucial so that it can be seen by other interested parties, which will
+     behave similarly.
+
+  2- That item will then start receiving UnownedTouchEvents for that touch from step 1. Once he's
+     made a decision he calls either:
+        TouchRegistry::instance()->requestTouchOwnership(touchId, this);
+     If he wants the touch point or:
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, this);
+     if he does not want it.
+
+  Candidates are put in a priority queue. The first one to call addCandidateOwnerForTouch() will
+  take precedence over the others for receiving ownership over the touch point (from now on called
+  simply top-candidate).
+
+  If the top-candidate calls requestTouchOwnership() he will immediately receive a
+  TouchOwnershipEvent(gained=true) for that touch point. He can then safely call
+  QQuickItem::grabTouchPoints to actually get the owned touch points. The other candidates
+  will receive TouchOwnershipEvent(gained=false) and will no longer receive UnownedTouchEvents
+  for that touch point. They will have to undo whatever action they were performing with that
+  touch point.
+
+  But if the top-candidate calls removeCandidateOwnerForTouch() instead, he's popped from the
+  candidacy queue and ownership is given to the new top-most candidate if he has already
+  made his decision, that is.
+
+  The TouchRegistry cannot enforce the results of this pointer ownership negotiation (i.e.,
+  who gets to grab the touch points) as that would clash with QQuickWindow's input event
+  dispatching logic. The candidates have to respect the decision and grab the touch points
+  themselves.
+
+  If an item wants ownership over touches as soon as he receives the TouchBegin for them, his step 1
+  would be instead:
+        TouchRegistry::instance()->requestTouchOwnership(touchId, this);
+        return true;
+  He would then be notified once ownership has been granted to him, from which point onwards he could
+  safely assume other TouchRegistry users wouldn't snatch this touch away from him.
+
+  Items oblivious to TouchRegistry will lose their touch points without warning, just like in plain Qt.
+
+  [1] - http://www.x.org/releases/X11R7.7/doc/inputproto/XI2proto.txt (see multitouch-ownership)
+ */
+class UBUNTUGESTURES_EXPORT TouchRegistry : public QObject
+{
+    Q_OBJECT
+public:
+    TouchRegistry(QObject *parent = nullptr);
+    // Useful for tests, where you should feed a fake timer
+    TouchRegistry(QObject *parent, UbuntuGestures::AbstractTimerFactory *timerFactory);
+
+    virtual ~TouchRegistry();
+
+    // Returns a pointer to the application's TouchRegistry instance.
+    // If no instance has been allocated, null is returned.
+    static TouchRegistry *instance() { return m_instance; }
+
+    void update(const QTouchEvent *event);
+
+    // Calls update() if the given event is a QTouchEvent
+    bool eventFilter(QObject *watched, QEvent *event) override;
+
+    // An item that might later request ownership over the given touch point.
+    // He will be kept informed about that touch point through UnownedTouchEvents
+    // All candidates must eventually decide whether they want to own the touch point
+    // or not. That decision is informed through requestTouchOwnership() or
+    // removeCandidateOwnerForTouch()
+    void addCandidateOwnerForTouch(int id, QQuickItem *candidate);
+
+    // The same as rejecting ownership of a touch
+    void removeCandidateOwnerForTouch(int id, QQuickItem *candidate);
+
+    // The candidate object wants to be the owner of the touch with the given id.
+    // If he's currently the oldest/top-most candidate, he will get an ownership
+    // event immediately. If not, he will get ownership if (or once) he becomes the
+    // top-most candidate.
+    void requestTouchOwnership(int id, QQuickItem *candidate);
+
+    // An item that has no interest (effective or potential) in owning a touch point
+    // but would nonetheless like to be kept up-to-date on its state.
+    void addTouchWatcher(int touchId, QQuickItem *watcherItem);
+
+private Q_SLOTS:
+    void rejectCandidateOwnerForTouch(int id, QQuickItem *candidate);
+
+private:
+    class CandidateInfo {
+    public:
+        bool undecided;
+        // TODO: Prune candidates that become null and resolve ownership accordingly.
+        QPointer<QQuickItem> item;
+        QPointer<UbuntuGestures::CandidateInactivityTimer> inactivityTimer;
+    };
+
+    class TouchInfo {
+    public:
+        TouchInfo() : id(-1) {}
+        TouchInfo(int id);
+        bool isValid() const { return id >= 0; }
+        void reset();
+        void init(int id);
+        int id;
+        bool physicallyEnded;
+        bool isOwned() const;
+        bool ended() const;
+        void notifyCandidatesOfOwnershipResolution();
+
+        // TODO optimize storage (s/QList/Pool)
+        QList<CandidateInfo> candidates;
+        QList<QPointer<QQuickItem>> watchers;
+    };
+
+    Pool<TouchInfo>::Iterator findTouchInfo(int id);
+
+    void deliverTouchUpdatesToUndecidedCandidatesAndWatchers(const QTouchEvent *event);
+
+    static void translateTouchPointFromScreenToWindowCoords(QTouchEvent::TouchPoint &touchPoint);
+
+    static void dispatchPointsToItem(const QTouchEvent *event, const QList<int> &touchIds,
+                                     QQuickItem *item);
+    void freeEndedTouchInfos();
+
+    Pool<TouchInfo> m_touchInfoPool;
+
+    // the singleton instance
+    static TouchRegistry *m_instance;
+
+    bool m_inDispatchLoop;
+
+    UbuntuGestures::AbstractTimerFactory *m_timerFactory;
+
+    friend class tst_TouchRegistry;
+    friend class tst_DirectionalDragArea;
+};
+
+#endif // UNITY_TOUCHREGISTRY_H

=== added file 'libs/UbuntuGestures/UbuntuGesturesGlobal.h'
--- libs/UbuntuGestures/UbuntuGesturesGlobal.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/UbuntuGesturesGlobal.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QtCore/QtGlobal>
+
+#if defined(UBUNTUGESTURES_LIBRARY)
+#  define UBUNTUGESTURES_EXPORT Q_DECL_EXPORT
+#else
+#  define UBUNTUGESTURES_EXPORT Q_DECL_IMPORT
+#endif

=== added file 'libs/UbuntuGestures/UnownedTouchEvent.cpp'
--- libs/UbuntuGestures/UnownedTouchEvent.cpp	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/UnownedTouchEvent.cpp	2014-10-14 12:55:09 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UnownedTouchEvent.h"
+
+QEvent::Type UnownedTouchEvent::m_unownedTouchEventType = (QEvent::Type)-1;
+
+UnownedTouchEvent::UnownedTouchEvent(QTouchEvent *touchEvent)
+    : QEvent(unownedTouchEventType())
+    , m_touchEvent(touchEvent)
+{
+}
+
+QEvent::Type UnownedTouchEvent::unownedTouchEventType()
+{
+    if (m_unownedTouchEventType == (QEvent::Type)-1) {
+        m_unownedTouchEventType = (QEvent::Type)registerEventType();
+    }
+
+    return m_unownedTouchEventType;
+}
+
+QTouchEvent *UnownedTouchEvent::touchEvent()
+{
+    return m_touchEvent.data();
+}

=== added file 'libs/UbuntuGestures/UnownedTouchEvent.h'
--- libs/UbuntuGestures/UnownedTouchEvent.h	1970-01-01 00:00:00 +0000
+++ libs/UbuntuGestures/UnownedTouchEvent.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTU_UNOWNEDTOUCHEVENT_H
+#define UBUNTU_UNOWNEDTOUCHEVENT_H
+
+#include <QTouchEvent>
+#include <QScopedPointer>
+#include "UbuntuGesturesGlobal.h"
+
+/*
+ A touch event with touch points that do not belong the item receiving it.
+
+ See TouchRegistry::addCandidateOwnerForTouch and TouchRegistry::addTouchWatcher
+ */
+class UBUNTUGESTURES_EXPORT UnownedTouchEvent : public QEvent
+{
+public:
+    UnownedTouchEvent(QTouchEvent *touchEvent);
+    static Type unownedTouchEventType();
+
+    // TODO: It might be cleaner to store the information directly in UnownedTouchEvent
+    //       instead of carrying around a synthesized QTouchEvent. But the latter option
+    //       is very convenient.
+    QTouchEvent *touchEvent();
+
+private:
+    static Type m_unownedTouchEventType;
+    QScopedPointer<QTouchEvent> m_touchEvent;
+};
+
+#endif // UBUNTU_UNOWNEDTOUCHEVENT_H

=== modified file 'plugins/Dash/listviewwithpageheader.cpp'
--- plugins/Dash/listviewwithpageheader.cpp	2014-09-17 10:20:47 +0000
+++ plugins/Dash/listviewwithpageheader.cpp	2014-10-14 12:55:09 +0000
@@ -851,7 +851,7 @@
                 if (nextItem) {
                     listItem->setY(nextItem->y() - listItem->height());
                 } else if (modelIndex == 0) {
-                    listItem->setY(m_headerItem ? m_headerItem->height() : 0);
+                    listItem->setY(-m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0));
                 } else if (!m_visibleItems.isEmpty()) {
                     lostItem = true;
                 }

=== modified file 'plugins/Ubuntu/Gestures/AxisVelocityCalculator.h'
--- plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2013-10-23 12:25:40 +0000
+++ plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2014-10-14 12:55:09 +0000
@@ -21,7 +21,7 @@
 #ifndef VELOCITY_CALCULATOR_H
 #define VELOCITY_CALCULATOR_H
 
-#include "UbuntuGesturesGlobal.h"
+#include "UbuntuGesturesQmlGlobal.h"
 #include <stdint.h>
 #include <QtCore/QObject>
 #include "TimeSource.h"
@@ -49,7 +49,7 @@
         }
     }
  */
-class UBUNTUGESTURES_EXPORT AxisVelocityCalculator : public QObject
+class UBUNTUGESTURESQML_EXPORT AxisVelocityCalculator : public QObject
 {
     Q_OBJECT
 

=== modified file 'plugins/Ubuntu/Gestures/CMakeLists.txt'
--- plugins/Ubuntu/Gestures/CMakeLists.txt	2014-05-02 22:57:00 +0000
+++ plugins/Ubuntu/Gestures/CMakeLists.txt	2014-10-14 12:55:09 +0000
@@ -1,19 +1,38 @@
-set(UbuntuGestureQml_SOURCES
+# in order to include Qt's private headers
+remove_definitions(-DQT_NO_KEYWORDS)
+
+set(UbuntuGesturesQml_SOURCES
     plugin.cpp
     AxisVelocityCalculator.cpp
     Direction.cpp
     DirectionalDragArea.cpp
     PressedOutsideNotifier.cpp
     TimeSource.cpp
+    TouchGate.cpp
 )
 
-add_definitions(-DUBUNTUGESTURES_LIBRARY)
-
-add_library(UbuntuGestureQml MODULE ${UbuntuGestureQml_SOURCES})
-
-qt5_use_modules(UbuntuGestureQml Core Quick)
+add_definitions(-DUBUNTUGESTURESQML_LIBRARY)
+
+add_library(UbuntuGesturesQml MODULE ${UbuntuGesturesQml_SOURCES})
+target_link_libraries(UbuntuGesturesQml UbuntuGestures)
+
+qt5_use_modules(UbuntuGesturesQml Core Quick)
 
 # So that Foo.cpp can #include "Foo.moc"
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-add_unity8_plugin(Ubuntu.Gestures 0.1 Ubuntu/Gestures TARGETS UbuntuGestureQml)
+include_directories(${CMAKE_SOURCE_DIR}/libs/UbuntuGestures)
+
+# There's no cmake var for v8 include path :-/ so create one
+LIST(GET Qt5Core_INCLUDE_DIRS 0 QtCoreDir0)
+SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/QtV8/${Qt5Core_VERSION_STRING}/QtV8)
+
+# DANGER! DANGER! Using Qt's private API!
+include_directories(
+    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
+    ${Qt5Quick_INCLUDE_DIRS}
+    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
+    ${Qt5V8_PRIVATE_INCLUDE_DIR}
+)
+
+add_unity8_plugin(Ubuntu.Gestures 0.1 Ubuntu/Gestures TARGETS UbuntuGesturesQml)

=== modified file 'plugins/Ubuntu/Gestures/Direction.h'
--- plugins/Ubuntu/Gestures/Direction.h	2013-06-19 08:29:34 +0000
+++ plugins/Ubuntu/Gestures/Direction.h	2014-10-14 12:55:09 +0000
@@ -17,14 +17,14 @@
 #ifndef DIRECTION_H
 #define DIRECTION_H
 
-#include "UbuntuGesturesGlobal.h"
+#include "UbuntuGesturesQmlGlobal.h"
 #include <QObject>
 
 /*
     A Direction enum wrapper so that we can do things like "direction: Direction.Righwards"
     from QML.
  */
-class UBUNTUGESTURES_EXPORT Direction : public QObject {
+class UBUNTUGESTURESQML_EXPORT Direction : public QObject {
     Q_OBJECT
     Q_ENUMS(Type)
 

=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2014-05-02 08:29:26 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2014-10-14 12:55:09 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2014 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,64 +14,32 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define ACTIVETOUCHESINFO_DEBUG 0
+#define DIRECTIONALDRAGAREA_DEBUG 0
+
 #include "DirectionalDragArea.h"
 
+#include <QQuickWindow>
 #include <QtCore/qmath.h>
-#include <QtCore/QTimer>
 #include <QDebug>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-pedantic"
+#include <private/qquickwindow_p.h>
+#pragma GCC diagnostic pop
+
+// local
+#include "TouchOwnershipEvent.h"
+#include "TouchRegistry.h"
+#include "UnownedTouchEvent.h"
+
 using namespace UbuntuGestures;
 
-#define DIRECTIONALDRAGAREA_DEBUG 0
-
 #if DIRECTIONALDRAGAREA_DEBUG
 #define DDA_DEBUG(msg) qDebug("[DDA] " msg)
+#include "DebugHelpers.h"
+
 namespace {
-QString touchPointStateToString(Qt::TouchPointState state) {
-    switch (state) {
-    case Qt::TouchPointPressed:
-        return QString("pressed");
-    case Qt::TouchPointMoved:
-        return QString("moved");
-    case Qt::TouchPointStationary:
-        return QString("stationary");
-    default: // Qt::TouchPointReleased:
-        return QString("released");
-    }
-}
-QString touchEventToString(QTouchEvent *ev)
-{
-    QString message;
-
-    switch (ev->type()) {
-    case QEvent::TouchBegin:
-        message.append("TouchBegin ");
-        break;
-    case QEvent::TouchUpdate:
-        message.append("TouchUpdate ");
-        break;
-    case QEvent::TouchEnd:
-        message.append("TouchEnd ");
-        break;
-    default: //QEvent::TouchCancel
-        message.append("TouchCancel ");
-    }
-
-    for (int i=0; i < ev->touchPoints().size(); ++i) {
-
-        const QTouchEvent::TouchPoint& touchPoint = ev->touchPoints().at(i);
-        message.append(
-            QString("(id:%1, state:%2, scenePos:(%3,%4)) ")
-                .arg(touchPoint.id())
-                .arg(touchPointStateToString(touchPoint.state()))
-                .arg(touchPoint.scenePos().x())
-                .arg(touchPoint.scenePos().y())
-            );
-    }
-
-    return message;
-}
-
 const char *statusToString(DirectionalDragArea::Status status)
 {
     if (status == DirectionalDragArea::WaitingForTouch) {
@@ -88,23 +56,6 @@
 #define DDA_DEBUG(msg) do{}while(0)
 #endif // DIRECTIONALDRAGAREA_DEBUG
 
-// Essentially a QTimer wrapper
-class RecognitionTimer : public UbuntuGestures::AbstractTimer
-{
-    Q_OBJECT
-public:
-    RecognitionTimer(QObject *parent) : UbuntuGestures::AbstractTimer(parent) {
-        m_timer.setSingleShot(false);
-        connect(&m_timer, &QTimer::timeout,
-                this, &UbuntuGestures::AbstractTimer::timeout);
-    }
-    virtual int interval() const { return m_timer.interval(); }
-    virtual void setInterval(int msecs) { m_timer.setInterval(msecs); }
-    virtual void start() { m_timer.start(); UbuntuGestures::AbstractTimer::start(); }
-    virtual void stop() { m_timer.stop(); UbuntuGestures::AbstractTimer::stop(); }
-private:
-    QTimer m_timer;
-};
 
 DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)
     : QQuickItem(parent)
@@ -126,12 +77,14 @@
     , m_timeSource(new RealTimeSource)
     , m_activeTouches(m_timeSource)
 {
-    setRecognitionTimer(new RecognitionTimer(this));
+    setRecognitionTimer(new Timer(this));
     m_recognitionTimer->setInterval(60);
+    m_recognitionTimer->setSingleShot(false);
 
     m_velocityCalculator = new AxisVelocityCalculator(this);
 
-    connect(this, &QQuickItem::enabledChanged, this, &DirectionalDragArea::onEnabledChanged);
+    connect(this, &QQuickItem::enabledChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
+    connect(this, &QQuickItem::visibleChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
 }
 
 Direction::Type DirectionalDragArea::direction() const
@@ -214,6 +167,7 @@
 {
     int interval = 0;
     bool timerWasRunning = false;
+    bool wasSingleShot = false;
 
     // can be null when called from the constructor
     if (m_recognitionTimer) {
@@ -226,6 +180,7 @@
 
     m_recognitionTimer = timer;
     timer->setInterval(interval);
+    timer->setSingleShot(wasSingleShot);
     connect(timer, &UbuntuGestures::AbstractTimer::timeout,
             this, &DirectionalDragArea::checkSpeed);
     if (timerWasRunning) {
@@ -280,8 +235,144 @@
     return m_previousScenePos.y();
 }
 
+bool DirectionalDragArea::event(QEvent *event)
+{
+    if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
+        touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
+        return true;
+    } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {
+        unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));
+        return true;
+    } else {
+        return QQuickItem::event(event);
+    }
+}
+
+void DirectionalDragArea::touchOwnershipEvent(TouchOwnershipEvent *event)
+{
+    if (event->gained()) {
+        QVector<int> ids;
+        ids.append(event->touchId());
+        DDA_DEBUG("grabbing touch");
+        grabTouchPoints(ids);
+
+        // Work around for Qt bug. If we grab a touch that is being used for mouse pointer
+        // emulation it will cause the emulation logic to go nuts.
+        // Thus we have to also grab the mouse in this case.
+        // TODO: Report bug to Qt
+        if (window()) {
+            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(window());
+            if (windowPrivate->touchMouseId == event->touchId() && window()->mouseGrabberItem()) {
+                DDA_DEBUG("removing mouse grabber");
+                window()->mouseGrabberItem()->ungrabMouse();
+            }
+        }
+    } else {
+        // We still wanna know when it ends for keeping the composition time window up-to-date
+        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+
+        setStatus(WaitingForTouch);
+    }
+}
+
+void DirectionalDragArea::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)
+{
+    QTouchEvent *event = unownedTouchEvent->touchEvent();
+
+    Q_ASSERT(!event->touchPointStates().testFlag(Qt::TouchPointPressed));
+
+    #if DIRECTIONALDRAGAREA_DEBUG
+    // TODO Consider using qCDebug() when available (Qt 5.2)
+    qDebug() << "[DDA] Unowned" << m_timeSource->msecsSinceReference()
+        << qPrintable(touchEventToString(event));
+    #endif
+
+    switch (m_status) {
+        case WaitingForTouch:
+            // do nothing
+            break;
+        case Undecided:
+            Q_ASSERT(isEnabled() && isVisible());
+            unownedTouchEvent_undecided(unownedTouchEvent);
+            break;
+        default: // Recognized:
+            // do nothing
+            break;
+    }
+
+    m_activeTouches.update(event);
+}
+
+void DirectionalDragArea::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)
+{
+    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(unownedTouchEvent->touchEvent());
+    if (!touchPoint) {
+        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << m_touchId
+            << "missing from UnownedTouchEvent without first reaching state Qt::TouchPointReleased. "
+               "Considering it as released.";
+
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        setStatus(WaitingForTouch);
+        return;
+    }
+
+    const QPointF &touchScenePos = touchPoint->scenePos();
+
+    if (touchPoint->state() == Qt::TouchPointReleased) {
+        // touch has ended before recognition concluded
+        DDA_DEBUG("Touch has ended before recognition concluded");
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        emitSignalIfTapped();
+        setStatus(WaitingForTouch);
+        return;
+    }
+
+    m_previousDampedScenePos.setX(m_dampedScenePos.x());
+    m_previousDampedScenePos.setY(m_dampedScenePos.y());
+    m_dampedScenePos.update(touchScenePos);
+    updateVelocityCalculator(touchScenePos);
+
+    if (!pointInsideAllowedArea()) {
+        DDA_DEBUG("Rejecting gesture because touch point is outside allowed area.");
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        // We still wanna know when it ends for keeping the composition time window up-to-date
+        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+        setStatus(WaitingForTouch);
+        return;
+    }
+
+    if (!movingInRightDirection()) {
+        DDA_DEBUG("Rejecting gesture because touch point is moving in the wrong direction.");
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        // We still wanna know when it ends for keeping the composition time window up-to-date
+        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+        setStatus(WaitingForTouch);
+        return;
+    }
+
+    setPreviousPos(touchPoint->pos());
+    setPreviousScenePos(touchScenePos);
+
+    if (isWithinTouchCompositionWindow()) {
+        // There's still time for some new touch to appear and ruin our party as it would be combined
+        // with our m_touchId one and therefore deny the possibility of a single-finger gesture.
+        DDA_DEBUG("Sill within composition window. Let's wait more.");
+        return;
+    }
+
+    if (movedFarEnough(touchScenePos)) {
+        TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
+        setStatus(Recognized);
+    } else {
+        DDA_DEBUG("Didn't move far enough yet. Let's wait more.");
+    }
+}
+
 void DirectionalDragArea::touchEvent(QTouchEvent *event)
 {
+    // TODO: Consider when more than one touch starts in the same event (although it's not possible
+    //       with Mir's android-input). Have to track them all. Consider it a plus/bonus.
+
     #if DIRECTIONALDRAGAREA_DEBUG
     // TODO Consider using qCDebug() when available (Qt 5.2)
     qDebug() << "[DDA]" << m_timeSource->msecsSinceReference()
@@ -310,29 +401,34 @@
 
 void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)
 {
+    // TODO: accept/reject is for the whole event, not per touch id. See how that affects us.
+
     if (!event->touchPointStates().testFlag(Qt::TouchPointPressed)) {
         // Nothing to see here. No touch starting in this event.
         return;
     }
 
+    // to be proven wrong, if that's the case
+    bool allGood = true;
+
     if (isWithinTouchCompositionWindow()) {
         // too close to the last touch start. So we consider them as starting roughly at the same time.
         // Can't be a single-touch gesture.
         #if DIRECTIONALDRAGAREA_DEBUG
         qDebug("[DDA] A new touch point came in but we're still within time composition window. Ignoring it.");
         #endif
-        return;
+        allGood = false;
     }
 
     const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
 
     const QTouchEvent::TouchPoint *newTouchPoint = nullptr;
-    for (int i = 0; i < touchPoints.count(); ++i) {
+    for (int i = 0; i < touchPoints.count() && allGood; ++i) {
         const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
         if (touchPoint.state() == Qt::TouchPointPressed) {
             if (newTouchPoint) {
                 // more than one touch starting in this QTouchEvent. Can't be a single-touch gesture
-                return;
+                allGood = false;
             } else {
                 // that's our candidate
                 m_touchId = touchPoint.id();
@@ -341,85 +437,61 @@
         }
     }
 
-    Q_ASSERT(newTouchPoint);
-
-    // If we have made this far, we are good to go to the next status.
-
-    m_startPos = newTouchPoint->pos();
-    m_startScenePos = newTouchPoint->scenePos();
-    m_touchId = newTouchPoint->id();
-    m_dampedScenePos.reset(m_startScenePos);
-    m_velocityCalculator->setTrackedPosition(0.);
-    m_velocityCalculator->reset();
-    m_numSamplesOnLastSpeedCheck = 0;
-    m_silenceTime = 0;
-    setPreviousPos(m_startPos);
-    setPreviousScenePos(m_startScenePos);
-    updateSceneDirectionVector();
-
-    setStatus(Undecided);
+    if (allGood) {
+        Q_ASSERT(newTouchPoint);
+
+        m_startPos = newTouchPoint->pos();
+        m_startScenePos = newTouchPoint->scenePos();
+        m_touchId = newTouchPoint->id();
+        m_dampedScenePos.reset(m_startScenePos);
+        m_velocityCalculator->setTrackedPosition(0.);
+        m_velocityCalculator->reset();
+        m_numSamplesOnLastSpeedCheck = 0;
+        m_silenceTime = 0;
+        setPreviousPos(m_startPos);
+        setPreviousScenePos(m_startScenePos);
+        updateSceneDirectionVector();
+
+        if (recognitionIsDisabled()) {
+            // Behave like a dumb TouchArea
+            TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
+            setStatus(Recognized);
+            event->accept();
+        } else {
+            // just monitor the touch points for now.
+            TouchRegistry::instance()->addCandidateOwnerForTouch(m_touchId, this);
+
+            setStatus(Undecided);
+            // Let the item below have it. We will monitor it and grab it later if a gesture
+            // gets recognized.
+            event->ignore();
+        }
+    } else {
+        watchPressedTouchPoints(touchPoints);
+        event->ignore();
+    }
 }
 
 void DirectionalDragArea::touchEvent_undecided(QTouchEvent *event)
 {
-    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
-
-    if (!touchPoint) {
-        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << m_touchId
-            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
-               "Considering it as released.";
-        setStatus(WaitingForTouch);
-        return;
-    }
-
-    const QPointF &touchScenePos = touchPoint->scenePos();
-
-    if (touchPoint->state() == Qt::TouchPointReleased) {
-        // touch has ended before recognition concluded
-        DDA_DEBUG("Touch has ended before recognition concluded");
-        setStatus(WaitingForTouch);
-        Q_EMIT tapped();
-        return;
-    }
+    Q_ASSERT(event->type() == QEvent::TouchBegin);
+    Q_ASSERT(fetchTargetTouchPoint(event) == nullptr);
+
+    // We're not interested in new touch points. We already have our candidate (m_touchId).
+    // But we do want to know when those new touches end for keeping the composition time
+    // window up-to-date
+    event->ignore();
+    watchPressedTouchPoints(event->touchPoints());
 
     if (event->touchPointStates().testFlag(Qt::TouchPointPressed) && isWithinTouchCompositionWindow()) {
         // multi-finger drags are not accepted
         DDA_DEBUG("Multi-finger drags are not accepted");
-        setStatus(WaitingForTouch);
-        return;
-    }
-
-    m_previousDampedScenePos.setX(m_dampedScenePos.x());
-    m_previousDampedScenePos.setY(m_dampedScenePos.y());
-    m_dampedScenePos.update(touchScenePos);
-    updateVelocityCalculator(touchScenePos);
-
-    if (!pointInsideAllowedArea()) {
-        DDA_DEBUG("Rejecting gesture because touch point is outside allowed area.");
-        setStatus(WaitingForTouch);
-        return;
-    }
-
-    if (!movingInRightDirection()) {
-        DDA_DEBUG("Rejecting gesture becauuse touch point is moving in the wrong direction.");
-        setStatus(WaitingForTouch);
-        return;
-    }
-
-    setPreviousPos(touchPoint->pos());
-    setPreviousScenePos(touchScenePos);
-
-    if (isWithinTouchCompositionWindow()) {
-        // There's still time for some new touch to appear and ruin our party as it would be combined
-        // with our m_touchId one and therefore deny the possibility of a single-finger gesture.
-        DDA_DEBUG("Sill within composition window. Let's wait more.");
-        return;
-    }
-
-    if (movedFarEnough(touchScenePos)) {
-        setStatus(Recognized);
-    } else {
-        DDA_DEBUG("Didn't move far enough yet. Let's wait more.");
+
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        // We still wanna know when it ends for keeping the composition time window up-to-date
+        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+
+        setStatus(WaitingForTouch);
     }
 }
 
@@ -437,11 +509,35 @@
         setPreviousScenePos(touchPoint->scenePos());
 
         if (touchPoint->state() == Qt::TouchPointReleased) {
+            emitSignalIfTapped();
             setStatus(WaitingForTouch);
         }
     }
 }
 
+void DirectionalDragArea::watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints)
+{
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
+        if (touchPoint.state() == Qt::TouchPointPressed) {
+            TouchRegistry::instance()->addTouchWatcher(touchPoint.id(), this);
+        }
+    }
+}
+
+bool DirectionalDragArea::recognitionIsDisabled() const
+{
+    return distanceThreshold() <= 0 && compositionTime() <= 0;
+}
+
+void DirectionalDragArea::emitSignalIfTapped()
+{
+    qint64 touchDuration = m_timeSource->msecsSinceReference() - m_activeTouches.touchStartTime(m_touchId);
+    if (touchDuration <= maxTapDuration()) {
+        Q_EMIT tapped();
+    }
+}
+
 const QTouchEvent::TouchPoint *DirectionalDragArea::fetchTargetTouchPoint(QTouchEvent *event)
 {
     const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
@@ -509,12 +605,16 @@
 
 void DirectionalDragArea::checkSpeed()
 {
+    Q_ASSERT(m_status == Undecided);
+
     if (m_velocityCalculator->numSamples() >= AxisVelocityCalculator::MIN_SAMPLES_NEEDED) {
         qreal speed = qFabs(m_velocityCalculator->calculate());
         qreal minSpeedMsecs = m_minSpeed / 1000.0;
 
         if (speed < minSpeedMsecs) {
             DDA_DEBUG("Rejecting gesture because it's below minimum speed.");
+            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
             setStatus(WaitingForTouch);
         }
     }
@@ -523,7 +623,9 @@
         m_silenceTime += m_recognitionTimer->interval();
 
         if (m_silenceTime > m_maxSilenceTime) {
-            DDA_DEBUG("Rejecting gesture because it's silence time has been exceeded.");
+            DDA_DEBUG("Rejecting gesture because its silence time has been exceeded.");
+            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
             setStatus(WaitingForTouch);
         }
     } else {
@@ -532,10 +634,19 @@
     m_numSamplesOnLastSpeedCheck = m_velocityCalculator->numSamples();
 }
 
-void DirectionalDragArea::onEnabledChanged()
+void DirectionalDragArea::giveUpIfDisabledOrInvisible()
 {
-    if (!isEnabled() && m_status != WaitingForTouch) {
-        setStatus(WaitingForTouch);
+    if (!isEnabled() || !isVisible()) {
+        if (m_status == Undecided) {
+            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+            // We still wanna know when it ends for keeping the composition time window up-to-date
+            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+        }
+
+        if (m_status != WaitingForTouch) {
+            DDA_DEBUG("Resetting status because got disabled or made invisible");
+            setStatus(WaitingForTouch);
+        }
     }
 }
 
@@ -631,7 +742,9 @@
 
 bool DirectionalDragArea::isWithinTouchCompositionWindow()
 {
-    return !m_activeTouches.isEmpty() &&
+    return
+        compositionTime() > 0 &&
+        !m_activeTouches.isEmpty() &&
         m_timeSource->msecsSinceReference() <=
             m_activeTouches.mostRecentStartTime() + (qint64)compositionTime();
 }
@@ -639,18 +752,17 @@
 //**************************  ActiveTouchesInfo **************************
 
 DirectionalDragArea::ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
-    : m_timeSource(timeSource), m_lastUsedIndex(-1)
+    : m_timeSource(timeSource)
 {
-    // Estimate of the maximum number of active touches we might reach.
-    // Not a problem if it ends up being an underestimate as this is just
-    // an optimization.
-    m_vector.resize(3);
 }
 
 void DirectionalDragArea::ActiveTouchesInfo::update(QTouchEvent *event)
 {
     if (!(event->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))) {
         // nothing to update
+        #if ACTIVETOUCHESINFO_DEBUG
+        qDebug("[DDA::ActiveTouchesInfo] Nothing to Update");
+        #endif
         return;
     }
 
@@ -658,74 +770,88 @@
     for (int i = 0; i < touchPoints.count(); ++i) {
         const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
         if (touchPoint.state() == Qt::TouchPointPressed) {
-            addTouchPoint(touchPoint);
+            addTouchPoint(touchPoint.id());
         } else if (touchPoint.state() == Qt::TouchPointReleased) {
-            removeTouchPoint(touchPoint);
+            removeTouchPoint(touchPoint.id());
         }
     }
 }
 
-void DirectionalDragArea::ActiveTouchesInfo::addTouchPoint(const QTouchEvent::TouchPoint &touchPoint)
-{
-    ActiveTouchInfo &activeTouchInfo = getEmptySlot();
-    activeTouchInfo.id = touchPoint.id();
+#if ACTIVETOUCHESINFO_DEBUG
+QString DirectionalDragArea::ActiveTouchesInfo::toString()
+{
+    QString string = "(";
+
+    {
+        QTextStream stream(&string);
+        m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
+            stream << "(id=" << touchInfo->id << ",startTime=" << touchInfo->startTime << ")";
+            return true;
+        });
+    }
+
+    string.append(")");
+
+    return string;
+}
+#endif // ACTIVETOUCHESINFO_DEBUG
+
+void DirectionalDragArea::ActiveTouchesInfo::addTouchPoint(int touchId)
+{
+    ActiveTouchInfo &activeTouchInfo = m_touchInfoPool.getEmptySlot();
+    activeTouchInfo.id = touchId;
     activeTouchInfo.startTime = m_timeSource->msecsSinceReference();
-}
-
-void DirectionalDragArea::ActiveTouchesInfo::removeTouchPoint(const QTouchEvent::TouchPoint &touchPoint)
-{
-    for (int i = 0; i <= m_lastUsedIndex; ++i) {
-        if (touchPoint.id() == m_vector.at(i).id) {
-            freeSlot(i);
-            return;
-        }
-    }
-    Q_ASSERT(false); // shouldn't reach this point
-}
-
-DirectionalDragArea::ActiveTouchInfo &DirectionalDragArea::ActiveTouchesInfo::getEmptySlot()
-{
-    Q_ASSERT(m_lastUsedIndex < m_vector.size());
-
-    // Look for an in-between vacancy first
-    for (int i = 0; i < m_lastUsedIndex; ++i) {
-        ActiveTouchInfo &activeTouchInfo = m_vector[i];
-        if (!activeTouchInfo.isValid()) {
-            return activeTouchInfo;
-        }
-    }
-
-    ++m_lastUsedIndex;
-    if (m_lastUsedIndex >= m_vector.size()) {
-        m_vector.resize(m_lastUsedIndex + 1);
-    }
-
-    return m_vector[m_lastUsedIndex];
-}
-
-void DirectionalDragArea::ActiveTouchesInfo::freeSlot(int index)
-{
-    m_vector[index].reset();
-    if (index == m_lastUsedIndex) {
-        do {
-            --m_lastUsedIndex;
-        } while (m_lastUsedIndex >= 0 && !m_vector.at(m_lastUsedIndex).isValid());
-    }
+
+    #if ACTIVETOUCHESINFO_DEBUG
+    qDebug() << "[DDA::ActiveTouchesInfo]" << qPrintable(toString());
+    #endif
+}
+
+qint64 DirectionalDragArea::ActiveTouchesInfo::touchStartTime(int touchId)
+{
+    qint64 result = -1;
+
+    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
+        if (touchId == touchInfo->id) {
+            result = touchInfo->startTime;
+            return false;
+        } else {
+            return true;
+        }
+    });
+
+    Q_ASSERT(result != -1);
+    return result;
+}
+
+void DirectionalDragArea::ActiveTouchesInfo::removeTouchPoint(int touchId)
+{
+    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
+        if (touchId == touchInfo->id) {
+            m_touchInfoPool.freeSlot(touchInfo);
+            return false;
+        } else {
+            return true;
+        }
+    });
+
+    #if ACTIVETOUCHESINFO_DEBUG
+    qDebug() << "[DDA::ActiveTouchesInfo]" << qPrintable(toString());
+    #endif
 }
 
 qint64 DirectionalDragArea::ActiveTouchesInfo::mostRecentStartTime()
 {
-    Q_ASSERT(m_lastUsedIndex >= 0);
-
-    qint64 highestStartTime = m_vector.at(0).startTime;
-    int i = 1;
-    do {
-        const ActiveTouchInfo &activeTouchInfo = m_vector.at(i);
-        if (activeTouchInfo.isValid() && activeTouchInfo.startTime > highestStartTime) {
-            highestStartTime = activeTouchInfo.startTime;
+    Q_ASSERT(!m_touchInfoPool.isEmpty());
+
+    qint64 highestStartTime = -1;
+
+    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &activeTouchInfo) {
+        if (activeTouchInfo->startTime > highestStartTime) {
+            highestStartTime = activeTouchInfo->startTime;
         }
-        ++i;
-    } while (i < m_lastUsedIndex);
+        return true;
+    });
 
     return highestStartTime;
 }

=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.h'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.h	2014-05-02 08:29:26 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.h	2014-10-14 12:55:09 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013,2014 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,27 +19,16 @@
 
 #include <QtQuick/QQuickItem>
 #include "AxisVelocityCalculator.h"
-#include "UbuntuGesturesGlobal.h"
+#include "UbuntuGesturesQmlGlobal.h"
 #include "Damper.h"
 #include "Direction.h"
 
-namespace UbuntuGestures {
-/* Defines an interface for a Timer. */
-class UBUNTUGESTURES_EXPORT AbstractTimer : public QObject {
-    Q_OBJECT
-public:
-    AbstractTimer(QObject *parent) : QObject(parent), m_isRunning(false) {}
-    virtual int interval() const = 0;
-    virtual void setInterval(int msecs) = 0;
-    virtual void start() { m_isRunning = true; };
-    virtual void stop() { m_isRunning = false; }
-    bool isRunning() const { return m_isRunning; }
-Q_SIGNALS:
-    void timeout();
-private:
-    bool m_isRunning;
-};
-}
+// lib UbuntuGestures
+#include <Pool.h>
+#include <Timer.h>
+
+class TouchOwnershipEvent;
+class UnownedTouchEvent;
 
 /*
  An area that detects axis-aligned single-finger drag gestures
@@ -50,7 +39,7 @@
 
  See doc/DirectionalDragArea.svg
  */
-class UBUNTUGESTURES_EXPORT DirectionalDragArea : public QQuickItem {
+class UBUNTUGESTURESQML_EXPORT DirectionalDragArea : public QQuickItem {
     Q_OBJECT
 
     // The direction in which the gesture should move in order to be recognized.
@@ -196,6 +185,12 @@
     // Useful for testing, where a fake time source can be supplied
     void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
 
+    bool event(QEvent *e) override;
+
+    // Maximum time, in milliseconds, between a press and a release, for a touch
+    // sequence to be considered a tap.
+    int maxTapDuration() const { return 300; }
+
 Q_SIGNALS:
     void directionChanged(Direction::Type direction);
     void statusChanged(Status value);
@@ -212,6 +207,10 @@
     void touchYChanged(qreal value);
     void touchSceneXChanged(qreal value);
     void touchSceneYChanged(qreal value);
+
+    // TODO: I would rather not have such signal as it has nothing to do with drag gestures.
+    // Remove when no longer used or move its implementation to the QML code that uses it
+    // See maxTapDuration()
     void tapped();
 
 protected:
@@ -219,7 +218,7 @@
 
 private Q_SLOTS:
     void checkSpeed();
-    void onEnabledChanged();
+    void giveUpIfDisabledOrInvisible();
 
 private:
     void touchEvent_absent(QTouchEvent *event);
@@ -238,6 +237,12 @@
     // returns the scalar projection between the given vector (in scene coordinates)
     // and m_sceneDirectionVector
     qreal projectOntoDirectionVector(const QPointF &sceneVector) const;
+    void touchOwnershipEvent(TouchOwnershipEvent *event);
+    void unownedTouchEvent(UnownedTouchEvent *event);
+    void unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent);
+    void watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints);
+    bool recognitionIsDisabled() const;
+    void emitSignalIfTapped();
 
     Status m_status;
 
@@ -283,18 +288,21 @@
     public:
         ActiveTouchesInfo(const UbuntuGestures::SharedTimeSource &timeSource);
         void update(QTouchEvent *event);
-        ActiveTouchInfo &touchInfo(int id);
+        qint64 touchStartTime(int id);
+        bool isEmpty() const { return m_touchInfoPool.isEmpty(); }
         qint64 mostRecentStartTime();
         UbuntuGestures::SharedTimeSource m_timeSource;
-        bool isEmpty() const { return m_lastUsedIndex == -1; }
     private:
-        void addTouchPoint(const QTouchEvent::TouchPoint &touchPoint);
-        ActiveTouchInfo &getEmptySlot();
-        void freeSlot(int index);
-        void removeTouchPoint(const QTouchEvent::TouchPoint &touchPoint);
-        QVector<struct ActiveTouchInfo> m_vector;
-        int m_lastUsedIndex;
+        void addTouchPoint(int touchId);
+        void removeTouchPoint(int touchId);
+        #if ACTIVETOUCHESINFO_DEBUG
+        QString toString();
+        #endif
+
+        Pool<ActiveTouchInfo> m_touchInfoPool;
     } m_activeTouches;
+
+    friend class tst_DirectionalDragArea;
 };
 
 #endif // DIRECTIONAL_DRAG_AREA_H

=== modified file 'plugins/Ubuntu/Gestures/TimeSource.h'
--- plugins/Ubuntu/Gestures/TimeSource.h	2013-10-22 15:56:37 +0000
+++ plugins/Ubuntu/Gestures/TimeSource.h	2014-10-14 12:55:09 +0000
@@ -21,14 +21,14 @@
 #ifndef UBUNTUGESTURES_TIMESOURCE_H
 #define UBUNTUGESTURES_TIMESOURCE_H
 
-#include "UbuntuGesturesGlobal.h"
+#include "UbuntuGesturesQmlGlobal.h"
 #include <QSharedPointer>
 
 namespace UbuntuGestures {
 /*
     Interface for a time source.
  */
-class UBUNTUGESTURES_EXPORT TimeSource {
+class UBUNTUGESTURESQML_EXPORT TimeSource {
 public:
     virtual ~TimeSource() {}
     /* Returns the current time in milliseconds since some reference time in the past. */

=== added file 'plugins/Ubuntu/Gestures/TouchGate.cpp'
--- plugins/Ubuntu/Gestures/TouchGate.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Gestures/TouchGate.cpp	2014-10-14 12:55:09 +0000
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TouchGate.h"
+
+#include <QCoreApplication>
+#include <QDebug>
+
+#include <TouchOwnershipEvent.h>
+#include <TouchRegistry.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-pedantic"
+#include <private/qquickitem_p.h>
+#pragma GCC diagnostic pop
+
+#if TOUCHGATE_DEBUG
+#include <DebugHelpers.h>
+#endif
+
+
+bool TouchGate::event(QEvent *e)
+{
+    if (e->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
+        touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(e));
+        return true;
+    } else {
+        return QQuickItem::event(e);
+    }
+}
+
+void TouchGate::touchEvent(QTouchEvent *event)
+{
+    #if TOUCHGATE_DEBUG
+    qDebug() << "[TouchGate] got touch event" << qPrintable(touchEventToString(event));
+    #endif
+    event->accept();
+
+    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
+    bool goodToGo = true;
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        const QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
+
+        if (touchPoint.state() == Qt::TouchPointPressed) {
+            Q_ASSERT(!m_touchInfoMap.contains(touchPoint.id()));
+            m_touchInfoMap[touchPoint.id()].ownership = OwnershipRequested;
+            m_touchInfoMap[touchPoint.id()].ended = false;
+            TouchRegistry::instance()->requestTouchOwnership(touchPoint.id(), this);
+        }
+
+        goodToGo &= m_touchInfoMap.contains(touchPoint.id())
+            && m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted;
+
+        if (touchPoint.state() == Qt::TouchPointReleased && m_touchInfoMap.contains(touchPoint.id())) {
+            m_touchInfoMap[touchPoint.id()].ended = true;
+        }
+
+    }
+
+    if (goodToGo) {
+        if (m_storedEvents.isEmpty()) {
+            // let it pass through
+            dispatchTouchEventToTarget(event);
+        } else {
+            // Retain the event to ensure TouchGate dispatches them in order.
+            // Otherwise the current event would come before the stored ones, which are older.
+            #if TOUCHGATE_DEBUG
+            qDebug("[TouchGate] Storing event because thouches %s are still pending ownership.",
+                qPrintable(oldestPendingTouchIdsString()));
+            #endif
+            storeTouchEvent(event);
+        }
+    } else {
+        // Retain events that have unowned touches
+        storeTouchEvent(event);
+    }
+}
+
+void TouchGate::touchOwnershipEvent(TouchOwnershipEvent *event)
+{
+    // TODO: Optimization: batch those actions as TouchOwnershipEvents
+    //       might come one right after the other.
+
+    Q_ASSERT(m_touchInfoMap.contains(event->touchId()));
+
+    TouchInfo &touchInfo = m_touchInfoMap[event->touchId()];
+
+    if (event->gained()) {
+        #if TOUCHGATE_DEBUG
+        qDebug() << "[TouchGate] Got ownership of touch " << event->touchId();
+        #endif
+        touchInfo.ownership = OwnershipGranted;
+    } else {
+        #if TOUCHGATE_DEBUG
+        qDebug() << "[TouchGate] Lost ownership of touch " << event->touchId();
+        #endif
+        m_touchInfoMap.remove(event->touchId());
+        removeTouchFromStoredEvents(event->touchId());
+    }
+
+    dispatchFullyOwnedEvents();
+}
+
+bool TouchGate::isTouchPointOwned(int touchId) const
+{
+    return m_touchInfoMap[touchId].ownership == OwnershipGranted;
+}
+
+void TouchGate::storeTouchEvent(const QTouchEvent *event)
+{
+    #if TOUCHGATE_DEBUG
+    qDebug() << "[TouchGate] Storing" << qPrintable(touchEventToString(event));
+    #endif
+
+    TouchEvent clonedEvent(event);
+    m_storedEvents.append(std::move(clonedEvent));
+}
+
+void TouchGate::removeTouchFromStoredEvents(int touchId)
+{
+    int i = 0;
+    while (i < m_storedEvents.count()) {
+        TouchEvent &event = m_storedEvents[i];
+        bool removed = event.removeTouch(touchId);
+
+        if (removed && event.touchPoints.isEmpty()) {
+            m_storedEvents.removeAt(i);
+        } else {
+            ++i;
+        }
+    }
+}
+
+void TouchGate::dispatchFullyOwnedEvents()
+{
+    while (!m_storedEvents.isEmpty() && eventIsFullyOwned(m_storedEvents.first())) {
+        TouchEvent event = m_storedEvents.takeFirst();
+        dispatchTouchEventToTarget(event);
+    }
+}
+
+#if TOUCHGATE_DEBUG
+QString TouchGate::oldestPendingTouchIdsString()
+{
+    Q_ASSERT(!m_storedEvents.isEmpty());
+
+    QString str;
+
+    const auto &touchPoints = m_storedEvents.first().touchPoints;
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        if (!isTouchPointOwned(touchPoints[i].id())) {
+            if (!str.isEmpty()) {
+                str.append(", ");
+            }
+            str.append(QString::number(touchPoints[i].id()));
+        }
+    }
+
+    return str;
+}
+#endif
+
+bool TouchGate::eventIsFullyOwned(const TouchGate::TouchEvent &event) const
+{
+    for (int i = 0; i < event.touchPoints.count(); ++i) {
+        if (!isTouchPointOwned(event.touchPoints[i].id())) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void TouchGate::setTargetItem(QQuickItem *item)
+{
+    // TODO: changing the target item while dispatch of touch events is taking place will
+    //       create a mess
+
+    if (item == m_targetItem.data())
+        return;
+
+    m_targetItem = item;
+    Q_EMIT targetItemChanged(item);
+}
+
+void TouchGate::dispatchTouchEventToTarget(const TouchEvent &event)
+{
+    dispatchTouchEventToTarget(event.eventType,
+            event.device,
+            event.modifiers,
+            event.touchPoints,
+            event.target,
+            event.window,
+            event.timestamp);
+}
+
+void TouchGate::dispatchTouchEventToTarget(QTouchEvent* event)
+{
+    dispatchTouchEventToTarget(event->type(),
+            event->device(),
+            event->modifiers(),
+            event->touchPoints(),
+            event->target(),
+            event->window(),
+            event->timestamp());
+}
+
+void TouchGate::dispatchTouchEventToTarget(QEvent::Type eventType,
+        QTouchDevice *device,
+        Qt::KeyboardModifiers modifiers,
+        const QList<QTouchEvent::TouchPoint> &touchPoints,
+        QObject *target,
+        QWindow *window,
+        ulong timestamp)
+{
+    removeTouchInfoForEndedTouches(touchPoints);
+
+    if (m_targetItem.isNull()) {
+        qWarning("[TouchGate] Cannot dispatch touch event because target item is null");
+        return;
+    }
+
+    QQuickItem *targetItem = m_targetItem.data();
+
+    if (!targetItem->isEnabled() || !targetItem->isVisible()) {
+        #if TOUCHGATE_DEBUG
+        qDebug() << "[TouchGate] Cannot dispatch touch event to" << targetItem
+            << "because it's disabled or invisible.";
+        #endif
+        return;
+    }
+
+    // Map touch points to targetItem coordinates
+    QList<QTouchEvent::TouchPoint> targetTouchPoints = touchPoints;
+    transformTouchPoints(targetTouchPoints, QQuickItemPrivate::get(targetItem)->windowToItemTransform());
+    QTouchEvent *eventForTargetItem = createQTouchEvent(eventType, device, modifiers, targetTouchPoints,
+            target, window, timestamp);
+
+    #if TOUCHGATE_DEBUG
+    qDebug() << "[TouchGate] dispatching" << qPrintable(touchEventToString(eventForTargetItem))
+            << "to" << targetItem;
+    #endif
+
+    QCoreApplication::sendEvent(targetItem, eventForTargetItem);
+
+    delete eventForTargetItem;
+}
+
+// NB: From QQuickWindow
+void TouchGate::transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform)
+{
+    QMatrix4x4 transformMatrix(transform);
+    for (int i=0; i<touchPoints.count(); i++) {
+        QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
+        touchPoint.setRect(transform.mapRect(touchPoint.sceneRect()));
+        touchPoint.setStartPos(transform.map(touchPoint.startScenePos()));
+        touchPoint.setLastPos(transform.map(touchPoint.lastScenePos()));
+        touchPoint.setVelocity(transformMatrix.mapVector(touchPoint.velocity()).toVector2D());
+    }
+}
+
+QTouchEvent *TouchGate::createQTouchEvent(QEvent::Type eventType,
+        QTouchDevice *device,
+        Qt::KeyboardModifiers modifiers,
+        const QList<QTouchEvent::TouchPoint> &touchPoints,
+        QObject *target,
+        QWindow *window,
+        ulong timestamp)
+{
+    Qt::TouchPointStates eventStates = 0;
+    for (int i = 0; i < touchPoints.count(); i++)
+        eventStates |= touchPoints[i].state();
+    // if all points have the same state, set the event type accordingly
+    switch (eventStates) {
+        case Qt::TouchPointPressed:
+            eventType = QEvent::TouchBegin;
+            break;
+        case Qt::TouchPointReleased:
+            eventType = QEvent::TouchEnd;
+            break;
+        default:
+            eventType = QEvent::TouchUpdate;
+            break;
+    }
+
+    QTouchEvent *touchEvent = new QTouchEvent(eventType);
+    touchEvent->setWindow(window);
+    touchEvent->setTarget(target);
+    touchEvent->setDevice(device);
+    touchEvent->setModifiers(modifiers);
+    touchEvent->setTouchPoints(touchPoints);
+    touchEvent->setTouchPointStates(eventStates);
+    touchEvent->setTimestamp(timestamp);
+    touchEvent->accept();
+    return touchEvent;
+}
+
+void TouchGate::removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints)
+{
+    for (int i = 0; i < touchPoints.size(); ++i) {\
+        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
+
+        if (touchPoint.state() == Qt::TouchPointReleased) {
+            Q_ASSERT(m_touchInfoMap.contains(touchPoint.id()));
+            Q_ASSERT(m_touchInfoMap[touchPoint.id()].ended);
+            Q_ASSERT(m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted);
+            m_touchInfoMap.remove(touchPoint.id());
+        }
+    }
+}
+
+TouchGate::TouchEvent::TouchEvent(const QTouchEvent *event)
+    : eventType(event->type())
+    , device(event->device())
+    , modifiers(event->modifiers())
+    , touchPoints(event->touchPoints())
+    , target(event->target())
+    , window(event->window())
+    , timestamp(event->timestamp())
+{
+}
+
+bool TouchGate::TouchEvent::removeTouch(int touchId)
+{
+    bool removed = false;
+    for (int i = 0; i < touchPoints.count() && !removed; ++i) {
+        if (touchPoints[i].id() == touchId) {
+            touchPoints.removeAt(i);
+            removed = true;
+        }
+    }
+
+    return removed;
+}

=== added file 'plugins/Ubuntu/Gestures/TouchGate.h'
--- plugins/Ubuntu/Gestures/TouchGate.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Gestures/TouchGate.h	2014-10-14 12:55:09 +0000
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTU_TOUCH_GATE_H
+#define UBUNTU_TOUCH_GATE_H
+
+#include "UbuntuGesturesQmlGlobal.h"
+
+#include <QQuickItem>
+#include <QList>
+#include <QPointer>
+#include <QMap>
+
+#define TOUCHGATE_DEBUG 0
+
+class TouchOwnershipEvent;
+
+/*
+  Blocks the passage of events until ownership over the related touch points is granted.
+
+  Blocked touch events won't be discarded. Instead they will be buffered until ownership
+  is granted. If ownership is given to another item, the event buffer is cleared.
+
+  A TouchGate is useful as a mediator for items that do not understand, or gracefully handle,
+  touch canceling. By having a TouchGate in front of them you guarantee that only owned touches (i.e.,
+  touches that won't be canceled later) reaches them.
+ */
+class UBUNTUGESTURESQML_EXPORT TouchGate : public QQuickItem {
+    Q_OBJECT
+
+    // Item that's going to receive the touch events that make it through the gate.
+    Q_PROPERTY(QQuickItem* targetItem READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
+
+public:
+    bool event(QEvent *e) override;
+
+    QQuickItem *targetItem() { return m_targetItem; }
+    void setTargetItem(QQuickItem *item);
+
+Q_SIGNALS:
+    void targetItemChanged(QQuickItem *item);
+
+protected:
+    void touchEvent(QTouchEvent *event) override;
+private:
+    class TouchEvent {
+    public:
+        TouchEvent(const QTouchEvent *event);
+
+        bool removeTouch(int touchId);
+
+        QEvent::Type eventType;
+        QTouchDevice *device;
+        Qt::KeyboardModifiers modifiers;
+        QList<QTouchEvent::TouchPoint> touchPoints;
+        QObject *target;
+        QWindow *window;
+        ulong timestamp;
+    };
+
+    void touchOwnershipEvent(TouchOwnershipEvent *event);
+    bool isTouchPointOwned(int touchId) const;
+    void storeTouchEvent(const QTouchEvent *event);
+    void removeTouchFromStoredEvents(int touchId);
+    void dispatchFullyOwnedEvents();
+    bool eventIsFullyOwned(const TouchEvent &event) const;
+
+    void dispatchTouchEventToTarget(const TouchEvent &event);
+    void dispatchTouchEventToTarget(QTouchEvent* event);
+    void dispatchTouchEventToTarget(
+        QEvent::Type eventType,
+        QTouchDevice *device,
+        Qt::KeyboardModifiers modifiers,
+        const QList<QTouchEvent::TouchPoint> &touchPoints,
+        QObject *target,
+        QWindow *window,
+        ulong timestamp);
+
+    void transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform);
+    static QTouchEvent *createQTouchEvent(QEvent::Type eventType,
+            QTouchDevice *device,
+            Qt::KeyboardModifiers modifiers,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            QObject *target,
+            QWindow *window,
+            ulong timestamp);
+    void removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints);
+
+    #if TOUCHGATE_DEBUG
+    QString oldestPendingTouchIdsString();
+    #endif
+
+    QList<TouchEvent> m_storedEvents;
+
+    enum {
+        OwnershipUndefined,
+        OwnershipRequested,
+        OwnershipGranted,
+    };
+    class TouchInfo {
+    public:
+        TouchInfo() {ownership = OwnershipUndefined; ended = false;}
+        int ownership;
+        bool ended;
+    };
+    QMap<int, TouchInfo> m_touchInfoMap;
+
+    QPointer<QQuickItem> m_targetItem;
+
+    friend class tst_TouchGate;
+};
+
+#endif // UBUNTU_TOUCH_GATE_H

=== renamed file 'plugins/Ubuntu/Gestures/UbuntuGesturesGlobal.h' => 'plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h'
--- plugins/Ubuntu/Gestures/UbuntuGesturesGlobal.h	2013-06-05 22:03:08 +0000
+++ plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h	2014-10-14 12:55:09 +0000
@@ -16,8 +16,8 @@
 
 #include <QtCore/QtGlobal>
 
-#if defined(UBUNTUGESTURES_LIBRARY)
-#  define UBUNTUGESTURES_EXPORT Q_DECL_EXPORT
+#if defined(UBUNTUGESTURESQML_LIBRARY)
+#  define UBUNTUGESTURESQML_EXPORT Q_DECL_EXPORT
 #else
-#  define UBUNTUGESTURES_EXPORT Q_DECL_IMPORT
+#  define UBUNTUGESTURESQML_EXPORT Q_DECL_IMPORT
 #endif

=== modified file 'plugins/Ubuntu/Gestures/plugin.cpp'
--- plugins/Ubuntu/Gestures/plugin.cpp	2013-11-22 13:43:40 +0000
+++ plugins/Ubuntu/Gestures/plugin.cpp	2014-10-14 12:55:09 +0000
@@ -19,6 +19,7 @@
 #include "Direction.h"
 #include "DirectionalDragArea.h"
 #include "PressedOutsideNotifier.h"
+#include "TouchGate.h"
 
 #include <qqml.h>
 
@@ -28,10 +29,11 @@
   return new Direction;
 }
 
-void UbuntuGestureQmlPlugin::registerTypes(const char *uri)
+void UbuntuGesturesQmlPlugin::registerTypes(const char *uri)
 {
     qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);
     qmlRegisterType<DirectionalDragArea>(uri, 0, 1, "DirectionalDragArea");
     qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");
     qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");
+    qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");
 }

=== modified file 'plugins/Ubuntu/Gestures/plugin.h'
--- plugins/Ubuntu/Gestures/plugin.h	2013-06-05 22:03:08 +0000
+++ plugins/Ubuntu/Gestures/plugin.h	2014-10-14 12:55:09 +0000
@@ -19,7 +19,7 @@
 
 #include <QtQml/QQmlExtensionPlugin>
 
-class UbuntuGestureQmlPlugin : public QQmlExtensionPlugin
+class UbuntuGesturesQmlPlugin : public QQmlExtensionPlugin
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")

=== modified file 'plugins/Ubuntu/Gestures/qmldir'
--- plugins/Ubuntu/Gestures/qmldir	2014-05-02 22:57:00 +0000
+++ plugins/Ubuntu/Gestures/qmldir	2014-10-14 12:55:09 +0000
@@ -1,3 +1,3 @@
 module Ubuntu.Gestures
-plugin UbuntuGestureQml
+plugin UbuntuGesturesQml
 typeinfo Gestures.qmltypes

=== modified file 'po/ast.po'
--- po/ast.po	2014-10-09 06:37:11 +0000
+++ po/ast.po	2014-10-14 12:55:09 +0000
@@ -8,14 +8,14 @@
 "Project-Id-Version: unity8\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-10-03 22:20+0000\n"
-"Last-Translator: Xuacu Saturio <[e-mail]>\n"
+"PO-Revision-Date: 2014-10-09 09:49+0000\n"
+"Last-Translator: ivarela <[e-mail]>\n"
 "Language-Team: Asturian <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:36+0000\n"
+"X-Launchpad-Export-Date: 2014-10-10 05:23+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 
 #: plugins/LightDM/Greeter.cpp:130
@@ -37,11 +37,12 @@
 
 #: qml/Components/DelayedLockscreen.qml:62
 msgid "You have been locked out due to too many failed passphrase attempts."
-msgstr ""
+msgstr "Quedasti bloquiáu polos escesivos intentos fallíos de frase de pasu."
 
 #: qml/Components/DelayedLockscreen.qml:63
 msgid "You have been locked out due to too many failed passcode attempts."
 msgstr ""
+"Quedasti bloquiáu polos escesivos intentos fallíos de códigu de pasu."
 
 #: qml/Components/DelayedLockscreen.qml:72
 #, qt-format
@@ -213,11 +214,11 @@
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:55
 msgid "Pull to refresh…"
-msgstr ""
+msgstr "Tirar p'anovar..."
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:60
 msgid "Release to refresh…"
-msgstr ""
+msgstr "Soltar p'anovar..."
 
 #: qml/Dash/ScopesOverview.qml:206
 msgid "Manage Scopes"
@@ -313,7 +314,7 @@
 
 #: qml/Shell.qml:346
 msgid "Enter passphrase"
-msgstr ""
+msgstr "Escribi la frase contraseña"
 
 #: qml/Shell.qml:347
 msgid "Sorry, incorrect passphrase"
@@ -325,7 +326,7 @@
 
 #: qml/Shell.qml:350
 msgid "Enter passcode"
-msgstr ""
+msgstr "Escribi'l códigu de pasu"
 
 #: qml/Shell.qml:351
 msgid "Sorry, incorrect passcode"

=== modified file 'po/en_AU.po'
--- po/en_AU.po	2014-10-09 06:37:11 +0000
+++ po/en_AU.po	2014-10-14 12:55:09 +0000
@@ -8,14 +8,14 @@
 "Project-Id-Version: unity\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-09-23 01:24+0000\n"
+"PO-Revision-Date: 2014-10-12 09:41+0000\n"
 "Last-Translator: Jared Norris <[e-mail]>\n"
 "Language-Team: English (Australia) <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:37+0000\n"
+"X-Launchpad-Export-Date: 2014-10-13 06:15+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 
 #: plugins/LightDM/Greeter.cpp:130
@@ -33,22 +33,22 @@
 
 #: qml/Components/DelayedLockscreen.qml:47
 msgid "Device Locked"
-msgstr ""
+msgstr "Device Locked"
 
 #: qml/Components/DelayedLockscreen.qml:62
 msgid "You have been locked out due to too many failed passphrase attempts."
-msgstr ""
+msgstr "You have been locked out due to too many failed passphrase attempts."
 
 #: qml/Components/DelayedLockscreen.qml:63
 msgid "You have been locked out due to too many failed passcode attempts."
-msgstr ""
+msgstr "You have been locked out due to too many failed passcode attempts."
 
 #: qml/Components/DelayedLockscreen.qml:72
 #, qt-format
 msgid "Please wait %1 minute and then try again…"
 msgid_plural "Please wait %1 minutes and then try again…"
-msgstr[0] ""
-msgstr[1] ""
+msgstr[0] "Please wait %1 minute and then try again…"
+msgstr[1] "Please wait %1 minutes and then try again…"
 
 #: qml/Components/Dialogs.qml:70
 msgid "Log out"
@@ -211,15 +211,15 @@
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:55
 msgid "Pull to refresh…"
-msgstr ""
+msgstr "Pull to refresh…"
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:60
 msgid "Release to refresh…"
-msgstr ""
+msgstr "Release to refresh…"
 
 #: qml/Dash/ScopesOverview.qml:206
 msgid "Manage Scopes"
-msgstr ""
+msgstr "Manage Scopes"
 
 #: qml/Dash/ScopesOverview.qml:428
 msgid "Done"
@@ -239,7 +239,7 @@
 
 #: qml/Greeter/Greeter.qml:157
 msgid "Unlock"
-msgstr ""
+msgstr "Unlock"
 
 #: qml/Hud/HudParametrizedActionsPage.qml:139
 msgid "Confirm"
@@ -275,7 +275,7 @@
 
 #: qml/Panel/Indicators/MenuItemFactory.qml:600
 msgid "Nothing is playing"
-msgstr ""
+msgstr "Nothing is playing"
 
 #: qml/Panel/Indicators/MenuItemFactory.qml:748
 msgid "In queue…"
@@ -311,7 +311,7 @@
 
 #: qml/Shell.qml:346
 msgid "Enter passphrase"
-msgstr ""
+msgstr "Enter passphrase"
 
 #: qml/Shell.qml:347
 msgid "Sorry, incorrect passphrase"
@@ -319,11 +319,11 @@
 
 #: qml/Shell.qml:348
 msgid "Please re-enter"
-msgstr ""
+msgstr "Please re-enter"
 
 #: qml/Shell.qml:350
 msgid "Enter passcode"
-msgstr ""
+msgstr "Enter passcode"
 
 #: qml/Shell.qml:351
 msgid "Sorry, incorrect passcode"
@@ -332,7 +332,7 @@
 #: qml/Shell.qml:354
 #, qt-format
 msgid "Enter %1"
-msgstr ""
+msgstr "Enter %1"
 
 #: qml/Shell.qml:355
 #, qt-format
@@ -366,9 +366,3 @@
 msgstr ""
 "If passcode is entered incorrectly, your phone will conduct a factory reset "
 "and all personal data will be deleted."
-
-#~ msgid "Sorry, incorrect PIN"
-#~ msgstr "Sorry, incorrect PIN"
-
-#~ msgid "Enter SIM PIN"
-#~ msgstr "Enter SIM PIN"

=== modified file 'po/es.po'
--- po/es.po	2014-10-09 06:37:11 +0000
+++ po/es.po	2014-10-14 12:55:09 +0000
@@ -8,14 +8,14 @@
 "Project-Id-Version: unity\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-10-05 08:50+0000\n"
-"Last-Translator: Paco Molinero <[e-mail]>\n"
+"PO-Revision-Date: 2014-10-09 07:43+0000\n"
+"Last-Translator: Adolfo Jayme <[e-mail]>\n"
 "Language-Team: Spanish <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:36+0000\n"
+"X-Launchpad-Export-Date: 2014-10-10 05:23+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 
 #: plugins/LightDM/Greeter.cpp:130
@@ -218,11 +218,11 @@
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:55
 msgid "Pull to refresh…"
-msgstr ""
+msgstr "Deslice para actualizar…"
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:60
 msgid "Release to refresh…"
-msgstr ""
+msgstr "Suelte para actualizar…"
 
 #: qml/Dash/ScopesOverview.qml:206
 msgid "Manage Scopes"

=== modified file 'po/fa.po'
--- po/fa.po	2014-10-09 06:37:11 +0000
+++ po/fa.po	2014-10-14 12:55:09 +0000
@@ -8,14 +8,14 @@
 "Project-Id-Version: unity8\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-10-02 23:07+0000\n"
+"PO-Revision-Date: 2014-10-11 23:41+0000\n"
 "Last-Translator: Danial Behzadi <[e-mail]>\n"
 "Language-Team: Persian <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=1; plural=0;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:36+0000\n"
+"X-Launchpad-Export-Date: 2014-10-12 06:55+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 
 #: plugins/LightDM/Greeter.cpp:130
@@ -211,11 +211,11 @@
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:55
 msgid "Pull to refresh…"
-msgstr ""
+msgstr "برای تازه‌سازی بکشید…"
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:60
 msgid "Release to refresh…"
-msgstr ""
+msgstr "برای تازه‌سازی رها کنید…"
 
 #: qml/Dash/ScopesOverview.qml:206
 msgid "Manage Scopes"
@@ -366,9 +366,3 @@
 msgstr ""
 "اگر رمزعبور نادرست وارد شود، تلفن شما بازنشانی کارخانه خواهد شد و تمامی "
 "اطّلاعات شخصی حذف خواهند شد."
-
-#~ msgid "Sorry, incorrect PIN"
-#~ msgstr "متأسّفیم، PIN نادرست بود"
-
-#~ msgid "Enter SIM PIN"
-#~ msgstr "PIN سیم‌کارت را وارد کنید"

=== modified file 'po/fr.po'
--- po/fr.po	2014-10-09 06:37:11 +0000
+++ po/fr.po	2014-10-14 12:55:09 +0000
@@ -8,14 +8,14 @@
 "Project-Id-Version: unity\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-10-06 19:06+0000\n"
-"Last-Translator: Jean Marc <Unknown>\n"
+"PO-Revision-Date: 2014-10-09 19:00+0000\n"
+"Last-Translator: Anne <[e-mail]>\n"
 "Language-Team: French <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n > 1;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:36+0000\n"
+"X-Launchpad-Export-Date: 2014-10-10 05:23+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 
 #: plugins/LightDM/Greeter.cpp:130
@@ -222,11 +222,11 @@
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:55
 msgid "Pull to refresh…"
-msgstr ""
+msgstr "Tirer pour actualiser..."
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:60
 msgid "Release to refresh…"
-msgstr ""
+msgstr "Relâcher pour actualiser..."
 
 #: qml/Dash/ScopesOverview.qml:206
 msgid "Manage Scopes"

=== modified file 'po/gd.po'
--- po/gd.po	2014-10-09 06:37:11 +0000
+++ po/gd.po	2014-10-14 12:55:09 +0000
@@ -8,7 +8,7 @@
 "Project-Id-Version: unity8\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-10-03 19:54+0000\n"
+"PO-Revision-Date: 2014-10-09 18:09+0000\n"
 "Last-Translator: GunChleoc <Unknown>\n"
 "Language-Team: Fòram na Gàidhlig\n"
 "MIME-Version: 1.0\n"
@@ -16,7 +16,7 @@
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=4; plural=(n==1 || n==11) ? 0 : (n==2 || n==12) ? 1 : "
 "(n > 2 && n < 20) ? 2 : 3;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:36+0000\n"
+"X-Launchpad-Export-Date: 2014-10-10 05:23+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 "Language: gd\n"
 
@@ -225,11 +225,11 @@
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:55
 msgid "Pull to refresh…"
-msgstr ""
+msgstr "Tarraing airson ath-nuadhachadh…"
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:60
 msgid "Release to refresh…"
-msgstr ""
+msgstr "Leig às airson ath-nuadhachadh…"
 
 #: qml/Dash/ScopesOverview.qml:206
 msgid "Manage Scopes"

=== modified file 'po/hu.po'
--- po/hu.po	2014-10-09 06:37:11 +0000
+++ po/hu.po	2014-10-14 12:55:09 +0000
@@ -8,14 +8,14 @@
 "Project-Id-Version: unity\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-10-08 08:13+0000\n"
+"PO-Revision-Date: 2014-10-11 10:50+0000\n"
 "Last-Translator: Richard Somlói <[e-mail]>\n"
 "Language-Team: Hungarian <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:36+0000\n"
+"X-Launchpad-Export-Date: 2014-10-12 06:55+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 
 #: plugins/LightDM/Greeter.cpp:130
@@ -321,7 +321,7 @@
 
 #: qml/Shell.qml:348
 msgid "Please re-enter"
-msgstr "Kérjük adja meg újra"
+msgstr "Kérjük próbálja újra"
 
 #: qml/Shell.qml:350
 msgid "Enter passcode"
@@ -368,9 +368,3 @@
 msgstr ""
 "Ha helytelen jelkódot ad meg, a telefonja visszaállítja a gyári "
 "beállításokat és törli minden személyes adatát."
-
-#~ msgid "Sorry, incorrect PIN"
-#~ msgstr "Sajnáljuk, helytelen PIN"
-
-#~ msgid "Enter SIM PIN"
-#~ msgstr "Adja meg a SIM PIN kódját"

=== modified file 'po/is.po'
--- po/is.po	2014-10-09 06:37:11 +0000
+++ po/is.po	2014-10-14 12:55:09 +0000
@@ -10,14 +10,14 @@
 "Project-Id-Version: po_unity8-is\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
 "POT-Creation-Date: 2014-10-07 11:37+0300\n"
-"PO-Revision-Date: 2014-10-05 08:44+0000\n"
+"PO-Revision-Date: 2014-10-09 10:49+0000\n"
 "Last-Translator: Sveinn í Felli <[e-mail]>\n"
 "Language-Team: Icelandic <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Launchpad-Export-Date: 2014-10-09 06:36+0000\n"
+"X-Launchpad-Export-Date: 2014-10-10 05:23+0000\n"
 "X-Generator: Launchpad (build 17196)\n"
 "Language: is\n"
 
@@ -36,7 +36,7 @@
 
 #: qml/Components/DelayedLockscreen.qml:47
 msgid "Device Locked"
-msgstr ""
+msgstr "Tæki læst"
 
 #: qml/Components/DelayedLockscreen.qml:62
 msgid "You have been locked out due to too many failed passphrase attempts."
@@ -50,8 +50,8 @@
 #, qt-format
 msgid "Please wait %1 minute and then try again…"
 msgid_plural "Please wait %1 minutes and then try again…"
-msgstr[0] ""
-msgstr[1] ""
+msgstr[0] "Bíddu í %1 mínútu og reyndu svo aftur"
+msgstr[1] "Bíddu í %1 mínútur og reyndu svo aftur"
 
 #: qml/Components/Dialogs.qml:70
 msgid "Log out"
@@ -219,7 +219,7 @@
 
 #: qml/Dash/PullToRefreshScopeStyle.qml:60
 msgid "Release to refresh…"
-msgstr ""
+msgstr "Slepptu til að endurlesa..."
 
 #: qml/Dash/ScopesOverview.qml:206
 msgid "Manage Scopes"
@@ -243,7 +243,7 @@
 
 #: qml/Greeter/Greeter.qml:157
 msgid "Unlock"
-msgstr ""
+msgstr "Aflæsa"
 
 #: qml/Hud/HudParametrizedActionsPage.qml:139
 msgid "Confirm"
@@ -323,7 +323,7 @@
 
 #: qml/Shell.qml:348
 msgid "Please re-enter"
-msgstr ""
+msgstr "Settu aftur inn"
 
 #: qml/Shell.qml:350
 msgid "Enter passcode"
@@ -336,7 +336,7 @@
 #: qml/Shell.qml:354
 #, qt-format
 msgid "Enter %1"
-msgstr ""
+msgstr "Settu inn %1"
 
 #: qml/Shell.qml:355
 #, qt-format

=== modified file 'qml/Components/Carousel.qml'
--- qml/Components/Carousel.qml	2014-07-08 17:49:18 +0000
+++ qml/Components/Carousel.qml	2014-10-14 12:55:09 +0000
@@ -17,6 +17,7 @@
 import QtQuick 2.0
 import Ubuntu.Components 0.1
 import "carousel.js" as CarouselJS
+import "Flickables" as Flickables
 
 /*! The Carousel component presents the items of a model in a carousel view. It's similar to a
     cover flow. But it stops at it's boundaries (therefore no PathView is used).
@@ -63,7 +64,7 @@
        and footer item to compensate that.
 
        The scaling of the items is controlled by the variable continuousIndex, described below. */
-    ListView {
+    Flickables.ListView {
         id: listView
         objectName: "listView"
 
@@ -135,8 +136,6 @@
 
         boundsBehavior: Flickable.DragOverBounds
         cacheBuffer: carousel.cacheBuffer
-        flickDeceleration: Math.max(1500 * Math.pow(realWidth / referenceWidth, 1.5), 1500) // 1500 is platform default
-        maximumFlickVelocity: Math.max(2500 * Math.pow(realWidth / referenceWidth, 1.5), 2500) // 2500 is platform default
         orientation: ListView.Horizontal
 
         function getXFromContinuousIndex(index) {

=== modified file 'qml/Components/DragHandle.qml'
--- qml/Components/DragHandle.qml	2014-02-12 18:51:36 +0000
+++ qml/Components/DragHandle.qml	2014-10-14 12:55:09 +0000
@@ -47,12 +47,12 @@
     id: dragArea
     objectName: "dragHandle"
 
-    // Disable most of the gesture recognition parameters by default when hinting is used as
+    // Disable gesture recognition by default when hinting is used as
     // it conflicts with the hinting idea.
-    // The only part we keep in this situation is that it must be a single-finger gesture.
     distanceThreshold: hintDisplacement > 0 ? 0 : defaultDistanceThreshold
     maxSilenceTime: hintDisplacement > 0 ? 60*60*1000 : defaultMaxSilenceTime
     maxDeviation: hintDisplacement > 0 ? 999999 : defaultMaxDeviation
+    compositionTime: hintDisplacement > 0 ? 0 : defaultCompositionTime
 
     property bool stretch: false
 

=== modified file 'qml/Components/EdgeDragArea.qml'
--- qml/Components/EdgeDragArea.qml	2013-10-22 15:56:37 +0000
+++ qml/Components/EdgeDragArea.qml	2014-10-14 12:55:09 +0000
@@ -34,6 +34,7 @@
     distanceThreshold: defaultDistanceThreshold
     minSpeed: defaultMinSpeed
     maxSilenceTime: defaultMaxSilenceTime
+    compositionTime: defaultCompositionTime
 
     readonly property real defaultMaxDeviation: units.gu(3)
     readonly property real defaultWideningAngle: 50
@@ -41,4 +42,5 @@
     // some people were getting false negatives with it enabled.
     readonly property real defaultMinSpeed: units.gu(0)
     readonly property int defaultMaxSilenceTime: 200
+    readonly property int defaultCompositionTime: 60
 }

=== added directory 'qml/Components/Flickables'
=== added file 'qml/Components/Flickables/Flickable.qml'
--- qml/Components/Flickables/Flickable.qml	1970-01-01 00:00:00 +0000
+++ qml/Components/Flickables/Flickable.qml	2014-10-14 12:55:09 +0000
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3 as QtQuick
+import Ubuntu.Components 1.1
+
+QtQuick.Flickable {
+    flickDeceleration: 1500 * units.gridUnit / 8
+    maximumFlickVelocity: 2500 * units.gridUnit / 8
+}

=== added file 'qml/Components/Flickables/GridView.qml'
--- qml/Components/Flickables/GridView.qml	1970-01-01 00:00:00 +0000
+++ qml/Components/Flickables/GridView.qml	2014-10-14 12:55:09 +0000
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3 as QtQuick
+import Ubuntu.Components 1.1
+
+QtQuick.GridView {
+    // Attached components and usages like GridView.onRemove are known not to work
+    // please use GridView directly from QtQuick if needed
+    flickDeceleration: 1500 * units.gridUnit / 8
+    maximumFlickVelocity: 2500 * units.gridUnit / 8
+}

=== added file 'qml/Components/Flickables/ListView.qml'
--- qml/Components/Flickables/ListView.qml	1970-01-01 00:00:00 +0000
+++ qml/Components/Flickables/ListView.qml	2014-10-14 12:55:09 +0000
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3 as QtQuick
+import Ubuntu.Components 1.1
+
+QtQuick.ListView {
+    // Attached components and usages like ListView.onRemove are known not to work
+    // please use ListView directly from QtQuick if needed
+    flickDeceleration: 1500 * units.gridUnit / 8
+    maximumFlickVelocity: 2500 * units.gridUnit / 8
+}

=== added file 'qml/Components/Flickables/ListViewWithPageHeader.qml'
--- qml/Components/Flickables/ListViewWithPageHeader.qml	1970-01-01 00:00:00 +0000
+++ qml/Components/Flickables/ListViewWithPageHeader.qml	2014-10-14 12:55:09 +0000
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import Dash 0.1
+import Ubuntu.Components 1.1
+
+ListViewWithPageHeader {
+    flickDeceleration: 1500 * units.gridUnit / 8
+    maximumFlickVelocity: 2500 * units.gridUnit / 8
+}

=== modified file 'qml/Components/InputMethod.qml'
--- qml/Components/InputMethod.qml	2014-07-23 18:25:53 +0000
+++ qml/Components/InputMethod.qml	2014-10-14 12:55:09 +0000
@@ -17,6 +17,7 @@
 import QtQuick 2.0
 import Unity.Application 0.1
 import Ubuntu.Components 0.1
+import Ubuntu.Gestures 0.1
 
 Item {
     id: root
@@ -25,6 +26,18 @@
 
     property int transitionDuration: UbuntuAnimation.FastDuration
 
+    Binding { target: surface; property: "z"; value: 0 }
+
+    TouchGate {
+        x: UbuntuKeyboardInfo.x
+        y: UbuntuKeyboardInfo.y
+        z: 1
+        width: UbuntuKeyboardInfo.width
+        height: UbuntuKeyboardInfo.height
+
+        targetItem: root.surface
+    }
+
     state: {
         if (surface && surface.state != MirSurfaceItem.Minimized) {
             return "shown";

=== removed file 'qml/Components/ListItems/Highlight.qml'
--- qml/Components/ListItems/Highlight.qml	2013-06-05 22:03:08 +0000
+++ qml/Components/ListItems/Highlight.qml	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2013 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-import QtQuick 2.0
-
-Rectangle {
-    id: highlight
-
-    property bool pressed: false
-    property real pressedOpacity: 0.3
-
-    color: "black"
-    opacity: 0
-    state: pressed ? "pressed" : ""
-    states: [
-        State {
-            name: "pressed"
-            PropertyChanges { target: highlight; opacity: pressedOpacity}
-        }
-    ]
-    transitions: [
-        Transition {
-            from: ""
-            to: "pressed"
-            NumberAnimation { target: highlight; property: "opacity"; duration: 50}
-        },
-        Transition {
-            from: "pressed"
-            to: ""
-            NumberAnimation { target: highlight; property: "opacity"; duration: 100}
-        }
-    ]
-}

=== modified file 'qml/Components/ResponsiveGridView.qml'
--- qml/Components/ResponsiveGridView.qml	2014-09-19 10:31:14 +0000
+++ qml/Components/ResponsiveGridView.qml	2014-10-14 12:55:09 +0000
@@ -16,6 +16,7 @@
 
 import QtQuick 2.3
 import Ubuntu.Components 0.1
+import "Flickables" as Flickables
 
 /*
    Essentially a GridView where you can specify the maximum number of columns it can have.
@@ -55,7 +56,7 @@
         return rows * height
     }
 
-    GridView {
+    Flickables.GridView {
         id: gridView
         objectName: "responsiveGridViewGrid"
         anchors {

=== modified file 'qml/Components/ZoomableImage.qml'
--- qml/Components/ZoomableImage.qml	2014-04-30 13:51:11 +0000
+++ qml/Components/ZoomableImage.qml	2014-10-14 12:55:09 +0000
@@ -16,7 +16,7 @@
 
 import QtQuick 2.0
 import Ubuntu.Components 0.1
-import "../Components"
+import "Flickables" as Flickables
 
 /*! \brief Zoomable for image.
 
@@ -32,7 +32,7 @@
     property alias scaleTo: lazyImage.scaleTo
     property alias asynchronous: lazyImage.asynchronous
 
-    Flickable {
+    Flickables.Flickable {
         id: flickable
         objectName: "flickable"
         clip: true

=== modified file 'qml/Dash/CardHorizontalList.qml'
--- qml/Dash/CardHorizontalList.qml	2014-09-30 09:23:23 +0000
+++ qml/Dash/CardHorizontalList.qml	2014-10-14 12:55:09 +0000
@@ -17,6 +17,7 @@
 import QtQuick 2.2
 import Ubuntu.Components 1.1
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 DashRenderer {
     id: root
@@ -25,7 +26,7 @@
     collapsedHeight: expandedHeight
     clip: true
 
-    ListView {
+    Flickables.ListView {
         id: listView
         anchors {
             fill: parent

=== modified file 'qml/Dash/Dash.qml'
--- qml/Dash/Dash.qml	2014-10-09 14:04:53 +0000
+++ qml/Dash/Dash.qml	2014-10-14 12:55:09 +0000
@@ -207,6 +207,12 @@
             }
         }
 
+        // This is to avoid the situation where a bottom-edge swipe would bring up the dash overview
+        // (as expected) but would also cause the dash content flickable to move a bit, because
+        // that flickable was getting the touch events while overviewDragHandle was still undecided
+        // about whether that touch was indeed performing a directional drag gesture.
+        forceNonInteractive: overviewDragHandle.status != DirectionalDragArea.WaitingForTouch
+
         enabled: overviewController.progress == 0
         opacity: enabled ? 1 : 0
     }
@@ -363,16 +369,32 @@
         height: units.gu(2)
 
         onSceneDistanceChanged: {
-            if (overviewController.enableAnimation) {
-                dashContentCache.scheduleUpdate();
+            if (status == DirectionalDragArea.Recognized && initialSceneDistance != -1) {
+                if (overviewController.enableAnimation) {
+                    dashContentCache.scheduleUpdate();
+                }
+                overviewController.enableAnimation = false;
+                var deltaDistance = sceneDistance - initialSceneDistance;
+                overviewController.progress = Math.max(0, Math.min(1, deltaDistance / fullMovement));
             }
-            overviewController.enableAnimation = false;
-            overviewController.progress = Math.max(0, Math.min(1, sceneDistance / fullMovement));
         }
 
-        onDraggingChanged: {
-            overviewController.enableAnimation = true;
-            overviewController.progress = (overviewController.progress > 0.7)  ? 1 : 0;
+        property int previousStatus: -1
+        property int currentStatus: DirectionalDragArea.WaitingForTouch
+        property real initialSceneDistance: -1
+
+        onStatusChanged: {
+            previousStatus = currentStatus;
+            currentStatus = status;
+
+            if (status == DirectionalDragArea.Recognized) {
+                initialSceneDistance = sceneDistance;
+            } else if (status == DirectionalDragArea.WaitingForTouch &&
+                    previousStatus == DirectionalDragArea.Recognized) {
+                overviewController.enableAnimation = true;
+                overviewController.progress = (overviewController.progress > 0.7)  ? 1 : 0;
+                initialSceneDistance = -1;
+            }
         }
     }
 

=== renamed file 'qml/Components/ListItems/Base.qml' => 'qml/Dash/DashCategoryBase.qml'
--- qml/Components/ListItems/Base.qml	2014-10-03 11:39:18 +0000
+++ qml/Dash/DashCategoryBase.qml	2014-10-14 12:55:09 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Canonical, Ltd.
+ * Copyright (C) 2012-2014 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,46 +18,8 @@
 import Ubuntu.Components 0.1
 
 Item {
-    id: emptyListItem
-    width: parent ? parent.width : units.gu(31)
-    height: body.height + bottomDividerLine.height
-
-    /*!
-      \preliminary
-      Specifies whether the list item is selected.
-     */
-    property bool selected: false
-
-    /*!
-      \preliminary
-      Set to show or hide the thin bottom divider line (drawn by the \l ThinDivider component).
-      This line is shown by default except in cases where this item is the delegate of a ListView.
-     */
-    property bool showDivider: __showDivider()
-
-    /*!
-      \internal
-      Method to automatically determine if the bottom divider line should be drawn.
-      This always returns true, unless item is a delegate in a ListView. If in a ListView
-      it will return false only when:
-       + if this is the final item in the list, and ListView.footer is set (again as thin
-         divider line won't look well with footer below it)
-     */
-    function __showDivider() {
-        // if we're not in ListView, always show a thin dividing line at the bottom
-        var model = null;
-        if (typeof ListViewWithPageHeader !== 'undefined') {
-            if (typeof ListViewWithPageHeader.model !== 'undefined') {
-                model = ListViewWithPageHeader.model;
-            }
-        } else if (ListView.view !== null) {
-            model = ListView.view.model;
-        }
-            // if we're last item in ListView don't show divider
-        if (model && index === model.count - 1) return false;
-
-        return true;
-    }
+    width: parent.width
+    height: body.height
 
     /* Relevant really only for ListViewWithPageHeader case: specify how many pixels we can overlap with the section header */
     readonly property int allowedOverlap: units.dp(1)
@@ -92,25 +54,9 @@
             anchors {
                 left: parent.left
                 right: parent.right
-                bottom: bottomDividerLine.top
+                bottom: parent.bottom
             }
             height: childrenRect.height
         }
-
-        ThinDivider {
-            id: bottomDividerLine
-            anchors.bottom: parent.bottom
-            visible: showDivider
-        }
-
-        Highlight {
-            anchors {
-                top: parent.top
-                left: parent.left
-                right: parent.right
-                bottom: bottomDividerLine.top
-            }
-            pressed: emptyListItem.selected
-        }
     }
 }

=== modified file 'qml/Dash/DashContent.qml'
--- qml/Dash/DashContent.qml	2014-09-22 14:24:34 +0000
+++ qml/Dash/DashContent.qml	2014-10-14 12:55:09 +0000
@@ -19,10 +19,12 @@
 import Unity 0.2
 import Utils 0.1
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 Item {
     id: dashContent
 
+    property bool forceNonInteractive: false
     property alias scopes: dashContentList.model
     readonly property alias currentIndex: dashContentList.currentIndex
     readonly property string currentScopeId: dashContentList.currentItem ? dashContentList.currentItem.scopeId : ""
@@ -97,16 +99,15 @@
             anchors.fill: parent
         }
 
-        ListView {
+        Flickables.ListView {
             id: dashContentList
             objectName: "dashContentList"
 
-            interactive: dashContent.scopes.loaded && currentItem && !currentItem.moving && !currentItem.navigationShown && !currentItem.subPageShown
+            interactive: !dashContent.forceNonInteractive && dashContent.scopes.loaded && currentItem
+                      && !currentItem.moving && !currentItem.navigationShown && !currentItem.subPageShown
             anchors.fill: parent
             orientation: ListView.Horizontal
             boundsBehavior: Flickable.DragAndOvershootBounds
-            flickDeceleration: units.gu(625)
-            maximumFlickVelocity: width * 5
             snapMode: ListView.SnapOneItem
             highlightMoveDuration: 250
             highlightRangeMode: ListView.StrictlyEnforceRange
@@ -180,6 +181,7 @@
                         item.paginationCount = Qt.binding(function() { return dashContentList.count } )
                         item.paginationIndex = Qt.binding(function() { return dashContentList.currentIndex } )
                         item.holdingList = dashContentList;
+                        item.forceNonInteractive = Qt.binding(function() { return dashContent.forceNonInteractive } )
                     }
                     Connections {
                         target: isCurrent ? scope : null

=== modified file 'qml/Dash/DashNavigationButton.qml'
--- qml/Dash/DashNavigationButton.qml	2014-08-29 07:59:08 +0000
+++ qml/Dash/DashNavigationButton.qml	2014-10-14 12:55:09 +0000
@@ -16,6 +16,7 @@
 
 import QtQuick 2.2
 import Ubuntu.Components 1.1
+import "../Components/Flickables" as Flickables
 
 AbstractButton {
     id: root
@@ -75,7 +76,7 @@
     }
 
     //  navigationListView is outside root
-    ListView {
+    Flickables.ListView {
         id: navigationListView
         objectName: "navigationListView"
         visible: height > 0

=== modified file 'qml/Dash/DashNavigationList.qml'
--- qml/Dash/DashNavigationList.qml	2014-08-27 10:25:47 +0000
+++ qml/Dash/DashNavigationList.qml	2014-10-14 12:55:09 +0000
@@ -17,6 +17,7 @@
 import QtQuick 2.2
 import Ubuntu.Components 1.1
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 Item {
     id: root
@@ -45,7 +46,7 @@
         }
     }
 
-    Flickable {
+    Flickables.Flickable {
         id: flickable
 
         anchors.fill: parent

=== modified file 'qml/Dash/GenericScopeView.qml'
--- qml/Dash/GenericScopeView.qml	2014-10-06 15:54:18 +0000
+++ qml/Dash/GenericScopeView.qml	2014-10-14 12:55:09 +0000
@@ -26,6 +26,7 @@
     id: scopeView
 
     readonly property bool navigationShown: pageHeaderLoader.item ? pageHeaderLoader.item.bottomItem[0].openList : false
+    property bool forceNonInteractive: false
     property var scope: null
     property SortFilterProxyModel categories: categoryFilter
     property bool isCurrent: false
@@ -149,6 +150,7 @@
     ScopeListView {
         id: categoryView
         objectName: "categoryListView"
+        interactive: !forceNonInteractive
 
         x: subPageLoader.open ? -width : 0
         visible: x != -width
@@ -210,10 +212,9 @@
             }
         }
 
-        delegate: ListItems.Base {
+        delegate: DashCategoryBase {
             id: baseItem
             objectName: "dashCategory" + category
-            showDivider: false
 
             property Item seeAllButton: seeAll
 
@@ -236,7 +237,7 @@
             CardTool {
                 id: cardTool
                 objectName: "cardTool"
-                count: results.count
+                count: results ? results.count : 0
                 template: model.renderer
                 components: model.components
                 viewWidth: parent.width

=== modified file 'qml/Dash/PageHeader.qml'
--- qml/Dash/PageHeader.qml	2014-09-18 21:25:41 +0000
+++ qml/Dash/PageHeader.qml	2014-10-14 12:55:09 +0000
@@ -21,6 +21,7 @@
 import Ubuntu.Components.ListItems 1.0
 import "../Components"
 import "../Components/SearchHistoryModel"
+import "../Components/Flickables" as Flickables
 
 Item {
     id: root
@@ -127,7 +128,7 @@
         }
     }
 
-    Flickable {
+    Flickables.Flickable {
         id: headerContainer
         objectName: "headerContainer"
         clip: contentY < height

=== modified file 'qml/Dash/PreviewListView.qml'
--- qml/Dash/PreviewListView.qml	2014-09-18 05:05:56 +0000
+++ qml/Dash/PreviewListView.qml	2014-10-14 12:55:09 +0000
@@ -18,6 +18,7 @@
 import Ubuntu.Components 0.1
 import Unity 0.2
 import "../Components"
+import "../Components/Flickables" as Flickables
 import "Previews" as Previews
 
 Item {
@@ -52,7 +53,7 @@
         onBackClicked: root.backClicked()
     }
 
-    ListView  {
+    Flickables.ListView {
         id: previewListView
         objectName: "listView"
         anchors {
@@ -66,8 +67,6 @@
         snapMode: ListView.SnapOneItem
         boundsBehavior: Flickable.DragAndOvershootBounds
         highlightMoveDuration: 250
-        flickDeceleration: units.gu(625)
-        maximumFlickVelocity: width * 5
         cacheBuffer: 0
 
         property bool open: false

=== modified file 'qml/Dash/Previews/Preview.qml'
--- qml/Dash/Previews/Preview.qml	2014-08-11 18:32:23 +0000
+++ qml/Dash/Previews/Preview.qml	2014-10-14 12:55:09 +0000
@@ -16,6 +16,7 @@
 
 import QtQuick 2.0
 import Ubuntu.Components 0.1
+import "../../Components/Flickables" as Flickables
 
 /*! \brief This component constructs the Preview UI.
  *
@@ -63,7 +64,7 @@
         Repeater {
             model: previewModel
 
-            delegate: ListView {
+            delegate: Flickables.ListView {
                 id: column
                 anchors { top: parent.top; bottom: parent.bottom }
                 width: row.columnWidth

=== modified file 'qml/Dash/Previews/PreviewImageGallery.qml'
--- qml/Dash/Previews/PreviewImageGallery.qml	2014-09-30 08:12:23 +0000
+++ qml/Dash/Previews/PreviewImageGallery.qml	2014-10-14 12:55:09 +0000
@@ -17,6 +17,7 @@
 import QtQuick 2.0
 import Ubuntu.Components 1.1
 import "../../Components"
+import "../../Components/Flickables" as Flickables
 
 /*! This preview widget shows a horizontal list of images.
  *  The URIs for the images should be an array in widgetData["sources"].
@@ -28,7 +29,7 @@
 
     property Item rootItem: QuickUtils.rootItem(root)
 
-    ListView {
+    Flickables.ListView {
         id: previewImageListView
         objectName: "previewImageListView"
         spacing: units.gu(1)
@@ -102,7 +103,7 @@
             UbuntuNumberAnimation { duration: UbuntuAnimation.FastDuration }
         }
 
-        ListView  {
+        Flickables.ListView {
             id: slideShowListView
             objectName: "slideShowListView"
             anchors.fill: parent

=== modified file 'qml/Dash/Previews/PreviewTextSummary.qml'
--- qml/Dash/Previews/PreviewTextSummary.qml	2014-08-13 10:29:21 +0000
+++ qml/Dash/Previews/PreviewTextSummary.qml	2014-10-14 12:55:09 +0000
@@ -63,7 +63,7 @@
         lineHeight: 1.2
         color: root.scopeStyle ? root.scopeStyle.foreground : Theme.palette.normal.baseText
         opacity: .8
-        text: widgetData["text"]
+        text: widgetData["text"] || ""
         wrapMode: Text.Wrap
 
         Behavior on height {

=== modified file 'qml/Dash/ScopeListView.qml'
--- qml/Dash/ScopeListView.qml	2014-08-26 09:44:35 +0000
+++ qml/Dash/ScopeListView.qml	2014-10-14 12:55:09 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2014 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,11 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import QtQuick 2.0
-import Dash 0.1
+import "../Components/Flickables" as Flickables
 
-ListViewWithPageHeader {
-    maximumFlickVelocity: height * 10
-    flickDeceleration: height * 2
+Flickables.ListViewWithPageHeader {
     cacheBuffer: Number.MAX_VALUE
 }

=== modified file 'qml/Dash/ScopeSettingsPage.qml'
--- qml/Dash/ScopeSettingsPage.qml	2014-09-30 15:02:23 +0000
+++ qml/Dash/ScopeSettingsPage.qml	2014-10-14 12:55:09 +0000
@@ -18,6 +18,7 @@
 import Ubuntu.Components 1.1
 import Unity 0.2
 import "../Components"
+import "../Components/Flickables" as Flickables
 import "ScopeSettings"
 
 Item {
@@ -39,7 +40,7 @@
         onBackClicked: root.backClicked()
     }
 
-    ListView {
+    Flickables.ListView {
         id: scopeSettings
         objectName: "scopeSettings"
         anchors {

=== modified file 'qml/Dash/ScopesOverviewAll.qml'
--- qml/Dash/ScopesOverviewAll.qml	2014-09-19 10:36:07 +0000
+++ qml/Dash/ScopesOverviewAll.qml	2014-10-14 12:55:09 +0000
@@ -16,8 +16,9 @@
 
 import QtQuick 2.0
 import Ubuntu.Components 0.1
+import "../Components/Flickables" as Flickables
 
-Flickable {
+Flickables.Flickable {
     id: root
 
     property alias model: cardGrid.model

=== modified file 'qml/Dash/ScopesOverviewFavorites.qml'
--- qml/Dash/ScopesOverviewFavorites.qml	2014-09-04 16:54:15 +0000
+++ qml/Dash/ScopesOverviewFavorites.qml	2014-10-14 12:55:09 +0000
@@ -14,9 +14,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import QtQuick 2.0
+import QtQuick 2.3
+import Ubuntu.Components 1.1
+import "../Components/Flickables" as Flickables
 
-Flickable {
+Flickables.Flickable {
     id: root
 
     signal clicked(int index, var result, var itemModel)

=== modified file 'qml/Greeter/LoginList.qml'
--- qml/Greeter/LoginList.qml	2014-10-08 19:17:28 +0000
+++ qml/Greeter/LoginList.qml	2014-10-14 12:55:09 +0000
@@ -18,6 +18,7 @@
 import Ubuntu.Components 0.1
 import LightDM 0.1 as LightDM
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 Item {
     id: root
@@ -68,7 +69,7 @@
         antialiasing: true
     }
 
-    ListView {
+    Flickables.ListView {
         id: userList
         objectName: "userList"
 
@@ -78,7 +79,6 @@
         preferredHighlightEnd: userList.height / 2 - root.highlightedHeight / 2
         highlightRangeMode: ListView.StrictlyEnforceRange
         highlightMoveDuration: root.moveDuration
-        flickDeceleration: 10000
 
         readonly property bool movingInternally: moveTimer.running || userList.moving
 

=== modified file 'qml/Hud/Hud.qml'
--- qml/Hud/Hud.qml	2014-06-11 15:36:51 +0000
+++ qml/Hud/Hud.qml	2014-10-14 12:55:09 +0000
@@ -19,6 +19,7 @@
 import HudClient 0.1
 
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 Item {
     id: hud
@@ -400,7 +401,7 @@
                     }
                     progress: MathUtils.clamp((y - hudShowable.y + height - units.gu(8))/elementsYSliding, 0, 1)
 
-                    Flickable {
+                    Flickables.Flickable {
                         anchors.left: parent.left
                         anchors.right: parent.right
                         contentHeight: resultList.height

=== modified file 'qml/Hud/HudParametrizedActionsPage.qml'
--- qml/Hud/HudParametrizedActionsPage.qml	2014-08-13 11:56:16 +0000
+++ qml/Hud/HudParametrizedActionsPage.qml	2014-10-14 12:55:09 +0000
@@ -18,6 +18,7 @@
 import Ubuntu.Components 1.1
 import Ubuntu.Components.Themes.Ambiance 1.1
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 Item {
     property alias header: header.title
@@ -74,7 +75,7 @@
         return values
     }
 
-    Flickable {
+    Flickables.Flickable {
         anchors.top: parent.top
         anchors.bottom: buttons.top
         anchors.left: parent.left

=== modified file 'qml/Launcher/Launcher.qml'
--- qml/Launcher/Launcher.qml	2014-10-06 16:39:10 +0000
+++ qml/Launcher/Launcher.qml	2014-10-14 12:55:09 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2014 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -76,6 +76,7 @@
 
     Timer {
         id: dismissTimer
+        objectName: "dismissTimer"
         interval: 5000
         onTriggered: {
             if (!panel.preventHiding) {
@@ -218,6 +219,7 @@
 
     EdgeDragArea {
         id: dragArea
+        objectName: "launcherDragArea"
 
         direction: Direction.Rightwards
 

=== modified file 'qml/Launcher/LauncherDelegate.qml'
--- qml/Launcher/LauncherDelegate.qml	2014-10-07 11:11:09 +0000
+++ qml/Launcher/LauncherDelegate.qml	2014-10-14 12:55:09 +0000
@@ -27,7 +27,6 @@
     property bool itemFocused: false
     property real maxAngle: 0
     property bool inverted: false
-    property alias pinned: pin.visible
 
     readonly property int effectiveHeight: Math.cos(angle * Math.PI / 180) * itemHeight
     readonly property real foldedHeight: Math.cos(maxAngle * Math.PI / 180) * itemHeight
@@ -71,31 +70,15 @@
             height: root.itemHeight - units.gu(1)
         }
 
-        Rectangle {
-            id: pin
-            anchors {
-                left: iconShape.left
-                top: iconShape.top
-                topMargin: -units.dp(2)
-            }
-            width: units.gu(1)
-            height: width
-            radius: width / 2
-            color: "white"
-        }
-
         UbuntuShape {
             id: countEmblem
             objectName: "countEmblem"
-
-            readonly property real pinMargin: pin.visible ? pin.width + units.gu(1) - anchors.leftMargin : 0
-
             anchors {
                 right: parent.right
                 top: parent.top
                 margins: units.dp(3)
             }
-            width: Math.min(root.itemWidth - pinMargin, Math.max(units.gu(2), countLabel.implicitWidth + units.gu(1)))
+            width: Math.min(root.itemWidth, Math.max(units.gu(2), countLabel.implicitWidth + units.gu(1)))
             height: units.gu(2)
             color: UbuntuColors.orange
             visible: root.countVisible
@@ -109,7 +92,7 @@
                 // FIXME: verticalCenter seems to be off wee bit and QML doesn't have a centerLine
                 // property for Text: https://bugreports.qt-project.org/browse/QTBUG-40479
                 anchors.verticalCenterOffset: -units.dp(.5)
-                width: root.itemWidth - units.gu(1) - countEmblem.pinMargin
+                width: root.itemWidth - units.gu(1)
                 horizontalAlignment: Text.AlignHCenter
                 elide: Text.ElideRight
                 color: "white"

=== modified file 'qml/Launcher/LauncherPanel.qml'
--- qml/Launcher/LauncherPanel.qml	2014-10-07 08:25:59 +0000
+++ qml/Launcher/LauncherPanel.qml	2014-10-14 12:55:09 +0000
@@ -21,6 +21,7 @@
 import Ubuntu.Components.Popups 0.1
 import "../Components/ListItems"
 import "../Components/"
+import "../Components/Flickables" as Flickables
 
 Rectangle {
     id: root
@@ -45,6 +46,7 @@
         }
 
         Rectangle {
+            objectName: "buttonShowDashHome"
             width: parent.width
             height: units.gu(7)
             color: UbuntuColors.orange
@@ -74,7 +76,7 @@
                 anchors.fill: parent
                 clip: true
 
-                ListView {
+                Flickables.ListView {
                     id: launcherListView
                     objectName: "launcherListView"
                     anchors {
@@ -149,7 +151,6 @@
                         count: model.count
                         countVisible: model.countVisible
                         progress: model.progress
-                        pinned: model.pinned
                         itemFocused: model.focused
                         inverted: root.inverted
                         z: -Math.abs(offset)
@@ -460,10 +461,6 @@
                 width: itemWidth
                 rotation: root.rotation
                 itemOpacity: 0.9
-                pinned: dndArea.draggedIndex > -1 &&
-                        LauncherModel.get(dndArea.draggedIndex).pinned &&
-                        !dndArea.preDragging &&
-                        !dndArea.dragging
 
                 function flatten() {
                     fakeDragItemAnimation.start();

=== modified file 'qml/Notifications/Notification.qml'
--- qml/Notifications/Notification.qml	2014-09-18 21:25:00 +0000
+++ qml/Notifications/Notification.qml	2014-10-14 12:55:09 +0000
@@ -20,6 +20,7 @@
 import Unity.Notifications 1.0
 import QMenuModel 0.1
 import Utils 0.1
+import "../Components/Flickables" as Flickables
 
 import Ubuntu.Components.ListItems 0.1 as ListItem
 
@@ -455,7 +456,7 @@
                 onClicked: notification.notification.invokeAction(comboRepeater.itemAt(2).actionId)
                 expanded: false
                 expandedHeight: (comboRepeater.count - 2) * units.gu(4) + units.gu(.5)
-                comboList: Flickable {
+                comboList: Flickables.Flickable {
                     // this has to be wrapped inside a flickable
                     // to work around a feature/bug? of the
                     // ComboButton SDK-element, making a regular

=== modified file 'qml/Notifications/Notifications.qml'
--- qml/Notifications/Notifications.qml	2014-08-25 11:31:05 +0000
+++ qml/Notifications/Notifications.qml	2014-10-14 12:55:09 +0000
@@ -19,8 +19,9 @@
 import Unity.Notifications 1.0 as UnityNotifications
 import Utils 0.1
 import "../Components"
+import "../Components/Flickables" as Flickables
 
-ListView {
+Flickables.ListView {
     id: notificationList
 
     objectName: "notificationList"

=== modified file 'qml/Panel/IndicatorRow.qml'
--- qml/Panel/IndicatorRow.qml	2014-05-07 13:59:58 +0000
+++ qml/Panel/IndicatorRow.qml	2014-10-14 12:55:09 +0000
@@ -18,6 +18,7 @@
 import Ubuntu.Components 0.1
 import Unity.Indicators 0.1 as Indicators
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 Item {
     id: indicatorRow
@@ -60,7 +61,7 @@
         }
     }
 
-    ListView {
+    Flickables.ListView {
         id: itemView
         objectName: "indicatorRowItems"
         interactive: false

=== modified file 'qml/Panel/Indicators/DefaultIndicatorPage.qml'
--- qml/Panel/Indicators/DefaultIndicatorPage.qml	2014-09-29 10:24:58 +0000
+++ qml/Panel/Indicators/DefaultIndicatorPage.qml	2014-10-14 12:55:09 +0000
@@ -21,6 +21,7 @@
 import QtQuick 2.0
 import Ubuntu.Components 0.1 as Components
 import Unity.Indicators 0.1 as Indicators
+import "../../Components/Flickables" as Flickables
 
 IndicatorBase {
     id: main
@@ -65,7 +66,7 @@
         }
     }
 
-    ListView {
+    Flickables.ListView {
         id: mainMenu
         objectName: "mainMenu"
         model: menuStack.rootMenu

=== modified file 'qml/Panel/Indicators/client/IndicatorsList.qml'
--- qml/Panel/Indicators/client/IndicatorsList.qml	2014-01-30 14:54:01 +0000
+++ qml/Panel/Indicators/client/IndicatorsList.qml	2014-10-14 12:55:09 +0000
@@ -22,6 +22,7 @@
 import Ubuntu.Components.ListItems 0.1 as ListItem
 import Unity.Indicators 0.1 as Indicators
 import "../.."
+import "../../../Components/Flickables" as Flickables
 
 Page {
     id: page
@@ -35,7 +36,7 @@
         Component.onCompleted: load(profile)
     }
 
-    ListView {
+    Flickables.ListView {
         id: mainMenu
         objectName: "mainMenu"
         anchors.fill: parent

=== modified file 'qml/Panel/Indicators/client/IndicatorsTree.qml'
--- qml/Panel/Indicators/client/IndicatorsTree.qml	2013-11-24 02:23:56 +0000
+++ qml/Panel/Indicators/client/IndicatorsTree.qml	2014-10-14 12:55:09 +0000
@@ -22,6 +22,7 @@
 import Unity.Indicators 0.1 as Indicators
 import QMenuModel 0.1
 import Ubuntu.Components.ListItems 0.1 as ListItem
+import "../../../Components/Flickables" as Flickables
 
 Page {
     id: page
@@ -52,7 +53,7 @@
         model: unityModel
     }
 
-    Flickable {
+    Flickables.Flickable {
         anchors.fill: parent
         contentHeight: all_data.height
         clip:true

=== modified file 'qml/Panel/MenuContent.qml'
--- qml/Panel/MenuContent.qml	2014-09-29 10:24:58 +0000
+++ qml/Panel/MenuContent.qml	2014-10-14 12:55:09 +0000
@@ -20,6 +20,7 @@
 import Unity.Indicators 0.1 as Indicators
 import Utils 0.1
 import "../Components"
+import "../Components/Flickables" as Flickables
 import "Indicators"
 
 Rectangle {
@@ -39,7 +40,7 @@
         listViewHeader.currentIndex = index;
     }
 
-    ListView {
+    Flickables.ListView {
         id: listViewHeader
         objectName: "indicatorsHeaderListView"
         model: content.indicatorsModel
@@ -80,7 +81,7 @@
         }
     }
 
-    ListView {
+    Flickables.ListView {
         id: listViewContent
         objectName: "indicatorsContentListView"
         anchors {

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2014-10-08 20:36:48 +0000
+++ qml/Shell.qml	2014-10-14 12:55:09 +0000
@@ -53,7 +53,9 @@
     property url background
     readonly property real panelHeight: panel.panelHeight
 
-    readonly property bool locked: LightDM.Greeter.active && !LightDM.Greeter.authenticated
+    readonly property bool locked: LightDM.Greeter.active && !LightDM.Greeter.authenticated && !forcedUnlock
+    readonly property bool forcedUnlock: edgeDemo.running
+    onForcedUnlockChanged: if (forcedUnlock) lockscreen.hide()
 
     property bool sideStageEnabled: shell.width >= units.gu(100)
     readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId
@@ -87,11 +89,13 @@
         }
     }
 
-    function setLockedApp(app) {
-        if (shell.locked) {
-            greeter.lockedApp = app
-            lockscreen.hide()
+    function startLockedApp(app) {
+        if (!shell.locked) {
+            console.warn("Called startLockedApp(%1) when not locked, ignoring".arg(app))
+            return
         }
+        greeter.lockedApp = app
+        shell.activateApplication(app)
     }
 
     Binding {
@@ -170,12 +174,18 @@
             target: ApplicationManager
             onFocusRequested: {
                 if (greeter.narrowMode) {
-                    if (appId === "dialer-app") {
-                        // Always let the dialer-app through.  Either user asked
-                        // for an emergency call or accepted an incoming call.
-                        setLockedApp(appId)
-                    } else if (greeter.hasLockedApp && greeter.lockedApp !== appId) {
-                        greeter.startUnlock()
+                    if (appId === "dialer-app" && callManager.hasCalls) {
+                        // If we are in the middle of a call, make dialer lockedApp and show it.
+                        // This can happen if user backs out of dialer back to greeter, then
+                        // launches dialer again.
+                        greeter.lockedApp = appId;
+                    }
+                    if (greeter.hasLockedApp) {
+                        if (appId === greeter.lockedApp) {
+                            lockscreen.hide() // show locked app
+                        } else {
+                            greeter.startUnlock() // show lockscreen if necessary
+                        }
                     }
                     greeter.hide();
                 } else {
@@ -196,10 +206,8 @@
                 if (greeter.shown && appId != "unity8-dash") {
                     greeter.startUnlock()
                 }
-                if (greeter.narrowMode && appId === "dialer-app") {
-                    // Always let the dialer-app through.  Either user asked
-                    // for an emergency call or accepted an incoming call.
-                    setLockedApp(appId)
+                if (greeter.narrowMode && greeter.hasLockedApp && appId === greeter.lockedApp) {
+                    lockscreen.hide() // show locked app
                 }
                 launcher.hide();
             }
@@ -325,10 +333,16 @@
 
         onEntered: LightDM.Greeter.respond(passphrase);
         onCancel: greeter.show()
-        onEmergencyCall: shell.activateApplication("dialer-app") // will automatically enter locked-app mode
+        onEmergencyCall: startLockedApp("dialer-app")
 
         onShownChanged: if (shown) greeter.lockedApp = ""
 
+        function maybeShow() {
+            if (!shell.forcedUnlock) {
+                show()
+            }
+        }
+
         Timer {
             id: forcedDelayTimer
             interval: 1000 * 60
@@ -371,7 +385,7 @@
                     lockscreen.errorText = i18n.tr("Sorry, incorrect %1").arg(text.toLowerCase())
                 }
 
-                lockscreen.show();
+                lockscreen.maybeShow();
             }
         }
 
@@ -381,7 +395,7 @@
                     lockscreen.hide()
                 } else {
                     lockscreen.reset();
-                    lockscreen.show();
+                    lockscreen.maybeShow();
                 }
             }
         }
@@ -460,14 +474,14 @@
             // Wait until the greeter is completely covering lockscreen before resetting it.
             if (greeter.narrowMode && fullyShown && !LightDM.Greeter.authenticated) {
                 lockscreen.reset();
-                lockscreen.show();
+                lockscreen.maybeShow();
             }
         }
 
         readonly property real showProgress: MathUtils.clamp((1 - x/width) + greeter.showProgress - 1, 0, 1)
         onShowProgressChanged: {
             if (showProgress === 0) {
-                if (LightDM.Greeter.promptless && LightDM.Greeter.authenticated) {
+                if ((LightDM.Greeter.promptless && LightDM.Greeter.authenticated) || shell.forcedUnlock) {
                     greeter.login()
                 } else if (greeter.narrowMode) {
                     lockscreen.clear(false) // to reset focus if necessary
@@ -501,7 +515,7 @@
             function startUnlock() {
                 if (narrowMode) {
                     if (!LightDM.Greeter.authenticated) {
-                        lockscreen.show()
+                        lockscreen.maybeShow()
                     }
                     hide()
                 } else {
@@ -557,6 +571,25 @@
     }
 
     Connections {
+        id: callConnection
+        target: callManager
+
+        onHasCallsChanged: {
+            if (shell.locked && callManager.hasCalls) {
+                // We just received an incoming call while locked.  The
+                // indicator will have already launched dialer-app for us, but
+                // there is a race between "hasCalls" changing and the dialer
+                // starting up.  So in case we lose that race, we'll start/
+                // focus the dialer ourselves here too.  Even if the indicator
+                // didn't launch the dialer for some reason (or maybe a call
+                // started via some other means), if an active call is
+                // happening, we want to be in the dialer.
+                startLockedApp("dialer-app")
+            }
+        }
+    }
+
+    Connections {
         id: powerConnection
         target: Powerd
 
@@ -725,6 +758,7 @@
 
     EdgeDemo {
         id: edgeDemo
+        objectName: "edgeDemo"
         z: alphaDisclaimerLabel.z + 10
         paused: Powerd.status === Powerd.Off // Saves power
         greeter: greeter

=== modified file 'qml/Stages/ApplicationWindow.qml'
--- qml/Stages/ApplicationWindow.qml	2014-09-19 11:20:07 +0000
+++ qml/Stages/ApplicationWindow.qml	2014-10-14 12:55:09 +0000
@@ -61,14 +61,6 @@
         // Remove this when possible
         property bool surfaceInitialized: false
 
-        function forceSurfaceActiveFocusIfReady() {
-            if (sessionContainer.surface !== null &&
-                    sessionContainer.surface.focus &&
-                    sessionContainer.surface.parent === sessionContainer.surfaceContainer &&
-                    sessionContainer.surface.enabled) {
-                sessionContainer.surface.forceActiveFocus();
-            }
-        }
     }
 
     Timer {
@@ -77,15 +69,6 @@
         onTriggered: { if (sessionContainer.surface) {d.surfaceInitialized = true;} }
     }
 
-    Connections {
-        target: sessionContainer.surface
-        // FIXME: I would rather not need to do this, but currently it doesn't get
-        // active focus without it and I don't know why.
-        onFocusChanged: d.forceSurfaceActiveFocusIfReady();
-        onParentChanged: d.forceSurfaceActiveFocusIfReady();
-        onEnabledChanged: d.forceSurfaceActiveFocusIfReady();
-    }
-
     Image {
         id: screenshotImage
         objectName: "screenshotImage"
@@ -132,7 +115,6 @@
         onSurfaceChanged: {
             if (sessionContainer.surface) {
                 surfaceInitTimer.start();
-                d.forceSurfaceActiveFocusIfReady();
             } else {
                 d.surfaceInitialized = false;
             }

=== modified file 'qml/Stages/PhoneStage.qml'
--- qml/Stages/PhoneStage.qml	2014-10-07 18:18:44 +0000
+++ qml/Stages/PhoneStage.qml	2014-10-14 12:55:09 +0000
@@ -21,6 +21,7 @@
 import Unity.Session 0.1
 import Utils 0.1
 import "../Components"
+import "../Components/Flickables" as Flickables
 
 Rectangle {
     id: root
@@ -120,7 +121,7 @@
 
     }
 
-    Flickable {
+    Flickables.Flickable {
         id: spreadView
         objectName: "spreadView"
         anchors.fill: parent
@@ -131,7 +132,7 @@
 
         // This indicates when the spreadView is active. That means, all the animations
         // are activated and tiles need to line up for the spread.
-        readonly property bool active: shiftedContentX > 0 || spreadDragArea.dragging
+        readonly property bool active: shiftedContentX > 0 || spreadDragArea.status === DirectionalDragArea.Recognized
 
         // The flickable needs to fill the screen in order to get touch events all over.
         // However, we don't want to the user to be able to scroll back all the way. For
@@ -418,6 +419,7 @@