Merge lp:~osomon/webbrowser-app/use-uitk-swipearea into lp:webbrowser-app

[Olivier Tilloy]

Use the UITK’s SwipeArea component for the bottom edge gesture recognition.
This requires oxide 1.14 to work well (because of bug #1459362).

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1393
http://jenkins.qa.ubuntu.com/job/webbrowser-app-ci/2678/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/6790
    SUCCESS: http://jenkins.qa.ubuntu.com/job/webbrowser-app-vivid-amd64-ci/1431
    SUCCESS: http://jenkins.qa.ubuntu.com/job/webbrowser-app-vivid-armhf-ci/1431
        deb: http://jenkins.qa.ubuntu.com/job/webbrowser-app-vivid-armhf-ci/1431/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/webbrowser-app-vivid-i386-ci/1431
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-touch/5145
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/6801
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/6801/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/28052

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/webbrowser-app-ci/2678/rebuild

review: Needs Fixing (continuous-integration)

[system-apps-ci-bot (system-apps-ci-bot)]

FAILED: Continuous integration, rev:1393
https://jenkins.canonical.com/system-apps/job/lp-webbrowser-app-ci/91/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/system-apps/job/build/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-0-fetch/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-1-sourcepkg/release=vivid+overlay/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-1-sourcepkg/release=xenial/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=vivid+overlay/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=vivid+overlay/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=vivid+overlay/91/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial/91/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-webbrowser-app-ci/91/rebuild

review: Needs Fixing (continuous-integration)

[lp:~osomon/webbrowser-app/use-uitk-swipearea]

1394. By Olivier Tilloy on 2016-04-12

Merge the latest changes from trunk and resolve conflicts.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1394
http://jenkins.qa.ubuntu.com/job/webbrowser-app-ci/2688/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/6814/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/webbrowser-app-vivid-amd64-ci/1442/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/webbrowser-app-vivid-armhf-ci/1442/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/webbrowser-app-vivid-i386-ci/1442/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/6825/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/webbrowser-app-ci/2688/rebuild

review: Needs Fixing (continuous-integration)

[system-apps-ci-bot (system-apps-ci-bot)]

FAILED: Continuous integration, rev:1394
https://jenkins.canonical.com/system-apps/job/lp-webbrowser-app-ci/350/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/system-apps/job/build/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-0-fetch/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-1-sourcepkg/release=vivid+overlay/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-1-sourcepkg/release=xenial/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=vivid+overlay/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=amd64,release=xenial/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=vivid+overlay/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=armhf,release=xenial/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=vivid+overlay/350/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-2-binpkg/arch=i386,release=xenial/350/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-webbrowser-app-ci/350/rebuild

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-09-07 10:37:42 +0000
+++ CMakeLists.txt	2016-04-12 20:15:29 +0000
@@ -34,7 +34,6 @@
     ENABLE_COVERAGE_REPORT(EXCLUDES tests/*|.*moc_.*.cpp FILTER tests/* moc_*.cpp)
 endif()
 
-# for unity8 components
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 
 # enable QML debugging

=== modified file 'debian/control'
--- debian/control	2016-04-08 17:06:09 +0000
+++ debian/control	2016-04-12 20:15:29 +0000
@@ -29,7 +29,6 @@
                qtbase5-dev-tools,
                qtbase5-private-dev,
                qtdeclarative5-dev,
-               qtdeclarative5-private-dev,
                qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3),
                xvfb,
 Standards-Version: 3.9.6

=== modified file 'src/app/CMakeLists.txt'
--- src/app/CMakeLists.txt	2016-03-29 11:01:18 +0000
+++ src/app/CMakeLists.txt	2016-04-12 20:15:29 +0000
@@ -32,8 +32,7 @@
 
 add_library(${COMMONLIB} STATIC ${COMMONLIB_SRC})
 
-include_directories(${unity8_SOURCE_DIR}/libs/UbuntuGestures
-                    ${unity8_SOURCE_DIR}/plugins
+include_directories(${unity8_SOURCE_DIR}/plugins
                     ${LIBAPPARMOR_INCLUDE_DIRS}
                     ${Qt5Gui_PRIVATE_INCLUDE_DIRS})
 target_link_libraries(${COMMONLIB}
@@ -43,7 +42,6 @@
     Qt5::Qml
     Qt5::Quick
     Qt5::Widgets
-    UbuntuGesturesQml
     InputInfo
     ${LIBAPPARMOR_LDFLAGS}
 )

=== modified file 'src/app/browserapplication.cpp'
--- src/app/browserapplication.cpp	2016-03-29 11:01:18 +0000
+++ src/app/browserapplication.cpp	2016-04-12 20:15:29 +0000
@@ -42,9 +42,6 @@
 #include "session-storage.h"
 #include "webbrowser-window.h"
 
-#include "TouchRegistry.h"
-#include "Ubuntu/Gestures/Direction.h"
-#include "Ubuntu/Gestures/DirectionalDragArea.h"
 #include "Unity/InputInfo/qdeclarativeinputdevicemodel_p.h"
 
 BrowserApplication::BrowserApplication(int& argc, char** argv)
@@ -117,7 +114,6 @@
 
 MAKE_SINGLETON_FACTORY(MemInfo)
 MAKE_SINGLETON_FACTORY(MimeDatabase)
-MAKE_SINGLETON_FACTORY(Direction)
 
 
 bool BrowserApplication::initialize(const QString& qmlFileSubPath)
@@ -182,10 +178,6 @@
     qmlRegisterType<SessionStorage>(uri, 0, 1, "SessionStorage");
     qmlRegisterType<QQuickShortcut>(uri, 0, 1, "Shortcut");
 
-    const char* gesturesUri = "Ubuntu.Gestures";
-    qmlRegisterSingletonType<Direction>(gesturesUri, 0, 1, "Direction", Direction_singleton_factory);
-    qmlRegisterType<DirectionalDragArea>(gesturesUri, 0, 1, "DirectionalDragArea");
-
     const char* inputInfoUri = "Unity.InputInfo";
     qmlRegisterType<QDeclarativeInputDeviceModel>(inputInfoUri, 0, 1, "InputDeviceModel");
     qmlRegisterType<QInputDevice>(inputInfoUri, 0, 1, "InputInfo");
@@ -215,8 +207,6 @@
     m_window = qobject_cast<QQuickWindow*>(browser);
     m_webbrowserWindowProxy->setWindow(m_window);
 
-    m_window->installEventFilter(new TouchRegistry(this));
-
     browser->setProperty("developerExtrasEnabled", inspectorEnabled);
     browser->setProperty("forceFullscreen", m_arguments.contains("--fullscreen"));
 

=== modified file 'src/app/unity8/CMakeLists.txt'
--- src/app/unity8/CMakeLists.txt	2015-02-04 10:56:38 +0000
+++ src/app/unity8/CMakeLists.txt	2016-04-12 20:15:29 +0000
@@ -1,4 +1,3 @@
 project(unity8)
 
-add_subdirectory(libs)
 add_subdirectory(plugins)

=== modified file 'src/app/unity8/README'
--- src/app/unity8/README	2016-01-28 13:51:25 +0000
+++ src/app/unity8/README	2016-04-12 20:15:29 +0000
@@ -1,9 +1,5 @@
 Code in this directory was copied over from unity8.
 
-Ubuntu.Gestures:
- - first import: 2015-02-04, at revision 1583 of lp:unity8
- - last sync: 2015-03-17, at revision 1663 of lp:unity8
-
 Unity.InputInfo:
  - first import: 2016-01-28, at revision 2143 of lp:unity8
 
@@ -11,9 +7,5 @@
 code in the future. Minor changes were made to the build system to integrate it
 with the existing webbrowser-app code base.
 
-As of 2015-12-09, the SwipeArea component is available in the UITK, so we should
-start using it instead of building a local copy of Ubuntu.Gestures. This is
-currently blocked on https://launchpad.net/bugs/1459362.
-
 The Unity.InputInfo plugin should be replaced by an upstream Qt API in the near
 future.

=== removed directory 'src/app/unity8/libs'
=== removed file 'src/app/unity8/libs/CMakeLists.txt'
--- src/app/unity8/libs/CMakeLists.txt	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-add_subdirectory(UbuntuGestures)

=== removed directory 'src/app/unity8/libs/UbuntuGestures'
=== removed file 'src/app/unity8/libs/UbuntuGestures/CMakeLists.txt'
--- src/app/unity8/libs/UbuntuGestures/CMakeLists.txt	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-# 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 STATIC ${UbuntuGestures_SOURCES})
-
-qt5_use_modules(UbuntuGestures Core Quick)
-
-# So that Foo.cpp can #include "Foo.moc"
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
-
-# 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}
-)

=== removed file 'src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.cpp'
--- src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.cpp	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-/*
- * 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

=== removed file 'src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.h'
--- src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.h	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
-/*
- * 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

=== removed file 'src/app/unity8/libs/UbuntuGestures/DebugHelpers.cpp'
--- src/app/unity8/libs/UbuntuGestures/DebugHelpers.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/DebugHelpers.cpp	1970-01-01 00:00:00 +0000
@@ -1,95 +0,0 @@
-/*
- * 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>
-#include <QMouseEvent>
-
-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;
-}
-
-QString mouseEventToString(const QMouseEvent *ev)
-{
-    QString message;
-
-    switch (ev->type()) {
-    case QEvent::MouseButtonPress:
-        message.append("MouseButtonPress ");
-        break;
-    case QEvent::MouseButtonRelease:
-        message.append("MouseButtonRelease ");
-        break;
-    case QEvent::MouseButtonDblClick:
-        message.append("MouseButtonDblClick ");
-        break;
-    case QEvent::MouseMove:
-        message.append("MouseMove ");
-        break;
-    default:
-        message.append("INVALID_MOUSE_EVENT_TYPE ");
-    }
-
-    message.append(QString("pos(%1, %2)").arg(ev->x()).arg(ev->y()));
-
-    return message;
-}

=== removed file 'src/app/unity8/libs/UbuntuGestures/DebugHelpers.h'
--- src/app/unity8/libs/UbuntuGestures/DebugHelpers.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/DebugHelpers.h	1970-01-01 00:00:00 +0000
@@ -1,31 +0,0 @@
-/*
- * 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 QMouseEvent;
-class QTouchEvent;
-
-UBUNTUGESTURES_EXPORT QString touchPointStateToString(Qt::TouchPointState state);
-UBUNTUGESTURES_EXPORT QString touchEventToString(const QTouchEvent *ev);
-UBUNTUGESTURES_EXPORT QString mouseEventToString(const QMouseEvent *ev);
-
-#endif // UBUNTUGESTURES_DEBUG_HELPER_H

=== removed file 'src/app/unity8/libs/UbuntuGestures/Pool.h'
--- src/app/unity8/libs/UbuntuGestures/Pool.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/Pool.h	1970-01-01 00:00:00 +0000
@@ -1,132 +0,0 @@
-/*
- * 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;
-    };
-
-    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

=== removed file 'src/app/unity8/libs/UbuntuGestures/Timer.cpp'
--- src/app/unity8/libs/UbuntuGestures/Timer.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/Timer.cpp	1970-01-01 00:00:00 +0000
@@ -1,109 +0,0 @@
-/*
- * 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

=== removed file 'src/app/unity8/libs/UbuntuGestures/Timer.h'
--- src/app/unity8/libs/UbuntuGestures/Timer.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/Timer.h	1970-01-01 00:00:00 +0000
@@ -1,105 +0,0 @@
-/*
- * 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

=== removed file 'src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.cpp'
--- src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.cpp	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-/*
- * 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;
-}

=== removed file 'src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.h'
--- src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.h	1970-01-01 00:00:00 +0000
@@ -1,50 +0,0 @@
-/*
- * 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

=== removed file 'src/app/unity8/libs/UbuntuGestures/TouchRegistry.cpp'
--- src/app/unity8/libs/UbuntuGestures/TouchRegistry.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/TouchRegistry.cpp	1970-01-01 00:00:00 +0000
@@ -1,500 +0,0 @@
-/*
- * 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);
-    }
-}

=== removed file 'src/app/unity8/libs/UbuntuGestures/TouchRegistry.h'
--- src/app/unity8/libs/UbuntuGestures/TouchRegistry.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/TouchRegistry.h	1970-01-01 00:00:00 +0000
@@ -1,182 +0,0 @@
-/*
- * 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

=== removed file 'src/app/unity8/libs/UbuntuGestures/UbuntuGesturesGlobal.h'
--- src/app/unity8/libs/UbuntuGestures/UbuntuGesturesGlobal.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/UbuntuGesturesGlobal.h	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-/*
- * 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

=== removed file 'src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.cpp'
--- src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.cpp	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-/*
- * 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();
-}

=== removed file 'src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.h'
--- src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.h	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-/*
- * 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 'src/app/unity8/plugins/CMakeLists.txt'
--- src/app/unity8/plugins/CMakeLists.txt	2016-01-28 13:51:25 +0000
+++ src/app/unity8/plugins/CMakeLists.txt	2016-04-12 20:15:29 +0000
@@ -1,2 +1,1 @@
-add_subdirectory(Ubuntu)
 add_subdirectory(Unity)

=== removed directory 'src/app/unity8/plugins/Ubuntu'
=== removed file 'src/app/unity8/plugins/Ubuntu/CMakeLists.txt'
--- src/app/unity8/plugins/Ubuntu/CMakeLists.txt	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-add_subdirectory(Gestures)

=== removed directory 'src/app/unity8/plugins/Ubuntu/Gestures'
=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp	1970-01-01 00:00:00 +0000
@@ -1,149 +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 Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the applicable version of the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of both the GNU Lesser General Public
- * License along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- */
-
-#include "AxisVelocityCalculator.h"
-#include <QtCore/QElapsedTimer>
-
-using namespace UbuntuGestures;
-
-AxisVelocityCalculator::AxisVelocityCalculator(QObject *parent)
-    : AxisVelocityCalculator(SharedTimeSource(new RealTimeSource), parent)
-{
-}
-
-AxisVelocityCalculator::AxisVelocityCalculator(const SharedTimeSource &timeSource,
-                                               QObject *parent)
-    : QObject(parent)
-    , m_timeSource(timeSource)
-    , m_trackedPosition(0.0)
-{
-    reset();
-}
-
-AxisVelocityCalculator::~AxisVelocityCalculator()
-{
-}
-
-qreal AxisVelocityCalculator::trackedPosition() const
-{
-    return m_trackedPosition;
-}
-
-void AxisVelocityCalculator::setTrackedPosition(qreal newPosition)
-{
-    processMovement(newPosition - m_trackedPosition);
-
-    if (newPosition != m_trackedPosition) {
-        m_trackedPosition = newPosition;
-        Q_EMIT trackedPositionChanged(newPosition);
-    }
-}
-
-void AxisVelocityCalculator::updateIdleTime()
-{
-    processMovement(0);
-}
-
-void AxisVelocityCalculator::processMovement(qreal movement)
-{
-    if (m_samplesRead == -1) {
-        m_samplesRead = m_samplesWrite;
-    } else if (m_samplesRead == m_samplesWrite) {
-        /* the oldest value is going to be overwritten.
-           so now the oldest will be the next one. */
-        m_samplesRead = (m_samplesRead + 1) % MAX_SAMPLES;
-    }
-
-    m_samples[m_samplesWrite].mov = movement;
-    m_samples[m_samplesWrite].time = m_timeSource->msecsSinceReference();
-    m_samplesWrite = (m_samplesWrite + 1) % MAX_SAMPLES;
-}
-
-qreal AxisVelocityCalculator::calculate()
-{
-    if (numSamples() < MIN_SAMPLES_NEEDED) {
-        return 0.0;
-    }
-    updateIdleTime(); // consider the time elapsed since the last update and now
-
-    int lastIndex;
-    if (m_samplesWrite == 0) {
-        lastIndex = MAX_SAMPLES - 1;
-    } else {
-        lastIndex = m_samplesWrite - 1;
-    }
-
-    qint64 currTime = m_samples[lastIndex].time;
-
-    qreal totalTime = 0;
-    qreal totalDistance = 0;
-
-    int sampleIndex = (m_samplesRead + 1) % MAX_SAMPLES;
-    qint64 previousTime = m_samples[m_samplesRead].time;
-    while (sampleIndex != m_samplesWrite) {
-        // Skip this sample if it's too old
-        if (currTime - m_samples[sampleIndex].time <= AGE_OLDEST_SAMPLE) {
-            int deltaTime = m_samples[sampleIndex].time - previousTime;
-            totalDistance += m_samples[sampleIndex].mov;
-            totalTime += deltaTime;
-        }
-
-        previousTime = m_samples[sampleIndex].time;
-        sampleIndex = (sampleIndex + 1) % MAX_SAMPLES;
-    }
-
-    return totalDistance / totalTime;
-}
-
-void AxisVelocityCalculator::reset()
-{
-    m_samplesRead = -1;
-    m_samplesWrite = 0;
-}
-
-int AxisVelocityCalculator::numSamples() const
-{
-    if (m_samplesRead == -1) {
-        return 0;
-    } else {
-        if (m_samplesWrite == 0) {
-            /* consider only what's to the right of m_samplesRead (including himself) */
-            return MAX_SAMPLES - m_samplesRead;
-        } else if (m_samplesWrite == m_samplesRead) {
-            return MAX_SAMPLES; /* buffer is full */
-        } else if (m_samplesWrite < m_samplesRead) {
-            return (MAX_SAMPLES - m_samplesRead) + m_samplesWrite;
-        } else {
-            return m_samplesWrite - m_samplesRead;
-        }
-    }
-}
-
-void AxisVelocityCalculator::setTimeSource(const SharedTimeSource &timeSource)
-{
-    m_timeSource = timeSource;
-
-    if (numSamples() > 0) {
-        qWarning("AxisVelocityCalculator: changing time source while there are samples present.");
-        // Any existent samples are based on the old time source and are, therefore, incompatible
-        // with this new one.
-        reset();
-    }
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	1970-01-01 00:00:00 +0000
@@ -1,146 +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 Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the applicable version of the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of both the GNU Lesser General Public
- * License along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- */
-
-#ifndef VELOCITY_CALCULATOR_H
-#define VELOCITY_CALCULATOR_H
-
-#include "UbuntuGesturesQmlGlobal.h"
-#include <stdint.h>
-#include <QtCore/QObject>
-#include "TimeSource.h"
-
-/*
-  Estimates the current velocity of a finger based on recent movement along an axis
-
-  Taking an estimate from a reasonable number of samples, instead of only
-  from its last movement, removes wild variations in velocity caused
-  by the jitter normally present in input from a touchscreen.
-
-  Usage example:
-
-    AxisVelocityCalculator {
-        id: velocityCalculator
-        trackedPosition: myMouseArea.mouseX
-    }
-
-    MouseArea {
-        id: myMouseArea
-
-        onReleased: {
-            console.log("Drag velocity along the X axis before release was: "
-                        + velocityCalculator.calculate())
-        }
-    }
- */
-class UBUNTUGESTURESQML_EXPORT AxisVelocityCalculator : public QObject
-{
-    Q_OBJECT
-
-    /*
-        Position whose movement will be tracked to calculate its velocity
-     */
-    Q_PROPERTY(qreal trackedPosition READ trackedPosition WRITE setTrackedPosition
-               NOTIFY trackedPositionChanged)
-public:
-
-    /*
-      Regular, simple, constructor
-     */
-    AxisVelocityCalculator(QObject *parent = 0);
-
-    /*
-      Constructor that takes a TimeSource
-     */
-    AxisVelocityCalculator(const UbuntuGestures::SharedTimeSource &timeSource, QObject *parent = 0);
-
-    virtual ~AxisVelocityCalculator();
-
-    qreal trackedPosition() const;
-    void setTrackedPosition(qreal value);
-
-    /*
-      Calculates the finger velocity, in axis units/millisecond
-    */
-    Q_INVOKABLE qreal calculate();
-
-    /*
-      Removes all stored movements from previous calls to setTrackedPosition()
-    */
-    Q_INVOKABLE void reset();
-
-    int numSamples() const;
-
-    /*
-        Replaces the TimeSource with the given one. Useful for testing purposes.
-     */
-    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
-
-    /*
-        The minimum amount of samples needed for a velocity calculation.
-     */
-    static const int MIN_SAMPLES_NEEDED = 2;
-
-    /*
-      Maximum number of movement samples stored
-    */
-    static const int MAX_SAMPLES = 50;
-
-    /*
-      Age of the oldest sample considered in the velocity calculations, in
-      milliseconds, compared to the most recent one.
-    */
-    static const int AGE_OLDEST_SAMPLE = 100;
-
-Q_SIGNALS:
-    void trackedPositionChanged(qreal value);
-
-private:
-
-    /*
-        Inform that trackedPosition remained motionless since the time it was
-        last changed.
-
-        It's the same as calling setTrackedPosition(trackedPosition())
-     */
-    void updateIdleTime();
-
-    /*
-      How much the finger has moved since processMovement() was last called.
-    */
-    void processMovement(qreal movement);
-
-    class Sample
-    {
-        public:
-            qreal mov; /* movement distance since last sample */
-            qint64 time; /* time, in milliseconds */
-    };
-
-    /* a circular buffer of samples */
-    Sample m_samples[MAX_SAMPLES];
-    int m_samplesRead; /* index of the oldest sample available. -1 if buffer is empty */
-    int m_samplesWrite; /* index where the next sample will be written */
-
-    UbuntuGestures::SharedTimeSource m_timeSource;
-
-    qreal m_trackedPosition;
-};
-
-#endif // VELOCITY_CALCULATOR_H

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/CMakeLists.txt'
--- src/app/unity8/plugins/Ubuntu/Gestures/CMakeLists.txt	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-# 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
-    TouchDispatcher.cpp
-    TouchGate.cpp
-)
-
-add_definitions(-DUBUNTUGESTURESQML_LIBRARY)
-
-add_library(UbuntuGesturesQml STATIC ${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})
-
-include_directories(${unity8_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)
-# TODO

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/Damper.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/Damper.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/Damper.h	1970-01-01 00:00:00 +0000
@@ -1,87 +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/>.
- */
-
-#ifndef UBUNTU_GESTURES_DAMPER_H
-#define UBUNTU_GESTURES_DAMPER_H
-
-#include <QtCore/QPointF>
-
-/*
-  Decreases the oscillations of a value along an axis.
- */
-template <class Type> class Damper {
-public:
-    Damper() : m_value(0), m_maxDelta(0) { }
-
-    // Maximum delta between the raw value and its dampened counterpart.
-    void setMaxDelta(Type maxDelta) {
-        if (maxDelta < 0) qFatal("Damper::maxDelta must be a positive number.");
-        m_maxDelta = maxDelta;
-    }
-    Type maxDelta() const { return m_maxDelta; }
-
-    void reset(Type value) {
-        m_value = value;
-    }
-
-    Type update(Type value) {
-        Type delta = value - m_value;
-        if (delta > 0 && delta > m_maxDelta) {
-            m_value += delta - m_maxDelta;
-        } else if (delta < 0 && delta < -m_maxDelta) {
-            m_value += delta + m_maxDelta;
-        }
-
-        return m_value;
-    }
-
-    Type value() const { return m_value; }
-
-private:
-    Type m_value;
-    Type m_maxDelta;
-};
-
-/*
-    A point that has its movement dampened.
- */
-class DampedPointF {
-public:
-    void setMaxDelta(qreal maxDelta) {
-        m_x.setMaxDelta(maxDelta);
-        m_y.setMaxDelta(maxDelta);
-    }
-
-    qreal maxDelta() const { return m_x.maxDelta(); }
-
-    void reset(const QPointF &point) {
-        m_x.reset(point.x());
-        m_y.reset(point.y());
-    }
-
-    void update(const QPointF &point) {
-        m_x.update(point.x());
-        m_y.update(point.y());
-    }
-
-    qreal x() const { return m_x.value(); }
-    qreal y() const { return m_y.value(); }
-private:
-    Damper<qreal> m_x;
-    Damper<qreal> m_y;
-};
-
-#endif // UBUNTU_GESTURES_DAMPER_H

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/Direction.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/Direction.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/Direction.cpp	1970-01-01 00:00:00 +0000
@@ -1,36 +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/>.
- */
-
-#include "Direction.h"
-
-bool Direction::isHorizontal(Direction::Type type)
-{
-    return type == Direction::Leftwards
-        || type == Direction::Rightwards
-        || type == Direction::Horizontal;
-}
-
-bool Direction::isVertical(Direction::Type type)
-{
-    return type == Direction::Upwards || type == Direction::Downwards;
-}
-
-bool Direction::isPositive(Direction::Type type)
-{
-    return type == Rightwards
-        || type == Downwards
-        || type == Horizontal;
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/Direction.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/Direction.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/Direction.h	1970-01-01 00:00:00 +0000
@@ -1,45 +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/>.
- */
-
-#ifndef DIRECTION_H
-#define DIRECTION_H
-
-#include "UbuntuGesturesQmlGlobal.h"
-#include <QObject>
-
-/*
-    A Direction enum wrapper so that we can do things like "direction: Direction.Righwards"
-    from QML.
- */
-class UBUNTUGESTURESQML_EXPORT Direction : public QObject {
-    Q_OBJECT
-    Q_ENUMS(Type)
-
-public:
-    enum Type {
-        Rightwards, // Along the positive direction of the X axis
-        Leftwards, // Along the negative direction of the X axis
-        Downwards, // Along the positive direction of the Y axis
-        Upwards, // Along the negative direction of the Y axis
-        Horizontal // Along the X axis, in any direction
-    };
-
-    Q_INVOKABLE static bool isHorizontal(Direction::Type type);
-    Q_INVOKABLE static bool isVertical(Direction::Type type);
-    Q_INVOKABLE static bool isPositive(Direction::Type type);
-};
-
-#endif // DIRECTION_H

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	1970-01-01 00:00:00 +0000
@@ -1,886 +0,0 @@
-/*
- * 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
- * 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/>.
- */
-
-#define ACTIVETOUCHESINFO_DEBUG 0
-#define DIRECTIONALDRAGAREA_DEBUG 0
-
-#include "DirectionalDragArea.h"
-
-#include <QQuickWindow>
-#include <QtCore/qmath.h>
-#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;
-
-#if DIRECTIONALDRAGAREA_DEBUG
-#define ddaDebug(params) qDebug().nospace() << "[DDA(" << qPrintable(objectName()) << ")] " << params
-#include "DebugHelpers.h"
-
-namespace {
-const char *statusToString(DirectionalDragArea::Status status)
-{
-    if (status == DirectionalDragArea::WaitingForTouch) {
-        return "WaitingForTouch";
-    } else if (status == DirectionalDragArea::Undecided) {
-        return "Undecided";
-    } else {
-        return "Recognized";
-    }
-}
-
-} // namespace {
-#else // DIRECTIONALDRAGAREA_DEBUG
-#define ddaDebug(params) ((void)0)
-#endif // DIRECTIONALDRAGAREA_DEBUG
-
-
-DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)
-    : QQuickItem(parent)
-    , m_status(WaitingForTouch)
-    , m_sceneDistance(0)
-    , m_touchId(-1)
-    , m_direction(Direction::Rightwards)
-    , m_wideningAngle(0)
-    , m_wideningFactor(0)
-    , m_distanceThreshold(0)
-    , m_distanceThresholdSquared(0.)
-    , m_minSpeed(0)
-    , m_maxSilenceTime(200)
-    , m_silenceTime(0)
-    , m_compositionTime(60)
-    , m_numSamplesOnLastSpeedCheck(0)
-    , m_recognitionTimer(0)
-    , m_velocityCalculator(0)
-    , m_timeSource(new RealTimeSource)
-    , m_activeTouches(m_timeSource)
-{
-    setRecognitionTimer(new Timer(this));
-    m_recognitionTimer->setInterval(60);
-    m_recognitionTimer->setSingleShot(false);
-
-    m_velocityCalculator = new AxisVelocityCalculator(this);
-
-    connect(this, &QQuickItem::enabledChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
-    connect(this, &QQuickItem::visibleChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
-}
-
-Direction::Type DirectionalDragArea::direction() const
-{
-    return m_direction;
-}
-
-void DirectionalDragArea::setDirection(Direction::Type direction)
-{
-    if (direction != m_direction) {
-        m_direction = direction;
-        Q_EMIT directionChanged(m_direction);
-    }
-}
-
-void DirectionalDragArea::setMaxDeviation(qreal value)
-{
-    if (m_dampedScenePos.maxDelta() != value) {
-        m_dampedScenePos.setMaxDelta(value);
-        Q_EMIT maxDeviationChanged(value);
-    }
-}
-
-qreal DirectionalDragArea::wideningAngle() const
-{
-    return m_wideningAngle;
-}
-
-void DirectionalDragArea::setWideningAngle(qreal angle)
-{
-    if (angle == m_wideningAngle)
-        return;
-
-    m_wideningAngle = angle;
-
-    // wideningFactor = pow(cosine(angle), 2)
-    {
-        qreal angleRadians = angle * M_PI / 180.0;
-        m_wideningFactor = qCos(angleRadians);
-        m_wideningFactor = m_wideningFactor * m_wideningFactor;
-    }
-
-    Q_EMIT wideningAngleChanged(angle);
-}
-
-void DirectionalDragArea::setDistanceThreshold(qreal value)
-{
-    if (m_distanceThreshold != value) {
-        m_distanceThreshold = value;
-        m_distanceThresholdSquared = m_distanceThreshold * m_distanceThreshold;
-        Q_EMIT distanceThresholdChanged(value);
-    }
-}
-
-void DirectionalDragArea::setMinSpeed(qreal value)
-{
-    if (m_minSpeed != value) {
-        m_minSpeed = value;
-        Q_EMIT minSpeedChanged(value);
-    }
-}
-
-void DirectionalDragArea::setMaxSilenceTime(int value)
-{
-    if (m_maxSilenceTime != value) {
-        m_maxSilenceTime = value;
-        Q_EMIT maxSilenceTimeChanged(value);
-    }
-}
-
-void DirectionalDragArea::setCompositionTime(int value)
-{
-    if (m_compositionTime != value) {
-        m_compositionTime = value;
-        Q_EMIT compositionTimeChanged(value);
-    }
-}
-
-void DirectionalDragArea::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
-{
-    int interval = 0;
-    bool timerWasRunning = false;
-    bool wasSingleShot = false;
-
-    // can be null when called from the constructor
-    if (m_recognitionTimer) {
-        interval = m_recognitionTimer->interval();
-        timerWasRunning = m_recognitionTimer->isRunning();
-        if (m_recognitionTimer->parent() == this) {
-            delete m_recognitionTimer;
-        }
-    }
-
-    m_recognitionTimer = timer;
-    timer->setInterval(interval);
-    timer->setSingleShot(wasSingleShot);
-    connect(timer, &UbuntuGestures::AbstractTimer::timeout,
-            this, &DirectionalDragArea::checkSpeed);
-    if (timerWasRunning) {
-        m_recognitionTimer->start();
-    }
-}
-
-void DirectionalDragArea::setTimeSource(const SharedTimeSource &timeSource)
-{
-    m_timeSource = timeSource;
-    m_velocityCalculator->setTimeSource(timeSource);
-    m_activeTouches.m_timeSource = timeSource;
-}
-
-qreal DirectionalDragArea::distance() const
-{
-    if (Direction::isHorizontal(m_direction)) {
-        return m_previousPos.x() - m_startPos.x();
-    } else {
-        return m_previousPos.y() - m_startPos.y();
-    }
-}
-
-void DirectionalDragArea::updateSceneDistance()
-{
-    QPointF totalMovement = m_previousScenePos - m_startScenePos;
-    m_sceneDistance = projectOntoDirectionVector(totalMovement);
-}
-
-qreal DirectionalDragArea::sceneDistance() const
-{
-    return m_sceneDistance;
-}
-
-qreal DirectionalDragArea::touchX() const
-{
-    return m_previousPos.x();
-}
-
-qreal DirectionalDragArea::touchY() const
-{
-    return m_previousPos.y();
-}
-
-qreal DirectionalDragArea::touchSceneX() const
-{
-    return m_previousScenePos.x();
-}
-
-qreal DirectionalDragArea::touchSceneY() const
-{
-    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());
-        ddaDebug("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.
-        //
-        // The fix for this bug has landed in Qt 5.4 (https://codereview.qt-project.org/96887)
-        // TODO: Remove this workaround once we start using Qt 5.4
-        if (window()) {
-            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(window());
-            if (windowPrivate->touchMouseId == event->touchId() && window()->mouseGrabberItem()) {
-                ddaDebug("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));
-
-    ddaDebug("Unowned " << m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
-
-    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
-        ddaDebug("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()) {
-        ddaDebug("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()) {
-        ddaDebug("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.
-        ddaDebug("Sill within composition window. Let's wait more.");
-        return;
-    }
-
-    if (movedFarEnough(touchScenePos)) {
-        TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
-        setStatus(Recognized);
-    } else {
-        ddaDebug("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.
-
-    ddaDebug(m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
-
-    if (!isEnabled() || !isVisible()) {
-        QQuickItem::touchEvent(event);
-        return;
-    }
-
-    switch (m_status) {
-        case WaitingForTouch:
-            touchEvent_absent(event);
-            break;
-        case Undecided:
-            touchEvent_undecided(event);
-            break;
-        default: // Recognized:
-            touchEvent_recognized(event);
-            break;
-    }
-
-    m_activeTouches.update(event);
-}
-
-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.
-        ddaDebug("A new touch point came in but we're still within time composition window. Ignoring it.");
-        allGood = false;
-    }
-
-    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
-
-    const QTouchEvent::TouchPoint *newTouchPoint = nullptr;
-    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
-                allGood = false;
-            } else {
-                // that's our candidate
-                m_touchId = touchPoint.id();
-                newTouchPoint = &touchPoint;
-            }
-        }
-    }
-
-    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
-            ddaDebug("Gesture recognition is disabled. Requesting touch ownership immediately.");
-            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)
-{
-    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
-        ddaDebug("Multi-finger drags are not accepted");
-
-        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);
-    }
-}
-
-void DirectionalDragArea::touchEvent_recognized(QTouchEvent *event)
-{
-    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
-
-    if (!touchPoint) {
-        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << m_touchId
-            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
-               "Considering it as released.";
-        setStatus(WaitingForTouch);
-    } else {
-        setPreviousPos(touchPoint->pos());
-        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();
-    const QTouchEvent::TouchPoint *touchPoint = 0;
-    for (int i = 0; i < touchPoints.size(); ++i) {
-        if (touchPoints.at(i).id() == m_touchId) {
-            touchPoint = &touchPoints.at(i);
-            break;
-        }
-    }
-    return touchPoint;
-}
-
-bool DirectionalDragArea::pointInsideAllowedArea() const
-{
-    // NB: Using squared values to avoid computing the square root to find
-    // the length totalMovement
-
-    QPointF totalMovement(m_dampedScenePos.x() - m_startScenePos.x(),
-                          m_dampedScenePos.y() - m_startScenePos.y());
-
-    qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
-                                totalMovement.y() * totalMovement.y();
-
-    if (squaredTotalMovSize == 0.) {
-        // didn't move
-        return true;
-    }
-
-    qreal projectedMovement = projectOntoDirectionVector(totalMovement);
-
-
-    qreal cosineAngleSquared = (projectedMovement * projectedMovement) / squaredTotalMovSize;
-
-    // Same as:
-    // angle_between_movement_vector_and_gesture_direction_vector <= widening_angle
-    return cosineAngleSquared >= m_wideningFactor;
-}
-
-bool DirectionalDragArea::movingInRightDirection() const
-{
-    if (m_direction == Direction::Horizontal) {
-        return true;
-    } else {
-        QPointF movementVector(m_dampedScenePos.x() - m_previousDampedScenePos.x(),
-                               m_dampedScenePos.y() - m_previousDampedScenePos.y());
-
-        qreal scalarProjection = projectOntoDirectionVector(movementVector);
-
-        return scalarProjection >= 0.;
-    }
-}
-
-bool DirectionalDragArea::movedFarEnough(const QPointF &point) const
-{
-    if (m_distanceThreshold <= 0.) {
-        // distance threshold check is disabled
-        return true;
-    } else {
-        QPointF totalMovement(point.x() - m_startScenePos.x(),
-                              point.y() - m_startScenePos.y());
-
-        qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
-                                    totalMovement.y() * totalMovement.y();
-
-        return squaredTotalMovSize > m_distanceThresholdSquared;
-    }
-}
-
-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) {
-            ddaDebug("Rejecting gesture because it's below minimum speed.");
-            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
-            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
-            setStatus(WaitingForTouch);
-        }
-    }
-
-    if (m_velocityCalculator->numSamples() == m_numSamplesOnLastSpeedCheck) {
-        m_silenceTime += m_recognitionTimer->interval();
-
-        if (m_silenceTime > m_maxSilenceTime) {
-            ddaDebug("Rejecting gesture because its silence time has been exceeded.");
-            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
-            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
-            setStatus(WaitingForTouch);
-        }
-    } else {
-        m_silenceTime = 0;
-    }
-    m_numSamplesOnLastSpeedCheck = m_velocityCalculator->numSamples();
-}
-
-void DirectionalDragArea::giveUpIfDisabledOrInvisible()
-{
-    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) {
-            ddaDebug("Resetting status because got disabled or made invisible");
-            setStatus(WaitingForTouch);
-        }
-    }
-}
-
-void DirectionalDragArea::setStatus(DirectionalDragArea::Status newStatus)
-{
-    if (newStatus == m_status)
-        return;
-
-    DirectionalDragArea::Status oldStatus = m_status;
-
-    if (oldStatus == Undecided) {
-        m_recognitionTimer->stop();
-    }
-
-    m_status = newStatus;
-    Q_EMIT statusChanged(m_status);
-
-    ddaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));
-
-    switch (newStatus) {
-        case WaitingForTouch:
-            Q_EMIT draggingChanged(false);
-            break;
-        case Undecided:
-            m_recognitionTimer->start();
-            Q_EMIT draggingChanged(true);
-            break;
-        case Recognized:
-            if (oldStatus == WaitingForTouch)
-                Q_EMIT draggingChanged(true);
-            break;
-        default:
-            // no-op
-            break;
-    }
-}
-
-void DirectionalDragArea::setPreviousPos(const QPointF &point)
-{
-    bool xChanged = m_previousPos.x() != point.x();
-    bool yChanged = m_previousPos.y() != point.y();
-
-    m_previousPos = point;
-
-    if (xChanged) {
-        Q_EMIT touchXChanged(point.x());
-        if (Direction::isHorizontal(m_direction))
-            Q_EMIT distanceChanged(distance());
-    }
-
-    if (yChanged) {
-        Q_EMIT touchYChanged(point.y());
-        if (Direction::isVertical(m_direction))
-            Q_EMIT distanceChanged(distance());
-    }
-}
-
-void DirectionalDragArea::setPreviousScenePos(const QPointF &point)
-{
-    bool xChanged = m_previousScenePos.x() != point.x();
-    bool yChanged = m_previousScenePos.y() != point.y();
-
-    if (!xChanged && !yChanged)
-        return;
-
-    qreal oldSceneDistance = sceneDistance();
-    m_previousScenePos = point;
-    updateSceneDistance();
-
-    if (oldSceneDistance != sceneDistance()) {
-        Q_EMIT sceneDistanceChanged(sceneDistance());
-    }
-
-    if (xChanged) {
-        Q_EMIT touchSceneXChanged(point.x());
-    }
-
-    if (yChanged) {
-        Q_EMIT touchSceneYChanged(point.y());
-    }
-}
-
-void DirectionalDragArea::updateVelocityCalculator(const QPointF &scenePos)
-{
-    QPointF totalSceneMovement = scenePos - m_startScenePos;
-
-    qreal scalarProjection = projectOntoDirectionVector(totalSceneMovement);
-
-    m_velocityCalculator->setTrackedPosition(scalarProjection);
-}
-
-bool DirectionalDragArea::isWithinTouchCompositionWindow()
-{
-    return
-        compositionTime() > 0 &&
-        !m_activeTouches.isEmpty() &&
-        m_timeSource->msecsSinceReference() <=
-            m_activeTouches.mostRecentStartTime() + (qint64)compositionTime();
-}
-
-//**************************  ActiveTouchesInfo **************************
-
-DirectionalDragArea::ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
-    : m_timeSource(timeSource)
-{
-}
-
-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;
-    }
-
-    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) {
-            addTouchPoint(touchPoint.id());
-        } else if (touchPoint.state() == Qt::TouchPointReleased) {
-            removeTouchPoint(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();
-
-    #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_touchInfoPool.isEmpty());
-
-    qint64 highestStartTime = -1;
-
-    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &activeTouchInfo) {
-        if (activeTouchInfo->startTime > highestStartTime) {
-            highestStartTime = activeTouchInfo->startTime;
-        }
-        return true;
-    });
-
-    return highestStartTime;
-}
-
-void DirectionalDragArea::updateSceneDirectionVector()
-{
-    QPointF localOrigin(0., 0.);
-    QPointF localDirection;
-    switch (m_direction) {
-        case Direction::Upwards:
-            localDirection.rx() = 0.;
-            localDirection.ry() = -1.;
-            break;
-        case Direction::Downwards:
-            localDirection.rx() = 0.;
-            localDirection.ry() = 1;
-            break;
-        case Direction::Leftwards:
-            localDirection.rx() = -1.;
-            localDirection.ry() = 0.;
-            break;
-        default: // Direction::Rightwards || Direction.Horizontal
-            localDirection.rx() = 1.;
-            localDirection.ry() = 0.;
-            break;
-    }
-    QPointF sceneOrigin = mapToScene(localOrigin);
-    QPointF sceneDirection = mapToScene(localDirection);
-    m_sceneDirectionVector = sceneDirection - sceneOrigin;
-}
-
-qreal DirectionalDragArea::projectOntoDirectionVector(const QPointF &sceneVector) const
-{
-    // same as dot product as m_sceneDirectionVector is a unit vector
-    return  sceneVector.x() * m_sceneDirectionVector.x() +
-            sceneVector.y() * m_sceneDirectionVector.y();
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.h	1970-01-01 00:00:00 +0000
@@ -1,308 +0,0 @@
-/*
- * 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
- * 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 DIRECTIONAL_DRAG_AREA_H
-#define DIRECTIONAL_DRAG_AREA_H
-
-#include <QtQuick/QQuickItem>
-#include "AxisVelocityCalculator.h"
-#include "UbuntuGesturesQmlGlobal.h"
-#include "Damper.h"
-#include "Direction.h"
-
-// lib UbuntuGestures
-#include <Pool.h>
-#include <Timer.h>
-
-class TouchOwnershipEvent;
-class UnownedTouchEvent;
-
-/*
- An area that detects axis-aligned single-finger drag gestures
-
- If a drag deviates too much from the components' direction recognition will
- fail. It will also fail if the drag or flick is too short. E.g. a noisy or
- fidgety click
-
- See doc/DirectionalDragArea.svg
- */
-class UBUNTUGESTURESQML_EXPORT DirectionalDragArea : public QQuickItem {
-    Q_OBJECT
-
-    // The direction in which the gesture should move in order to be recognized.
-    Q_PROPERTY(Direction::Type direction READ direction WRITE setDirection NOTIFY directionChanged)
-
-    // The distance travelled by the finger along the axis specified by
-    // DirectionalDragArea's direction.
-    Q_PROPERTY(qreal distance READ distance NOTIFY distanceChanged)
-
-    // The distance travelled by the finger along the axis specified by
-    // DirectionalDragArea's direction in scene coordinates
-    Q_PROPERTY(qreal sceneDistance READ sceneDistance NOTIFY sceneDistanceChanged)
-
-    // Position of the touch point performing the drag relative to this item.
-    Q_PROPERTY(qreal touchX READ touchX NOTIFY touchXChanged)
-    Q_PROPERTY(qreal touchY READ touchY NOTIFY touchYChanged)
-
-    // Position of the touch point performing the drag, in scene's coordinate system
-    Q_PROPERTY(qreal touchSceneX READ touchSceneX NOTIFY touchSceneXChanged)
-    Q_PROPERTY(qreal touchSceneY READ touchSceneY NOTIFY touchSceneYChanged)
-
-    // The current status of the directional drag gesture area.
-    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
-
-    // Whether a drag gesture is taking place
-    // This will be true as long as status is Undecided or Recognized
-    // When a gesture gets rejected, dragging turns to false.
-    Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
-
-    /////
-    // stuff that will be set in stone at some point
-
-    // How far the touch point can move away from its expected position before
-    // it causes a rejection in the gesture recognition. This is to compensate
-    // for both noise in the touch input signal and for the natural irregularities
-    // in the finger movement.
-    // Proper value is likely device-specific.
-    Q_PROPERTY(qreal maxDeviation READ maxDeviation WRITE setMaxDeviation NOTIFY maxDeviationChanged)
-
-    // Widening angle, in degrees
-    // It's roughly the maximum angle a touch point can make relative to the
-    // axis defined by the compoment's direction for it to be recognized as a
-    // directional drag.
-    Q_PROPERTY(qreal wideningAngle READ wideningAngle WRITE setWideningAngle
-               NOTIFY wideningAngleChanged)
-
-    // How far a touch point has to move from its initial position in order for
-    // it to be recognized as a directional drag.
-    Q_PROPERTY(qreal distanceThreshold READ distanceThreshold WRITE setDistanceThreshold
-               NOTIFY distanceThresholdChanged)
-
-    // Minimum speed a gesture needs to have in order to be recognized as a
-    // directional drag.
-    // In pixels per second
-    Q_PROPERTY(qreal minSpeed READ minSpeed WRITE setMinSpeed NOTIFY minSpeedChanged)
-
-    // A gesture will be rejected if more than maxSilenceTime milliseconds has
-    // passed since we last got an input event from it (during Undecided state).
-    //
-    // Silence (i.e., lack of new input events) doesn't necessarily mean that the user's
-    // finger is still (zero drag speed). In some cases the finger might be moving but
-    // the driver's high noise filtering might cause those silence periods, specially
-    // in the moments succeeding a press (talking about Galaxy Nexus here).
-    Q_PROPERTY(int maxSilenceTime READ maxSilenceTime
-                                  WRITE setMaxSilenceTime
-                                  NOTIFY maxSilenceTimeChanged)
-
-    //
-    /////
-
-    // Maximum time (in milliseconds) after the start of a given touch point where
-    // subsequent touch starts are grouped with the first one into an N-touches gesture
-    // (e.g. a two-fingers tap or drag).
-    Q_PROPERTY(int compositionTime READ compositionTime
-                                   WRITE setCompositionTime
-                                   NOTIFY compositionTimeChanged)
-
-    Q_ENUMS(Direction)
-    Q_ENUMS(Status)
-public:
-    DirectionalDragArea(QQuickItem *parent = 0);
-
-    Direction::Type direction() const;
-    void setDirection(Direction::Type);
-
-    // Describes the state of the directional drag gesture.
-    enum Status {
-        // Waiting for a new touch point to land on this area. No gesture is being processed
-        // or tracked.
-        WaitingForTouch,
-
-        // A touch point has landed on this area but it's not know yet whether it is
-        // performing a drag in the correct direction.
-        // If it's decided that the touch point is not performing a directional drag gesture,
-        // it will be rejected/ignored and status will return to WaitingForTouch.
-        Undecided, //Recognizing,
-
-        // There's a touch point in this area and it performed a drag in the correct
-        // direction.
-        //
-        // Once recognized, the gesture state will move back to WaitingForTouch only once
-        // that touch point ends. The gesture will remain in the Recognized state even if
-        // the touch point starts moving in other directions or halts.
-        Recognized,
-    };
-    Status status() const { return m_status; }
-
-    qreal distance() const;
-    qreal sceneDistance() const;
-    void updateSceneDistance();
-
-    qreal touchX() const;
-    qreal touchY() const;
-
-    qreal touchSceneX() const;
-    qreal touchSceneY() const;
-
-    bool dragging() const { return (m_status == Undecided) || (m_status == Recognized); }
-
-    qreal maxDeviation() const { return m_dampedScenePos.maxDelta(); }
-    void setMaxDeviation(qreal value);
-
-    qreal wideningAngle() const;
-    void setWideningAngle(qreal value);
-
-    qreal distanceThreshold() const { return m_distanceThreshold; }
-    void setDistanceThreshold(qreal value);
-
-    qreal minSpeed() const { return m_minSpeed; }
-    void setMinSpeed(qreal value);
-
-    int maxSilenceTime() const { return m_maxSilenceTime; }
-    void setMaxSilenceTime(int value);
-
-    int compositionTime() const { return m_compositionTime; }
-    void setCompositionTime(int value);
-
-    // Replaces the existing Timer with the given one.
-    //
-    // Useful for providing a fake timer when testing.
-    void setRecognitionTimer(UbuntuGestures::AbstractTimer *timer);
-
-    // 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);
-    void draggingChanged(bool value);
-    void distanceChanged(qreal value);
-    void sceneDistanceChanged(qreal value);
-    void maxDeviationChanged(qreal value);
-    void wideningAngleChanged(qreal value);
-    void distanceThresholdChanged(qreal value);
-    void minSpeedChanged(qreal value);
-    void maxSilenceTimeChanged(int value);
-    void compositionTimeChanged(int value);
-    void touchXChanged(qreal value);
-    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:
-    virtual void touchEvent(QTouchEvent *event);
-
-private Q_SLOTS:
-    void checkSpeed();
-    void giveUpIfDisabledOrInvisible();
-
-private:
-    void touchEvent_absent(QTouchEvent *event);
-    void touchEvent_undecided(QTouchEvent *event);
-    void touchEvent_recognized(QTouchEvent *event);
-    bool pointInsideAllowedArea() const;
-    bool movingInRightDirection() const;
-    bool movedFarEnough(const QPointF &point) const;
-    const QTouchEvent::TouchPoint *fetchTargetTouchPoint(QTouchEvent *event);
-    void setStatus(Status newStatus);
-    void setPreviousPos(const QPointF &point);
-    void setPreviousScenePos(const QPointF &point);
-    void updateVelocityCalculator(const QPointF &point);
-    bool isWithinTouchCompositionWindow();
-    void updateSceneDirectionVector();
-    // 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;
-
-    QPointF m_startPos;
-    QPointF m_startScenePos;
-    QPointF m_previousPos;
-    QPointF m_previousScenePos;
-    qreal m_sceneDistance;
-    int m_touchId;
-
-    // A movement damper is used in some of the gesture recognition calculations
-    // to get rid of noise or small oscillations in the touch position.
-    DampedPointF m_dampedScenePos;
-    QPointF m_previousDampedScenePos;
-
-    // Unit vector in scene coordinates describing the direction of the gesture recognition
-    QPointF m_sceneDirectionVector;
-
-    Direction::Type m_direction;
-    qreal m_wideningAngle; // in degrees
-    qreal m_wideningFactor; // it's pow(cosine(m_wideningAngle), 2)
-    qreal m_distanceThreshold;
-    qreal m_distanceThresholdSquared; // it's pow(m_distanceThreshold, 2)
-    qreal m_minSpeed;
-    int m_maxSilenceTime; // in milliseconds
-    int m_silenceTime; // in milliseconds
-    int m_compositionTime; // in milliseconds
-    int m_numSamplesOnLastSpeedCheck;
-    UbuntuGestures::AbstractTimer *m_recognitionTimer;
-    AxisVelocityCalculator *m_velocityCalculator;
-
-    UbuntuGestures::SharedTimeSource m_timeSource;
-
-    // Information about an active touch point
-    struct ActiveTouchInfo {
-        ActiveTouchInfo() : id(-1), startTime(-1) {}
-        bool isValid() const { return id != -1; }
-        void reset() { id = -1; }
-        int id;
-        qint64 startTime;
-    };
-    class ActiveTouchesInfo {
-    public:
-        ActiveTouchesInfo(const UbuntuGestures::SharedTimeSource &timeSource);
-        void update(QTouchEvent *event);
-        qint64 touchStartTime(int id);
-        bool isEmpty() const { return m_touchInfoPool.isEmpty(); }
-        qint64 mostRecentStartTime();
-        UbuntuGestures::SharedTimeSource m_timeSource;
-    private:
-        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

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/Gestures.qmltypes'
--- src/app/unity8/plugins/Ubuntu/Gestures/Gestures.qmltypes	2015-03-17 15:14:11 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/Gestures.qmltypes	1970-01-01 00:00:00 +0000
@@ -1,168 +0,0 @@
-import QtQuick.tooling 1.1
-
-// This file describes the plugin-supplied types contained in the library.
-// It is used for QML tooling purposes only.
-//
-// This file was auto-generated by:
-// 'qmlplugindump -notrelocatable Ubuntu.Gestures 0.1 plugins'
-
-Module {
-    Component {
-        name: "AxisVelocityCalculator"
-        prototype: "QObject"
-        exports: ["Ubuntu.Gestures/AxisVelocityCalculator 0.1"]
-        exportMetaObjectRevisions: [0]
-        Property { name: "trackedPosition"; type: "double" }
-        Signal {
-            name: "trackedPositionChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Method { name: "calculate"; type: "double" }
-        Method { name: "reset" }
-    }
-    Component {
-        name: "Direction"
-        prototype: "QObject"
-        exports: ["Ubuntu.Gestures/Direction 0.1"]
-        isCreatable: false
-        isSingleton: true
-        exportMetaObjectRevisions: [0]
-        Enum {
-            name: "Type"
-            values: {
-                "Rightwards": 0,
-                "Leftwards": 1,
-                "Downwards": 2,
-                "Upwards": 3,
-                "Horizontal": 4
-            }
-        }
-        Method {
-            name: "isHorizontal"
-            type: "bool"
-            Parameter { name: "type"; type: "Direction::Type" }
-        }
-        Method {
-            name: "isVertical"
-            type: "bool"
-            Parameter { name: "type"; type: "Direction::Type" }
-        }
-        Method {
-            name: "isPositive"
-            type: "bool"
-            Parameter { name: "type"; type: "Direction::Type" }
-        }
-    }
-    Component {
-        name: "DirectionalDragArea"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        exports: ["Ubuntu.Gestures/DirectionalDragArea 0.1"]
-        exportMetaObjectRevisions: [0]
-        Enum {
-            name: "Status"
-            values: {
-                "WaitingForTouch": 0,
-                "Undecided": 1,
-                "Recognized": 2
-            }
-        }
-        Property { name: "direction"; type: "Direction::Type" }
-        Property { name: "distance"; type: "double"; isReadonly: true }
-        Property { name: "sceneDistance"; type: "double"; isReadonly: true }
-        Property { name: "touchX"; type: "double"; isReadonly: true }
-        Property { name: "touchY"; type: "double"; isReadonly: true }
-        Property { name: "touchSceneX"; type: "double"; isReadonly: true }
-        Property { name: "touchSceneY"; type: "double"; isReadonly: true }
-        Property { name: "status"; type: "Status"; isReadonly: true }
-        Property { name: "dragging"; type: "bool"; isReadonly: true }
-        Property { name: "maxDeviation"; type: "double" }
-        Property { name: "wideningAngle"; type: "double" }
-        Property { name: "distanceThreshold"; type: "double" }
-        Property { name: "minSpeed"; type: "double" }
-        Property { name: "maxSilenceTime"; type: "int" }
-        Property { name: "compositionTime"; type: "int" }
-        Signal {
-            name: "directionChanged"
-            Parameter { name: "direction"; type: "Direction::Type" }
-        }
-        Signal {
-            name: "statusChanged"
-            Parameter { name: "value"; type: "Status" }
-        }
-        Signal {
-            name: "draggingChanged"
-            Parameter { name: "value"; type: "bool" }
-        }
-        Signal {
-            name: "distanceChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "sceneDistanceChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "maxDeviationChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "wideningAngleChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "distanceThresholdChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "minSpeedChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "maxSilenceTimeChanged"
-            Parameter { name: "value"; type: "int" }
-        }
-        Signal {
-            name: "compositionTimeChanged"
-            Parameter { name: "value"; type: "int" }
-        }
-        Signal {
-            name: "touchXChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "touchYChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "touchSceneXChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "touchSceneYChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal { name: "tapped" }
-    }
-    Component {
-        name: "PressedOutsideNotifier"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        exports: ["Ubuntu.Gestures/PressedOutsideNotifier 0.1"]
-        exportMetaObjectRevisions: [0]
-        Signal { name: "pressedOutside" }
-    }
-    Component {
-        name: "TouchGate"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        exports: ["Ubuntu.Gestures/TouchGate 0.1"]
-        exportMetaObjectRevisions: [0]
-        Property { name: "targetItem"; type: "QQuickItem"; isPointer: true }
-        Signal {
-            name: "targetItemChanged"
-            Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
-        }
-        Signal { name: "pressed" }
-    }
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp	1970-01-01 00:00:00 +0000
@@ -1,119 +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/>.
- */
-
-#include "PressedOutsideNotifier.h"
-
-#include <QMouseEvent>
-
-PressedOutsideNotifier::PressedOutsideNotifier(QQuickItem *parent)
-    : QQuickItem(parent)
-{
-    connect(this, &QQuickItem::enabledChanged,
-            this, &PressedOutsideNotifier::setupOrTearDownEventFiltering);
-
-    m_signalEmissionTimer.setSingleShot(true);
-    m_signalEmissionTimer.setInterval(0); // times out on the next iteration of the event loop
-    connect(&m_signalEmissionTimer, &QTimer::timeout,
-            this, &PressedOutsideNotifier::pressedOutside);
-}
-
-bool PressedOutsideNotifier::eventFilter(QObject *watched, QEvent *event)
-{
-    Q_UNUSED(watched);
-    Q_ASSERT(watched == m_filteredWindow);
-
-    // We are already going to emit pressedOutside() anyway, thus no need
-    // for new checks.
-    // This case takes place when a QTouchEvent comes in and isn't handled by any item,
-    // causing QQuickWindow to synthesize a QMouseEvent out of it, which would
-    // be filtered by us as well and count as a second press, which is wrong.
-    if (m_signalEmissionTimer.isActive()) {
-        return false;
-    }
-
-    switch (event->type()) {
-    case QEvent::MouseButtonPress: {
-        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
-        QPointF p = mapFromScene(mouseEvent->windowPos());
-        if (!contains(p)) {
-            m_signalEmissionTimer.start();
-        }
-        break;
-    }
-    case QEvent::TouchBegin:
-        processFilteredTouchBegin(static_cast<QTouchEvent*>(event));
-    default:
-        break;
-    }
-
-    // let the event be handled further
-    return false;
-}
-
-void PressedOutsideNotifier::itemChange(ItemChange change, const ItemChangeData &value)
-{
-    if (change == QQuickItem::ItemSceneChange) {
-        setupOrTearDownEventFiltering();
-    }
-
-    QQuickItem::itemChange(change, value);
-}
-
-void PressedOutsideNotifier::setupOrTearDownEventFiltering()
-{
-    if (isEnabled() && window()) {
-        setupEventFiltering();
-    } else if (m_filteredWindow) {
-        tearDownEventFiltering();
-    }
-}
-
-void PressedOutsideNotifier::setupEventFiltering()
-{
-    QQuickWindow *currentWindow = window();
-    Q_ASSERT(currentWindow != nullptr);
-
-    if (currentWindow == m_filteredWindow)
-        return;
-
-    if (m_filteredWindow) {
-        m_filteredWindow->removeEventFilter(this);
-    }
-
-    currentWindow->installEventFilter(this);
-    m_filteredWindow = currentWindow;
-}
-
-void PressedOutsideNotifier::tearDownEventFiltering()
-{
-    m_filteredWindow->removeEventFilter(this);
-    m_filteredWindow.clear();
-}
-
-void PressedOutsideNotifier::processFilteredTouchBegin(QTouchEvent *event)
-{
-    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) {
-            QPointF p = mapFromScene(touchPoint.pos());
-            if (!contains(p)) {
-                m_signalEmissionTimer.start();
-                return;
-            }
-        }
-    }
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	1970-01-01 00:00:00 +0000
@@ -1,62 +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/>.
- */
-
-#ifndef PRESSED_OUTSIDE_NOTIFIER_H
-#define PRESSED_OUTSIDE_NOTIFIER_H
-
-#include <QQuickItem>
-
-#include <QQuickWindow>
-#include <QPointer>
-#include <QTimer>
-
-#include "UbuntuGesturesGlobal.h"
-
-/*
-   Notifies when a point, mouse or touch, is pressed outside its area.
-
-   Only enable it while needed.
- */
-class UBUNTUGESTURES_EXPORT PressedOutsideNotifier : public QQuickItem {
-    Q_OBJECT
-
-public:
-    PressedOutsideNotifier(QQuickItem * parent = nullptr);
-
-    // From QObject
-    bool eventFilter(QObject *watched, QEvent *event) override;
-
-Q_SIGNALS:
-    void pressedOutside();
-
-protected:
-    void itemChange(ItemChange change, const ItemChangeData &value) override;
-
-private Q_SLOTS:
-    void setupOrTearDownEventFiltering();
-
-private:
-    void setupEventFiltering();
-    void tearDownEventFiltering();
-    void processFilteredTouchBegin(QTouchEvent *event);
-
-    QPointer<QQuickWindow> m_filteredWindow;
-
-    // Emits pressedOutside() signal on timeout
-    QTimer m_signalEmissionTimer;
-};
-
-#endif // PRESSED_OUTSIDE_NOTIFIER_H

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.cpp	1970-01-01 00:00:00 +0000
@@ -1,49 +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 Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the applicable version of the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of both the GNU Lesser General Public
- * License along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- */
-
-#include "TimeSource.h"
-
-#include <QElapsedTimer>
-
-namespace UbuntuGestures {
-class RealTimeSourcePrivate {
-public:
-    QElapsedTimer timer;
-};
-}
-
-using namespace UbuntuGestures;
-
-RealTimeSource::RealTimeSource()
-    : UbuntuGestures::TimeSource()
-    , d(new RealTimeSourcePrivate)
-{
-    d->timer.start();
-}
-
-RealTimeSource::~RealTimeSource()
-{
-    delete d;
-}
-
-qint64 RealTimeSource::msecsSinceReference()
-{
-    return d->timer.elapsed();
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.h	1970-01-01 00:00:00 +0000
@@ -1,54 +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 Lesser General Public License, as
- * published by the  Free Software Foundation; either version 2.1 or 3.0
- * of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the applicable version of the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of both the GNU Lesser General Public
- * License along with this program. If not, see <http://www.gnu.org/licenses/>
- *
- * Authored by: Daniel d'Andrada <[e-mail]>
- */
-
-#ifndef UBUNTUGESTURES_TIMESOURCE_H
-#define UBUNTUGESTURES_TIMESOURCE_H
-
-#include "UbuntuGesturesQmlGlobal.h"
-#include <QSharedPointer>
-
-namespace UbuntuGestures {
-/*
-    Interface for a time source.
- */
-class UBUNTUGESTURESQML_EXPORT TimeSource {
-public:
-    virtual ~TimeSource() {}
-    /* Returns the current time in milliseconds since some reference time in the past. */
-    virtual qint64 msecsSinceReference() = 0;
-};
-typedef QSharedPointer<TimeSource> SharedTimeSource;
-
-/*
-    Implementation of a time source
- */
-class RealTimeSourcePrivate;
-class RealTimeSource : public TimeSource {
-public:
-    RealTimeSource();
-    virtual ~RealTimeSource();
-    qint64 msecsSinceReference() override;
-private:
-    RealTimeSourcePrivate *d;
-};
-
-} // namespace UbuntuGestures
-
-#endif // UBUNTUGESTURES_TIMESOURCE_H

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.cpp	1970-01-01 00:00:00 +0000
@@ -1,367 +0,0 @@
-/*
- * 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 "TouchDispatcher.h"
-
-#include <QGuiApplication>
-#include <QScopedPointer>
-#include <QStyleHints>
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-pedantic"
-#include <private/qquickitem_p.h>
-#pragma GCC diagnostic pop
-
-#define TOUCHDISPATCHER_DEBUG 0
-
-#if TOUCHDISPATCHER_DEBUG
-#include <DebugHelpers.h>
-#endif
-
-TouchDispatcher::TouchDispatcher()
-    : m_status(NoActiveTouch)
-    , m_touchMouseId(-1)
-    , m_touchMousePressTimestamp(0)
-{
-}
-
-void TouchDispatcher::setTargetItem(QQuickItem *target)
-{
-    if (target != m_targetItem) {
-        m_targetItem = target;
-        if (m_status != NoActiveTouch) {
-            qWarning("[TouchDispatcher] Changing target item in the middle of a touch stream");
-            m_status = TargetRejectedTouches;
-        }
-    }
-}
-
-void TouchDispatcher::dispatch(QEvent::Type eventType,
-                               QTouchDevice *device,
-                               Qt::KeyboardModifiers modifiers,
-                               const QList<QTouchEvent::TouchPoint> &touchPoints,
-                               QWindow *window,
-                               ulong timestamp)
-{
-    if (m_targetItem.isNull()) {
-        qWarning("[TouchDispatcher] Cannot dispatch touch event because target item is null");
-        return;
-    }
-
-    if (eventType == QEvent::TouchBegin) {
-        dispatchTouchBegin(device, modifiers, touchPoints, window, timestamp);
-
-    } else if (eventType == QEvent::TouchUpdate || eventType == QEvent::TouchEnd) {
-
-        if (m_status == DeliveringTouchEvents) {
-            dispatchAsTouch(eventType, device, modifiers, touchPoints, window, timestamp);
-        } else if (m_status == DeliveringMouseEvents) {
-            dispatchAsMouse(device, modifiers, touchPoints, timestamp);
-        } else {
-            Q_ASSERT(m_status == TargetRejectedTouches);
-            #if TOUCHDISPATCHER_DEBUG
-            qDebug() << "[TouchDispatcher] Not dispatching touch event to" << m_targetItem.data()
-                << "because it already rejected the touch stream.";
-            #endif
-            // Do nothing
-        }
-
-        if (eventType == QEvent::TouchEnd) {
-            m_status = NoActiveTouch;
-            m_touchMouseId = -1;
-        }
-
-    } else {
-        // Should never happen
-        qCritical() << "[TouchDispatcher] Unexpected event type" << eventType;
-        Q_ASSERT(false);
-        return;
-    }
-}
-
-void TouchDispatcher::dispatchTouchBegin(
-            QTouchDevice *device,
-            Qt::KeyboardModifiers modifiers,
-            const QList<QTouchEvent::TouchPoint> &touchPoints,
-            QWindow *window,
-            ulong timestamp)
-{
-    Q_ASSERT(m_status == NoActiveTouch);
-    QQuickItem *targetItem = m_targetItem.data();
-
-    if (!targetItem->isEnabled() || !targetItem->isVisible()) {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] 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());
-
-    QScopedPointer<QTouchEvent> touchEvent(
-            createQTouchEvent(QEvent::TouchBegin, device, modifiers, targetTouchPoints, window, timestamp));
-
-
-    #if TOUCHDISPATCHER_DEBUG
-    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(touchEvent.data()))
-            << "to" << targetItem;
-    #endif
-    QCoreApplication::sendEvent(targetItem, touchEvent.data());
-
-
-    if (touchEvent->isAccepted()) {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] Item accepted the touch event.";
-        #endif
-        m_status = DeliveringTouchEvents;
-    } else if (targetItem->acceptedMouseButtons() & Qt::LeftButton) {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] Item rejected the touch event. Trying a QMouseEvent";
-        #endif
-        // NB: Arbitrarily chose the first touch point to emulate the mouse pointer
-        QScopedPointer<QMouseEvent> mouseEvent(
-                touchToMouseEvent(QEvent::MouseButtonPress, targetTouchPoints.at(0), timestamp,
-                                  modifiers, false /* transformNeeded */));
-        Q_ASSERT(targetTouchPoints.at(0).state() == Qt::TouchPointPressed);
-
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
-                << "to" << m_targetItem.data();
-        #endif
-        QCoreApplication::sendEvent(targetItem, mouseEvent.data());
-        if (mouseEvent->isAccepted()) {
-            #if TOUCHDISPATCHER_DEBUG
-            qDebug() << "[TouchDispatcher] Item accepted the QMouseEvent.";
-            #endif
-            m_status = DeliveringMouseEvents;
-            m_touchMouseId = targetTouchPoints.at(0).id();
-
-            if (checkIfDoubleClicked(timestamp)) {
-                QScopedPointer<QMouseEvent> doubleClickEvent(
-                        touchToMouseEvent(QEvent::MouseButtonDblClick, targetTouchPoints.at(0), timestamp,
-                                          modifiers, false /* transformNeeded */));
-                #if TOUCHDISPATCHER_DEBUG
-                qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(doubleClickEvent.data()))
-                        << "to" << m_targetItem.data();
-                #endif
-                QCoreApplication::sendEvent(targetItem, doubleClickEvent.data());
-            }
-
-        } else {
-            #if TOUCHDISPATCHER_DEBUG
-            qDebug() << "[TouchDispatcher] Item rejected the QMouseEvent.";
-            #endif
-            m_status = TargetRejectedTouches;
-        }
-    } else {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] Item rejected the touch event and does not accept mouse buttons.";
-        #endif
-        m_status = TargetRejectedTouches;
-    }
-}
-
-void TouchDispatcher::dispatchAsTouch(QEvent::Type eventType,
-        QTouchDevice *device,
-        Qt::KeyboardModifiers modifiers,
-        const QList<QTouchEvent::TouchPoint> &touchPoints,
-        QWindow *window,
-        ulong timestamp)
-{
-    QQuickItem *targetItem = m_targetItem.data();
-
-    // Map touch points to targetItem coordinates
-    QList<QTouchEvent::TouchPoint> targetTouchPoints = touchPoints;
-    transformTouchPoints(targetTouchPoints, QQuickItemPrivate::get(targetItem)->windowToItemTransform());
-
-    QScopedPointer<QTouchEvent> eventForTargetItem(
-            createQTouchEvent(eventType, device, modifiers, targetTouchPoints, window, timestamp));
-
-
-    #if TOUCHDISPATCHER_DEBUG
-    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(eventForTargetItem.data()))
-            << "to" << targetItem;
-    #endif
-    QCoreApplication::sendEvent(targetItem, eventForTargetItem.data());
-}
-
-void TouchDispatcher::dispatchAsMouse(
-        QTouchDevice * /*device*/,
-        Qt::KeyboardModifiers modifiers,
-        const QList<QTouchEvent::TouchPoint> &touchPoints,
-        ulong timestamp)
-{
-    // TODO: Detect double clicks in order to synthesize QEvent::MouseButtonDblClick events accordingly
-
-    Q_ASSERT(!touchPoints.isEmpty());
-
-    const QTouchEvent::TouchPoint *touchMouse = nullptr;
-
-    if (m_touchMouseId != -1) {
-        for (int i = 0; i < touchPoints.count() && !touchMouse; ++i) {
-            const auto &touchPoint = touchPoints.at(i);
-            if (touchPoint.id() == m_touchMouseId) {
-                touchMouse = &touchPoint;
-            }
-        }
-
-        Q_ASSERT(touchMouse);
-        if (!touchMouse) {
-            // should not happen, but deal with it just in case.
-            qWarning("[TouchDispatcher] Didn't find touch with id %d, used for mouse pointer emulation.",
-                    m_touchMouseId);
-            m_touchMouseId = touchPoints.at(0).id();
-            touchMouse = &touchPoints.at(0);
-        }
-    } else {
-        // Try to find a new touch for mouse emulation
-        for (int i = 0; i < touchPoints.count() && !touchMouse; ++i) {
-            const auto &touchPoint = touchPoints.at(i);
-            if (touchPoint.state() == Qt::TouchPointPressed) {
-                touchMouse = &touchPoint;
-                m_touchMouseId = touchMouse->id();
-            }
-        }
-    }
-
-    if (touchMouse) {
-        QEvent::Type eventType;
-        if (touchMouse->state() == Qt::TouchPointPressed) {
-            eventType = QEvent::MouseButtonPress;
-        } if (touchMouse->state() == Qt::TouchPointReleased) {
-            eventType = QEvent::MouseButtonRelease;
-            m_touchMouseId = -1;
-        } else {
-            eventType = QEvent::MouseMove;
-        }
-
-        QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(eventType, *touchMouse, timestamp, modifiers,
-                    true /* transformNeeded */));
-
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
-                << "to" << m_targetItem.data();
-        #endif
-        QCoreApplication::sendEvent(m_targetItem.data(), mouseEvent.data());
-    }
-}
-
-QTouchEvent *TouchDispatcher::createQTouchEvent(QEvent::Type eventType,
-        QTouchDevice *device,
-        Qt::KeyboardModifiers modifiers,
-        const QList<QTouchEvent::TouchPoint> &touchPoints,
-        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(m_targetItem.data());
-    touchEvent->setDevice(device);
-    touchEvent->setModifiers(modifiers);
-    touchEvent->setTouchPoints(touchPoints);
-    touchEvent->setTouchPointStates(eventStates);
-    touchEvent->setTimestamp(timestamp);
-    touchEvent->accept();
-    return touchEvent;
-}
-
-// NB: From QQuickWindow
-void TouchDispatcher::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());
-    }
-}
-
-// Copied with minor modifications from qtdeclarative/src/quick/items/qquickwindow.cpp
-QMouseEvent *TouchDispatcher::touchToMouseEvent(
-        QEvent::Type type, const QTouchEvent::TouchPoint &p,
-        ulong timestamp, Qt::KeyboardModifiers modifiers,
-        bool transformNeeded)
-{
-    QQuickItem *item = m_targetItem.data();
-
-    // The touch point local position and velocity are not yet transformed.
-    QMouseEvent *me = new QMouseEvent(type, transformNeeded ? item->mapFromScene(p.scenePos()) : p.pos(),
-                                      p.scenePos(), p.screenPos(), Qt::LeftButton,
-                                      (type == QEvent::MouseButtonRelease ? Qt::NoButton : Qt::LeftButton),
-                                      modifiers);
-    me->setAccepted(true);
-    me->setTimestamp(timestamp);
-    QVector2D transformedVelocity = p.velocity();
-    if (transformNeeded) {
-        QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
-        QMatrix4x4 transformMatrix(itemPrivate->windowToItemTransform());
-        transformedVelocity = transformMatrix.mapVector(p.velocity()).toVector2D();
-    }
-
-    // Add these later if needed:
-    //QGuiApplicationPrivate::setMouseEventCapsAndVelocity(me, event->device()->capabilities(), transformedVelocity);
-    //QGuiApplicationPrivate::setMouseEventSource(me, Qt::MouseEventSynthesizedByQt);
-    return me;
-}
-
-/*
-    Copied from qquickwindow.cpp which has:
-    Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies)
-    Under GPL 3.0 license.
-*/
-bool TouchDispatcher::checkIfDoubleClicked(ulong newPressEventTimestamp)
-{
-    bool doubleClicked;
-
-    if (m_touchMousePressTimestamp == 0) {
-        // just initialize the variable
-        m_touchMousePressTimestamp = newPressEventTimestamp;
-        doubleClicked = false;
-    } else {
-        ulong timeBetweenPresses = newPressEventTimestamp - m_touchMousePressTimestamp;
-        ulong doubleClickInterval = static_cast<ulong>(qApp->styleHints()->
-                mouseDoubleClickInterval());
-        doubleClicked = timeBetweenPresses < doubleClickInterval;
-        if (doubleClicked) {
-            m_touchMousePressTimestamp = 0;
-        } else {
-            m_touchMousePressTimestamp = newPressEventTimestamp;
-        }
-    }
-
-    return doubleClicked;
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.h	1970-01-01 00:00:00 +0000
@@ -1,89 +0,0 @@
-/*
- * 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_DISPATCHER_H
-#define UBUNTU_TOUCH_DISPATCHER_H
-
-#include "UbuntuGesturesQmlGlobal.h"
-
-#include <QPointer>
-#include <QQuickItem>
-
-/*
-   Dispatches touches to the given target, converting the touch point
-   coordinates accordingly.
-
-   Also takes care of synthesizing mouse events in case the target
-   doesn't work with touch events.
- */
-class UBUNTUGESTURESQML_EXPORT TouchDispatcher {
-public:
-    TouchDispatcher();
-
-    void setTargetItem(QQuickItem *target);
-    QQuickItem *targetItem() { return m_targetItem; }
-
-    void dispatch(QEvent::Type eventType,
-            QTouchDevice *device,
-            Qt::KeyboardModifiers modifiers,
-            const QList<QTouchEvent::TouchPoint> &touchPoints,
-            QWindow *window,
-            ulong timestamp);
-private:
-    void dispatchTouchBegin(
-            QTouchDevice *device,
-            Qt::KeyboardModifiers modifiers,
-            const QList<QTouchEvent::TouchPoint> &touchPoints,
-            QWindow *window,
-            ulong timestamp);
-    void dispatchAsTouch(QEvent::Type eventType,
-            QTouchDevice *device,
-            Qt::KeyboardModifiers modifiers,
-            const QList<QTouchEvent::TouchPoint> &touchPoints,
-            QWindow *window,
-            ulong timestamp);
-    void dispatchAsMouse(
-            QTouchDevice *device,
-            Qt::KeyboardModifiers modifiers,
-            const QList<QTouchEvent::TouchPoint> &touchPoints,
-            ulong timestamp);
-
-    static void transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform);
-    QTouchEvent *createQTouchEvent(QEvent::Type eventType,
-            QTouchDevice *device,
-            Qt::KeyboardModifiers modifiers,
-            const QList<QTouchEvent::TouchPoint> &touchPoints,
-            QWindow *window,
-            ulong timestamp);
-    QMouseEvent *touchToMouseEvent(QEvent::Type type, const QTouchEvent::TouchPoint &p,
-            ulong timestamp, Qt::KeyboardModifiers modifiers, bool transformNeeded = true);
-
-    bool checkIfDoubleClicked(ulong newPressEventTimestamp);
-
-    QPointer<QQuickItem> m_targetItem;
-
-    enum {
-        NoActiveTouch,
-        DeliveringTouchEvents,
-        DeliveringMouseEvents,
-        TargetRejectedTouches
-    } m_status;
-
-    int m_touchMouseId;
-    ulong m_touchMousePressTimestamp;
-};
-
-#endif // UBUNTU_TOUCH_DISPATCHER_H

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.cpp	2015-03-17 15:14:11 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.cpp	1970-01-01 00:00:00 +0000
@@ -1,253 +0,0 @@
-/*
- * 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>
-
-#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);
-
-            Q_EMIT pressed();
-        }
-
-        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_dispatcher.targetItem())
-        return;
-
-    m_dispatcher.setTargetItem(item);
-    Q_EMIT targetItemChanged(item);
-}
-
-void TouchGate::dispatchTouchEventToTarget(const TouchEvent &event)
-{
-    removeTouchInfoForEndedTouches(event.touchPoints);
-    m_dispatcher.dispatch(event.eventType,
-            event.device,
-            event.modifiers,
-            event.touchPoints,
-            event.window,
-            event.timestamp);
-}
-
-void TouchGate::dispatchTouchEventToTarget(QTouchEvent* event)
-{
-    removeTouchInfoForEndedTouches(event->touchPoints());
-    m_dispatcher.dispatch(event->type(),
-            event->device(),
-            event->modifiers(),
-            event->touchPoints(),
-            event->window(),
-            event->timestamp());
-}
-
-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(qobject_cast<QQuickItem*>(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;
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.h	2015-03-17 15:14:11 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.h	1970-01-01 00:00:00 +0000
@@ -1,112 +0,0 @@
-/*
- * 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 "TouchDispatcher.h"
-
-#include <QQuickItem>
-#include <QList>
-#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_dispatcher.targetItem(); }
-    void setTargetItem(QQuickItem *item);
-
-Q_SIGNALS:
-    void targetItemChanged(QQuickItem *item);
-
-    void pressed();
-
-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;
-        QQuickItem *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 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;
-
-    TouchDispatcher m_dispatcher;
-
-    friend class tst_TouchGate;
-};
-
-#endif // UBUNTU_TOUCH_GATE_H

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h	1970-01-01 00:00:00 +0000
@@ -1,23 +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/>.
- */
-
-#include <QtCore/QtGlobal>
-
-#if defined(UBUNTUGESTURESQML_LIBRARY)
-#  define UBUNTUGESTURESQML_EXPORT Q_DECL_EXPORT
-#else
-#  define UBUNTUGESTURESQML_EXPORT Q_DECL_IMPORT
-#endif

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/plugin.cpp'
--- src/app/unity8/plugins/Ubuntu/Gestures/plugin.cpp	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/plugin.cpp	1970-01-01 00:00:00 +0000
@@ -1,39 +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/>.
- */
-
-#include "plugin.h"
-#include "AxisVelocityCalculator.h"
-#include "Direction.h"
-#include "DirectionalDragArea.h"
-#include "PressedOutsideNotifier.h"
-#include "TouchGate.h"
-
-#include <qqml.h>
-
-static QObject* directionSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
-  Q_UNUSED(engine);
-  Q_UNUSED(scriptEngine);
-  return new Direction;
-}
-
-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");
-}

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/plugin.h'
--- src/app/unity8/plugins/Ubuntu/Gestures/plugin.h	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/plugin.h	1970-01-01 00:00:00 +0000
@@ -1,31 +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/>.
- */
-
-#ifndef PLUGIN_H
-#define PLUGIN_H
-
-#include <QtQml/QQmlExtensionPlugin>
-
-class UbuntuGesturesQmlPlugin : public QQmlExtensionPlugin
-{
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
-public:
-    void registerTypes(const char *uri);
-};
-
-
-#endif

=== removed file 'src/app/unity8/plugins/Ubuntu/Gestures/qmldir'
--- src/app/unity8/plugins/Ubuntu/Gestures/qmldir	2015-02-04 10:56:38 +0000
+++ src/app/unity8/plugins/Ubuntu/Gestures/qmldir	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-module Ubuntu.Gestures
-plugin UbuntuGesturesQml
-typeinfo Gestures.qmltypes

=== modified file 'src/app/webbrowser/BottomEdgeHandle.qml'
--- src/app/webbrowser/BottomEdgeHandle.qml	2015-08-10 15:22:00 +0000
+++ src/app/webbrowser/BottomEdgeHandle.qml	2016-04-12 20:15:29 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2015 Canonical Ltd.
+ * Copyright 2014-2016 Canonical Ltd.
  *
  * This file is part of webbrowser-app.
  *
@@ -17,20 +17,12 @@
  */
 
 import QtQuick 2.4
-import Ubuntu.Gestures 0.1
-
-DirectionalDragArea {
-    direction: Direction.Upwards
-
-    // default values taken from unity8’s EdgeDragArea component
-    maxDeviation: units.gu(3)
-    wideningAngle: 50
-    distanceThreshold: units.gu(1.5)
-    minSpeed: 0
-    maxSilenceTime: 200
-    compositionTime: 60
-
-    readonly property real dragFraction: dragging ? Math.min(1.0, Math.max(0.0, sceneDistance / parent.height)) : 0.0
+import Ubuntu.Components 1.3
+
+SwipeArea {
+    direction: SwipeArea.Upwards
+
+    readonly property real dragFraction: dragging ? Math.min(1.0, Math.max(0.0, distance / parent.height)) : 0.0
     readonly property var thresholds: [0.05, 0.18, 0.36, 0.54, 1.0]
     readonly property int stage: thresholds.map(function(t) { return dragFraction <= t }).indexOf(true)
 }