Unity 8

Merge lp:~aacid/unity8/nodda into lp:unity8

nodda
Merge into trunk

Proposed by Albert Astals Cid on 2015-12-17

Status:	Merged
Approved by:	Daniel d'Andrada on 2016-05-02
Approved revision:	2125
Merged at revision:	2410
Proposed branch:	lp:~aacid/unity8/nodda
Merge into:	lp:unity8
Prerequisite:	lp:~aacid/unity8/fixQmlTestsNewSDK
Diff against target:	7650 lines (+314/-6218) 77 files modified CMakeLists.txt (+12/-1) debian/control (+2/-0) debian/unity8-private.install (+0/-1) libs/CMakeLists.txt (+0/-1) libs/UbuntuGestures/CMakeLists.txt (+0/-41) libs/UbuntuGestures/CandidateInactivityTimer.cpp (+0/-46) libs/UbuntuGestures/CandidateInactivityTimer.h (+0/-51) libs/UbuntuGestures/DebugHelpers.cpp (+0/-95) libs/UbuntuGestures/DebugHelpers.h (+0/-31) libs/UbuntuGestures/Pool.h (+0/-124) libs/UbuntuGestures/TimeSource.cpp (+0/-49) libs/UbuntuGestures/TimeSource.h (+0/-64) libs/UbuntuGestures/Timer.cpp (+0/-152) libs/UbuntuGestures/Timer.h (+0/-122) libs/UbuntuGestures/TouchOwnershipEvent.cpp (+0/-35) libs/UbuntuGestures/TouchOwnershipEvent.h (+0/-50) libs/UbuntuGestures/TouchRegistry.cpp (+0/-553) libs/UbuntuGestures/TouchRegistry.h (+0/-201) libs/UbuntuGestures/UbuntuGesturesGlobal.h (+0/-23) libs/UbuntuGestures/UnownedTouchEvent.cpp (+0/-39) libs/UbuntuGestures/UnownedTouchEvent.h (+0/-45) plugins/Ubuntu/Gestures/AxisVelocityCalculator.h (+1/-1) plugins/Ubuntu/Gestures/CMakeLists.txt (+5/-5) plugins/Ubuntu/Gestures/Damper.cpp (+0/-24) plugins/Ubuntu/Gestures/Damper.h (+0/-89) plugins/Ubuntu/Gestures/Direction.h (+1/-0) plugins/Ubuntu/Gestures/DirectionalDragArea.cpp (+0/-932) plugins/Ubuntu/Gestures/DirectionalDragArea.h (+0/-143) plugins/Ubuntu/Gestures/DirectionalDragArea_p.h (+0/-169) plugins/Ubuntu/Gestures/Gestures.qmltypes (+0/-132) plugins/Ubuntu/Gestures/MouseEventGenerator.cpp (+48/-134) plugins/Ubuntu/Gestures/MouseEventGenerator.h (+23/-61) plugins/Ubuntu/Gestures/PressedOutsideNotifier.h (+1/-1) plugins/Ubuntu/Gestures/TouchGate.cpp (+2/-2) plugins/Ubuntu/Gestures/TouchGestureArea.cpp (+9/-6) plugins/Ubuntu/Gestures/TouchGestureArea.h (+1/-2) plugins/Ubuntu/Gestures/plugin.cpp (+3/-5) qml/Components/DragHandle.qml (+16/-18) qml/Components/FloatingFlickable.qml (+59/-0) qml/Dash/Dash.qml (+3/-3) qml/Launcher/Launcher.qml (+4/-4) qml/Panel/IndicatorsMenu.qml (+17/-13) qml/Stages/DesktopStage.qml (+1/-1) qml/Stages/PhoneStage.qml (+4/-4) qml/Stages/TabletStage.qml (+4/-4) qml/Tutorial/TutorialBottom.qml (+3/-3) src/CMakeLists.txt (+0/-4) tests/CMakeLists.txt (+0/-1) tests/libs/CMakeLists.txt (+0/-1) tests/libs/UbuntuGestures/CMakeLists.txt (+0/-16) tests/libs/UbuntuGestures/tst_TouchRegistry.cpp (+0/-974) tests/plugins/Ubuntu/Gestures/CMakeLists.txt (+4/-4) tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml (+0/-72) tests/plugins/Ubuntu/Gestures/GestureTest.cpp (+2/-2) tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml (+0/-76) tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml (+0/-76) tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml (+0/-76) tests/plugins/Ubuntu/Gestures/tst_Damper.cpp (+0/-40) tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp (+0/-1250) tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.qml (+0/-76) tests/plugins/Ubuntu/Gestures/tst_FloatingFlickable.cpp (+26/-19) tests/plugins/Ubuntu/Gestures/tst_FloatingFlickable.qml (+1/-0) tests/plugins/Ubuntu/Gestures/tst_TouchGate.cpp (+1/-1) tests/qmltests/Components/CMakeLists.txt (+6/-3) tests/qmltests/Components/tst_DragHandle.cpp (+25/-21) tests/qmltests/Components/tst_EdgeDragEvaluator.cpp (+1/-1) tests/qmltests/Greeter/tst_Greeter.qml (+1/-1) tests/qmltests/Greeter/tst_NarrowView.qml (+1/-1) tests/qmltests/Greeter/tst_WideView.qml (+1/-1) tests/qmltests/Launcher/tst_Launcher.qml (+1/-1) tests/qmltests/Tutorial/tst_Tutorial.qml (+2/-2) tests/qmltests/tst_OrientedShell.qml (+1/-1) tests/qmltests/tst_Shell.qml (+7/-5) tests/qmltests/tst_ShellWithPin.qml (+1/-1) tests/utils/modules/Unity/Test/CMakeLists.txt (+4/-2) tests/utils/modules/Unity/Test/UnityTestCase.qml (+8/-8) tests/utils/modules/Unity/Test/testutil.cpp (+2/-2)
To merge this branch:	bzr merge lp:~aacid/unity8/nodda
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Unity8 CI Bot	continuous-integration		Needs Fixing on 2016-05-02
Daniel d'Andrada (community)		2015-12-17	Approve on 2016-05-02
PS Jenkins bot	continuous-integration	2015-12-17	Needs Fixing on 2015-12-17
Review via email: mp+280814@code.launchpad.net

This proposal supersedes a proposal from 2015-12-07.

Commit Message

Remove DirectionalDragArea and libs/UbuntuGestures and port to SDK equivalents

Description of the Change

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

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

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

* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A

* If you changed the UI, has there been a design review?
N/A

PS Jenkins bot (ps-jenkins) wrote on 2015-12-10: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6909/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-12-10: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6910/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-12-11: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6923/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-12-11: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6924/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-12-11: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6925/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-12-14: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6930/rebuild

review: Needs Fixing (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2015-12-14: Posted in a previous version of this proposal

Please document FloatingFlickableHelper. Explain what's its purpose.

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2015-12-14: Posted in a previous version of this proposal

> Please document FloatingFlickableHelper. Explain what's its purpose.

You could even give it a more informative/accurate name, such as MouseEventSynthesizer

Daniel d'Andrada (dandrader) wrote on 2015-12-14: Posted in a previous version of this proposal

"""
* Copyright (C) 2013 Canonical, Ltd.
"""

Please fix the copyright year in FloatingFlickable.qml

review: Needs Fixing

PS Jenkins bot (ps-jenkins) wrote on 2015-12-14: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6937/rebuild

review: Needs Fixing (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2015-12-16: Posted in a previous version of this proposal

In tests/autopilot/unity8/dash.py:

"""
- current_header.select_single(objectName="search_action_button")
+ current_header.select_single(objectName="search_button")
"""

Seems unrelated.

Same in tests/qmltests/Dash/tst_GenericScopeView.qml and tests/qmltests/Dash/tst_Dash.qml

-------------------------

I don't get why you had to make those changes in tests/qmltests/Panel/tst_IndicatorsMenu.qml

----------------------

This "wait(1000);" in tests/qmltests/Stages/tst_PhoneStage.qml doesn't look right.

Albert Astals Cid (aacid) wrote on 2015-12-17: Posted in a previous version of this proposal

> In tests/autopilot/unity8/dash.py:
>
> """
> - current_header.select_single(objectName="search_action_button")
> + current_header.select_single(objectName="search_button")
> """
>
> Seems unrelated.
>
> Same in tests/qmltests/Dash/tst_GenericScopeView.qml and
> tests/qmltests/Dash/tst_Dash.qml

Yeah i merged https://code.launchpad.net/~aacid/unity8/fixQmlTestsNewSDK/+merge/280260 and forgot to set it as prerequisite, will do now.

Albert Astals Cid (aacid) wrote on 2015-12-17:

> I don't get why you had to make those changes in tests/qmltests/Panel/tst_IndicatorsMenu.qml

That's https://code.launchpad.net/~aacid/unity8/testIndicatorsMenuFix/+merge/280165 I merged it in because i wanted to have as few errors as possible in qmluitests run

Albert Astals Cid (aacid) wrote on 2015-12-17:

> This "wait(1000);" in tests/qmltests/Stages/tst_PhoneStage.qml doesn't look right.

Yeah, removed, now for some reason there's failing tests there i did not have when i presented the branch, i'll investigate.

Daniel d'Andrada (dandrader) wrote on 2015-12-17:

-- checking for module 'UbuntuGestures'
-- package 'UbuntuGestures' not found

Getting this error in my arm chroot. Might be related to the fact that uitk replaced the package libubuntugestures with libubuntugestures5

Daniel d'Andrada (dandrader) wrote on 2015-12-17:

In src/CMakeLists.txt

"""
# For it to find libUbuntuGestures.so
set_target_properties(${SHELL_APP} PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${SHELL_PRIVATE_LIBDIR}")
"""

You can remove this since we no longer build libUbuntuGestures ourselves.

Daniel d'Andrada (dandrader) wrote on 2015-12-17:

In src/CMakeLists.txt:

"""
include_directories(
    ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
    ${CMAKE_SOURCE_DIR}/libs/UbuntuGestures
    ${CONNECTIVITY_INCLUDE_DIRS}
)
"""

"${CMAKE_SOURCE_DIR}/libs/UbuntuGestures" should go away as well.

PS Jenkins bot (ps-jenkins) wrote on 2015-12-17:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6970/rebuild

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2015-12-17:

Fixed the src/CMakeLists.txt issues

Daniel d'Andrada (dandrader) wrote on 2015-12-17:

"""
// don't go the whole distance in order to smooth out the movement
"""

Please remove that comment from qml/Components/DragHandle.qml as well

Daniel d'Andrada (dandrader) wrote on 2015-12-17:

Looks like FloatingFlickable is broken. I'm no longer able to move the list of windows in the desktop spread with my finger.

review: Needs Fixing

Michael Terry (mterry) wrote on 2015-12-17:

Ugh, if this lands it blocks my tutorial-redesign branch on landing the monitorOnly mode in the SDK. Which I'll get started on trying to land anyway. But still. I'm sad to lose the race. :(

PS Jenkins bot (ps-jenkins) wrote on 2015-12-17:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/6975/rebuild

review: Needs Fixing (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2016-01-11:

Code looks good. Didn't spot any regressions on my Nexus 7 in tablet nor desktop modes

review: Approve

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-02-02:

FAILED: Continuous integration, rev:2114
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/245/
Executed test runs:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/245/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-10:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/645/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-14:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/700/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-14:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/713/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-14:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/720/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-23:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/801/rebuild

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2016-03-24:

Lots of stuff changed behind my feet so need to update this :'(

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-24:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/865/rebuild

review: Needs Fixing (continuous-integration)

Michael Terry (mterry) wrote on 2016-04-12:

The new SwipeArea property "grabGesture" (which is an inverse of the property the new tutorial uses -- "monitorOnly"), landed in the released toolkit now.

So that's not a blocker anymore.

Albert Astals Cid (aacid) wrote on 2016-04-13:

> The new SwipeArea property "grabGesture" (which is an inverse of the property
> the new tutorial uses -- "monitorOnly"), landed in the released toolkit now.
>
> So that's not a blocker anymore.

I'd say we should still wait for https://code.launchpad.net/~aacid/unity8/nodda/+merge/280814 to get released too since it's a bugfix that we have on our side that the SDK doesn't.

lp:~aacid/unity8/nodda updated on 2016-04-13

2121. By Albert Astals Cid on 2016-04-13: Merge

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-13:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/986/rebuild

review: Needs Fixing (continuous-integration)

lp:~aacid/unity8/nodda updated on 2016-04-13

2122. By Albert Astals Cid on 2016-04-13: Fix borken merge

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-13:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/987/rebuild

review: Needs Fixing (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2016-04-13:

On 13/04/2016 05:28, Albert Astals Cid wrote:
>> The new SwipeArea property "grabGesture" (which is an inverse of the property
>> the new tutorial uses -- "monitorOnly"), landed in the released toolkit now.
>>
>> So that's not a blocker anymore.
> I'd say we should still wait for https://code.launchpad.net/~aacid/unity8/nodda/+merge/280814 to get released too since it's a bugfix that we have on our side that the SDK doesn't.

I think you pasted the wrong URL...

Albert Astals Cid (aacid) wrote on 2016-04-13:

> On 13/04/2016 05:28, Albert Astals Cid wrote:
> >> The new SwipeArea property "grabGesture" (which is an inverse of the
> property
> >> the new tutorial uses -- "monitorOnly"), landed in the released toolkit
> now.
> >>
> >> So that's not a blocker anymore.
> > I'd say we should still wait for
> https://code.launchpad.net/~aacid/unity8/nodda/+merge/280814 to get released
> too since it's a bugfix that we have on our side that the SDK doesn't.
>
> I think you pasted the wrong URL...

Right, i meant https://code.launchpad.net/~aacid/ubuntu-ui-toolkit/touchRegistryUnity8Fixes/+merge/290024

lp:~aacid/unity8/nodda updated on 2016-04-26

2123. By Albert Astals Cid on 2016-04-26: Merge

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-26:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1052/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-26:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1066/rebuild

review: Needs Fixing (continuous-integration)

lp:~aacid/unity8/nodda updated on 2016-05-02

2124. By Albert Astals Cid on 2016-05-02: Merge

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-05-02:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1098/rebuild

review: Needs Fixing (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2016-05-02:

Addded cmake checks for libubuntugestures5-dev and libubuntugestures5-private-dev in lp:~dandrader/unity8/nodda (rev 2377)

lp:~aacid/unity8/nodda updated on 2016-05-02

2125. By Daniel d'Andrada on 2016-05-02: Add cmake check for libubuntugestures5-dev and libubuntugestures5-private-dev

Daniel d'Andrada (dandrader) wrote on 2016-05-02:

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

* Did CI run pass? If not, please explain why.
Only one failure which seems unrelated (https://unity8-jenkins.ubuntu.com/job/test-0-autopkgtest/label=phone-armhf,release=vivid+overlay,testname=autopilot.sh/651/console). Link doesn't even exist...

review: Approve

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-05-02:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1105/rebuild

review: Needs Fixing (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches

to all changes:

Albert Astals Cid

Mohammad Rakibul Hasan

Unity Team

 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2016-04-27 15:01:10 +0000
 +++ CMakeLists.txt	2016-05-02 15:26:52 +0000
@@ -63,6 +63,18 @@
  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/control'
 --- debian/control	2016-04-27 15:01:10 +0000
 +++ debian/control	2016-05-02 15:26:52 +0000
@@ -29,6 +29,8 @@
                 libqt5svg5-dev,
                 libqt5xmlpatterns5-dev,
                 libsystemsettings-dev,
++               libubuntugestures5-dev,
++               libubuntugestures5-private-dev,
                 libudev-dev,
                 libunity-api-dev (>= 7.110),
                 libusermetricsoutput1-dev,
 === modified file 'debian/unity8-private.install'
 --- debian/unity8-private.install	2016-04-04 13:38:56 +0000
 +++ debian/unity8-private.install	2016-05-02 15:26:52 +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 <daniel.dandrada@canonical.com>
-- */
--
--#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 <daniel.dandrada@canonical.com>
-- */
--
--#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/Ubuntu/Gestures/AxisVelocityCalculator.h'
 --- plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2014-10-01 13:20:32 +0000
 +++ plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2016-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +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-05-02 15:26:52 +0000
@@ -21,8 +21,7 @@
  #include <QQuickItem>
--// lib UbuntuGestures
--#include <Timer.h>
++#include <UbuntuGestures/Timer>
  class TouchOwnershipEvent;
  class UnownedTouchEvent;
 === modified file 'plugins/Ubuntu/Gestures/plugin.cpp'
 --- plugins/Ubuntu/Gestures/plugin.cpp	2016-03-29 03:47:39 +0000
 +++ plugins/Ubuntu/Gestures/plugin.cpp	2016-05-02 15:26:52 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2013,2015 Canonical, Ltd.
++ * Copyright (C) 2013,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
@@ -17,8 +17,7 @@
  #include "plugin.h"
  #include "AxisVelocityCalculator.h"
  #include "Direction.h"
--#include "DirectionalDragArea.h"
--#include "FloatingFlickable.h"
++#include "MouseEventGenerator.h"
  #include "PressedOutsideNotifier.h"
  #include "TouchGate.h"
  #include "TouchGestureArea.h"
@@ -34,9 +33,8 @@
  void UbuntuGesturesQmlPlugin::registerTypes(const char *uri)
+ {
      qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);
--    qmlRegisterType<DirectionalDragArea>(uri, 0, 1, "DirectionalDragArea");
      qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");
--    qmlRegisterType<FloatingFlickable>(uri, 0, 1, "FloatingFlickable");
++    qmlRegisterType<MouseEventGenerator>(uri, 0, 1, "MouseEventGenerator");
      qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");
      qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");
      qmlRegisterType<TouchGestureArea>(uri, 0, 1, "TouchGestureArea");
 === modified file 'qml/Components/DragHandle.qml'
 --- qml/Components/DragHandle.qml	2015-07-15 15:07:19 +0000
 +++ qml/Components/DragHandle.qml	2016-05-02 15:26:52 +0000
@@ -38,12 +38,12 @@
          anchors.bottom: parent.bottom
          width: units.gu(2)
--        direction: DirectionalDragArea::Leftwards
++        direction: SwipeArea::Leftwards
+     }
+   }
   */
--DirectionalDragArea {
++SwipeArea {
      id: dragArea
      property bool stretch: false
@@ -118,26 +118,26 @@
+             }
+         }
--        function limitMovement(inputStep) {
--            var targetValue = MathUtils.clamp(dragParent[targetProp] + inputStep, minValue, maxValue);
--            var step = targetValue - dragParent[targetProp];
++        function limitMovement(distance) {
++            var targetValue = MathUtils.clamp(d.startValue + distance, minValue, maxValue);
++            var diff = targetValue - d.startValue;
              if (hintDisplacement == 0) {
--                return step;
++                return diff;
+             }
              // we should not go behind hintingAnimation's current value
              if (Direction.isPositive(direction)) {
--                if (dragParent[targetProp] + step < hintingAnimation.targetValue) {
--                    step = hintingAnimation.targetValue - dragParent[targetProp];
++                if (d.startValue + diff < hintingAnimation.targetValue) {
++                    diff = hintingAnimation.targetValue - d.startValue;
+                 }
              } else {
--                if (dragParent[targetProp] + step > hintingAnimation.targetValue) {
--                    step = hintingAnimation.targetValue - dragParent[targetProp];
++                if (d.startValue + diff > hintingAnimation.targetValue) {
++                    diff = hintingAnimation.targetValue - d.startValue;
+                 }
+             }
--            return step;
++            return diff;
+         }
          function onFinishedRecognizedGesture() {
@@ -171,19 +171,17 @@
          objectName: "edgeDragEvaluator"
          id: dragEvaluator
          // Effectively convert distance into the drag position projected onto the gesture direction axis
--        trackedPosition: Direction.isPositive(dragArea.direction) ? sceneDistance : -sceneDistance
++        trackedPosition: Direction.isPositive(dragArea.direction) ? distance : -distance
          maxDragDistance: maxTotalDragDistance
          direction: dragArea.direction
+     }
      onDistanceChanged: {
          if (dragging) {
--            // don't go the whole distance in order to smooth out the movement
--            var step = distance * 0.3;
--
--            step = d.limitMovement(step);
--
--            parent[d.targetProp] += step;
++            if (!Direction.isPositive(direction))
++                distance = -distance;
++            var toAdd = d.limitMovement(distance);
++            parent[d.targetProp] = d.startValue + toAdd;
+         }
+     }
 === added file 'qml/Components/FloatingFlickable.qml'
 --- qml/Components/FloatingFlickable.qml	1970-01-01 00:00:00 +0000
 +++ qml/Components/FloatingFlickable.qml	2016-05-02 15:26:52 +0000
@@ -0,0 +1,59 @@
++/*
++ * 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
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import Ubuntu.Components 1.3
++import Ubuntu.Gestures 0.1
++
++/*
++    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.
++ */
++Item {
++    property alias contentWidth: flickable.contentWidth
++    property alias contentHeight: flickable.contentHeight
++    property alias contentX: flickable.contentX
++    property alias contentY: flickable.contentY
++    property alias direction: swipeArea.direction
++
++    MouseEventGenerator {
++        id: mouseEventGenerator
++        targetItem: flickable
++    }
++
++    Flickable {
++        id: flickable
++        enabled: false
++        anchors.fill: parent
++        flickableDirection: Direction.isHorizontal(swipeArea.direction) ? Flickable.HorizontalFlick : Flickable.VerticalFlick
++    }
++
++    SwipeArea {
++        id: swipeArea
++        anchors.fill: parent
++        direction: Direction.Horizontal
++
++        onTouchPositionChanged: mouseEventGenerator.move(touchPosition);
++        onDraggingChanged: dragging ? mouseEventGenerator.press(touchPosition)
++                                    : mouseEventGenerator.release(touchPosition)
++    }
++}
 === modified file 'qml/Dash/Dash.qml'
 --- qml/Dash/Dash.qml	2016-04-12 19:10:21 +0000
 +++ qml/Dash/Dash.qml	2016-05-02 15:26:52 +0000
@@ -349,7 +349,7 @@
+         }
+     }
--    DirectionalDragArea {
++    SwipeArea {
          id: overviewDragHandle
          objectName: "overviewDragHandle"
          z: 1
@@ -364,10 +364,10 @@
          anchors { left: parent.left; right: parent.right; bottom: parent.bottom }
          height: units.gu(2)
--        onSceneDistanceChanged: {
++        onDistanceChanged: {
              if (dragging) {
                  bottomEdgeController.enableAnimation = false;
--                bottomEdgeController.progress = Math.max(0, Math.min(1, sceneDistance / fullMovement));
++                bottomEdgeController.progress = Math.max(0, Math.min(1, distance / fullMovement));
+             }
+         }
 === modified file 'qml/Launcher/Launcher.qml'
 --- qml/Launcher/Launcher.qml	2016-04-27 15:01:10 +0000
 +++ qml/Launcher/Launcher.qml	2016-05-02 15:26:52 +0000
@@ -31,14 +31,14 @@
      property int panelWidth: units.gu(10)
      property int dragAreaWidth: units.gu(1)
      property int minimizeDistance: units.gu(26)
--    property real progress: dragArea.dragging && dragArea.touchX > panelWidth ?
--                                (width * (dragArea.touchX-panelWidth) / (width - panelWidth)) : 0
++    property real progress: dragArea.dragging && dragArea.touchPosition.x > panelWidth ?
++                                (width * (dragArea.touchPosition.x-panelWidth) / (width - panelWidth)) : 0
      property bool superPressed: false
      property bool superTabPressed: false
      readonly property bool dragging: dragArea.dragging
--    readonly property real dragDistance: dragArea.dragging ? dragArea.touchX : 0
++    readonly property real dragDistance: dragArea.dragging ? dragArea.touchPosition.x : 0
      readonly property real visibleWidth: panel.width + panel.x
      readonly property bool shown: panel.x > -panel.width
@@ -400,7 +400,7 @@
+         }
+     }
--    DirectionalDragArea {
++    SwipeArea {
          id: dragArea
          objectName: "launcherDragArea"
 === modified file 'qml/Panel/IndicatorsMenu.qml'
 --- qml/Panel/IndicatorsMenu.qml	2016-03-29 03:47:39 +0000
 +++ qml/Panel/IndicatorsMenu.qml	2016-05-02 15:26:52 +0000
@@ -39,7 +39,7 @@
      property bool showOnClick: true
      property color panelColor: theme.palette.normal.background
--    signal showTapped(point position)
++    signal showTapped()
      // TODO: Perhaps we need a animation standard for showing/hiding? Each showable seems to
      // use its own values. Need to ask design about this.
@@ -194,7 +194,7 @@
              } else {
                  var touchReleaseTime = new Date().getTime();
                  if (touchReleaseTime - touchPressTime <= 300) {
--                    root.showTapped(Qt.point(touchSceneX, touchSceneY));
++                    root.showTapped();
+                 }
+             }
+         }
@@ -223,10 +223,10 @@
          stretch: true
          maxTotalDragDistance: openedHeight - expandedPanelHeight - handle.height
--        onTouchSceneXChanged: {
++        onTouchPositionChanged: {
              if (root.state === "locked") {
--                d.xDisplacementSinceLock += (touchSceneX - d.lastHideTouchSceneX)
--                d.lastHideTouchSceneX = touchSceneX;
++                d.xDisplacementSinceLock += (touchPosition.x - d.lastHideTouchX)
++                d.lastHideTouchX = touchPosition.x;
+             }
+         }
+     }
@@ -234,7 +234,11 @@
      PanelVelocityCalculator {
          id: yVelocityCalculator
          velocityThreshold: d.hasCommitted ? 0.1 : 0.3
--        trackedValue: d.activeDragHandle ? d.activeDragHandle.touchSceneY : 0
++        trackedValue: d.activeDragHandle ?
++                            (Direction.isPositive(d.activeDragHandle.direction) ?
++                                    d.activeDragHandle.distance :
++                                    -d.activeDragHandle.distance)
++                            : 0
          onVelocityAboveThresholdChanged: d.updateState()
+     }
@@ -261,13 +265,13 @@
          id: d
          property var activeDragHandle: showDragHandle.dragging ? showDragHandle : hideDragHandle.dragging ? hideDragHandle : null
          property bool hasCommitted: false
--        property real lastHideTouchSceneX: 0
++        property real lastHideTouchX: 0
          property real xDisplacementSinceLock: 0
          onXDisplacementSinceLockChanged: d.updateState()
          property real rowMappedLateralPosition: {
              if (!d.activeDragHandle) return -1;
--            return d.activeDragHandle.mapToItem(bar, d.activeDragHandle.touchX, 0).x;
++            return d.activeDragHandle.mapToItem(bar, d.activeDragHandle.touchPosition.x, 0).x;
+         }
          function updateState() {
@@ -295,7 +299,7 @@
                  script: {
                      yVelocityCalculator.reset();
                      // initial item selection
--                    if (!d.hasCommitted) bar.selectItemAt(d.activeDragHandle ? d.activeDragHandle.touchX : -1);
++                    if (!d.hasCommitted) bar.selectItemAt(d.activeDragHandle ? d.activeDragHandle.touchPosition.x : -1);
                      d.hasCommitted = false;
+                 }
+             }
@@ -313,7 +317,7 @@
                  target: leftScroller
                  lateralPosition: {
                      if (!d.activeDragHandle) return -1;
--                    var mapped = d.activeDragHandle.mapToItem(leftScroller, d.activeDragHandle.touchX, 0);
++                    var mapped = d.activeDragHandle.mapToItem(leftScroller, d.activeDragHandle.touchPosition.x, 0);
                      return mapped.x;
+                 }
+             }
@@ -322,7 +326,7 @@
                  target: rightScroller
                  lateralPosition: {
                      if (!d.activeDragHandle) return -1;
--                    var mapped = d.activeDragHandle.mapToItem(rightScroller, d.activeDragHandle.touchX, 0);
++                    var mapped = d.activeDragHandle.mapToItem(rightScroller, d.activeDragHandle.touchPosition.x, 0);
                      return mapped.x;
+                 }
+             }
@@ -332,7 +336,7 @@
              StateChangeScript {
                  script: {
                      d.xDisplacementSinceLock = 0;
--                    d.lastHideTouchSceneX = hideDragHandle.touchSceneX;
++                    d.lastHideTouchX = hideDragHandle.touchPosition.x;
+                 }
+             }
              PropertyChanges { target: bar; expanded: true }
@@ -344,7 +348,7 @@
              PropertyChanges {
                  target: d;
                  hasCommitted: true
--                lastHideTouchSceneX: 0
++                lastHideTouchX: 0
                  xDisplacementSinceLock: 0
                  restoreEntryValues: false
+             }
 === modified file 'qml/Stages/DesktopStage.qml'
 --- qml/Stages/DesktopStage.qml	2016-04-27 15:01:10 +0000
 +++ qml/Stages/DesktopStage.qml	2016-05-02 15:26:52 +0000
@@ -643,7 +643,7 @@
+         }
+     }
--    DirectionalDragArea {
++    SwipeArea {
          direction: Direction.Leftwards
          anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
          width: units.gu(1)
 === modified file 'qml/Stages/PhoneStage.qml'
 --- qml/Stages/PhoneStage.qml	2016-04-27 15:01:10 +0000
 +++ qml/Stages/PhoneStage.qml	2016-05-02 15:26:52 +0000
@@ -711,7 +711,7 @@
          enabled: spreadDragArea.dragging
+     }
--    DirectionalDragArea {
++    SwipeArea {
          id: spreadDragArea
          objectName: "spreadDragArea"
          direction: Direction.Leftwards
@@ -722,10 +722,10 @@
          property var gesturePoints: new Array()
--        onTouchXChanged: {
++        onTouchPositionChanged: {
              if (dragging) {
                  // Gesture recognized. Let's move the spreadView with the finger
--                var dragX = Math.min(touchX + width, width); // Prevent dragging rightwards
++                var dragX = Math.min(touchPosition.x + width, width); // Prevent dragging rightwards
                  dragX = -dragX + spreadDragArea.width - spreadView.shift;
                  // Don't allow dragging further than the animation crossing with phase2's animation
                  var maxMovement =  spreadView.width * spreadView.positionMarker4 - spreadView.shift;
@@ -737,7 +737,7 @@
                  spreadView.contentX = -spreadView.shift;
+             }
--            gesturePoints.push(touchX);
++            gesturePoints.push(touchPosition.x);
+         }
          onDraggingChanged: {
 === modified file 'qml/Stages/TabletStage.qml'
 --- qml/Stages/TabletStage.qml	2016-04-27 15:01:10 +0000
 +++ qml/Stages/TabletStage.qml	2016-05-02 15:26:52 +0000
@@ -1102,7 +1102,7 @@
          enabled: spreadDragArea.dragging
+     }
--    DirectionalDragArea {
++    SwipeArea {
          id: spreadDragArea
          objectName: "spreadDragArea"
          x: parent.width - root.dragAreaWidth
@@ -1113,18 +1113,18 @@
          property var gesturePoints: new Array()
--        onTouchXChanged: {
++        onTouchPositionChanged: {
              if (!dragging) {
                  spreadView.phase = 0;
                  spreadView.contentX = -spreadView.shift;
+             }
              if (dragging) {
--                var dragX = -touchX + spreadDragArea.width - spreadView.shift;
++                var dragX = -touchPosition.x + spreadDragArea.width - spreadView.shift;
                  var maxDrag = spreadView.width * spreadView.positionMarker4 - spreadView.shift;
                  spreadView.contentX = Math.min(dragX, maxDrag);
+             }
--            gesturePoints.push(touchX);
++            gesturePoints.push(touchPosition.x);
+         }
          onDraggingChanged: {
 === modified file 'qml/Tutorial/TutorialBottom.qml'
 --- qml/Tutorial/TutorialBottom.qml	2016-04-07 16:53:41 +0000
 +++ qml/Tutorial/TutorialBottom.qml	2016-05-02 15:26:52 +0000
@@ -51,7 +51,7 @@
      readonly property real dragAreaHeight: units.gu(3) // based on PageWithBottomEdge.qml
      readonly property real targetDistance: height * 0.2 + dragAreaHeight // based on PageWithBottomEdge.qml
--    opacityOverride: dragArea.dragging ? 1 - (-dragArea.distance / targetDistance) : 1
++    opacityOverride: dragArea.dragging ? 1 - (dragArea.distance / targetDistance) : 1
      mouseArea {
          anchors.bottomMargin: root.dragAreaHeight
@@ -95,9 +95,9 @@
      // Watches drag events but does not intercept them, so that the app beneath
      // will still drag the bottom edge up.
--    DirectionalDragArea {
++    SwipeArea {
          id: dragArea
--        monitorOnly: true
++        grabGesture: false
          direction: Direction.Upwards
          anchors.left: parent.left
          anchors.right: parent.right
 === modified file 'src/CMakeLists.txt'
 --- src/CMakeLists.txt	2016-02-17 15:54:34 +0000
 +++ src/CMakeLists.txt	2016-05-02 15:26:52 +0000
@@ -2,7 +2,6 @@
  include_directories(
      ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
--    ${CMAKE_SOURCE_DIR}/libs/UbuntuGestures
      ${CONNECTIVITY_INCLUDE_DIRS}
+ )
@@ -44,9 +43,6 @@
      target_link_libraries(${SHELL_APP} ${MOUSETOUCHADAPTOR_LIBS_LDFLAGS})
  endif()
--# For it to find libUbuntuGestures.so
--set_target_properties(${SHELL_APP} PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${SHELL_PRIVATE_LIBDIR}")
--
  # install binaries
  install(TARGETS ${SHELL_APP}
       RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 === modified file 'tests/CMakeLists.txt'
 --- tests/CMakeLists.txt	2015-11-04 14:57:45 +0000
 +++ tests/CMakeLists.txt	2016-05-02 15:26:52 +0000
@@ -128,7 +128,6 @@
  # Actual test definitions
--add_subdirectory(libs)
  add_subdirectory(plugins)
  add_subdirectory(qmltests)
  add_subdirectory(whitespace)
 === removed directory 'tests/libs'
 === removed file 'tests/libs/CMakeLists.txt'
 --- tests/libs/CMakeLists.txt	2014-10-01 13:20:32 +0000
 +++ tests/libs/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
--add_subdirectory(UbuntuGestures)
 === removed directory 'tests/libs/UbuntuGestures'
 === removed file 'tests/libs/UbuntuGestures/CMakeLists.txt'
 --- tests/libs/UbuntuGestures/CMakeLists.txt	2015-04-29 22:05:49 +0000
 +++ tests/libs/UbuntuGestures/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
--include_directories(
--    ${CMAKE_SOURCE_DIR}/libs/UbuntuGestures
--    ${CMAKE_CURRENT_BINARY_DIR}
--    )
--
--macro(add_gesture_test CLASSNAME)
--    add_executable(${CLASSNAME}TestExec tst_${CLASSNAME}.cpp)
--    qt5_use_modules(${CLASSNAME}TestExec Test Core Gui Quick)
--    target_link_libraries(${CLASSNAME}TestExec UbuntuGestures)
--
--    add_unity8_unittest(${CLASSNAME} ${CLASSNAME}TestExec
--        ENVIRONMENT LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/libs/UbuntuGestures
--    )
--endmacro(add_gesture_test)
--
--add_gesture_test(TouchRegistry)
 === removed file 'tests/libs/UbuntuGestures/tst_TouchRegistry.cpp'
 --- tests/libs/UbuntuGestures/tst_TouchRegistry.cpp	2016-04-27 15:01:10 +0000
 +++ tests/libs/UbuntuGestures/tst_TouchRegistry.cpp	1970-01-01 00:00:00 +0000
@@ -1,974 +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 <QtTest>
--#include <QSet>
--#include <QTouchEvent>
--
--#include <Timer.h>
--#include <TouchOwnershipEvent.h>
--#include <TouchRegistry.h>
--#include <UnownedTouchEvent.h>
--
--using namespace UbuntuGestures;
--
--class TouchMemento {
--public:
--    TouchMemento(const QTouchEvent *touchEvent);
--    Qt::TouchPointStates touchPointStates;
--    QList<QTouchEvent::TouchPoint> touchPoints;
--
--    bool containsTouchWithId(int touchId) const;
--};
--
--class DummyCandidate : public QQuickItem
--{
--    Q_OBJECT
--public:
--    bool event(QEvent *e) override;
--    QSet<int> ownedTouches;
--    QSet<int> lostTouches;
--    QList<TouchMemento> unownedTouchEvents;
--
--Q_SIGNALS:
--    void gainedOwnership();
--    void lostOwnership();
--};
--
--class tst_TouchRegistry : public QObject
--{
--    Q_OBJECT
--public:
--    tst_TouchRegistry() : QObject(0) { }
--private Q_SLOTS:
--    void initTestCase() {} // will be called before the first test function is executed
--    void cleanupTestCase() {} // will be called after the last test function was executed.
--
--    void init(); // called right before each and every test function is executed
--    void cleanup(); // called right after each and every test function is executed
--
--    void requestWithNoCandidates();
--    void lateCandidateRequestGetsNothing();
--    void lateCandidateGestOwnershipOnceEarlyCandidateQuits();
--    void dispatchesTouchEventsToCandidates();
--    void dispatchesTouchEventsToWatchers();
--    void keepDispatchingToWatchersAfterLastCandidateGivesUp();
--    void candidatesAndWatchers_1();
--    void candidatesAndWatchers_2();
--    void rejectingTouchfterItsEnd();
--    void removeOldUndecidedCandidates();
--    void interimOwnerWontGetUnownedTouchEvents();
--    void candidateVanishes();
--    void candicateOwnershipReentrace();
--
--private:
--    TouchRegistry *touchRegistry;
--};
--
--void tst_TouchRegistry::init()
--{
--    touchRegistry = TouchRegistry::instance();
--}
--
--void tst_TouchRegistry::cleanup()
--{
--    delete touchRegistry;
--}
--
--void tst_TouchRegistry::requestWithNoCandidates()
--{
--    DummyCandidate candidate;
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->requestTouchOwnership(0, &candidate);
--
--    QVERIFY(candidate.ownedTouches.contains(0));
--}
--
--void tst_TouchRegistry::lateCandidateRequestGetsNothing()
--{
--    DummyCandidate earlyCandidate;
--    earlyCandidate.setObjectName("early");
--    DummyCandidate lateCandidate;
--    lateCandidate.setObjectName("late");
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->addCandidateOwnerForTouch(0, &earlyCandidate);
--    touchRegistry->addCandidateOwnerForTouch(0, &lateCandidate);
--
--    QVERIFY(earlyCandidate.ownedTouches.isEmpty());
--    QVERIFY(lateCandidate.ownedTouches.isEmpty());
--
--    touchRegistry->requestTouchOwnership(0, &lateCandidate);
--
--    QVERIFY(earlyCandidate.ownedTouches.isEmpty());
--    QVERIFY(lateCandidate.ownedTouches.isEmpty());
--
--    touchRegistry->requestTouchOwnership(0, &earlyCandidate);
--
--    QVERIFY(earlyCandidate.ownedTouches.contains(0));
--    QVERIFY(lateCandidate.ownedTouches.isEmpty());
--}
--
--void tst_TouchRegistry::lateCandidateGestOwnershipOnceEarlyCandidateQuits()
--{
--    DummyCandidate earlyCandidate;
--    DummyCandidate lateCandidate;
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->addCandidateOwnerForTouch(0, &earlyCandidate);
--    touchRegistry->addCandidateOwnerForTouch(0, &lateCandidate);
--
--    QVERIFY(earlyCandidate.ownedTouches.isEmpty());
--    QVERIFY(lateCandidate.ownedTouches.isEmpty());
--
--    touchRegistry->requestTouchOwnership(0, &lateCandidate);
--
--    QVERIFY(earlyCandidate.ownedTouches.isEmpty());
--    QVERIFY(lateCandidate.ownedTouches.isEmpty());
--
--    touchRegistry->removeCandidateOwnerForTouch(0, &earlyCandidate);
--
--    QVERIFY(earlyCandidate.ownedTouches.isEmpty());
--    QVERIFY(lateCandidate.ownedTouches.contains(0));
--}
--
--void tst_TouchRegistry::dispatchesTouchEventsToCandidates()
--{
--    QQuickItem rootItem;
--
--    DummyCandidate candidate0;
--    candidate0.setObjectName("0");
--    candidate0.setParentItem(&rootItem);
--    candidate0.setX(1);
--    candidate0.setY(2);
--
--    DummyCandidate candidate1;
--    candidate1.setObjectName("1");
--    candidate0.setParentItem(&rootItem);
--    candidate1.setX(3);
--    candidate1.setY(4);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        touchPoints[0].setRect(QRect(10, 10, 0, 0));
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->addCandidateOwnerForTouch(0, &candidate0);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints[0].setRect(QRect(11, 11, 0, 0));
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointPressed);
--        touchPoints[1].setRect(QRect(20, 20, 0, 0));
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    // candidate0 should have received an update on the touch he's interested on.
--    QCOMPARE(candidate0.unownedTouchEvents.count(), 1);
--    // make sure only touch 0 is there (i.e. no mention of touch 1)
--    QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints.count(), 1);
--    QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints[0].id(), 0);
--    // Check that the points local coordinates have been mapped to candidate0's coordinate system.
--    QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints[0].rect().x(), 11 - candidate0.x());
--    QCOMPARE(candidate0.unownedTouchEvents[0].touchPoints[0].rect().y(), 11 - candidate0.y());
--
--    touchRegistry->addCandidateOwnerForTouch(1, &candidate1);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints[0].setRect(QRect(12, 12, 0, 0));
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointMoved);
--        touchPoints[1].setRect(QRect(21, 21, 0, 0));
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    // candidate0 gets updates only for touch 0 and
--    // candidate1 gets updates only for touch 1
--
--    QCOMPARE(candidate0.unownedTouchEvents.count(), 2);
--    QCOMPARE(candidate0.unownedTouchEvents[1].touchPoints.count(), 1);
--    QCOMPARE(candidate0.unownedTouchEvents[1].touchPoints[0].id(), 0);
--
--    QCOMPARE(candidate1.unownedTouchEvents.count(), 1);
--    QCOMPARE(candidate1.unownedTouchEvents[0].touchPoints.count(), 1);
--    QCOMPARE(candidate1.unownedTouchEvents[0].touchPoints[0].id(), 1);
--}
--
--void tst_TouchRegistry::dispatchesTouchEventsToWatchers()
--{
--    QQuickItem rootItem;
--
--    DummyCandidate watcher;
--    watcher.setObjectName("watcher");
--    watcher.setParentItem(&rootItem);
--    watcher.setX(1);
--    watcher.setY(2);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        touchPoints[0].setRect(QRect(10, 10, 0, 0));
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->addTouchWatcher(0, &watcher);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints[0].setRect(QRect(11, 11, 0, 0));
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointPressed);
--        touchPoints[1].setRect(QRect(20, 20, 0, 0));
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    // watcher should have received an update on the touch he's interested on.
--    QCOMPARE(watcher.unownedTouchEvents.count(), 1);
--    // make sure only touch 0 is there (i.e. no mention of touch 1)
--    QCOMPARE(watcher.unownedTouchEvents[0].touchPoints.count(), 1);
--    QCOMPARE(watcher.unownedTouchEvents[0].touchPoints[0].id(), 0);
--    // Check that the points local coordinates have been mapped to watcher's coordinate system.
--    QCOMPARE(watcher.unownedTouchEvents[0].touchPoints[0].rect().x(), 11 - watcher.x());
--    QCOMPARE(watcher.unownedTouchEvents[0].touchPoints[0].rect().y(), 11 - watcher.y());
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints[0].setRect(QRect(12, 12, 0, 0));
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointMoved);
--        touchPoints[1].setRect(QRect(21, 21, 0, 0));
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    // watcher gets updates only for touch 0
--
--    QCOMPARE(watcher.unownedTouchEvents.count(), 2);
--    QCOMPARE(watcher.unownedTouchEvents[1].touchPoints.count(), 1);
--    QCOMPARE(watcher.unownedTouchEvents[1].touchPoints[0].id(), 0);
--}
--
--void tst_TouchRegistry::keepDispatchingToWatchersAfterLastCandidateGivesUp()
--{
--    DummyCandidate item;
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->addCandidateOwnerForTouch(0, &item);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    QCOMPARE(item.unownedTouchEvents.count(), 1);
--    QCOMPARE(item.unownedTouchEvents[0].touchPoints.count(), 1);
--    QCOMPARE(item.unownedTouchEvents[0].touchPoints[0].id(), 0);
--    item.unownedTouchEvents.clear();
--
--    touchRegistry->addTouchWatcher(1, &item);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointMoved);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    QCOMPARE(item.unownedTouchEvents.count(), 1);
--    QCOMPARE(item.unownedTouchEvents[0].touchPoints.count(), 2);
--    QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(0));
--    QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(1));
--    item.unownedTouchEvents.clear();
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointReleased);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointMoved);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointReleased | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    QCOMPARE(item.unownedTouchEvents.count(), 1);
--    QCOMPARE(item.unownedTouchEvents[0].touchPoints.count(), 2);
--    QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(0));
--    QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(1));
--    item.unownedTouchEvents.clear();
--
--    touchRegistry->removeCandidateOwnerForTouch(0, &item);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[0].setState(Qt::TouchPointReleased);
--        QTouchEvent touchEvent(QEvent::TouchEnd,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointReleased,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    QCOMPARE(item.unownedTouchEvents.count(), 1);
--    QCOMPARE(item.unownedTouchEvents[0].touchPoints.count(), 1);
--    QVERIFY(item.unownedTouchEvents[0].containsTouchWithId(1));
--    item.unownedTouchEvents.clear();
--
--    QVERIFY(touchRegistry->m_touchInfoPool.isEmpty());
--}
--
--/*
--  Regression test that reproduces a problematic scenario that came up during manual testing.
--  It reproduces the interaction between TouchRegistry and a DirectionalDragArea
-- */
--void tst_TouchRegistry::candidatesAndWatchers_1()
--{
--    DummyCandidate item;
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->addCandidateOwnerForTouch(0, &item);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    touchRegistry->addTouchWatcher(1, &item);
--
--    touchRegistry->removeCandidateOwnerForTouch(0, &item);
--
--    touchRegistry->addTouchWatcher(0, &item);
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointReleased);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointMoved);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointReleased | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[0].setState(Qt::TouchPointReleased);
--        QTouchEvent touchEvent(QEvent::TouchEnd,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointReleased,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    QVERIFY(touchRegistry->m_touchInfoPool.isEmpty());
--
--    item.unownedTouchEvents.clear();
--
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    // Haven't made any subscription for that new touch 0.
--    QCOMPARE(item.unownedTouchEvents.count(), 0);
--}
--
--/*
--  Regression test that reproduces a problematic scenario that came up during manual testing.
--  It reproduces the interaction between TouchRegistry, DirectionalDragArea and a TouchGate.
-- */
--void tst_TouchRegistry::candidatesAndWatchers_2()
--{
--    DummyCandidate directionalDragArea;
--    directionalDragArea.setObjectName("DirectionalDragArea");
--
--    DummyCandidate touchGate;
--    touchGate.setObjectName("TouchGate");
--
--    // [DDA] 1298 TouchBegin (id:0, state:pressed, scenePos:(147,1023))
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchBegin,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    // [TouchRegistry] addCandidateOwnerForTouch id 0 candidate DirectionalDragArea
--    touchRegistry->addCandidateOwnerForTouch(0, &directionalDragArea);
--
--    // [TouchRegistry] requestTouchOwnership id  0 candidate TouchGate
--    touchRegistry->requestTouchOwnership(0, &touchGate);
--
--    //[TouchRegistry] got TouchUpdate (id:0, state:moved, scenePos:(147,1023)) (id:1, state:pressed, scenePos:(327,792))
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointPressed);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointPressed | Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    // [TouchRegistry] addTouchWatcher id 1 watcher DirectionalDragArea
--    touchRegistry->addTouchWatcher(1, &directionalDragArea);
--
--    // [TouchRegistry] removeCandidateOwnerForTouch id 0 candidate DirectionalDragArea
--    touchRegistry->removeCandidateOwnerForTouch(0, &directionalDragArea);
--
--    //[TouchRegistry] sending TouchWonershipEvent(id = 0  gained) to candidate TouchGate
--    QCOMPARE(touchGate.ownedTouches.count(), 1);
--    QVERIFY(touchGate.ownedTouches.contains(0));
--
--    // [TouchRegistry] addTouchWatcher id 0 watcher DirectionalDragArea
--    touchRegistry->addTouchWatcher(0, &directionalDragArea);
--
--    // [TouchRegistry] requestTouchOwnership id  1 candidate TouchGate
--    touchRegistry->requestTouchOwnership(1, &touchGate);
--
--    //[TouchRegistry] sending TouchWonershipEvent(id = 1  gained) to candidate TouchGate
--    QCOMPARE(touchGate.ownedTouches.count(), 2);
--    QVERIFY(touchGate.ownedTouches.contains(1));
--
--    directionalDragArea.unownedTouchEvents.clear();
--    touchGate.unownedTouchEvents.clear();
--
--    //[TouchRegistry] got TouchUpdate (id:0, state:moved, scenePos:(148,1025)) (id:1, state:moved, scenePos:(329,795))
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointMoved);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointMoved,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--
--    //vvvvv  DDA Watchers are being ignored from now on vvvvvvv
--
--    QCOMPARE(directionalDragArea.unownedTouchEvents.count(), 1);
--    QCOMPARE(directionalDragArea.unownedTouchEvents.first().touchPoints.count(), 2);
--    QVERIFY(directionalDragArea.unownedTouchEvents.first().containsTouchWithId(0));
--    QVERIFY(directionalDragArea.unownedTouchEvents.first().containsTouchWithId(1));
--
--    QVERIFY(touchGate.unownedTouchEvents.isEmpty());
--
--    directionalDragArea.unownedTouchEvents.clear();
--
--    //[TouchRegistry] got TouchUpdate (id:0, state:moved, scenePos:(151,1029)) (id:1, state:released, scenePos:(329,795))
--    {
--        QList<QTouchEvent::TouchPoint> touchPoints;
--        touchPoints.append(QTouchEvent::TouchPoint(0));
--        touchPoints[0].setState(Qt::TouchPointMoved);
--        touchPoints.append(QTouchEvent::TouchPoint(1));
--        touchPoints[1].setState(Qt::TouchPointReleased);
--        QTouchEvent touchEvent(QEvent::TouchUpdate,
--                               0 /* device */,
--                               Qt::NoModifier,
--                               Qt::TouchPointMoved | Qt::TouchPointReleased,
--                               touchPoints);
--        touchRegistry->update(&touchEvent);
--    }
--