Merge lp:~ci-train-bot/unity8/unity8-ubuntu-yakkety-landing-059 into lp:unity8

[Michał Sawicz]

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-05-18 11:17:20 +0000
+++ CMakeLists.txt	2016-06-01 16:58:47 +0000
@@ -57,12 +57,24 @@
 find_package(Qt5Concurrent 5.4 REQUIRED)
 find_package(Qt5Sql 5.4 REQUIRED)
 
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=16)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=17)
 pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)
 pkg_check_modules(GIO REQUIRED gio-2.0>=2.32)
 pkg_check_modules(GLIB REQUIRED glib-2.0>=2.32)
 pkg_check_modules(QMENUMODEL REQUIRED qmenumodel)
 
+pkg_check_modules(UBUNTUGESTURES REQUIRED UbuntuGestures)
+
+### Check UbuntuGestures private headers. No pkg-config (.pc) file is provided for them
+find_path(UBUNTUGESTUREPRIV
+    NAMES UbuntuGestures/private/damper_p.h UbuntuGestures/private/ucswipearea_p.h UbuntuGestures/private/ucswipearea_p_p.h
+    PATHS ${UBUNTUGESTURES_INCLUDEDIR}/UbuntuGestures/${UBUNTUGESTURES_VERSION}
+    NO_DEFAULT_PATH)
+if (${UBUNTUGESTUREPRIV} STREQUAL UBUNTUGESTUREPRIV-NOTFOUND)
+   message(FATAL_ERROR "UbuntuGestures private headers not found.")
+endif()
+# end of UbuntuGesture private headers check
+
 # Standard install paths
 include(GNUInstallDirs)
 
@@ -144,7 +156,6 @@
 
 # add subdirectories to build
 add_subdirectory(include)
-add_subdirectory(libs)
 add_subdirectory(src)
 add_subdirectory(tools)
 add_subdirectory(qml)

=== modified file 'debian/changelog'
--- debian/changelog	2016-05-20 08:44:19 +0000
+++ debian/changelog	2016-06-01 16:58:47 +0000
@@ -1,3 +1,68 @@
+unity8 (8.12+16.10.20160527-0ubuntu1) yakkety; urgency=medium
+
+  [ Albert Astals Cid ]
+  * Activate on click for SimpleMessages (LP: #1421696)
+  * Add override
+  * Change the art back to the cardData value if it changes from broken
+    to valid image (LP: #1533577)
+  * Concierge mode generated code optimization
+  * Don't use context properties but properties of the delegates
+  * Listen to contentItem::widthChanged instead of
+    Flickable::contentWidthChanged (LP: #1565763)
+  * Make some AP code faster
+  * Make tests a bit more stable
+  * Make unity8 and unity8-dash handle termination signals
+  * Remove  workaround not needed anymore (LP: #1475643)
+  * Resolve cardArtStyle on compile time
+  * Set the theme earlier (LP: #1574048)
+
+  [ Albert Astals Cid, Daniel d'Andrada ]
+  * Remove DirectionalDragArea and libs/UbuntuGestures and port to SDK
+    equivalents
+
+  [ Andrea Cimitan ]
+  * Hide the preview review input field when a rating is required (LP:
+    #1541971)
+
+  [ CI Train Bot ]
+  * Resync trunk.
+
+  [ Daniel d'Andrada ]
+  * Fix DragHandle so it works in all directions
+  * Support animated cursors
+  * WindowInputMonitor - also map Qt::Key_HomePage to our home key
+  * plugins/Cursor: properly register to the screen's QPlatformCursor
+    when screen changes (LP: #1579742)
+
+  [ Josh Arenson ]
+  * Close the PageHeaderExtraPanel when a filter option is selected (LP:
+    #1569498)
+  * Wrap primaryFilter in a flickable to make it behave nicely. (LP:
+    #1569492)
+
+  [ Lukáš Tinkl ]
+  * First snap decision should always be expanded, unless user decides
+    otherwise (LP: #1580090, #1575045)
+  * Fullscreen notification bug fixes (LP: #1583944, #1581498, #1422711)
+  * Implement maximizing windows horizontally/vertically
+  * Lock the session when putting the laptop into sleep (LP: #1581063)
+
+  [ Lukáš Tinkl, Michael Terry ]
+  * With a maximized window, "dragging" the panel down should restore it
+
+  [ Michael Terry ]
+  * Change some dash button colors from orange to green. (LP: #1581047)
+  * Use PageHeader instead Ambiance's PageHeadStyle
+  * Use new setTimeZone method to set user-friendly timezone name in the
+    wizard. (LP: #1566295)
+
+  [ Michael Zanetti ]
+  * Remove the background dimming when the launcher is revealed by a
+    drag (LP: #1575137)
+  * reenable or drop disabled tests
+
+ -- Michael Terry <[e-mail]>  Fri, 27 May 2016 13:54:44 +0000
+
 unity8 (8.12+16.10.20160520.1-0ubuntu1) yakkety; urgency=medium
 
   [ Lukáš Tinkl ]

=== modified file 'debian/control'
--- debian/control	2016-05-17 19:42:10 +0000
+++ debian/control	2016-06-01 16:58:47 +0000
@@ -29,8 +29,10 @@
                libqt5svg5-dev,
                libqt5xmlpatterns5-dev,
                libsystemsettings-dev,
+               libubuntugestures5-dev,
+               libubuntugestures5-private-dev,
                libudev-dev,
-               libunity-api-dev (>= 7.112),
+               libunity-api-dev (>= 7.113),
                libusermetricsoutput1-dev,
 # Need those X11 libs touch emulation from mouse events in manual QML tests on a X11 desktop
                libx11-dev[!armhf],
@@ -106,7 +108,7 @@
          qtdeclarative5-qtmir-plugin (>= 0.4.8),
          qtdeclarative5-ubuntu-telephony0.1,
          qtdeclarative5-ubuntu-web-plugin,
-         ubuntu-system-settings,
+         ubuntu-system-settings (>= 0.4),
          unity-launcher-impl-7,
          unity8-common (= ${source:Version}),
          unity8-private (= ${binary:Version}),
@@ -133,7 +135,7 @@
          qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1845) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1845),
          qtdeclarative5-unity-notifications-plugin (>= 0.1.2) | unity-notifications-impl,
          ubuntu-thumbnailer-impl-0,
-         unity-application-impl-16,
+         unity-application-impl-17,
          unity-notifications-impl-3,
          unity-plugin-scopes | unity-scopes-impl,
          unity-scopes-impl-12,

=== modified file 'debian/unity8-private.install'
--- debian/unity8-private.install	2016-04-28 12:06:22 +0000
+++ debian/unity8-private.install	2016-06-01 16:58:47 +0000
@@ -1,5 +1,4 @@
 usr/lib/*/libunity8-private.*
-usr/lib/*/unity8/libUbuntuGestures*
 usr/lib/*/unity8/qml/AccountsService
 usr/lib/*/unity8/qml/Cursor
 usr/lib/*/unity8/qml/Dash

=== removed directory 'libs'
=== removed file 'libs/CMakeLists.txt'
--- libs/CMakeLists.txt	2014-10-01 13:20:32 +0000
+++ libs/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-add_subdirectory(UbuntuGestures)

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

=== removed file 'libs/UbuntuGestures/CandidateInactivityTimer.cpp'
--- libs/UbuntuGestures/CandidateInactivityTimer.cpp	2015-04-17 18:31:12 +0000
+++ libs/UbuntuGestures/CandidateInactivityTimer.cpp	1970-01-01 00:00:00 +0000
@@ -1,46 +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,
-        AbstractTimer *timer, QObject *parent)
-    : QObject(parent)
-    , m_timer(timer)
-    , m_touchId(touchId)
-    , m_candidate(candidate)
-{
-    connect(m_timer, &AbstractTimer::timeout,
-            this, &CandidateInactivityTimer::onTimeout);
-    m_timer->setInterval(durationMs);
-    m_timer->setSingleShot(true);
-    m_timer->start();
-}
-
-CandidateInactivityTimer::~CandidateInactivityTimer()
-{
-    delete m_timer;
-}
-
-void CandidateInactivityTimer::onTimeout()
-{
-    qWarning("[TouchRegistry] Candidate for touch %d defaulted!", m_touchId);
-    Q_EMIT candidateDefaulted(m_touchId, m_candidate);
-}
-
-} // namespace UbuntuGestures

=== removed file 'libs/UbuntuGestures/CandidateInactivityTimer.h'
--- libs/UbuntuGestures/CandidateInactivityTimer.h	2015-04-17 18:31:12 +0000
+++ libs/UbuntuGestures/CandidateInactivityTimer.h	1970-01-01 00:00:00 +0000
@@ -1,51 +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,
-                             AbstractTimer *timer,
-                             QObject *parent = nullptr);
-
-    virtual ~CandidateInactivityTimer();
-
-    const int durationMs = 1000;
-
-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 'libs/UbuntuGestures/DebugHelpers.cpp'
--- libs/UbuntuGestures/DebugHelpers.cpp	2015-09-14 09:11:08 +0000
+++ 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 QStringLiteral("pressed");
-    case Qt::TouchPointMoved:
-        return QStringLiteral("moved");
-    case Qt::TouchPointStationary:
-        return QStringLiteral("stationary");
-    case Qt::TouchPointReleased:
-        return QStringLiteral("released");
-    default:
-        return QStringLiteral("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(
-            QStringLiteral("(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(QStringLiteral("pos(%1, %2)").arg(ev->x()).arg(ev->y()));
-
-    return message;
-}

=== removed file 'libs/UbuntuGestures/DebugHelpers.h'
--- libs/UbuntuGestures/DebugHelpers.h	2014-10-17 11:01:53 +0000
+++ 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 'libs/UbuntuGestures/Pool.h'
--- libs/UbuntuGestures/Pool.h	2015-11-20 15:01:39 +0000
+++ libs/UbuntuGestures/Pool.h	1970-01-01 00:00:00 +0000
@@ -1,124 +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; }
-
-        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 'libs/UbuntuGestures/TimeSource.cpp'
--- libs/UbuntuGestures/TimeSource.cpp	2015-04-10 21:16:37 +0000
+++ libs/UbuntuGestures/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 'libs/UbuntuGestures/TimeSource.h'
--- libs/UbuntuGestures/TimeSource.h	2015-04-10 21:16:37 +0000
+++ libs/UbuntuGestures/TimeSource.h	1970-01-01 00:00:00 +0000
@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2013,2015 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 "UbuntuGesturesGlobal.h"
-#include <QSharedPointer>
-
-namespace UbuntuGestures {
-/*
-    Interface for a time source.
- */
-class UBUNTUGESTURES_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 UBUNTUGESTURES_EXPORT RealTimeSource : public TimeSource {
-public:
-    RealTimeSource();
-    virtual ~RealTimeSource();
-    qint64 msecsSinceReference() override;
-private:
-    RealTimeSourcePrivate *d;
-};
-
-/*
-    A fake time source, useful for tests
- */
-class FakeTimeSource : public TimeSource {
-public:
-    FakeTimeSource() { m_msecsSinceReference = 0; }
-    qint64 msecsSinceReference() override { return m_msecsSinceReference; }
-    qint64 m_msecsSinceReference;
-};
-
-} // namespace UbuntuGestures
-
-#endif // UBUNTUGESTURES_TIMESOURCE_H

=== removed file 'libs/UbuntuGestures/Timer.cpp'
--- libs/UbuntuGestures/Timer.cpp	2015-04-24 13:19:24 +0000
+++ libs/UbuntuGestures/Timer.cpp	1970-01-01 00:00:00 +0000
@@ -1,152 +0,0 @@
-/*
- * Copyright (C) 2014-2015 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(const SharedTimeSource &timeSource, QObject *parent)
-    : UbuntuGestures::AbstractTimer(parent)
-    , m_interval(0)
-    , m_singleShot(false)
-    , m_timeSource(timeSource)
-{
-}
-
-void FakeTimer::update()
-{
-    if (!isRunning()) {
-        return;
-    }
-
-    if (m_nextTimeoutTime <= m_timeSource->msecsSinceReference()) {
-        if (isSingleShot()) {
-            stop();
-        } else {
-            m_nextTimeoutTime += interval();
-        }
-        Q_EMIT timeout();
-    }
-}
-
-void FakeTimer::start()
-{
-    AbstractTimer::start();
-    m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)interval();
-}
-
-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 //////////////////////////////////
-
-FakeTimerFactory::FakeTimerFactory()
-{
-    m_timeSource.reset(new FakeTimeSource);
-}
-
-void FakeTimerFactory::updateTime(qint64 targetTime)
-{
-    qint64 minTimeoutTime = targetTime;
-
-    for (int i = 0; i < timers.count(); ++i) {
-        FakeTimer *timer = timers[i].data();
-        if (timer && timer->isRunning() && timer->nextTimeoutTime() < minTimeoutTime) {
-            minTimeoutTime = timer->nextTimeoutTime();
-        }
-    }
-
-    m_timeSource->m_msecsSinceReference = minTimeoutTime;
-
-    for (int i = 0; i < timers.count(); ++i) {
-        FakeTimer *timer = timers[i].data();
-        if (timer) {
-            timer->update();
-        }
-    }
-
-    if (m_timeSource->msecsSinceReference() < targetTime) {
-        updateTime(targetTime);
-    }
-}
-
-AbstractTimer *FakeTimerFactory::createTimer(QObject *parent)
-{
-    FakeTimer *fakeTimer = new FakeTimer(m_timeSource, parent);
-
-    timers.append(fakeTimer);
-
-    return fakeTimer;
-}
-
-} // namespace UbuntuGestures

=== removed file 'libs/UbuntuGestures/Timer.h'
--- libs/UbuntuGestures/Timer.h	2016-03-29 03:47:39 +0000
+++ libs/UbuntuGestures/Timer.h	1970-01-01 00:00:00 +0000
@@ -1,122 +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 "TimeSource.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 start(int msecs)
-    {
-        setInterval(msecs);
-        start();
-    }
-    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(const SharedTimeSource &timeSource, QObject *parent = nullptr);
-
-    void update();
-    qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }
-
-    int interval() const override;
-    void setInterval(int msecs) override;
-    void start() override;
-    bool isSingleShot() const override;
-    void setSingleShot(bool value) override;
-private:
-    int m_interval;
-    bool m_singleShot;
-    SharedTimeSource m_timeSource;
-    qint64 m_nextTimeoutTime;
-};
-
-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:
-    FakeTimerFactory();
-    virtual ~FakeTimerFactory() {}
-
-    void updateTime(qint64 msecsSinceReference);
-    QSharedPointer<TimeSource> timeSource() { return m_timeSource; }
-
-    AbstractTimer *createTimer(QObject *parent = nullptr) override;
-    QList<QPointer<FakeTimer>> timers;
-private:
-    QSharedPointer<FakeTimeSource> m_timeSource;
-};
-
-} // namespace UbuntuGestures
-
-#endif // UBUNTUGESTURES_TIMER_H

=== removed file 'libs/UbuntuGestures/TouchOwnershipEvent.cpp'
--- libs/UbuntuGestures/TouchOwnershipEvent.cpp	2014-10-01 13:20:32 +0000
+++ 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 'libs/UbuntuGestures/TouchOwnershipEvent.h'
--- libs/UbuntuGestures/TouchOwnershipEvent.h	2014-10-01 13:20:32 +0000
+++ 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 'libs/UbuntuGestures/TouchRegistry.cpp'
--- libs/UbuntuGestures/TouchRegistry.cpp	2016-03-29 03:47:39 +0000
+++ libs/UbuntuGestures/TouchRegistry.cpp	1970-01-01 00:00:00 +0000
@@ -1,553 +0,0 @@
-/*
- * Copyright (C) 2014-2015 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)
-    : QObject(parent)
-    , m_inDispatchLoop(false)
-    , m_timerFactory(new TimerFactory)
-{
-}
-
-TouchRegistry::~TouchRegistry()
-{
-    Q_ASSERT(m_instance != nullptr);
-    m_instance = nullptr;
-    delete m_timerFactory;
-}
-
-TouchRegistry *TouchRegistry::instance()
-{
-    if (m_instance == nullptr) {
-        m_instance = new TouchRegistry;
-    }
-    return m_instance;
-}
-
-void TouchRegistry::setTimerFactory(AbstractTimerFactory *timerFactory)
-{
-    delete m_timerFactory;
-    m_timerFactory = 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.
-
-    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.
-    QHash<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());
-                        if (candidate.state != CandidateInfo::InterimOwner) {
-                            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.state = CandidateInfo::Undecided;
-    candidateInfo.item = candidate;
-    candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,
-                                                                 m_timerFactory->createTimer(),
-                                                                 this);
-    connect(candidateInfo.inactivityTimer, &CandidateInactivityTimer::candidateDefaulted,
-            this, &TouchRegistry::rejectCandidateOwnerForTouch);
-
-    touchInfo->candidates.append(candidateInfo);
-
-    connect(candidate, &QObject::destroyed, this, [=](){ pruneNullCandidatesForTouch(id); });
-}
-
-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"); }
-
-
-    // TODO: check if the candidate is in fact the owner of the touch
-
-    bool removed = false;
-    for (int i = 0; i < touchInfo->candidates.count() && !removed; ++i) {
-        if (touchInfo->candidates[i].item == candidate) {
-            removeCandidateOwnerForTouchByIndex(touchInfo, i);
-            removed = true;
-        }
-    }
-}
-
-void TouchRegistry::pruneNullCandidatesForTouch(int touchId)
-{
-    #if TOUCHREGISTRY_DEBUG
-    UG_DEBUG << "pruneNullCandidatesForTouch touchId" << touchId;
-    #endif
-
-    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(touchId);
-    if (!touchInfo) {
-        // doesn't matter as touch is already gone.
-        return;
-    }
-
-    int i = 0;
-    while (i < touchInfo->candidates.count()) {
-        if (touchInfo->candidates[i].item.isNull()) {
-            removeCandidateOwnerForTouchByIndex(touchInfo, i);
-        } else {
-            ++i;
-        }
-    }
-}
-
-void TouchRegistry::removeCandidateOwnerForTouchByIndex(Pool<TouchRegistry::TouchInfo>::Iterator &touchInfo,
-        int candidateIndex)
-{
-    // TODO: check if the candidate is in fact the owner of the touch
-
-    Q_ASSERT(candidateIndex < touchInfo->candidates.count());
-
-    if (candidateIndex == 0 && touchInfo->candidates[candidateIndex].state != CandidateInfo::Undecided) {
-        qCritical("TouchRegistry: touch owner is being removed.");
-    }
-    removeCandidateHelper(touchInfo, candidateIndex);
-
-    if (candidateIndex == 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)
-{
-    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.state = CandidateInfo::Requested;
-            delete candidateInfo.inactivityTimer;
-            candidateInfo.inactivityTimer = nullptr;
-            candidateIndex = i;
-            break;
-        }
-    }
-    #if TOUCHREGISTRY_DEBUG
-    UG_DEBUG << "requestTouchOwnership id " << id << "candidate" << candidate << "index: " << candidateIndex;
-    #endif
-
-    // add it as a candidate if not present yet
-    if (candidateIndex < 0) {
-        CandidateInfo candidateInfo;
-        candidateInfo.state = CandidateInfo::InterimOwner;
-        candidateInfo.item = candidate;
-        candidateInfo.inactivityTimer = nullptr;
-        touchInfo->candidates.append(candidateInfo);
-        // it's the last one
-        candidateIndex = touchInfo->candidates.count() - 1;
-        connect(candidate, &QObject::destroyed, this, [=](){ pruneNullCandidatesForTouch(id); });
-    }
-
-    // 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.state == CandidateInfo::Undecided);
-            if (i == 0 && candidateInfo.state != 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);
-    }
-
-    removeCandidateHelper(touchInfo, 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();
-        }
-    }
-}
-
-void TouchRegistry::removeCandidateHelper(Pool<TouchInfo>::Iterator &touchInfo, int candidateIndex)
-{
-    {
-        CandidateInfo &candidateInfo = touchInfo->candidates[candidateIndex];
-
-        delete candidateInfo.inactivityTimer;
-        candidateInfo.inactivityTimer = nullptr;
-
-        if (candidateInfo.item) {
-            disconnect(candidateInfo.item.data(), nullptr, this, nullptr);
-        }
-    }
-    touchInfo->candidates.removeAt(candidateIndex);
-}
-
-////////////////////////////////////// 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().state != CandidateInfo::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
-
-    // need to take a copy of the item list in case
-    // we call back in to remove candidate during the lost ownership event.
-    QList<QPointer<QQuickItem>> items;
-    Q_FOREACH(const CandidateInfo& info, candidates) {
-        items << info.item;
-    }
-
-    TouchOwnershipEvent gainedOwnershipEvent(id, true /*gained*/);
-    QCoreApplication::sendEvent(items[0], &gainedOwnershipEvent);
-
-    TouchOwnershipEvent lostOwnershipEvent(id, false /*gained*/);
-    for (int i = 1; i < items.count(); ++i) {
-        #if TOUCHREGISTRY_DEBUG
-        UG_DEBUG << "sending TouchOwnershipEvent(id =" << id << " lost) to candidate"
-            << items[i];
-        #endif
-        QCoreApplication::sendEvent(items[i], &lostOwnershipEvent);
-    }
-}

=== removed file 'libs/UbuntuGestures/TouchRegistry.h'
--- libs/UbuntuGestures/TouchRegistry.h	2015-07-20 16:30:40 +0000
+++ libs/UbuntuGestures/TouchRegistry.h	1970-01-01 00:00:00 +0000
@@ -1,201 +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 "Timer.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);
-        touchEvent->accept();
-  He won't get any UnownedTouchEvent for that touch as he is already the interim owner (ie, QQuickWindow
-  will keep sending touch updates to him already). Eventually he will be notified once ownership has
-  been granted to him (from TouchRegistry perspective), 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:
-    virtual ~TouchRegistry();
-
-    // Returns a pointer to the application's TouchRegistry instance.
-    static TouchRegistry *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);
-
-    // Useful for tests, where you should use fake timers
-    void setTimerFactory(UbuntuGestures::AbstractTimerFactory *timerFactory);
-
-private Q_SLOTS:
-    void rejectCandidateOwnerForTouch(int id, QQuickItem *candidate);
-
-private:
-    // Only instance() can cronstruct one
-    TouchRegistry(QObject *parent = nullptr);
-
-    class CandidateInfo {
-    public:
-        enum {
-            // A candidate owner that doesn't yet know for sure whether he wants the touch point
-            // (gesture recognition is stilll going on)
-            Undecided = 0,
-            // A candidate owner that wants the touch but hasn't been granted it yet,
-            // most likely because there's an undecided candidate with higher priority
-            Requested = 1,
-            // An item that is the interim owner of the touch, receiving QTouchEvents of it
-            // from QQuickWindow. Ie, it's the actual touch owner from Qt's point of view.
-            // It wants to keep its touch ownership but hasn't been granted it by TouchRegistry
-            // yet because of undecided candidates higher up.
-            InterimOwner = 2
-        } state;
-        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;
-    };
-
-    void pruneNullCandidatesForTouch(int touchId);
-    void removeCandidateOwnerForTouchByIndex(Pool<TouchInfo>::Iterator &touchInfo, int candidateIndex);
-    void removeCandidateHelper(Pool<TouchInfo>::Iterator &touchInfo, int candidateIndex);
-
-    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 'libs/UbuntuGestures/UbuntuGesturesGlobal.h'
--- libs/UbuntuGestures/UbuntuGesturesGlobal.h	2014-10-01 13:20:32 +0000
+++ 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 'libs/UbuntuGestures/UnownedTouchEvent.cpp'
--- libs/UbuntuGestures/UnownedTouchEvent.cpp	2014-10-01 13:20:32 +0000
+++ 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 'libs/UbuntuGestures/UnownedTouchEvent.h'
--- libs/UbuntuGestures/UnownedTouchEvent.h	2014-10-01 13:20:32 +0000
+++ 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 'plugins/Cursor/CMakeLists.txt'
--- plugins/Cursor/CMakeLists.txt	2015-09-29 13:45:05 +0000
+++ plugins/Cursor/CMakeLists.txt	2016-06-01 16:58:47 +0000
@@ -8,8 +8,9 @@
 
 set(QMLPLUGIN_SRC
     plugin.cpp
+    CursorImageInfo.cpp
+    CursorImageProvider.cpp
     MousePointer.cpp
-    CursorImageProvider.cpp
     # We need to run moc on this header
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
     )

=== modified file 'plugins/Cursor/Cursor.qml'
--- plugins/Cursor/Cursor.qml	2015-12-03 15:00:04 +0000
+++ plugins/Cursor/Cursor.qml	2016-06-01 16:58:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Canonical, Ltd.
+ * Copyright (C) 2015-2016 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
@@ -15,14 +15,30 @@
  */
 
 import QtQuick 2.4
-import Cursor 1.0 // For MousePointer
+import Cursor 1.1
 
 MousePointer {
     id: mousePointer
 
-    Image {
-        x: -mousePointer.hotspotX
-        y: -mousePointer.hotspotY
+    CursorImageInfo {
+        id: imageInfo
+        themeName: mousePointer.themeName
+        cursorName: mousePointer.cursorName
+    }
+
+    AnimatedSprite {
+        x: -imageInfo.hotspot.x
+        y: -imageInfo.hotspot.y
         source: "image://cursor/" + mousePointer.themeName + "/" + mousePointer.cursorName
+
+        interpolate: false
+
+        width: imageInfo.frameWidth
+        height: imageInfo.frameHeight
+
+        frameCount: imageInfo.frameCount
+        frameDuration: imageInfo.frameDuration
+        frameWidth: imageInfo.frameWidth
+        frameHeight: imageInfo.frameHeight
     }
 }

=== removed file 'plugins/Cursor/Cursor.qmltypes'
--- plugins/Cursor/Cursor.qmltypes	2016-03-11 20:18:12 +0000
+++ plugins/Cursor/Cursor.qmltypes	1970-01-01 00:00:00 +0000
@@ -1,78 +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 Cursor 1.0 plugins'
-
-Module {
-    Component {
-        name: "MirMousePointerInterface"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        Property { name: "cursorName"; type: "string"; isReadonly: true }
-        Property { name: "themeName"; type: "string"; isReadonly: true }
-        Property { name: "hotspotX"; type: "double"; isReadonly: true }
-        Property { name: "hotspotY"; type: "double"; isReadonly: true }
-        Signal {
-            name: "cursorNameChanged"
-            Parameter { name: "name"; type: "string" }
-        }
-        Signal {
-            name: "themeNameChanged"
-            Parameter { name: "name"; type: "string" }
-        }
-        Signal {
-            name: "hotspotXChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "hotspotYChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Method {
-            name: "handleMouseEvent"
-            Parameter { name: "timestamp"; type: "ulong" }
-            Parameter { name: "movement"; type: "QPointF" }
-            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
-            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
-        }
-        Method {
-            name: "handleWheelEvent"
-            Parameter { name: "timestamp"; type: "ulong" }
-            Parameter { name: "angleDelta"; type: "QPoint" }
-            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
-        }
-    }
-    Component {
-        name: "MousePointer"
-        defaultProperty: "data"
-        prototype: "MirMousePointerInterface"
-        exports: ["Cursor/MousePointer 1.0"]
-        exportMetaObjectRevisions: [0]
-        Signal {
-            name: "pushedLeftBoundary"
-            Parameter { name: "amount"; type: "double" }
-            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
-        }
-        Signal {
-            name: "pushedRightBoundary"
-            Parameter { name: "amount"; type: "double" }
-            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
-        }
-        Method {
-            name: "handleMouseEvent"
-            Parameter { name: "timestamp"; type: "ulong" }
-            Parameter { name: "movement"; type: "QPointF" }
-            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
-            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
-        }
-        Method {
-            name: "handleWheelEvent"
-            Parameter { name: "timestamp"; type: "ulong" }
-            Parameter { name: "angleDelta"; type: "QPoint" }
-            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
-        }
-    }
-}

=== added file 'plugins/Cursor/CursorImageInfo.cpp'
--- plugins/Cursor/CursorImageInfo.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/CursorImageInfo.cpp	2016-06-01 16:58:47 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2016 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 "CursorImageInfo.h"
+
+CursorImageInfo::CursorImageInfo(QObject *parent)
+    : QObject(parent)
+{
+    m_updateTimer.setInterval(0);
+    m_updateTimer.setSingleShot(true);
+    connect(&m_updateTimer, &QTimer::timeout, this, &CursorImageInfo::update);
+}
+
+void CursorImageInfo::setCursorName(const QString &cursorName)
+{
+    if (cursorName != m_cursorName) {
+        m_cursorName = cursorName;
+        Q_EMIT cursorNameChanged();
+        scheduleUpdate();
+    }
+}
+
+void CursorImageInfo::setThemeName(const QString &themeName)
+{
+    if (m_themeName != themeName) {
+        m_themeName = themeName;
+        Q_EMIT themeNameChanged();
+        scheduleUpdate();
+    }
+}
+
+void CursorImageInfo::scheduleUpdate()
+{
+    if (!m_updateTimer.isActive()) {
+        m_updateTimer.start();
+    }
+}
+
+void CursorImageInfo::update()
+{
+    m_cursorImage = CursorImageProvider::instance()->fetchCursor(m_themeName, m_cursorName);
+
+    Q_EMIT hotspotChanged();
+    Q_EMIT frameWidthChanged();
+    Q_EMIT frameHeightChanged();
+    Q_EMIT frameCountChanged();
+    Q_EMIT frameDurationChanged();
+}
+
+QPoint CursorImageInfo::hotspot() const
+{
+    if (m_cursorImage) {
+        return m_cursorImage->hotspot;
+    } else {
+        return QPoint();
+    }
+}
+
+qreal CursorImageInfo::frameWidth() const
+{
+    if (m_cursorImage) {
+        return m_cursorImage->frameWidth;
+    } else {
+        return 0;
+    }
+}
+
+qreal CursorImageInfo::frameHeight() const
+{
+    if (m_cursorImage) {
+        return m_cursorImage->frameHeight;
+    } else {
+        return 0;
+    }
+}
+
+int CursorImageInfo::frameCount() const
+{
+    if (m_cursorImage) {
+        return m_cursorImage->frameCount;
+    } else {
+        return 0;
+    }
+}
+
+int CursorImageInfo::frameDuration() const
+{
+    if (m_cursorImage) {
+        return m_cursorImage->frameDuration;
+    } else {
+        return 0;
+    }
+}

=== added file 'plugins/Cursor/CursorImageInfo.h'
--- plugins/Cursor/CursorImageInfo.h	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/CursorImageInfo.h	2016-06-01 16:58:47 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2016 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 CURSOR_IMAGE_INFO_H
+#define CURSOR_IMAGE_INFO_H
+
+#include "CursorImageProvider.h"
+
+#include <QObject>
+#include <QString>
+#include <QTimer>
+
+class CursorImageInfo : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString themeName READ themeName WRITE setThemeName NOTIFY themeNameChanged)
+    Q_PROPERTY(QString cursorName READ cursorName WRITE setCursorName NOTIFY cursorNameChanged)
+
+    Q_PROPERTY(QPoint hotspot READ hotspot NOTIFY hotspotChanged)
+    Q_PROPERTY(qreal frameWidth READ frameWidth NOTIFY frameWidthChanged)
+    Q_PROPERTY(qreal frameHeight READ frameHeight NOTIFY frameHeightChanged)
+    Q_PROPERTY(int frameCount READ frameCount NOTIFY frameCountChanged)
+    Q_PROPERTY(int frameDuration READ frameDuration NOTIFY frameDurationChanged)
+
+public:
+    CursorImageInfo(QObject *parent = nullptr);
+
+    QString themeName() const { return m_themeName; }
+    void setThemeName(const QString &);
+
+    QString cursorName() const { return m_cursorName; }
+    void setCursorName(const QString &);
+
+    QPoint hotspot() const;
+    qreal frameWidth() const;
+    qreal frameHeight() const;
+    int frameCount() const;
+    int frameDuration() const;
+
+Q_SIGNALS:
+    void themeNameChanged();
+    void cursorNameChanged();
+    void hotspotChanged();
+    void frameWidthChanged();
+    void frameHeightChanged();
+    void frameCountChanged();
+    void frameDurationChanged();
+
+private Q_SLOTS:
+    void update();
+
+private:
+    void scheduleUpdate();
+    QTimer m_updateTimer;
+
+    QString m_themeName;
+    QString m_cursorName;
+
+    CursorImage *m_cursorImage{nullptr};
+};
+
+#endif // CURSOR_IMAGE_INFO_H

=== modified file 'plugins/Cursor/CursorImageProvider.cpp'
--- plugins/Cursor/CursorImageProvider.cpp	2015-11-30 17:38:20 +0000
+++ plugins/Cursor/CursorImageProvider.cpp	2016-06-01 16:58:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Canonical, Ltd.
+ * Copyright (C) 2015-2016 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 version 3, as published by
@@ -46,6 +46,9 @@
     qimage.fill(Qt::transparent);
     QPainter imagePainter(&qimage);
 
+    frameWidth = qimage.width();
+    frameHeight = qimage.height();
+
     QSvgRenderer *svgRenderer = new QSvgRenderer(QByteArray(svgString));
     svgRenderer->render(&imagePainter);
     delete svgRenderer;
@@ -59,6 +62,8 @@
 {
     qimage = QImage(1, 1, QImage::Format_ARGB32);
     qimage.fill(Qt::transparent);
+    frameWidth = qimage.width();
+    frameHeight = qimage.height();
 }
 
 /////
@@ -69,40 +74,74 @@
 {
     qimage = cursor.pixmap().toImage();
     hotspot = cursor.hotSpot();
+    frameWidth = qimage.width();
+    frameHeight = qimage.height();
 }
 
 /////
 // XCursorImage
 
 XCursorImage::XCursorImage(const QString &theme, const QString &file)
-    : xcursorImages(nullptr)
 {
     // TODO: Consider grid unit value
     //       Hardcoding to a medium size for now
     int preferredCursorHeightPx = 32;
 
-    xcursorImages = XcursorLibraryLoadImages(QFile::encodeName(file), QFile::encodeName(theme),
+    XcursorImages *xcursorImages = XcursorLibraryLoadImages(QFile::encodeName(file), QFile::encodeName(theme),
             preferredCursorHeightPx);
-    if (!xcursorImages) {
+    if (!xcursorImages || xcursorImages->nimage == 0) {
         return;
     }
 
-    // Just take the first one. It will have multiple images in case of an animated cursor.
-    // TODO: Support animated cursors
-    if ( xcursorImages->nimage > 0) {
-        XcursorImage *xcursorImage = xcursorImages->images[0];
-
-        qimage = QImage((uchar*)xcursorImage->pixels,
-                xcursorImage->width, xcursorImage->height, QImage::Format_ARGB32);
-
+    frameCount = xcursorImages->nimage;
+
+    for (int i = 0; i < xcursorImages->nimage; ++i) {
+        XcursorImage *xcursorImage = xcursorImages->images[0];
+        if (frameWidth <  (int)xcursorImage->width) {
+            frameWidth = xcursorImage->width;
+        }
+        if (frameHeight <  (int)xcursorImage->height) {
+            frameHeight = xcursorImage->height;
+        }
+        if (i == 0) {
+            frameDuration = (int)xcursorImage->delay;
+        } else {
+            if (frameDuration != (int)xcursorImage->delay) {
+                qWarning().nospace() << "CursorImageProvider: XCursorImage("<<theme<<","<<file<<") has"
+                                        " varying delays in its animation. Animation won't look right.";
+            }
+        }
+    }
+
+    {
+        // Assume that the hotspot position does not animate
+        XcursorImage *xcursorImage = xcursorImages->images[0];
         hotspot.setX(xcursorImage->xhot);
         hotspot.setY(xcursorImage->yhot);
     }
+
+    // Build the sprite as a single row of frames
+    qimage = QImage(frameWidth*frameCount, frameHeight, QImage::Format_ARGB32);
+    qimage.fill(Qt::transparent);
+
+    {
+        QPainter painter(&qimage);
+
+        for (int i = 0; i < xcursorImages->nimage; ++i) {
+            XcursorImage *xcursorImage = xcursorImages->images[i];
+
+            auto frameImage = QImage((uchar*)xcursorImage->pixels,
+                    xcursorImage->width, xcursorImage->height, QImage::Format_ARGB32);
+
+            painter.drawImage(QPoint(i*frameWidth, 0), frameImage);
+        }
+    }
+
+    XcursorImagesDestroy(xcursorImages);
 }
 
 XCursorImage::~XCursorImage()
 {
-    XcursorImagesDestroy(xcursorImages);
 }
 
 /////
@@ -205,16 +244,6 @@
     return cursorImage->qimage;
 }
 
-QPoint CursorImageProvider::hotspot(const QString &themeName, const QString &cursorName)
-{
-    CursorImage *cursorImage = fetchCursor(themeName, cursorName);
-    if (cursorImage) {
-        return cursorImage->hotspot;
-    } else {
-        return QPoint(0,0);
-    }
-}
-
 CursorImage *CursorImageProvider::fetchCursor(const QString &cursorThemeAndName)
 {
     QString themeName;

=== modified file 'plugins/Cursor/CursorImageProvider.h'
--- plugins/Cursor/CursorImageProvider.h	2015-11-16 14:27:31 +0000
+++ plugins/Cursor/CursorImageProvider.h	2016-06-01 16:58:47 +0000
@@ -31,15 +31,23 @@
     virtual ~CursorImage() {}
 
     QImage qimage;
+
+    // TODO: consider if there's a need to animate the hotspot
+    // ie, if there's a need to make it an array of points, one for each frame.
+    // Maybe no single xcursor (or at least the ones we know of or use)
+    // vary its hotspot position through its animation.
     QPoint hotspot;
+
+    int frameWidth{0};
+    int frameHeight{0};
+    int frameCount{1};
+    int frameDuration{40};
 };
 
 class XCursorImage : public CursorImage {
 public:
     XCursorImage(const QString &theme, const QString &file);
     virtual ~XCursorImage();
-
-    XcursorImages *xcursorImages;
 };
 
 class BuiltInCursorImage : public CursorImage {
@@ -68,16 +76,16 @@
 
     QImage requestImage(const QString &cursorName, QSize *size, const QSize &requestedSize) override;
 
-    QPoint hotspot(const QString &themeName, const QString &cursorName);
+    CursorImage *fetchCursor(const QString &themeName, const QString &cursorName);
 
     void setCustomCursor(const QCursor &customCursor);
 
 private:
     CursorImage *fetchCursor(const QString &cursorThemeAndName);
-    CursorImage *fetchCursor(const QString &themeName, const QString &cursorName);
     CursorImage *fetchCursorHelper(const QString &themeName, const QString &cursorName);
 
     // themeName -> (cursorName -> cursorImage)
+    // TODO: discard old, unused, cursors
     QMap<QString, QMap<QString, CursorImage*> > m_cursors;
 
     QScopedPointer<CursorImage> m_builtInCursorImage;

=== modified file 'plugins/Cursor/MousePointer.cpp'
--- plugins/Cursor/MousePointer.cpp	2015-12-01 21:54:18 +0000
+++ plugins/Cursor/MousePointer.cpp	2016-06-01 16:58:47 +0000
@@ -29,10 +29,7 @@
     : MirMousePointerInterface(parent)
     , m_cursorName(QStringLiteral("left_ptr"))
     , m_themeName(QStringLiteral("default"))
-    , m_hotspotX(0)
-    , m_hotspotY(0)
 {
-    updateHotspot();
 }
 
 void MousePointer::handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
@@ -89,8 +86,32 @@
 
 void MousePointer::registerWindow(QWindow *window)
 {
-    if (m_registeredWindow && window != m_registeredWindow) {
-        auto previousCursor = dynamic_cast<MirPlatformCursor*>(m_registeredWindow->screen()->handle()->cursor());
+    if (window == m_registeredWindow) {
+        return;
+    }
+
+    if (m_registeredWindow) {
+        m_registeredWindow->disconnect(this);
+    }
+
+    m_registeredWindow = window;
+
+    if (m_registeredWindow) {
+        connect(window, &QWindow::screenChanged, this, &MousePointer::registerScreen);
+        registerScreen(window->screen());
+    } else {
+        registerScreen(nullptr);
+    }
+}
+
+void MousePointer::registerScreen(QScreen *screen)
+{
+    if (m_registeredScreen == screen) {
+        return;
+    }
+
+    if (m_registeredScreen) {
+        auto previousCursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());
         if (previousCursor) {
             previousCursor->setMousePointer(nullptr);
         } else {
@@ -98,10 +119,10 @@
         }
     }
 
-    m_registeredWindow = window;
+    m_registeredScreen = screen;
 
-    if (m_registeredWindow) {
-        auto cursor = dynamic_cast<MirPlatformCursor*>(window->screen()->handle()->cursor());
+    if (m_registeredScreen) {
+        auto cursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());
         if (cursor) {
             cursor->setMousePointer(this);
         } else {
@@ -115,22 +136,6 @@
     if (cursorName != m_cursorName) {
         m_cursorName = cursorName;
         Q_EMIT cursorNameChanged(m_cursorName);
-        updateHotspot();
-    }
-}
-
-void MousePointer::updateHotspot()
-{
-    QPoint newHotspot = CursorImageProvider::instance()->hotspot(m_themeName, m_cursorName);
-
-    if (m_hotspotX != newHotspot.x()) {
-        m_hotspotX = newHotspot.x();
-        Q_EMIT hotspotXChanged(m_hotspotX);
-    }
-
-    if (m_hotspotY != newHotspot.y()) {
-        m_hotspotY = newHotspot.y();
-        Q_EMIT hotspotYChanged(m_hotspotY);
     }
 }
 

=== modified file 'plugins/Cursor/MousePointer.h'
--- plugins/Cursor/MousePointer.h	2015-12-01 21:40:13 +0000
+++ plugins/Cursor/MousePointer.h	2016-06-01 16:58:47 +0000
@@ -20,6 +20,7 @@
 // Qt
 #include <QPointer>
 #include <QWindow>
+#include <QScreen>
 
 // Unity API
 #include <unity/shell/application/MirMousePointerInterface.h>
@@ -35,9 +36,6 @@
     void setThemeName(const QString &themeName) override;
     QString themeName() const override { return m_themeName; }
 
-    qreal hotspotX() const override { return m_hotspotX; }
-    qreal hotspotY() const override { return m_hotspotY; }
-
     void setCustomCursor(const QCursor &) override;
 
 public Q_SLOTS:
@@ -53,15 +51,16 @@
 protected:
     void itemChange(ItemChange change, const ItemChangeData &value) override;
 
+private Q_SLOTS:
+    void registerScreen(QScreen *screen);
+
 private:
     void registerWindow(QWindow *window);
-    void updateHotspot();
 
     QPointer<QWindow> m_registeredWindow;
+    QPointer<QScreen> m_registeredScreen;
     QString m_cursorName;
     QString m_themeName;
-    int m_hotspotX;
-    int m_hotspotY;
 };
 
 #endif // MOUSEPOINTER_H

=== modified file 'plugins/Cursor/plugin.cpp'
--- plugins/Cursor/plugin.cpp	2015-11-20 15:01:39 +0000
+++ plugins/Cursor/plugin.cpp	2016-06-01 16:58:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Canonical, Ltd.
+ * Copyright (C) 2015-2016 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
@@ -22,13 +22,15 @@
 #include "plugin.h"
 
 // local
+#include "CursorImageInfo.h"
 #include "CursorImageProvider.h"
 #include "MousePointer.h"
 
 void CursorPlugin::registerTypes(const char *uri)
 {
     Q_ASSERT(uri == QLatin1String("Cursor"));
-    qmlRegisterType<MousePointer>(uri, 1, 0, "MousePointer");
+    qmlRegisterType<CursorImageInfo>(uri, 1, 1, "CursorImageInfo");
+    qmlRegisterType<MousePointer>(uri, 1, 1, "MousePointer");
 }
 
 void CursorPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'plugins/Cursor/qmldir'
--- plugins/Cursor/qmldir	2015-09-29 13:45:05 +0000
+++ plugins/Cursor/qmldir	2016-06-01 16:58:47 +0000
@@ -1,3 +1,3 @@
 module Cursor
 plugin Cursor-qml
-Cursor 1.0 Cursor.qml
+Cursor 1.1 Cursor.qml

=== modified file 'plugins/Dash/AudioProgressBar.qml'
--- plugins/Dash/AudioProgressBar.qml	2016-01-18 22:56:16 +0000
+++ plugins/Dash/AudioProgressBar.qml	2016-06-01 16:58:47 +0000
@@ -49,6 +49,6 @@
             rightMargin: maxWidth - (maxWidth * root.progress)
         }
         height: units.dp(2)
-        backgroundColor: UbuntuColors.orange
+        backgroundColor: theme.palette.normal.activity
     }
 }

=== modified file 'plugins/Dash/CardCreator.js'
--- plugins/Dash/CardCreator.js	2016-05-04 14:09:00 +0000
+++ plugins/Dash/CardCreator.js	2016-06-01 16:58:47 +0000
@@ -59,14 +59,30 @@
                                 } \n\
                             }\n';
 
+// %1 is the aspect of the UbuntuShape
+var kArtUbuntuShapeCode = 'UbuntuShape { \n\
+                                anchors.fill: parent; \n\
+                                source: artImage; \n\
+                                sourceFillMode: UbuntuShape.PreserveAspectCrop; \n\
+                                radius: "medium"; \n\
+                                aspect: %1; \n\
+                            }';
+
+var kArtProportionalShapeCode = 'ProportionalShape { \n\
+                                    anchors.fill: parent; \n\
+                                    source: artImage; \n\
+                                    aspect: UbuntuShape.DropShadow; \n\
+                                 }';
+
 // %1 is used as anchors of artShapeHolder
 // %2 is used as image width
 // %3 is used as image height
-// %4 is whether the image or the Loader with the UbuntuShape/ProportionalShape should be visible
+// %4 is whether the image should be visible
 // %5 is used as aspect ratio fallback
 // %6 is whether the loader should be asynchronous or not
-// %7 is injected as code to artImage
-// %8 is used as image fallback
+// %7 is the shape code we want to use
+// %8 is injected as code to artImage
+// %9 is used as image fallback
 var kArtShapeHolderCode = 'Item { \n\
                             id: artShapeHolder; \n\
                             height: root.fixedArtShapeSize.height > 0 ? root.fixedArtShapeSize.height : artShapeLoader.height; \n\
@@ -75,7 +91,8 @@
                             Loader { \n\
                                 id: artShapeLoader; \n\
                                 objectName: "artShapeLoader"; \n\
-                                readonly property string cardArt: cardData && cardData["art"] || %8; \n\
+                                readonly property string cardArt: cardData && cardData["art"] || %9; \n\
+                                onCardArtChanged: { if (item) { item.image.source = cardArt; } } \n\
                                 active: cardArt != ""; \n\
                                 asynchronous: %6; \n\
                                 visible: status == Loader.Ready; \n\
@@ -84,31 +101,7 @@
                                     objectName: "artShape"; \n\
                                     visible: image.status == Image.Ready; \n\
                                     readonly property alias image: artImage; \n\
-                                    Loader { \n\
-                                        anchors.fill: parent; \n\
-                                        visible: %4; \n\
-                                        sourceComponent: root.artShapeStyle === "icon" ? artShapeIconComponent : artShapeShapeComponent; \n\
-                                        Component { \n\
-                                            id: artShapeShapeComponent; \n\
-                                            UbuntuShape { \n\
-                                                source: artImage; \n\
-                                                sourceFillMode: UbuntuShape.PreserveAspectCrop; \n\
-                                                radius: "medium"; \n\
-                                                aspect: { \n\
-                                                    switch (root.artShapeStyle) { \n\
-                                                        case "inset": return UbuntuShape.Inset; \n\
-                                                        case "shadow": return UbuntuShape.DropShadow; \n\
-                                                        default: \n\
-                                                        case "flat": return UbuntuShape.Flat; \n\
-                                                    } \n\
-                                                } \n\
-                                            } \n\
-                                        } \n\
-                                        Component { \n\
-                                            id: artShapeIconComponent; \n\
-                                            ProportionalShape { source: artImage; aspect: UbuntuShape.DropShadow; } \n\
-                                        } \n\
-                                    } \n\
+                                    %7 \n\
                                     readonly property real fixedArtShapeSizeAspect: (root.fixedArtShapeSize.height > 0 && root.fixedArtShapeSize.width > 0) ? root.fixedArtShapeSize.width / root.fixedArtShapeSize.height : -1; \n\
                                     readonly property real aspect: fixedArtShapeSizeAspect > 0 ? fixedArtShapeSizeAspect : %5; \n\
                                     Component.onCompleted: { updateWidthHeightBindings(); } \n\
@@ -127,10 +120,10 @@
                                         objectName: "artImage"; \n\
                                         source: artShapeLoader.cardArt; \n\
                                         asynchronous: %6; \n\
-                                        visible: !%4; \n\
+                                        visible: %4; \n\
                                         width: %2; \n\
                                         height: %3; \n\
-                                        %7 \n\
+                                        %8 \n\
                                     } \n\
                                 } \n\
                             } \n\
@@ -318,7 +311,7 @@
                         id: touchdown; \n\
                         objectName: "touchdown"; \n\
                         anchors { %1 } \n\
-                        visible: root.artShapeStyle != "shadow" && root.artShapeStyle != "icon" && root.pressed; \n\
+                        visible: root.pressed; \n\
                         radius: "medium"; \n\
                         borderSource: "radius_pressed.sci" \n\
                     }\n';
@@ -412,7 +405,7 @@
     return colorString;
 }
 
-function cardString(template, components, isCardTool) {
+function cardString(template, components, isCardTool, artShapeStyle) {
     var code;
 
     var templateInteractive = (template == null ? true : (template["non-interactive"] !== undefined ? !template["non-interactive"] : true)) ? "true" : "false";
@@ -420,7 +413,6 @@
     code = 'AbstractButton { \n\
                 id: root; \n\
                 property var cardData; \n\
-                property string artShapeStyle: "inset"; \n\
                 property string backgroundShapeStyle: "inset"; \n\
                 property real fontScale: 1.0; \n\
                 property var scopeStyle: null; \n\
@@ -519,17 +511,35 @@
         var fallbackStatusCode = "";
         var fallbackURICode = '""';
         if (fallback !== "") {
-            // fallbackStatusCode has %6 in it because we want to substitute it for fallbackURICode
-            // which in kArtShapeHolderCode is %8
-            fallbackStatusCode += 'onStatusChanged: if (status === Image.Error) source = %8;';
+            // fallbackStatusCode has %9 in it because we want to substitute it for fallbackURICode
+            // which in kArtShapeHolderCode is %9
+            fallbackStatusCode += 'onStatusChanged: if (status === Image.Error) source = %9;';
             fallbackURICode = 'decodeURI("%1")'.arg(fallback);
         }
+        var artShapeHolderShapeCode;
+        if (!isConciergeMode) {
+            if (artShapeStyle === "icon") {
+                artShapeHolderShapeCode = kArtProportionalShapeCode;
+            } else {
+                var artShapeHolderShapeAspect;
+                switch (artShapeStyle) {
+                    case "inset": artShapeHolderShapeAspect = "UbuntuShape.Inset"; break;
+                    case "shadow": artShapeHolderShapeAspect = "UbuntuShape.DropShadow"; break;
+                    default:
+                    case "flat": artShapeHolderShapeAspect = "UbuntuShape.Flat"; break;
+                }
+                artShapeHolderShapeCode = kArtUbuntuShapeCode.arg(artShapeHolderShapeAspect);
+            }
+        } else {
+            artShapeHolderShapeCode = "";
+        }
         code += kArtShapeHolderCode.arg(artAnchors)
                                    .arg(widthCode)
                                    .arg(heightCode)
-                                   .arg(isConciergeMode ? "false" : "true")
+                                   .arg(isConciergeMode ? "true" : "false")
                                    .arg(aspectRatio)
                                    .arg(asynchronous)
+                                   .arg(artShapeHolderShapeCode)
                                    .arg(fallbackStatusCode)
                                    .arg(fallbackURICode);
     } else {
@@ -854,6 +864,10 @@
         code += kSummaryLabelCode.arg(summaryTopAnchor).arg(summaryTopMargin).arg(summaryColor);
     }
 
+// <<<<<<< TREE
+//     if (artShapeStyle != "shadow" && artShapeStyle != "icon") {
+//         var touchdownAnchors;
+// =======
     if (hasSocialActions) {
         var socialAnchors;
         var socialTopAnchor;
@@ -882,15 +896,17 @@
         code += kSocialActionsRowCode.arg(socialAnchors).arg(socialColor);
     }
 
-    var touchdownAnchors;
-    if (hasBackground) {
-        touchdownAnchors = 'fill: backgroundLoader';
-    } else if (touchdownOnArtShape) {
-        touchdownAnchors = 'fill: artShapeHolder';
-    } else {
-        touchdownAnchors = 'fill: root'
+    if (artShapeStyle != "shadow" && artShapeStyle != "icon") {
+        var touchdownAnchors;
+        if (hasBackground) {
+            touchdownAnchors = 'fill: backgroundLoader';
+        } else if (touchdownOnArtShape) {
+            touchdownAnchors = 'fill: artShapeHolder';
+        } else {
+            touchdownAnchors = 'fill: root'
+        }
+        code += kTouchdownCode.arg(touchdownAnchors);
     }
-    code += kTouchdownCode.arg(touchdownAnchors);
 
     var implicitHeight = 'implicitHeight: ';
     if (hasSocialActions) {
@@ -925,13 +941,13 @@
     return code;
 }
 
-function createCardComponent(parent, template, components, isCardTool, identifier) {
+function createCardComponent(parent, template, components, isCardTool, artShapeStyle, identifier) {
     var imports = 'import QtQuick 2.4; \n\
                    import Ubuntu.Components 1.3; \n\
                    import Ubuntu.Settings.Components 0.1; \n\
                    import Dash 0.1;\n\
                    import Utils 0.1;\n';
-    var card = cardString(template, components, isCardTool);
+    var card = cardString(template, components, isCardTool, artShapeStyle);
     var code = imports + 'Component {\n' + card + '}\n';
 
     try {

=== modified file 'plugins/Dash/CardCreatorCache.qml'
--- plugins/Dash/CardCreatorCache.qml	2016-02-16 14:26:58 +0000
+++ plugins/Dash/CardCreatorCache.qml	2016-06-01 16:58:47 +0000
@@ -23,7 +23,7 @@
 
     property var cache: new Object();
 
-    function getCardComponent(template, components, isCardTool) {
+    function getCardComponent(template, components, isCardTool, artShapeStyle) {
         if (template === undefined || components === undefined)
             return undefined;
 
@@ -32,7 +32,7 @@
         var allString = tString + cString + isCardTool;
         var component = cache[allString];
         if (component === undefined) {
-            component = CardCreator.createCardComponent(root, template, components, isCardTool, allString);
+            component = CardCreator.createCardComponent(root, template, components, isCardTool, artShapeStyle, allString);
             cache[allString] = component;
         }
         return component;

=== modified file 'plugins/Dash/ScopeStyle.qml'
--- plugins/Dash/ScopeStyle.qml	2016-03-29 03:47:39 +0000
+++ plugins/Dash/ScopeStyle.qml	2016-06-01 16:58:47 +0000
@@ -70,7 +70,7 @@
     readonly property url navigationBackground: "navigation-background" in d.headerStyle ? d.headerStyle["navigation-background"] : "color:///#f5f5f5"
 
     /// Color of the primary preview button
-    readonly property color previewButtonColor: "preview-button-color" in style ? style["preview-button-color"] : UbuntuColors.orange
+    readonly property color previewButtonColor: "preview-button-color" in style ? style["preview-button-color"] : theme.palette.normal.positive
 
     //! @cond
     property var d: QtObject {

=== modified file 'plugins/Dash/listviewwithpageheader.cpp'
--- plugins/Dash/listviewwithpageheader.cpp	2016-04-27 14:59:24 +0000
+++ plugins/Dash/listviewwithpageheader.cpp	2016-06-01 16:58:47 +0000
@@ -97,6 +97,7 @@
 #include <qqmlengine.h>
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-pedantic"
+#include <private/qqmlcontext_p.h>
 #include <private/qqmldelegatemodel_p.h>
 #include <private/qqmlglobal_p.h>
 #include <private/qquickitem_p.h>
@@ -168,7 +169,7 @@
     m_contentYAnimation->setDuration(200);
     m_contentYAnimation->setTargetObject(this);
 
-    connect(this, &ListViewWithPageHeader::contentWidthChanged, this, &ListViewWithPageHeader::onContentWidthChanged);
+    connect(contentItem(), &QQuickItem::widthChanged, this, &ListViewWithPageHeader::onContentWidthChanged);
     connect(this, &ListViewWithPageHeader::contentHeightChanged, this, &ListViewWithPageHeader::onContentHeightChanged);
     connect(this, &ListViewWithPageHeader::heightChanged, this, &ListViewWithPageHeader::onHeightChanged);
     connect(m_contentYAnimation, &QQuickNumberAnimation::runningChanged, this, &ListViewWithPageHeader::contentYAnimationRunningChanged);
@@ -757,8 +758,6 @@
 
     QQmlContext *creationContext = m_sectionDelegate->creationContext();
     QQmlContext *context = new QQmlContext(creationContext ? creationContext : qmlContext(this));
-    context->setContextProperty(QStringLiteral("section"), sectionText);
-    context->setContextProperty(QStringLiteral("delegateIndex"), -1);
     QObject *nobj = m_sectionDelegate->beginCreate(context);
     if (nobj) {
         QQml_setParent_noEvent(context, nobj);
@@ -766,6 +765,8 @@
         if (!sectionItem) {
             delete nobj;
         } else {
+            sectionItem->setProperty("text", sectionText);
+            sectionItem->setProperty("delegateIndex", -1);
             sectionItem->setZ(2);
             QQml_setParent_noEvent(sectionItem, m_clipItem);
             sectionItem->setParentItem(m_clipItem);
@@ -801,8 +802,7 @@
             if (!item->sectionItem()) {
                 item->setSectionItem(getSectionItem(sectionText));
             } else {
-                QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
-                context->setContextProperty(QStringLiteral("section"), sectionText);
+                item->sectionItem()->setProperty("text", sectionText);
             }
         } else {
             if (item->sectionItem()) {
@@ -923,8 +923,7 @@
                 polish();
             }
             if (listItem->sectionItem()) {
-                QQmlContext *context = QQmlEngine::contextForObject(listItem->sectionItem())->parentContext();
-                context->setContextProperty(QStringLiteral("delegateIndex"), modelIndex);
+                listItem->sectionItem()->setProperty("delegateIndex", modelIndex);
             }
             adjustMinYExtent();
             m_contentHeightDirty = true;
@@ -948,9 +947,10 @@
         return;
 
     item->setParentItem(m_clipItem);
+    // FIXME Why do we need the refreshExpressions call?
     QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
-    context->setContextProperty(QStringLiteral("ListViewWithPageHeader"), this);
-    context->setContextProperty(QStringLiteral("heightToClip"), QVariant::fromValue<int>(0));
+    QQmlContextPrivate::get(context)->data->refreshExpressions();
+    item->setProperty("heightToClip", QVariant::fromValue<int>(0));
     if (modelIndex == m_asyncRequestedIndex) {
         createItem(modelIndex, false);
         refill();
@@ -1116,8 +1116,7 @@
     for (int i = 0; i < m_visibleItems.count(); ++i) {
         ListItem *item = m_visibleItems[i];
         if (item->sectionItem()) {
-            QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
-            context->setContextProperty(QStringLiteral("delegateIndex"), m_firstVisibleIndex + i);
+            item->sectionItem()->setProperty("delegateIndex", m_firstVisibleIndex + i);
         }
     }
 
@@ -1287,8 +1286,7 @@
                     } else {
                         // Update the top sticky section header
                         const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
-                        QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
-                        context->setContextProperty(QStringLiteral("section"), section);
+                        m_topSectionItem->setProperty("text", section);
 
                         QQuickItemPrivate::get(m_topSectionItem)->setCulled(false);
                         m_topSectionItem->setY(topSectionStickPos);
@@ -1300,19 +1298,18 @@
                                 break;
                             delegateIndex--;
                         }
-                        context->setContextProperty(QStringLiteral("delegateIndex"), delegateIndex);
+                        m_topSectionItem->setProperty("delegateIndex", delegateIndex);
                         if (item->sectionItem()) {
                             QQuickItemPrivate::get(item->sectionItem())->setCulled(true);
                         }
                     }
                 }
             }
-            QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
             const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
             if (!cull && pos < clipFrom) {
-                context->setContextProperty(QStringLiteral("heightToClip"), clipFrom - pos);
+                item->m_item->setProperty("heightToClip", clipFrom - pos);
             } else {
-                context->setContextProperty(QStringLiteral("heightToClip"), QVariant::fromValue<int>(0));
+                item->m_item->setProperty("heightToClip", QVariant::fromValue<int>(0));
             }
 //             qDebug() << "ListViewWithPageHeader::layout" << item->m_item;
             pos += item->height();

=== modified file 'plugins/Ubuntu/Gestures/AxisVelocityCalculator.h'
--- plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2014-10-01 13:20:32 +0000
+++ plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2016-06-01 16:58:47 +0000
@@ -24,7 +24,7 @@
 #include "UbuntuGesturesQmlGlobal.h"
 #include <stdint.h>
 #include <QtCore/QObject>
-#include "TimeSource.h"
+#include <TimeSource>
 
 /*
   Estimates the current velocity of a finger based on recent movement along an axis

=== modified file 'plugins/Ubuntu/Gestures/CMakeLists.txt'
--- plugins/Ubuntu/Gestures/CMakeLists.txt	2016-03-29 03:47:39 +0000
+++ plugins/Ubuntu/Gestures/CMakeLists.txt	2016-06-01 16:58:47 +0000
@@ -4,27 +4,27 @@
 set(UbuntuGesturesQml_SOURCES
     plugin.cpp
     AxisVelocityCalculator.cpp
-    Damper.cpp
     Direction.cpp
-    DirectionalDragArea.cpp
-    FloatingFlickable.cpp
+    MouseEventGenerator.cpp
     PressedOutsideNotifier.cpp
     TouchDispatcher.cpp
     TouchGate.cpp
     TouchGestureArea.cpp
 )
 
+pkg_check_modules(UBUNTUGESTURES REQUIRED UbuntuGestures)
+
 add_definitions(-DUBUNTUGESTURESQML_LIBRARY)
 
 add_library(UbuntuGesturesQml MODULE ${UbuntuGesturesQml_SOURCES})
-target_link_libraries(UbuntuGesturesQml UbuntuGestures)
+target_link_libraries(UbuntuGesturesQml ${UBUNTUGESTURES_LIBRARIES})
 
 qt5_use_modules(UbuntuGesturesQml Core Quick)
 
 # So that Foo.cpp can #include "Foo.moc"
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-include_directories(${CMAKE_SOURCE_DIR}/libs/UbuntuGestures)
+include_directories(${UBUNTUGESTURES_INCLUDE_DIRS})
 
 # There's no cmake var for v8 include path :-/ so create one
 LIST(GET Qt5Core_INCLUDE_DIRS 0 QtCoreDir0)

=== removed file 'plugins/Ubuntu/Gestures/Damper.cpp'
--- plugins/Ubuntu/Gestures/Damper.cpp	2015-04-10 21:16:37 +0000
+++ plugins/Ubuntu/Gestures/Damper.cpp	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2015 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 "Damper.h"
-#include <QDebug>
-
-QDebug operator<<(QDebug dbg, const DampedPointF &p)
-{
-    dbg.nospace() << "(" << p.x() << ", " << p.y() << ")";
-    return dbg.space();
-}

=== removed file 'plugins/Ubuntu/Gestures/Damper.h'
--- plugins/Ubuntu/Gestures/Damper.h	2015-11-20 15:01:39 +0000
+++ plugins/Ubuntu/Gestures/Damper.h	1970-01-01 00:00:00 +0000
@@ -1,89 +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;
-};
-
-QDebug operator<<(QDebug dbg, const DampedPointF &p);
-
-#endif // UBUNTU_GESTURES_DAMPER_H

=== modified file 'plugins/Ubuntu/Gestures/Direction.h'
--- plugins/Ubuntu/Gestures/Direction.h	2015-04-17 14:21:43 +0000
+++ plugins/Ubuntu/Gestures/Direction.h	2016-06-01 16:58:47 +0000
@@ -29,6 +29,7 @@
     Q_ENUMS(Type)
 
 public:
+    // Make sure it is kept synchronized with SDK UCSwipeArea::Direction
     enum Type {
         Rightwards, // Along the positive direction of the X axis
         Leftwards, // Along the negative direction of the X axis

=== removed file 'plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2016-03-29 03:47:39 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	1970-01-01 00:00:00 +0000
@@ -1,932 +0,0 @@
-/*
- * Copyright (C) 2013-2015 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 <QScreen>
-#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"
-
-#include "DirectionalDragArea_p.h"
-
-using namespace UbuntuGestures;
-
-#if DIRECTIONALDRAGAREA_DEBUG
-#define ddaDebug(params) qDebug().nospace() << "[DDA(" << qPrintable(objectName()) << ")] " << params
-#include "DebugHelpers.h"
-
-namespace {
-const char *statusToString(DirectionalDragAreaPrivate::Status status)
-{
-    if (status == DirectionalDragAreaPrivate::WaitingForTouch) {
-        return "WaitingForTouch";
-    } else if (status == DirectionalDragAreaPrivate::Undecided) {
-        return "Undecided";
-    } else {
-        return "Recognized";
-    }
-}
-
-} // namespace {
-#else // DIRECTIONALDRAGAREA_DEBUG
-#define ddaDebug(params) ((void)0)
-#endif // DIRECTIONALDRAGAREA_DEBUG
-
-DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)
-    : QQuickItem(parent)
-    , d(new DirectionalDragAreaPrivate(this))
-{
-    d->setRecognitionTimer(new Timer(this));
-    d->recognitionTimer->setInterval(d->maxTime);
-    d->recognitionTimer->setSingleShot(true);
-
-    connect(this, &QQuickItem::enabledChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);
-    connect(this, &QQuickItem::visibleChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);
-}
-
-Direction::Type DirectionalDragArea::direction() const
-{
-    return d->direction;
-}
-
-void DirectionalDragArea::setDirection(Direction::Type direction)
-{
-    if (direction != d->direction) {
-        d->direction = direction;
-        Q_EMIT directionChanged(d->direction);
-    }
-}
-
-void DirectionalDragAreaPrivate::setDistanceThreshold(qreal value)
-{
-    if (distanceThreshold != value) {
-        distanceThreshold = value;
-        distanceThresholdSquared = distanceThreshold * distanceThreshold;
-    }
-}
-
-void DirectionalDragAreaPrivate::setMaxTime(int value)
-{
-    if (maxTime != value) {
-        maxTime = value;
-        recognitionTimer->setInterval(maxTime);
-    }
-}
-
-void DirectionalDragAreaPrivate::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
-{
-    int interval = 0;
-    bool timerWasRunning = false;
-    bool wasSingleShot = false;
-
-    // can be null when called from the constructor
-    if (recognitionTimer) {
-        interval = recognitionTimer->interval();
-        timerWasRunning = recognitionTimer->isRunning();
-        if (recognitionTimer->parent() == this) {
-            delete recognitionTimer;
-        }
-    }
-
-    recognitionTimer = timer;
-    timer->setInterval(interval);
-    timer->setSingleShot(wasSingleShot);
-    connect(timer, &UbuntuGestures::AbstractTimer::timeout,
-            this, &DirectionalDragAreaPrivate::rejectGesture);
-    if (timerWasRunning) {
-        recognitionTimer->start();
-    }
-}
-
-void DirectionalDragAreaPrivate::setTimeSource(const SharedTimeSource &timeSource)
-{
-    this->timeSource = timeSource;
-    activeTouches.m_timeSource = timeSource;
-}
-
-qreal DirectionalDragArea::distance() const
-{
-    if (Direction::isHorizontal(d->direction)) {
-        return d->publicPos.x() - d->startPos.x();
-    } else {
-        return d->publicPos.y() - d->startPos.y();
-    }
-}
-
-void DirectionalDragAreaPrivate::updateSceneDistance()
-{
-    QPointF totalMovement = publicScenePos - startScenePos;
-    sceneDistance = projectOntoDirectionVector(totalMovement);
-}
-
-qreal DirectionalDragArea::sceneDistance() const
-{
-    return d->sceneDistance;
-}
-
-qreal DirectionalDragArea::touchX() const
-{
-    return d->publicPos.x();
-}
-
-qreal DirectionalDragArea::touchY() const
-{
-    return d->publicPos.y();
-}
-
-qreal DirectionalDragArea::touchSceneX() const
-{
-    return d->publicScenePos.x();
-}
-
-qreal DirectionalDragArea::touchSceneY() const
-{
-    return d->publicScenePos.y();
-}
-
-bool DirectionalDragArea::dragging() const
-{
-    return d->status == DirectionalDragAreaPrivate::Recognized;
-}
-
-bool DirectionalDragArea::pressed() const
-{
-    return d->status != DirectionalDragAreaPrivate::WaitingForTouch;
-}
-
-bool DirectionalDragArea::immediateRecognition() const
-{
-    return d->immediateRecognition;
-}
-
-void DirectionalDragArea::setImmediateRecognition(bool enabled)
-{
-    if (d->immediateRecognition != enabled) {
-        d->immediateRecognition = enabled;
-        Q_EMIT immediateRecognitionChanged(enabled);
-    }
-}
-
-bool DirectionalDragArea::monitorOnly() const
-{
-    return d->monitorOnly;
-}
-
-void DirectionalDragArea::setMonitorOnly(bool monitorOnly)
-{
-    if (d->monitorOnly != monitorOnly) {
-        d->monitorOnly = monitorOnly;
-
-        if (monitorOnly && d->status == DirectionalDragAreaPrivate::Undecided) {
-            TouchRegistry::instance()->removeCandidateOwnerForTouch(d->touchId, this);
-            // We still wanna know when it ends for keeping the composition time window up-to-date
-            TouchRegistry::instance()->addTouchWatcher(d->touchId, this);
-        }
-
-        Q_EMIT monitorOnlyChanged(monitorOnly);
-    }
-}
-
-void DirectionalDragArea::removeTimeConstraints()
-{
-    d->setMaxTime(60 * 60 * 1000);
-    d->compositionTime = 0;
-    ddaDebug("removed time constraints");
-}
-
-bool DirectionalDragArea::event(QEvent *event)
-{
-    if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
-        d->touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
-        return true;
-    } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {
-        d->unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));
-        return true;
-    } else {
-        return QQuickItem::event(event);
-    }
-}
-
-void DirectionalDragAreaPrivate::touchOwnershipEvent(TouchOwnershipEvent *event)
-{
-    if (event->gained()) {
-        QVector<int> ids;
-        ids.append(event->touchId());
-        ddaDebug("grabbing touch");
-        q->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 (q->window()) {
-            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(q->window());
-            if (windowPrivate->touchMouseId == event->touchId() && q->window()->mouseGrabberItem()) {
-                ddaDebug("removing mouse grabber");
-                q->window()->mouseGrabberItem()->ungrabMouse();
-            }
-        }
-    } else {
-        // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(touchId, q);
-
-        setStatus(WaitingForTouch);
-    }
-}
-
-void DirectionalDragAreaPrivate::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)
-{
-    QTouchEvent *event = unownedTouchEvent->touchEvent();
-
-    Q_ASSERT(!event->touchPointStates().testFlag(Qt::TouchPointPressed));
-
-    ddaDebug("Unowned " << timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
-
-    switch (status) {
-        case WaitingForTouch:
-            // do nothing
-            break;
-        case Undecided:
-            Q_ASSERT(q->isEnabled() && q->isVisible());
-            unownedTouchEvent_undecided(unownedTouchEvent);
-            break;
-        default: // Recognized:
-            if (monitorOnly) {
-                // Treat unowned event as if we owned it, but we are really just watching it
-                touchEvent_recognized(event);
-            }
-            break;
-    }
-
-    activeTouches.update(event);
-}
-
-void DirectionalDragAreaPrivate::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)
-{
-    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(unownedTouchEvent->touchEvent());
-    if (!touchPoint) {
-        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << touchId
-            << "missing from UnownedTouchEvent without first reaching state Qt::TouchPointReleased. "
-               "Considering it as released.";
-
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
-        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(touchId, q);
-        setStatus(WaitingForTouch);
-        return;
-    }
-
-    previousDampedScenePos.setX(dampedScenePos.x());
-    previousDampedScenePos.setY(dampedScenePos.y());
-    dampedScenePos.update(touchScenePos);
-
-    if (!movingInRightDirection()) {
-        ddaDebug("Rejecting gesture because touch point is moving in the wrong direction.");
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
-        // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(touchId, q);
-        setStatus(WaitingForTouch);
-        return;
-    }
-
-    if (isWithinTouchCompositionWindow()) {
-        // There's still time for some new touch to appear and ruin our party as it would be combined
-        // with our touchId one and therefore deny the possibility of a single-finger gesture.
-        ddaDebug("Sill within composition window. Let's wait more.");
-        return;
-    }
-
-    if (movedFarEnoughAlongGestureAxis()) {
-        if (!monitorOnly) {
-            TouchRegistry::instance()->requestTouchOwnership(touchId, q);
-        }
-        setStatus(Recognized);
-        setPublicPos(touchPoint->pos());
-        setPublicScenePos(touchScenePos);
-    } else if (isPastMaxDistance()) {
-        ddaDebug("Rejecting gesture because it went farther than maxDistance without getting recognized.");
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
-        // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(touchId, q);
-        setStatus(WaitingForTouch);
-    } 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(d->timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
-
-    if (!isEnabled() || !isVisible()) {
-        QQuickItem::touchEvent(event);
-        return;
-    }
-
-    switch (d->status) {
-        case DirectionalDragAreaPrivate::WaitingForTouch:
-            d->touchEvent_absent(event);
-            break;
-        case DirectionalDragAreaPrivate::Undecided:
-            d->touchEvent_undecided(event);
-            break;
-        default: // Recognized:
-            d->touchEvent_recognized(event);
-            break;
-    }
-
-    d->activeTouches.update(event);
-}
-
-void DirectionalDragAreaPrivate::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
-                newTouchPoint = &touchPoint;
-            }
-        }
-    }
-
-    if (allGood) {
-        allGood = sanityCheckRecognitionProperties();
-        if (!allGood) {
-            qWarning("DirectionalDragArea: recognition properties are wrongly set. Gesture recognition"
-                " is impossible");
-        }
-    }
-
-    if (allGood) {
-        Q_ASSERT(newTouchPoint);
-
-        startPos = newTouchPoint->pos();
-        startScenePos = newTouchPoint->scenePos();
-        touchId = newTouchPoint->id();
-        dampedScenePos.reset(startScenePos);
-        setPublicPos(startPos);
-
-        setPublicScenePos(startScenePos);
-        updateSceneDirectionVector();
-
-        if (recognitionIsDisabled()) {
-            // Behave like a dumb TouchArea
-            ddaDebug("Gesture recognition is disabled. Requesting touch ownership immediately.");
-            setStatus(Recognized);
-            if (monitorOnly) {
-                watchPressedTouchPoints(touchPoints);
-                event->ignore();
-            } else {
-                TouchRegistry::instance()->requestTouchOwnership(touchId, q);
-                event->accept();
-            }
-        } else {
-            // just monitor the touch points for now.
-            if (monitorOnly) {
-                watchPressedTouchPoints(touchPoints);
-            } else {
-                TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, q);
-            }
-
-            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 DirectionalDragAreaPrivate::touchEvent_undecided(QTouchEvent *event)
-{
-    Q_ASSERT(fetchTargetTouchPoint(event) == nullptr);
-
-    // We're not interested in new touch points. We already have our candidate (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(touchId, q);
-        // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(touchId, q);
-
-        setStatus(WaitingForTouch);
-    }
-}
-
-void DirectionalDragAreaPrivate::touchEvent_recognized(QTouchEvent *event)
-{
-    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
-
-    if (!touchPoint) {
-        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << touchId
-            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
-               "Considering it as released.";
-        setStatus(WaitingForTouch);
-    } else {
-        setPublicPos(touchPoint->pos());
-        setPublicScenePos(touchPoint->scenePos());
-
-        if (touchPoint->state() == Qt::TouchPointReleased) {
-            setStatus(WaitingForTouch);
-        }
-    }
-}
-
-void DirectionalDragAreaPrivate::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(), q);
-        }
-    }
-}
-
-bool DirectionalDragAreaPrivate::recognitionIsDisabled() const
-{
-    return immediateRecognition || (distanceThreshold <= 0 && compositionTime <= 0);
-}
-
-bool DirectionalDragAreaPrivate::sanityCheckRecognitionProperties()
-{
-    return recognitionIsDisabled()
-        || (distanceThreshold < maxDistance && compositionTime < maxTime);
-}
-
-const QTouchEvent::TouchPoint *DirectionalDragAreaPrivate::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() == touchId) {
-            touchPoint = &touchPoints.at(i);
-            break;
-        }
-    }
-    return touchPoint;
-}
-
-bool DirectionalDragAreaPrivate::movingInRightDirection() const
-{
-    if (direction == Direction::Horizontal || direction == Direction::Vertical) {
-        return true;
-    } else {
-        QPointF movementVector(dampedScenePos.x() - previousDampedScenePos.x(),
-                               dampedScenePos.y() - previousDampedScenePos.y());
-
-        qreal scalarProjection = projectOntoDirectionVector(movementVector);
-
-        return scalarProjection >= 0.;
-    }
-}
-
-bool DirectionalDragAreaPrivate::movedFarEnoughAlongGestureAxis() const
-{
-    if (distanceThreshold <= 0.) {
-        // distance threshold check is disabled
-        return true;
-    } else {
-        QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),
-                              dampedScenePos.y() - startScenePos.y());
-
-        qreal scalarProjection = projectOntoDirectionVector(totalMovement);
-
-        ddaDebug(" movedFarEnoughAlongGestureAxis: scalarProjection=" << scalarProjection
-            << ", distanceThreshold=" << distanceThreshold);
-
-        if (direction == Direction::Horizontal || direction == Direction::Vertical) {
-            return qAbs(scalarProjection) > distanceThreshold;
-        } else {
-            return scalarProjection > distanceThreshold;
-        }
-    }
-}
-
-bool DirectionalDragAreaPrivate::isPastMaxDistance() const
-{
-    QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),
-                          dampedScenePos.y() - startScenePos.y());
-
-    qreal squaredDistance = totalMovement.x()*totalMovement.x() + totalMovement.y()*totalMovement.y();
-    return squaredDistance > maxDistance*maxDistance;
-}
-
-void DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible()
-{
-    if (!q->isEnabled() || !q->isVisible()) {
-        if (status == Undecided) {
-            TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
-            // We still wanna know when it ends for keeping the composition time window up-to-date
-            TouchRegistry::instance()->addTouchWatcher(touchId, q);
-        }
-
-        if (status != WaitingForTouch) {
-            ddaDebug("Resetting status because got disabled or made invisible");
-            setStatus(WaitingForTouch);
-        }
-    }
-}
-
-void DirectionalDragAreaPrivate::rejectGesture()
-{
-    if (status == Undecided) {
-        ddaDebug("Rejecting gesture because it's taking too long to drag beyond the threshold.");
-
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
-        // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(touchId, q);
-
-        setStatus(WaitingForTouch);
-    }
-}
-
-void DirectionalDragAreaPrivate::setStatus(Status newStatus)
-{
-    if (newStatus == status)
-        return;
-
-    Status oldStatus = status;
-
-    if (oldStatus == Undecided) {
-        recognitionTimer->stop();
-    }
-
-    status = newStatus;
-    Q_EMIT statusChanged(status);
-
-    ddaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));
-
-    switch (newStatus) {
-        case WaitingForTouch:
-            if (oldStatus == Recognized) {
-                Q_EMIT q->draggingChanged(false);
-            }
-            Q_EMIT q->pressedChanged(false);
-            break;
-        case Undecided:
-            recognitionTimer->start();
-            Q_EMIT q->pressedChanged(true);
-            break;
-        case Recognized:
-            if (oldStatus == WaitingForTouch) { // for immediate recognition
-                Q_EMIT q->pressedChanged(true);
-            }
-            Q_EMIT q->draggingChanged(true);
-            break;
-        default:
-            // no-op
-            break;
-    }
-}
-
-void DirectionalDragAreaPrivate::setPublicPos(const QPointF point)
-{
-    bool xChanged = publicPos.x() != point.x();
-    bool yChanged = publicPos.y() != point.y();
-
-    // Public position should not get updated while the gesture is still being recognized
-    // (ie, Undecided status).
-    Q_ASSERT(status == WaitingForTouch || status == Recognized);
-
-    if (status == Recognized && !recognitionIsDisabled()) {
-        // When the gesture finally gets recognized, the finger will likely be
-        // reasonably far from the edge. If we made the contentX immediately
-        // follow the finger position it would be visually unpleasant as it
-        // would appear right next to the user's finger out of nowhere (ie,
-        // it would jump). Instead, we make contentX go towards the user's
-        // finger in several steps. ie., in an animated way.
-        QPointF delta = point - publicPos;
-        // the trick is not to go all the way (1.0) as it would cause a sudden jump
-        publicPos.rx() += 0.4 * delta.x();
-        publicPos.ry() += 0.4 * delta.y();
-    } else {
-        // no smoothing when initializing or if gesture recognition was immediate as there will
-        // be no jump.
-        publicPos = point;
-    }
-
-    if (xChanged) {
-        Q_EMIT q->touchXChanged(publicPos.x());
-        if (Direction::isHorizontal(direction))
-            Q_EMIT q->distanceChanged(q->distance());
-    }
-
-    if (yChanged) {
-        Q_EMIT q->touchYChanged(publicPos.y());
-        if (Direction::isVertical(direction))
-            Q_EMIT q->distanceChanged(q->distance());
-    }
-}
-
-void DirectionalDragAreaPrivate::setPublicScenePos(const QPointF point)
-{
-    bool xChanged = publicScenePos.x() != point.x();
-    bool yChanged = publicScenePos.y() != point.y();
-
-    if (!xChanged && !yChanged)
-        return;
-
-    // Public position should not get updated while the gesture is still being recognized
-    // (ie, Undecided status).
-    Q_ASSERT(status == WaitingForTouch || status == Recognized);
-
-    qreal oldSceneDistance = sceneDistance;
-
-    if (status == Recognized && !recognitionIsDisabled()) {
-        // When the gesture finally gets recognized, the finger will likely be
-        // reasonably far from the edge. If we made the contentX immediately
-        // follow the finger position it would be visually unpleasant as it
-        // would appear right next to the user's finger out of nowhere (ie,
-        // it would jump). Instead, we make contentX go towards the user's
-        // finger in several steps. ie., in an animated way.
-        QPointF delta = point - publicScenePos;
-        // the trick is not to go all the way (1.0) as it would cause a sudden jump
-        publicScenePos.rx() += 0.4 * delta.x();
-        publicScenePos.ry() += 0.4 * delta.y();
-    } else {
-        // no smoothing when initializing or if gesture recognition was immediate as there will
-        // be no jump.
-        publicScenePos = point;
-    }
-
-    updateSceneDistance();
-
-    if (oldSceneDistance != sceneDistance) {
-        Q_EMIT q->sceneDistanceChanged(sceneDistance);
-    }
-
-    if (xChanged) {
-        Q_EMIT q->touchSceneXChanged(publicScenePos.x());
-    }
-
-    if (yChanged) {
-        Q_EMIT q->touchSceneYChanged(publicScenePos.y());
-    }
-}
-
-bool DirectionalDragAreaPrivate::isWithinTouchCompositionWindow()
-{
-    return
-        compositionTime > 0 &&
-        !activeTouches.isEmpty() &&
-        timeSource->msecsSinceReference() <=
-            activeTouches.mostRecentStartTime() + (qint64)compositionTime;
-}
-
-void DirectionalDragArea::itemChange(ItemChange change, const ItemChangeData &value)
-{
-    if (change == QQuickItem::ItemSceneChange) {
-        if (value.window != nullptr) {
-            value.window->installEventFilter(TouchRegistry::instance());
-
-            // TODO: Handle window->screen() changes (ie window changing screens)
-
-            qreal pixelsPerInch = value.window->screen()->physicalDotsPerInch();
-            if (pixelsPerInch < 0) {
-                // It can return garbage when run in a XVFB server (Virtual Framebuffer 'fake' X server)
-                pixelsPerInch = 72;
-            }
-
-            d->setPixelsPerMm(pixelsPerInch / 25.4);
-        }
-    }
-}
-
-void DirectionalDragAreaPrivate::setPixelsPerMm(qreal pixelsPerMm)
-{
-    dampedScenePos.setMaxDelta(1. * pixelsPerMm);
-    setDistanceThreshold(4. * pixelsPerMm);
-    maxDistance = 10. * pixelsPerMm;
-}
-
-//**************************  ActiveTouchesInfo **************************
-
-ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
-    : m_timeSource(timeSource)
-{
-}
-
-void 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 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 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 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 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 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 DirectionalDragAreaPrivate::updateSceneDirectionVector()
-{
-    QPointF localOrigin(0., 0.);
-    QPointF localDirection;
-    switch (direction) {
-        case Direction::Upwards:
-            localDirection.rx() = 0.;
-            localDirection.ry() = -1.;
-            break;
-        case Direction::Downwards:
-        case Direction::Vertical:
-            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 = q->mapToScene(localOrigin);
-    QPointF sceneDirection = q->mapToScene(localDirection);
-    sceneDirectionVector = sceneDirection - sceneOrigin;
-}
-
-qreal DirectionalDragAreaPrivate::projectOntoDirectionVector(const QPointF sceneVector) const
-{
-    // same as dot product as sceneDirectionVector is a unit vector
-    return  sceneVector.x() * sceneDirectionVector.x() +
-            sceneVector.y() * sceneDirectionVector.y();
-}
-
-DirectionalDragAreaPrivate::DirectionalDragAreaPrivate(DirectionalDragArea *q)
-    : q(q)
-    , status(WaitingForTouch)
-    , sceneDistance(0)
-    , touchId(-1)
-    , direction(Direction::Rightwards)
-    , distanceThreshold(0)
-    , distanceThresholdSquared(0.)
-    , maxTime(400)
-    , compositionTime(60)
-    , immediateRecognition(false)
-    , recognitionTimer(nullptr)
-    , timeSource(new RealTimeSource)
-    , activeTouches(timeSource)
-    , monitorOnly(false)
-{
-}

=== removed file 'plugins/Ubuntu/Gestures/DirectionalDragArea.h'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.h	2016-03-29 03:47:39 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.h	1970-01-01 00:00:00 +0000
@@ -1,143 +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 "UbuntuGesturesQmlGlobal.h"
-#include "Damper.h"
-#include "Direction.h"
-
-// lib UbuntuGestures
-#include <Pool.h>
-#include <Timer.h>
-
-class TouchOwnershipEvent;
-class UnownedTouchEvent;
-class DirectionalDragAreaPrivate;
-
-/*
- 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)
-
-    // Whether a drag gesture is taking place
-    Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
-
-    // Whether the drag area is pressed.
-    Q_PROPERTY(bool pressed READ pressed NOTIFY pressedChanged)
-
-    // Whether a gesture should be Recognized as soon a touch lands on the area.
-    // With this property enabled it will work pretty much like a MultiPointTouchArea,
-    // just with a different API.
-    //
-    // It's false by default. In most cases you will not want that enabled.
-    Q_PROPERTY(bool immediateRecognition
-            READ immediateRecognition
-            WRITE setImmediateRecognition
-            NOTIFY immediateRecognitionChanged)
-
-    // Whether we are merely monitoring touch events (in which case, we don't
-    // claim ownership of the touch).
-    Q_PROPERTY(bool monitorOnly READ monitorOnly WRITE setMonitorOnly NOTIFY monitorOnlyChanged)
-
-    Q_ENUMS(Direction)
-public:
-    DirectionalDragArea(QQuickItem *parent = 0);
-
-    Direction::Type direction() const;
-    void setDirection(Direction::Type);
-
-    qreal distance() const;
-    qreal sceneDistance() const;
-
-    qreal touchX() const;
-    qreal touchY() const;
-
-    qreal touchSceneX() const;
-    qreal touchSceneY() const;
-
-    bool dragging() const;
-
-    bool pressed() const;
-
-    bool immediateRecognition() const;
-    void setImmediateRecognition(bool enabled);
-
-    bool monitorOnly() const;
-    void setMonitorOnly(bool monitorOnly);
-
-    bool event(QEvent *e) override;
-
-    /*
-      In qmltests, sequences of touch events are sent all at once, unlike in "real life".
-      Also qmltests might run really slowly, e.g. when run from inside virtual machines.
-      Thus to remove a variable that qmltests cannot really control, namely time, this
-      function removes all constraints that are sensible to elapsed time.
-
-      This effectively makes the DirectionalDragArea easier to fool.
-     */
-    Q_INVOKABLE void removeTimeConstraints();
-
-Q_SIGNALS:
-    void directionChanged(Direction::Type direction);
-    void draggingChanged(bool value);
-    void pressedChanged(bool value);
-    void distanceChanged(qreal value);
-    void sceneDistanceChanged(qreal value);
-    void touchXChanged(qreal value);
-    void touchYChanged(qreal value);
-    void touchSceneXChanged(qreal value);
-    void touchSceneYChanged(qreal value);
-    void immediateRecognitionChanged(bool value);
-    void monitorOnlyChanged(bool value);
-
-protected:
-    void touchEvent(QTouchEvent *event) override;
-    void itemChange(ItemChange change, const ItemChangeData &value) override;
-
-public: // so tests can access it
-    DirectionalDragAreaPrivate *d;
-};
-
-#endif // DIRECTIONAL_DRAG_AREA_H

=== removed file 'plugins/Ubuntu/Gestures/DirectionalDragArea_p.h'
--- plugins/Ubuntu/Gestures/DirectionalDragArea_p.h	2016-03-29 03:47:39 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea_p.h	1970-01-01 00:00:00 +0000
@@ -1,169 +0,0 @@
-/*
- * Copyright (C) 2015 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_PRIV_H
-#define DIRECTIONAL_DRAG_AREA_PRIV_H
-
-// Information about an active touch point
-struct UBUNTUGESTURESQML_EXPORT ActiveTouchInfo {
-    ActiveTouchInfo() : id(-1), startTime(-1) {}
-    bool isValid() const { return id != -1; }
-    void reset() { id = -1; }
-    int id;
-    qint64 startTime;
-};
-class UBUNTUGESTURESQML_EXPORT 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;
-};
-
-class UBUNTUGESTURESQML_EXPORT DirectionalDragAreaPrivate : public QObject {
-    Q_OBJECT
-
-    Q_ENUMS(Status)
-public:
-    DirectionalDragAreaPrivate(DirectionalDragArea *q);
-
-public Q_SLOTS:
-    void giveUpIfDisabledOrInvisible();
-    void rejectGesture();
-
-public:
-    // 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,
-    };
-
-    void touchEvent_absent(QTouchEvent *event);
-    void touchEvent_undecided(QTouchEvent *event);
-    void touchEvent_recognized(QTouchEvent *event);
-    bool movingInRightDirection() const;
-    bool movedFarEnoughAlongGestureAxis() const;
-    bool isPastMaxDistance() const;
-    const QTouchEvent::TouchPoint *fetchTargetTouchPoint(QTouchEvent *event);
-    void setStatus(Status newStatus);
-    void setPublicPos(const QPointF point);
-    void setPublicScenePos(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;
-    bool sanityCheckRecognitionProperties();
-    void updateSceneDistance();
-    void setMaxTime(int value);
-    void setDistanceThreshold(qreal value);
-    void setPixelsPerMm(qreal pixelsPerMm);
-    QString objectName() const { return q->objectName(); }
-
-    // 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);
-
-    DirectionalDragArea *q;
-
-    // The current status of the directional drag gesture area.
-    Status status;
-
-    QPointF startPos;
-    QPointF startScenePos;
-    qreal sceneDistance;
-    int touchId;
-
-    // The touch position exposed in the public API.
-    // It only starts to move once the gesture gets recognized.
-    QPointF publicPos;
-    QPointF publicScenePos;
-
-    // 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 dampedScenePos;
-    QPointF previousDampedScenePos;
-
-    // Unit vector in scene coordinates describing the direction of the gesture recognition
-    QPointF sceneDirectionVector;
-
-    Direction::Type direction;
-
-    // How far a touch point has to move from its initial position along the gesture axis in order
-    // for it to be recognized as a directional drag.
-    qreal distanceThreshold;
-    qreal distanceThresholdSquared; // it's pow(distanceThreshold, 2)
-
-    // Maximum time (in milliseconds) the gesture can take to go beyond the distance threshold
-    int maxTime;
-
-    // Maximum distance the gesture can go without crossing the axis-aligned distance threshold
-    qreal maxDistance;
-
-    // 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).
-    int compositionTime;
-
-    bool immediateRecognition;
-
-    UbuntuGestures::AbstractTimer *recognitionTimer;
-
-    UbuntuGestures::SharedTimeSource timeSource;
-
-    ActiveTouchesInfo activeTouches;
-
-    bool monitorOnly;
-
-Q_SIGNALS:
-    void statusChanged(Status value);
-};
-
-#endif // DIRECTIONAL_DRAG_AREA_PRIV_H

=== modified file 'plugins/Ubuntu/Gestures/Gestures.qmltypes'
--- plugins/Ubuntu/Gestures/Gestures.qmltypes	2016-03-29 03:47:39 +0000
+++ plugins/Ubuntu/Gestures/Gestures.qmltypes	2016-06-01 16:58:47 +0000
@@ -55,88 +55,6 @@
         }
     }
     Component {
-        name: "DirectionalDragArea"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        exports: ["Ubuntu.Gestures/DirectionalDragArea 0.1"]
-        exportMetaObjectRevisions: [0]
-        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: "dragging"; type: "bool"; isReadonly: true }
-        Property { name: "pressed"; type: "bool"; isReadonly: true }
-        Property { name: "immediateRecognition"; type: "bool" }
-        Signal {
-            name: "directionChanged"
-            Parameter { name: "direction"; type: "Direction::Type" }
-        }
-        Signal {
-            name: "draggingChanged"
-            Parameter { name: "value"; type: "bool" }
-        }
-        Signal {
-            name: "pressedChanged"
-            Parameter { name: "value"; type: "bool" }
-        }
-        Signal {
-            name: "distanceChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "sceneDistanceChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        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: "immediateRecognitionChanged"
-            Parameter { name: "value"; type: "bool" }
-        }
-        Method { name: "removeTimeConstraints" }
-    }
-    Component {
-        name: "FloatingFlickable"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        exports: ["Ubuntu.Gestures/FloatingFlickable 0.1"]
-        exportMetaObjectRevisions: [0]
-        Property { name: "contentWidth"; type: "double" }
-        Property { name: "contentHeight"; type: "double" }
-        Property { name: "contentX"; type: "double" }
-        Property { name: "contentY"; type: "double" }
-        Property { name: "direction"; type: "Direction::Type" }
-    }
-    Component {
-        name: "GestureTouchPoint"
-        prototype: "QObject"
-        exports: ["Ubuntu.Gestures/GestureTouchPoint 0.1"]
-        isCreatable: false
-        exportMetaObjectRevisions: [0]
-        Property { name: "pointId"; type: "int"; isReadonly: true }
-        Property { name: "pressed"; type: "bool"; isReadonly: true }
-        Property { name: "x"; type: "double"; isReadonly: true }
-        Property { name: "y"; type: "double"; isReadonly: true }
-        Property { name: "dragging"; type: "bool"; isReadonly: true }
-    }
-    Component {
         name: "PressedOutsideNotifier"
         defaultProperty: "data"
         prototype: "QQuickItem"
@@ -156,54 +74,4 @@
             Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
         }
     }
-    Component {
-        name: "TouchGestureArea"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        exports: ["Ubuntu.Gestures/TouchGestureArea 0.1"]
-        exportMetaObjectRevisions: [0]
-        Enum {
-            name: "Status"
-            values: {
-                "WaitingForTouch": 0,
-                "Undecided": 1,
-                "Recognized": 2,
-                "Rejected": 3
-            }
-        }
-        Property { name: "touchPoints"; type: "GestureTouchPoint"; isList: true; isReadonly: true }
-        Property { name: "dragging"; type: "bool"; isReadonly: true }
-        Property { name: "minimumTouchPoints"; type: "int" }
-        Property { name: "maximumTouchPoints"; type: "int" }
-        Signal {
-            name: "statusChanged"
-            Parameter { name: "status"; type: "Status" }
-        }
-        Signal { name: "touchPointsUpdated" }
-        Signal {
-            name: "draggingChanged"
-            Parameter { name: "dragging"; type: "bool" }
-        }
-        Signal {
-            name: "minimumTouchPointsChanged"
-            Parameter { name: "value"; type: "bool" }
-        }
-        Signal {
-            name: "maximumTouchPointsChanged"
-            Parameter { name: "value"; type: "bool" }
-        }
-        Signal {
-            name: "pressed"
-            Parameter { name: "points"; type: "QList<QObject*>" }
-        }
-        Signal {
-            name: "released"
-            Parameter { name: "points"; type: "QList<QObject*>" }
-        }
-        Signal {
-            name: "updated"
-            Parameter { name: "points"; type: "QList<QObject*>" }
-        }
-        Signal { name: "clicked" }
-    }
 }

=== renamed file 'plugins/Ubuntu/Gestures/FloatingFlickable.cpp' => 'plugins/Ubuntu/Gestures/MouseEventGenerator.cpp'
--- plugins/Ubuntu/Gestures/FloatingFlickable.cpp	2015-05-27 09:37:34 +0000
+++ plugins/Ubuntu/Gestures/MouseEventGenerator.cpp	2016-06-01 16:58:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Canonical, Ltd.
+ * Copyright (C) 2015-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,137 +14,51 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "FloatingFlickable.h"
-
-#include <private/qquickflickable_p.h>
-#include "DirectionalDragArea.h"
-
-#include <QDebug>
-
-FloatingFlickable::FloatingFlickable(QQuickItem *parent)
-    : QQuickItem(parent)
-    , m_mousePressed(false)
-{
-    m_dragArea = new DirectionalDragArea(this);
-    m_dragArea->setWidth(width());
-    m_dragArea->setHeight(height());
-    m_dragArea->setDirection(Direction::Horizontal);
-    connect(m_dragArea, &DirectionalDragArea::touchXChanged,
-        this, &FloatingFlickable::onDragAreaTouchPosChanged);
-    connect(m_dragArea, &DirectionalDragArea::touchYChanged,
-        this, &FloatingFlickable::onDragAreaTouchPosChanged);
-    connect(m_dragArea, &DirectionalDragArea::draggingChanged,
-        this, &FloatingFlickable::onDragAreaDraggingChanged);
-    connect(m_dragArea, &DirectionalDragArea::directionChanged, this, &FloatingFlickable::directionChanged);
-
-    m_flickable = new QQuickFlickable(this);
-    m_flickable->setEnabled(false);
-    m_flickable->setWidth(width());
-    m_flickable->setHeight(height());
-    connect(m_flickable, &QQuickFlickable::contentWidthChanged, this, &FloatingFlickable::contentWidthChanged);
-    connect(m_flickable, &QQuickFlickable::contentHeightChanged, this, &FloatingFlickable::contentHeightChanged);
-    connect(m_flickable, &QQuickFlickable::contentXChanged, this, &FloatingFlickable::contentXChanged);
-    connect(m_flickable, &QQuickFlickable::contentYChanged, this, &FloatingFlickable::contentYChanged);
-
-    connect(this, &QQuickItem::widthChanged, this, &FloatingFlickable::updateChildrenWidth);
-    connect(this, &QQuickItem::heightChanged, this, &FloatingFlickable::updateChildrenHeight);
-}
-
-qreal FloatingFlickable::contentWidth() const
-{
-    return m_flickable->contentWidth();
-}
-
-void FloatingFlickable::setContentWidth(qreal contentWidth)
-{
-    m_flickable->setContentWidth(contentWidth);
-}
-
-qreal FloatingFlickable::contentHeight() const
-{
-    return m_flickable->contentHeight();
-}
-
-void FloatingFlickable::setContentHeight(qreal contentHeight)
-{
-    m_flickable->setContentHeight(contentHeight);
-}
-
-qreal FloatingFlickable::contentX() const
-{
-    return m_flickable->contentX();
-}
-
-void FloatingFlickable::setContentX(qreal contentX)
-{
-    m_flickable->setContentX(contentX);
-}
-
-qreal FloatingFlickable::contentY() const
-{
-    return m_flickable->contentY();
-}
-
-void FloatingFlickable::setContentY(qreal contentY)
-{
-    m_flickable->setContentY(contentY);
-}
-
-Direction::Type FloatingFlickable::direction() const
-{
-    return m_dragArea->direction();
-}
-
-void FloatingFlickable::setDirection(Direction::Type direction)
-{
-    m_dragArea->setDirection(direction);
-    if (Direction::isHorizontal(direction)) {
-        m_flickable->setFlickableDirection(QQuickFlickable::HorizontalFlick);
-    } else {
-        m_flickable->setFlickableDirection(QQuickFlickable::VerticalFlick);
-    }
-}
-
-void FloatingFlickable::updateChildrenWidth()
-{
-    m_dragArea->setWidth(width());
-    m_flickable->setWidth(width());
-}
-
-void FloatingFlickable::updateChildrenHeight()
-{
-    m_dragArea->setHeight(height());
-    m_flickable->setHeight(height());
-}
-
-void FloatingFlickable::onDragAreaTouchPosChanged(qreal)
-{
-    if (m_mousePressed) {
-        QMouseEvent mouseEvent(QEvent::MouseMove,
-                QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
-                Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
-
-        QCoreApplication::sendEvent(m_flickable, &mouseEvent);
-
-    }
-}
-
-void FloatingFlickable::onDragAreaDraggingChanged(bool dragging)
-{
-    if (dragging && !m_mousePressed) {
-        QMouseEvent mouseEvent(QEvent::MouseButtonPress,
-                QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
-                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-
-        QCoreApplication::sendEvent(m_flickable, &mouseEvent);
-        m_mousePressed = true;
-
-    } else if (!dragging && m_mousePressed) {
-        QMouseEvent mouseEvent(QEvent::MouseButtonRelease,
-                QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
-                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-
-        QCoreApplication::sendEvent(m_flickable, &mouseEvent);
-        m_mousePressed = false;
-    }
+#include "MouseEventGenerator.h"
+
+#include <QCoreApplication>
+#include <QMouseEvent>
+#include <QQuickItem>
+
+MouseEventGenerator::MouseEventGenerator(QObject *parent)
+    : QObject(parent)
+{
+}
+
+void MouseEventGenerator::move(const QPointF position)
+{
+    if (!m_mousePressed || !m_targetItem) {
+        return;
+    }
+
+    QMouseEvent mouseEvent(QEvent::MouseMove,
+            QPointF(position.x(), position.y()), Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
+
+    QCoreApplication::sendEvent(m_targetItem, &mouseEvent);
+}
+
+void MouseEventGenerator::press(const QPointF position)
+{
+    if (m_mousePressed || !m_targetItem) {
+        return;
+    }
+
+    QMouseEvent mouseEvent(QEvent::MouseButtonPress,
+            QPointF(position.x(), position.y()), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+
+    QCoreApplication::sendEvent(m_targetItem, &mouseEvent);
+    m_mousePressed = true;
+}
+
+void MouseEventGenerator::release(const QPointF position)
+{
+    if (!m_mousePressed || !m_targetItem) {
+        return;
+    }
+
+    QMouseEvent mouseEvent(QEvent::MouseButtonRelease,
+            QPointF(position.x(), position.y()), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+
+    QCoreApplication::sendEvent(m_targetItem, &mouseEvent);
+    m_mousePressed = false;
 }

=== renamed file 'plugins/Ubuntu/Gestures/FloatingFlickable.h' => 'plugins/Ubuntu/Gestures/MouseEventGenerator.h'
--- plugins/Ubuntu/Gestures/FloatingFlickable.h	2015-05-27 09:37:34 +0000
+++ plugins/Ubuntu/Gestures/MouseEventGenerator.h	2016-06-01 16:58:47 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Canonical, Ltd.
+ * Copyright (C) 2015-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,73 +14,35 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef FLOATING_FLICKABLE_H
-#define FLOATING_FLICKABLE_H
-
-#include <QQuickItem>
+#ifndef MOUSEEVENTGENERATOR_H
+#define MOUSEEVENTGENERATOR_H
+
+#include <QObject>
+#include <QPointF>
+
 #include "UbuntuGesturesQmlGlobal.h"
-#include "Direction.h"
-
-class DirectionalDragArea;
-class QQuickFlickable;
-
-/*
-    A Flickable that can be put in front of the item to be flicked and
-    still have the item-to-be-flicked receive input events that are not flicks.
-
-    Ie, it's a Flickable that, input-wise, is transparent to non-flick gestures.
-
-    With a regular Flickable you would have to make the item-to-be-flicked a child
-    of Flicakble to achieve the same result. FloatingFlickable has no such requirement
-    or limitation.
- */
-class UBUNTUGESTURESQML_EXPORT FloatingFlickable : public QQuickItem {
+
+class QQuickItem;
+
+class UBUNTUGESTURESQML_EXPORT MouseEventGenerator : public QObject {
     Q_OBJECT
-
-    Q_PROPERTY(qreal contentWidth READ contentWidth WRITE setContentWidth NOTIFY contentWidthChanged)
-    Q_PROPERTY(qreal contentHeight READ contentHeight WRITE setContentHeight NOTIFY contentHeightChanged)
-    Q_PROPERTY(qreal contentX READ contentX WRITE setContentX NOTIFY contentXChanged)
-    Q_PROPERTY(qreal contentY READ contentY WRITE setContentY NOTIFY contentYChanged)
-
-    Q_PROPERTY(Direction::Type direction READ direction WRITE setDirection NOTIFY directionChanged)
+    Q_PROPERTY(QQuickItem* targetItem MEMBER m_targetItem NOTIFY targetItemChanged)
+
+public:
+    MouseEventGenerator(QObject *parent = nullptr);
+
+    Q_INVOKABLE void move(const QPointF position);
+    Q_INVOKABLE void press(const QPointF position);
+    Q_INVOKABLE void release(const QPointF position);
 
 Q_SIGNALS:
-    void contentWidthChanged();
-    void contentHeightChanged();
-    void contentXChanged();
-    void contentYChanged();
-    void directionChanged();
-
-public:
-    FloatingFlickable(QQuickItem *parent = nullptr);
-
-    qreal contentWidth() const;
-    void setContentWidth(qreal contentWidth);
-
-    qreal contentHeight() const;
-    void setContentHeight(qreal contentHeight);
-
-    qreal contentX() const;
-    void setContentX(qreal contentX);
-
-    qreal contentY() const;
-    void setContentY(qreal contentY);
-
-    Direction::Type direction() const;
-    void setDirection(Direction::Type);
-
-private Q_SLOTS:
-    void updateChildrenWidth();
-    void updateChildrenHeight();
-    void onDragAreaTouchPosChanged(qreal);
-    void onDragAreaDraggingChanged(bool value);
+    void targetItemChanged(QQuickItem *);
 
 private:
-    DirectionalDragArea *m_dragArea;
-    QQuickFlickable *m_flickable;
-    bool m_mousePressed;
+    bool m_mousePressed {false};
+    QQuickItem *m_targetItem {nullptr};
 
     friend class tst_FloatingFlickable;
 };
 
-#endif // FLOATING_FLICKABLE_H
+#endif // MOUSEEVENTGENERATOR_H

=== modified file 'plugins/Ubuntu/Gestures/PressedOutsideNotifier.h'
--- plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	2013-11-22 13:43:40 +0000
+++ plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	2016-06-01 16:58:47 +0000
@@ -23,7 +23,7 @@
 #include <QPointer>
 #include <QTimer>
 
-#include "UbuntuGesturesGlobal.h"
+#include <ubuntugesturesglobal.h>
 
 /*
    Notifies when a point, mouse or touch, is pressed outside its area.

=== modified file 'plugins/Ubuntu/Gestures/TouchGate.cpp'
--- plugins/Ubuntu/Gestures/TouchGate.cpp	2015-06-24 11:41:09 +0000
+++ plugins/Ubuntu/Gestures/TouchGate.cpp	2016-06-01 16:58:47 +0000
@@ -20,8 +20,8 @@
 #include <QDebug>
 #include <QQuickWindow>
 
-#include <TouchOwnershipEvent.h>
-#include <TouchRegistry.h>
+#include <TouchOwnershipEvent>
+#include <TouchRegistry>
 
 #if TOUCHGATE_DEBUG
 #define ugDebug(params) qDebug().nospace() << "[TouchGate(" << (void*)this << ")] " << params

=== modified file 'plugins/Ubuntu/Gestures/TouchGestureArea.cpp'
--- plugins/Ubuntu/Gestures/TouchGestureArea.cpp	2016-03-11 20:18:12 +0000
+++ plugins/Ubuntu/Gestures/TouchGestureArea.cpp	2016-06-01 16:58:47 +0000
@@ -16,10 +16,11 @@
 
 #include "TouchGestureArea.h"
 
-// local
-#include "TouchOwnershipEvent.h"
-#include "TouchRegistry.h"
-#include "UnownedTouchEvent.h"
+#include <UbuntuGestures/TouchOwnershipEvent>
+#include <UbuntuGestures/TouchRegistry>
+#include <UbuntuGestures/UnownedTouchEvent>
+// #include "TouchRegistry.h"
+// #include "UnownedTouchEvent.h"
 
 #include <QGuiApplication>
 #include <QStyleHints>
@@ -588,13 +589,15 @@
             resyncCachedTouchPoints();
             break;
         case InternalStatus::WaitingForMoreTouches:
-            m_recognitionTimer->start(m_recognitionPeriod);
+            m_recognitionTimer->setInterval(m_recognitionPeriod);
+            m_recognitionTimer->start();
             break;
         case InternalStatus::Recognized:
             resyncCachedTouchPoints();
             break;
         case InternalStatus::WaitingForRejection:
-            m_recognitionTimer->start(m_releaseRejectPeriod);
+            m_recognitionTimer->setInterval(m_releaseRejectPeriod);
+            m_recognitionTimer->start();
             break;
         case InternalStatus::Rejected:
             resyncCachedTouchPoints();

=== modified file 'plugins/Ubuntu/Gestures/TouchGestureArea.h'
--- plugins/Ubuntu/Gestures/TouchGestureArea.h	2016-03-11 20:18:12 +0000
+++ plugins/Ubuntu/Gestures/TouchGestureArea.h	2016-06-01 16:58:47 +0000
@@ -21,8 +21,7 @@
 
 #include <QQuickItem>
 
-// lib UbuntuGestures
-#include <Timer.h>
+#include <UbuntuGestures/Timer>