webbrowser-app

Merge lp:~osomon/webbrowser-app/bottom-edge into lp:webbrowser-app

bottom-edge
Merge into trunk

Proposed by Olivier Tilloy on 2015-01-29

Status:

Merged

Approved by:

Olivier Tilloy on 2015-03-20

Approved revision:

955

Merged at revision:

935

Proposed branch:

lp:~osomon/webbrowser-app/bottom-edge

Merge into:

lp:webbrowser-app

Diff against target:

6448 lines (+5313/-361)

62 files modified

CMakeLists.txt (+3/-0)
debian/control (+2/-0)
src/app/CMakeLists.txt (+6/-0)
src/app/browserapplication.cpp (+17/-0)
src/app/favicon-fetcher.h (+1/-1)
src/app/unity8/CMakeLists.txt (+4/-0)
src/app/unity8/README (+11/-0)
src/app/unity8/libs/CMakeLists.txt (+1/-0)
src/app/unity8/libs/UbuntuGestures/CMakeLists.txt (+36/-0)
src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.cpp (+41/-0)
src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.h (+49/-0)
src/app/unity8/libs/UbuntuGestures/DebugHelpers.cpp (+95/-0)
src/app/unity8/libs/UbuntuGestures/DebugHelpers.h (+31/-0)
src/app/unity8/libs/UbuntuGestures/Pool.h (+132/-0)
src/app/unity8/libs/UbuntuGestures/Timer.cpp (+109/-0)
src/app/unity8/libs/UbuntuGestures/Timer.h (+105/-0)
src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.cpp (+35/-0)
src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.h (+50/-0)
src/app/unity8/libs/UbuntuGestures/TouchRegistry.cpp (+500/-0)
src/app/unity8/libs/UbuntuGestures/TouchRegistry.h (+182/-0)
src/app/unity8/libs/UbuntuGestures/UbuntuGesturesGlobal.h (+23/-0)
src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.cpp (+39/-0)
src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.h (+45/-0)
src/app/unity8/plugins/CMakeLists.txt (+1/-0)
src/app/unity8/plugins/Ubuntu/CMakeLists.txt (+1/-0)
src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp (+149/-0)
src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.h (+146/-0)
src/app/unity8/plugins/Ubuntu/Gestures/CMakeLists.txt (+40/-0)
src/app/unity8/plugins/Ubuntu/Gestures/Damper.h (+87/-0)
src/app/unity8/plugins/Ubuntu/Gestures/Direction.cpp (+36/-0)
src/app/unity8/plugins/Ubuntu/Gestures/Direction.h (+45/-0)
src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp (+886/-0)
src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.h (+308/-0)
src/app/unity8/plugins/Ubuntu/Gestures/Gestures.qmltypes (+168/-0)
src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp (+119/-0)
src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.h (+62/-0)
src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.cpp (+49/-0)
src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.h (+54/-0)
src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.cpp (+367/-0)
src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.h (+89/-0)
src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.cpp (+253/-0)
src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.h (+112/-0)
src/app/unity8/plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h (+23/-0)
src/app/unity8/plugins/Ubuntu/Gestures/plugin.cpp (+39/-0)
src/app/unity8/plugins/Ubuntu/Gestures/plugin.h (+31/-0)
src/app/unity8/plugins/Ubuntu/Gestures/qmldir (+3/-0)
src/app/webbrowser/BottomEdgeHandle.qml (+36/-0)
src/app/webbrowser/Browser.qml (+190/-26)
src/app/webbrowser/BrowserTab.qml (+13/-4)
src/app/webbrowser/ExpandedHistoryView.qml (+2/-2)
src/app/webbrowser/HistorySectionDelegate.qml (+2/-2)
src/app/webbrowser/HistoryView.qml (+2/-2)
src/app/webbrowser/TabChrome.qml (+144/-0)
src/app/webbrowser/TabPreview.qml (+67/-121)
src/app/webbrowser/TabsList.qml (+130/-0)
src/app/webbrowser/TabsView.qml (+0/-123)
src/app/webbrowser/Toolbar.qml (+36/-1)
src/app/webbrowser/UrlDelegate.qml (+3/-3)
tests/autopilot/webbrowser_app/emulators/browser.py (+44/-22)
tests/autopilot/webbrowser_app/tests/__init__.py (+20/-10)
tests/autopilot/webbrowser_app/tests/test_addressbar_bookmark.py (+9/-13)
tests/autopilot/webbrowser_app/tests/test_tabs.py (+30/-31)

To merge this branch:

bzr merge lp:~osomon/webbrowser-app/bottom-edge

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Florian Boucault (community)			Approve on 2015-03-20
PS Jenkins bot	continuous-integration		Needs Fixing on 2015-03-19
Ken VanDine		2015-01-29	Approve on 2015-03-19
Bartosz Kosiorek (community)			Needs Information on 2015-02-10
Review via email: mp+248019@code.launchpad.net

Commit Message

On mobile, reveal the tabs view with a swipe gesture from the bottom edge.

Note: this re-adds qtbase5-private-dev and qtdeclarative5-private-dev as build dependencies, required to build the code imported from unity8. This code will eventually go away, and the dependencies on private headers with it.

Description of the Change

On mobile, reveal the tabs view with a swipe gesture from the bottom edge.

PS Jenkins bot (ps-jenkins) wrote on 2015-01-29:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-01-30:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-01-30:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-01-30:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-03:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-04:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-04:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-04:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-04:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-05:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-06:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-06:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-09:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-02-09:

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

review: Needs Fixing (continuous-integration)

Bartosz Kosiorek (gang65) wrote on 2015-02-10:

Hello Olivier.
Thanks for this MR. It is most wanted feature in WebBrowser.

One small remark:
Could you please update README file, because executable location was changed.
To run you should type:

./src/app/webbrowser/webbrowser-app

Do you think it will be possible to use gestures on Desktop?
I'm unable to show up tabs from bottom edge.

review: Needs Information

Olivier Tilloy (osomon) wrote on 2015-02-10:

> Hello Olivier.
> Thanks for this MR. It is most wanted feature in WebBrowser.
>
> One small remark:
> Could you please update README file, because executable location was changed.
> To run you should type:
>
> ./src/app/webbrowser/webbrowser-app

The README file is already up-to-date in this regard.

> Do you think it will be possible to use gestures on Desktop?
> I'm unable to show up tabs from bottom edge.

No, by design this is meant to work on mobile only. In the future the desktop UX will gain visible tabs, much like other desktop browsers do.

PS Jenkins bot (ps-jenkins) wrote on 2015-02-10:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-03-18:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-03-18:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-03-19:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-03-19:

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

review: Needs Fixing (continuous-integration)

Ken VanDine (ken-vandine) wrote on 2015-03-19:

Packaging changes look fine, ACK from me.

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-03-19:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-03-19:

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

review: Needs Fixing (continuous-integration)

Florian Boucault (fboucault) wrote on 2015-03-20:

* tests/autopilot/webbrowser_app/tests/test_tabs.py
- Factor duplicated code to swipe up from the bottom in a common function

* src/app/webbrowser/Browser.qml
- #5d5d5d is UbuntuColors.darkGrey (lots of that value in the codebase)

* src/app/webbrowser/TabChrome.qml
- generally better for components to not define their own width/height but instead implicitWidth/implicitHeight
- "AbstractButton { id: closeButton" should use anchors instead of "height: parent.height"; same for unnamed Item below
- closeButton has a Rectangle without color
- closeButton has no visual feedback when pressing
- Images "tabBackgroundLeft", "tabBackgroundCenter" and "tabBackgroundRight", sources are PNGs without @GU suffix
- "MouseArea.width: parent.width / 2" should probably have a comment

review: Needs Fixing

Florian Boucault (fboucault) wrote on 2015-03-20:

Thanks!

review: Approve

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:

Olivier Tilloy

Ubuntu Phablet Team

to status/vote changes:

Rachel Liu

 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2014-11-12 17:00:12 +0000
 +++ CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -32,6 +32,9 @@
      ENABLE_COVERAGE_REPORT(EXCLUDES tests/*|.*moc_.*.cpp FILTER tests/* moc_*.cpp)
  endif()
++# for unity8 components
++set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
++
  # enable QML debugging
  if(CMAKE_BUILD_TYPE MATCHES DEBUG OR CMAKE_BUILD_TYPE MATCHES "Debug")
      add_definitions(-DQT_QML_DEBUG)
 === modified file 'debian/control'
 --- debian/control	2015-02-26 17:54:47 +0000
 +++ debian/control	2015-03-20 16:26:56 +0000
@@ -17,7 +17,9 @@
                 qt5-qmake,
                 qtbase5-dev (>= 5.4),
                 qtbase5-dev-tools,
++               qtbase5-private-dev,
                 qtdeclarative5-dev,
++               qtdeclarative5-private-dev,
                 qtdeclarative5-ubuntu-ui-toolkit-plugin,
                 xvfb,
  Standards-Version: 3.9.5
 === modified file 'src/app/CMakeLists.txt'
 --- src/app/CMakeLists.txt	2015-02-27 09:28:41 +0000
 +++ src/app/CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -1,5 +1,7 @@
  project(webbrowser-common)
++add_subdirectory(unity8)
++
  configure_file(
      config.h.in
      ${CMAKE_CURRENT_BINARY_DIR}/config.h
@@ -18,6 +20,10 @@
  qt5_use_modules(${COMMONLIB} Core Gui Network Qml Quick Widgets)
++include_directories(${unity8_SOURCE_DIR}/libs/UbuntuGestures
++                    ${unity8_SOURCE_DIR}/plugins)
++target_link_libraries(${COMMONLIB} UbuntuGesturesQml)
++
  file(GLOB QML_FILES *.qml)
  install(FILES ${QML_FILES} DESTINATION ${CMAKE_INSTALL_DATADIR}/webbrowser-app)
  file(GLOB JS_FILES *.js)
 === modified file 'src/app/browserapplication.cpp'
 --- src/app/browserapplication.cpp	2015-02-27 09:28:41 +0000
 +++ src/app/browserapplication.cpp	2015-03-20 16:26:56 +0000
@@ -34,6 +34,10 @@
  #include "session-storage.h"
  #include "webbrowser-window.h"
++#include "TouchRegistry.h"
++#include "Ubuntu/Gestures/Direction.h"
++#include "Ubuntu/Gestures/DirectionalDragArea.h"
++
  BrowserApplication::BrowserApplication(int& argc, char** argv)
      : QApplication(argc, argv)
      , m_engine(0)
@@ -95,6 +99,13 @@
      return QString();
+ }
++static QObject* Direction_singleton_factory(QQmlEngine* engine, QJSEngine* scriptEngine)
++{
++    Q_UNUSED(engine);
++    Q_UNUSED(scriptEngine);
++    return new Direction();
++}
++
  bool BrowserApplication::initialize(const QString& qmlFileSubPath)
+ {
      Q_ASSERT(m_window == 0);
@@ -133,6 +144,10 @@
      qmlRegisterType<FaviconFetcher>(uri, 0, 1, "FaviconFetcher");
      qmlRegisterType<SessionStorage>(uri, 0, 1, "SessionStorage");
++    const char* gesturesUri = "Ubuntu.Gestures";
++    qmlRegisterSingletonType<Direction>(gesturesUri, 0, 1, "Direction", Direction_singleton_factory);
++    qmlRegisterType<DirectionalDragArea>(gesturesUri, 0, 1, "DirectionalDragArea");
++
      m_engine = new QQmlEngine;
      connect(m_engine, SIGNAL(quit()), SLOT(quit()));
      if (!isRunningInstalled()) {
@@ -156,6 +171,8 @@
      m_window = qobject_cast<QQuickWindow*>(browser);
      m_webbrowserWindowProxy->setWindow(m_window);
++    m_window->installEventFilter(new TouchRegistry(this));
++
      browser->setProperty("developerExtrasEnabled", inspectorEnabled);
      browser->setProperty("forceFullscreen", m_arguments.contains("--fullscreen"));
 === modified file 'src/app/favicon-fetcher.h'
 --- src/app/favicon-fetcher.h	2014-11-26 16:24:53 +0000
 +++ src/app/favicon-fetcher.h	2015-03-20 16:26:56 +0000
@@ -29,7 +29,7 @@
  class QNetworkAccessManager;
  class QNetworkReply;
--class FaviconFetcher Q_DECL_FINAL : public QObject
++class FaviconFetcher : public QObject
+ {
      Q_OBJECT
 === added directory 'src/app/unity8'
 === added file 'src/app/unity8/CMakeLists.txt'
 --- src/app/unity8/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -0,0 +1,4 @@
++project(unity8)
++
++add_subdirectory(libs)
++add_subdirectory(plugins)
 === added file 'src/app/unity8/README'
 --- src/app/unity8/README	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/README	2015-03-20 16:26:56 +0000
@@ -0,0 +1,11 @@
++Code in this directory was copied over from unity8.
++ - first import: 2015-02-04, at revision 1583 of lp:unity8
++ - last sync: 2015-03-17, at revision 1663 of lp:unity8
++
++The structure of the directories has been kept identical, to ease syncing the
++code in the future. Minor changes were made to the build system to integrate it
++with the existing webbrowser-app code base.
++
++The goal is to eventually have those components moved over to the UITK, thus
++removing the need for a copy here. See
++https://docs.google.com/a/canonical.com/document/d/1_ljZunMXWqJfrBGEkCp0peVD8gq6-E4ZMFpuH0PVKRc.
 === added directory 'src/app/unity8/libs'
 === added file 'src/app/unity8/libs/CMakeLists.txt'
 --- src/app/unity8/libs/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -0,0 +1,1 @@
++add_subdirectory(UbuntuGestures)
 === added directory 'src/app/unity8/libs/UbuntuGestures'
 === added file 'src/app/unity8/libs/UbuntuGestures/CMakeLists.txt'
 --- src/app/unity8/libs/UbuntuGestures/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -0,0 +1,36 @@
++# in order to include Qt's private headers
++remove_definitions(-DQT_NO_KEYWORDS)
++
++set(UbuntuGestures_SOURCES
++    CandidateInactivityTimer.cpp
++    DebugHelpers.cpp
++    Timer.cpp
++    TouchOwnershipEvent.cpp
++    TouchRegistry.cpp
++    UnownedTouchEvent.cpp
++)
++
++add_definitions(-DUBUNTUGESTURES_LIBRARY)
++
++add_library(UbuntuGestures STATIC ${UbuntuGestures_SOURCES})
++
++qt5_use_modules(UbuntuGestures Core Quick)
++
++# So that Foo.cpp can #include "Foo.moc"
++include_directories(${CMAKE_CURRENT_BINARY_DIR})
++
++# There's no cmake var for v8 include path :-/ so create one
++LIST(GET Qt5Core_INCLUDE_DIRS 0 QtCoreDir0)
++if(${Qt5Core_VERSION_STRING} VERSION_LESS "5.1.0")
++    SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/../QtV8/${Qt5Core_VERSION_STRING}/QtV8)
++else()
++    SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/QtV8/${Qt5Core_VERSION_STRING}/QtV8)
++endif()
++
++# DANGER! DANGER! Using Qt's private API!
++include_directories(
++    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
++    ${Qt5Quick_INCLUDE_DIRS}
++    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
++    ${Qt5V8_PRIVATE_INCLUDE_DIR}
++)
 === added file 'src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.cpp'
 --- src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,41 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "CandidateInactivityTimer.h"
++
++namespace UbuntuGestures {
++
++CandidateInactivityTimer::CandidateInactivityTimer(int touchId, QQuickItem *candidate,
++        AbstractTimerFactory &timerFactory, QObject *parent)
++    : QObject(parent)
++    , m_touchId(touchId)
++    , m_candidate(candidate)
++{
++    m_timer = timerFactory.createTimer(this);
++    connect(m_timer, &AbstractTimer::timeout,
++            this, &CandidateInactivityTimer::onTimeout);
++    m_timer->setInterval(durationMs);
++    m_timer->setSingleShot(true);
++    m_timer->start();
++}
++
++void CandidateInactivityTimer::onTimeout()
++{
++    qWarning("[TouchRegistry] Candidate for touch %d defaulted!", m_touchId);
++    Q_EMIT candidateDefaulted(m_touchId, m_candidate);
++}
++
++} // namespace UbuntuGestures
 === added file 'src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.h'
 --- src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/CandidateInactivityTimer.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,49 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTUGESTURES_CANDIDATE_INACTIVITY_TIMER_H
++#define UBUNTUGESTURES_CANDIDATE_INACTIVITY_TIMER_H
++
++#include <QObject>
++
++class QQuickItem;
++
++#include "Timer.h"
++
++namespace UbuntuGestures {
++
++class UBUNTUGESTURES_EXPORT CandidateInactivityTimer : public QObject {
++    Q_OBJECT
++public:
++    CandidateInactivityTimer(int touchId, QQuickItem *candidate,
++                             AbstractTimerFactory &timerFactory,
++                             QObject *parent = nullptr);
++
++    const int durationMs = 350;
++
++Q_SIGNALS:
++    void candidateDefaulted(int touchId, QQuickItem *candidate);
++private Q_SLOTS:
++    void onTimeout();
++private:
++    AbstractTimer *m_timer;
++    int m_touchId;
++    QQuickItem *m_candidate;
++};
++
++} // namespace UbuntuGestures
++
++#endif // UBUNTUGESTURES_CANDIDATE_INACTIVITY_TIMER_H
 === added file 'src/app/unity8/libs/UbuntuGestures/DebugHelpers.cpp'
 --- src/app/unity8/libs/UbuntuGestures/DebugHelpers.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/DebugHelpers.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,95 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "DebugHelpers.h"
++#include <QTouchEvent>
++#include <QMouseEvent>
++
++QString touchPointStateToString(Qt::TouchPointState state)
++{
++    switch (state) {
++    case Qt::TouchPointPressed:
++        return QString("pressed");
++    case Qt::TouchPointMoved:
++        return QString("moved");
++    case Qt::TouchPointStationary:
++        return QString("stationary");
++    case Qt::TouchPointReleased:
++        return QString("released");
++    default:
++        return QString("INVALID_STATE");
++    }
++}
++
++QString touchEventToString(const QTouchEvent *ev)
++{
++    QString message;
++
++    switch (ev->type()) {
++    case QEvent::TouchBegin:
++        message.append("TouchBegin ");
++        break;
++    case QEvent::TouchUpdate:
++        message.append("TouchUpdate ");
++        break;
++    case QEvent::TouchEnd:
++        message.append("TouchEnd ");
++        break;
++    case QEvent::TouchCancel:
++        message.append("TouchCancel ");
++        break;
++    default:
++        message.append("INVALID_TOUCH_EVENT_TYPE ");
++    }
++
++    foreach(const QTouchEvent::TouchPoint& touchPoint, ev->touchPoints()) {
++        message.append(
++            QString("(id:%1, state:%2, scenePos:(%3,%4)) ")
++                .arg(touchPoint.id())
++                .arg(touchPointStateToString(touchPoint.state()))
++                .arg(touchPoint.scenePos().x())
++                .arg(touchPoint.scenePos().y())
++            );
++    }
++
++    return message;
++}
++
++QString mouseEventToString(const QMouseEvent *ev)
++{
++    QString message;
++
++    switch (ev->type()) {
++    case QEvent::MouseButtonPress:
++        message.append("MouseButtonPress ");
++        break;
++    case QEvent::MouseButtonRelease:
++        message.append("MouseButtonRelease ");
++        break;
++    case QEvent::MouseButtonDblClick:
++        message.append("MouseButtonDblClick ");
++        break;
++    case QEvent::MouseMove:
++        message.append("MouseMove ");
++        break;
++    default:
++        message.append("INVALID_MOUSE_EVENT_TYPE ");
++    }
++
++    message.append(QString("pos(%1, %2)").arg(ev->x()).arg(ev->y()));
++
++    return message;
++}
 === added file 'src/app/unity8/libs/UbuntuGestures/DebugHelpers.h'
 --- src/app/unity8/libs/UbuntuGestures/DebugHelpers.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/DebugHelpers.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,31 @@
++/*
++ * 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
 === added file 'src/app/unity8/libs/UbuntuGestures/Pool.h'
 --- src/app/unity8/libs/UbuntuGestures/Pool.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/Pool.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,132 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTUGESTURES_POOL_H
++#define UBUNTUGESTURES_POOL_H
++
++#include <QVector>
++
++#include "UbuntuGesturesGlobal.h"
++
++/*
++  An object pool.
++  Avoids unnecessary creations/initializations and deletions/destructions of items. Useful
++  in a scenario where items are created and destroyed very frequently but the total number
++  of items at any given time remains small. They're stored in a unordered fashion.
++
++  To be used in Pool, ItemType needs to have the following methods:
++
++  - ItemType();
++
++  A constructor that takes no parameters. An object contructed with it must return false if
++  isValid() is called.
++
++  - bool isValid() const;
++
++  Returns wheter the object holds a valid , "filled" state or is empty.
++  Used by Pool to check if the slot occupied by this object is actually available.
++
++  - void reset();
++
++  Resets the object to its initial, empty, state. After calling this method, isValid() must
++  return false.
++ */
++template <class ItemType> class Pool
++{
++public:
++    Pool() : m_lastUsedIndex(-1) {
++    }
++
++    class Iterator {
++    public:
++        Iterator() : index(-1), item(nullptr) {}
++        Iterator(int index, ItemType *item)
++            : index(index), item(item) {}
++
++        ItemType *operator->() const { return item; }
++        ItemType &operator*() const { return *item; }
++        ItemType &value() const { return *item; }
++
++        Iterator &operator= (const Iterator& other) {
++            index = other.index;
++            item = other.item;
++
++            // by convention, always return *this
++            return *this;
++        }
++
++        operator bool() const { return item != nullptr; }
++
++        int index;
++        ItemType *item;
++    };
++
++    ItemType &getEmptySlot() {
++        Q_ASSERT(m_lastUsedIndex < m_slots.size());
++
++        // Look for an in-between vacancy first
++        for (int i = 0; i < m_lastUsedIndex; ++i) {
++            ItemType &item = m_slots[i];
++            if (!item.isValid()) {
++                return item;
++            }
++        }
++
++        ++m_lastUsedIndex;
++        if (m_lastUsedIndex >= m_slots.size()) {
++            m_slots.resize(m_lastUsedIndex + 1);
++        }
++
++        return m_slots[m_lastUsedIndex];
++    }
++
++    void freeSlot(Iterator &iterator) {
++        m_slots[iterator.index].reset();
++        if (iterator.index == m_lastUsedIndex) {
++            do {
++                --m_lastUsedIndex;
++            } while (m_lastUsedIndex >= 0 && !m_slots.at(m_lastUsedIndex).isValid());
++        }
++    }
++
++    // Iterates through all valid items (i.e. the occupied slots)
++    // calling the given function, with the option of ending the loop early.
++    //
++    // bool Func(Iterator& item)
++    //
++    // Returning true means it wants to continue the "for" loop, false
++    // terminates the loop.
++    template<typename Func> void forEach(Func func) {
++        Iterator it;
++        for (it.index = 0; it.index <= m_lastUsedIndex; ++it.index) {
++            it.item = &m_slots[it.index];
++            if (!it.item->isValid())
++                continue;
++
++            if (!func(it))
++                break;
++        }
++    }
++
++    bool isEmpty() const { return m_lastUsedIndex == -1; }
++
++
++private:
++    QVector<ItemType> m_slots;
++    int m_lastUsedIndex;
++};
++
++#endif // UBUNTUGESTURES_POOL_H
 === added file 'src/app/unity8/libs/UbuntuGestures/Timer.cpp'
 --- src/app/unity8/libs/UbuntuGestures/Timer.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/Timer.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,109 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "Timer.h"
++
++namespace UbuntuGestures {
++
++Timer::Timer(QObject *parent) : AbstractTimer(parent)
++{
++    m_timer.setSingleShot(false);
++    connect(&m_timer, &QTimer::timeout, this, &AbstractTimer::timeout);
++}
++
++int Timer::interval() const
++{
++    return m_timer.interval();
++}
++
++void Timer::setInterval(int msecs)
++{
++    m_timer.setInterval(msecs);
++}
++
++void Timer::start()
++{
++    m_timer.start();
++    AbstractTimer::start();
++}
++
++void Timer::stop()
++{
++    m_timer.stop();
++    AbstractTimer::stop();
++}
++
++bool Timer::isSingleShot() const
++{
++    return m_timer.isSingleShot();
++}
++
++void Timer::setSingleShot(bool value)
++{
++    m_timer.setSingleShot(value);
++}
++
++/////////////////////////////////// FakeTimer //////////////////////////////////
++
++FakeTimer::FakeTimer(QObject *parent)
++    : UbuntuGestures::AbstractTimer(parent)
++    , m_interval(0)
++    , m_singleShot(false)
++{
++}
++
++int FakeTimer::interval() const
++{
++    return m_interval;
++}
++
++void FakeTimer::setInterval(int msecs)
++{
++    m_interval = msecs;
++}
++
++bool FakeTimer::isSingleShot() const
++{
++    return m_singleShot;
++}
++
++void FakeTimer::setSingleShot(bool value)
++{
++    m_singleShot = value;
++}
++
++/////////////////////////////////// FakeTimerFactory //////////////////////////////////
++
++AbstractTimer *FakeTimerFactory::createTimer(QObject *parent)
++{
++    FakeTimer *fakeTimer = new FakeTimer(parent);
++
++    timers.append(fakeTimer);
++
++    return fakeTimer;
++}
++
++void FakeTimerFactory::makeRunningTimersTimeout()
++{
++    for (int i = 0; i < timers.count(); ++i) {
++        FakeTimer *timer = timers[i].data();
++        if (timer && timer->isRunning()) {
++            timer->emitTimeout();
++        }
++    }
++}
++
++} // namespace UbuntuGestures
 === added file 'src/app/unity8/libs/UbuntuGestures/Timer.h'
 --- src/app/unity8/libs/UbuntuGestures/Timer.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/Timer.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,105 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTUGESTURES_TIMER_H
++#define UBUNTUGESTURES_TIMER_H
++
++#include "UbuntuGesturesGlobal.h"
++
++#include <QObject>
++#include <QPointer>
++#include <QTimer>
++
++namespace UbuntuGestures {
++
++/* Defines an interface for a Timer. Useful for tests. */
++class UBUNTUGESTURES_EXPORT AbstractTimer : public QObject
++{
++    Q_OBJECT
++public:
++    AbstractTimer(QObject *parent) : QObject(parent), m_isRunning(false) {}
++    virtual int interval() const = 0;
++    virtual void setInterval(int msecs) = 0;
++    virtual void start() { m_isRunning = true; }
++    virtual void stop() { m_isRunning = false; }
++    bool isRunning() const { return m_isRunning; }
++    virtual bool isSingleShot() const = 0;
++    virtual void setSingleShot(bool value) = 0;
++Q_SIGNALS:
++    void timeout();
++private:
++    bool m_isRunning;
++};
++
++/* Essentially a QTimer wrapper */
++class UBUNTUGESTURES_EXPORT Timer : public AbstractTimer
++{
++    Q_OBJECT
++public:
++    Timer(QObject *parent = nullptr);
++
++    int interval() const override;
++    void setInterval(int msecs) override;
++    void start() override;
++    void stop() override;
++    bool isSingleShot() const override;
++    void setSingleShot(bool value) override;
++private:
++    QTimer m_timer;
++};
++
++/* For tests */
++class UBUNTUGESTURES_EXPORT FakeTimer : public AbstractTimer
++{
++    Q_OBJECT
++public:
++    FakeTimer(QObject *parent = nullptr);
++
++    virtual void emitTimeout() { Q_EMIT timeout(); }
++
++    int interval() const override;
++    void setInterval(int msecs) override;
++    bool isSingleShot() const override;
++    void setSingleShot(bool value) override;
++private:
++    int m_interval;
++    bool m_singleShot;
++};
++
++class UBUNTUGESTURES_EXPORT AbstractTimerFactory
++{
++public:
++    virtual ~AbstractTimerFactory() {}
++    virtual AbstractTimer *createTimer(QObject *parent = nullptr) = 0;
++};
++
++class UBUNTUGESTURES_EXPORT TimerFactory : public AbstractTimerFactory
++{
++public:
++    AbstractTimer *createTimer(QObject *parent = nullptr) override { return new Timer(parent); }
++};
++
++class UBUNTUGESTURES_EXPORT FakeTimerFactory : public AbstractTimerFactory
++{
++public:
++    AbstractTimer *createTimer(QObject *parent = nullptr) override;
++    void makeRunningTimersTimeout();
++    QList<QPointer<FakeTimer>> timers;
++};
++
++} // namespace UbuntuGestures
++
++#endif // UBUNTUGESTURES_TIMER_H
 === added file 'src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.cpp'
 --- src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,35 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "TouchOwnershipEvent.h"
++
++QEvent::Type TouchOwnershipEvent::m_touchOwnershipType = (QEvent::Type)-1;
++
++TouchOwnershipEvent::TouchOwnershipEvent(int touchId, bool gained)
++    : QEvent(touchOwnershipEventType())
++    , m_touchId(touchId)
++    , m_gained(gained)
++{
++}
++
++QEvent::Type TouchOwnershipEvent::touchOwnershipEventType()
++{
++    if (m_touchOwnershipType == (QEvent::Type)-1) {
++        m_touchOwnershipType = (QEvent::Type)registerEventType();
++    }
++
++    return m_touchOwnershipType;
++}
 === added file 'src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.h'
 --- src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/TouchOwnershipEvent.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,50 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTU_TOUCHOWNERSHIPEVENT_H
++#define UBUNTU_TOUCHOWNERSHIPEVENT_H
++
++#include <QEvent>
++#include "UbuntuGesturesGlobal.h"
++
++/*
++   When an item get an ownership event for a touch it can grab/steal that touch
++   with a clean conscience.
++ */
++class UBUNTUGESTURES_EXPORT TouchOwnershipEvent : public QEvent
++{
++public:
++    TouchOwnershipEvent(int touchId, bool gained);
++
++    static Type touchOwnershipEventType();
++
++    /*
++      Whether ownership was gained (true) or lost (false)
++     */
++    bool gained() const { return m_gained; }
++
++    /*
++        Id of the touch whose ownership was granted.
++     */
++    int touchId() const { return m_touchId; }
++
++private:
++    static Type m_touchOwnershipType;
++    int m_touchId;
++    bool m_gained;
++};
++
++#endif // UBUNTU_TOUCHOWNERSHIPEVENT_H
 === added file 'src/app/unity8/libs/UbuntuGestures/TouchRegistry.cpp'
 --- src/app/unity8/libs/UbuntuGestures/TouchRegistry.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/TouchRegistry.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,500 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "TouchRegistry.h"
++
++#include <QCoreApplication>
++#include <QDebug>
++
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-pedantic"
++#include <private/qquickitem_p.h>
++#pragma GCC diagnostic pop
++
++#include "CandidateInactivityTimer.h"
++#include "Timer.h"
++#include "TouchOwnershipEvent.h"
++#include "UnownedTouchEvent.h"
++
++#define TOUCHREGISTRY_DEBUG 0
++
++#if TOUCHREGISTRY_DEBUG
++    #include "DebugHelpers.h"
++    #define UG_DEBUG qDebug() << "[TouchRegistry]"
++#endif // TOUCHREGISTRY_DEBUG
++
++using namespace UbuntuGestures;
++
++TouchRegistry *TouchRegistry::m_instance = nullptr;
++
++TouchRegistry::TouchRegistry(QObject *parent)
++    : TouchRegistry(parent, new TimerFactory)
++{
++}
++
++TouchRegistry::TouchRegistry(QObject *parent, AbstractTimerFactory *timerFactory)
++    : QObject(parent)
++    , m_inDispatchLoop(false)
++    , m_timerFactory(timerFactory)
++{
++    if (m_instance == nullptr) {
++        m_instance = this;
++    } else {
++        qFatal("Cannot have more than one instance of TouchRegistry. It must be a singleton.");
++    }
++}
++
++TouchRegistry::~TouchRegistry()
++{
++    Q_ASSERT(m_instance != nullptr);
++    m_instance = nullptr;
++    delete m_timerFactory;
++}
++
++void TouchRegistry::update(const QTouchEvent *event)
++{
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "got" << qPrintable(touchEventToString(event));
++    #endif
++
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            TouchInfo &touchInfo = m_touchInfoPool.getEmptySlot();
++            touchInfo.init(touchPoint.id());
++        } else if (touchPoint.state() == Qt::TouchPointReleased) {
++            Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(touchPoint.id());
++
++            touchInfo->physicallyEnded = true;
++        }
++    }
++
++    deliverTouchUpdatesToUndecidedCandidatesAndWatchers(event);
++
++    freeEndedTouchInfos();
++}
++
++void TouchRegistry::deliverTouchUpdatesToUndecidedCandidatesAndWatchers(const QTouchEvent *event)
++{
++    // TODO: Look into how we could optimize this whole thing.
++    //       Although it's not really a problem as we should have at most two candidates
++    //       for each point and there should not be many active points at any given moment.
++    //       But having three nested for-loops does scare.
++
++    // TODO: Don't send it to the object that is already receiving the regular event
++    // because QQuickWindow is sending it to him (i.e., he's the touch owner from Qt's point of view)
++    // Problem is, we cannnot easily get this information.
++
++    const QList<QTouchEvent::TouchPoint> &updatedTouchPoints = event->touchPoints();
++
++    // Maps an item to the touches in this event he should be informed about.
++    // E.g.: a QTouchEvent might have three touches but a given item might be interested in only
++    // one of them. So he will get a UnownedTouchEvent from this QTouchEvent containing only that
++    // touch point.
++    QMap<QQuickItem*, QList<int>> touchIdsForItems;
++
++    // Build touchIdsForItems
++    m_touchInfoPool.forEach([&](Pool<TouchInfo>::Iterator &touchInfo) {
++        if (touchInfo->isOwned() && touchInfo->watchers.isEmpty())
++            return true;
++
++        for (int j = 0; j < updatedTouchPoints.count(); ++j) {
++            if (updatedTouchPoints[j].id() == touchInfo->id) {
++                if (!touchInfo->isOwned()) {
++                    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
++                        CandidateInfo &candidate = touchInfo->candidates[i];
++                        Q_ASSERT(!candidate.item.isNull());
++                        touchIdsForItems[candidate.item.data()].append(touchInfo->id);
++                    }
++                }
++
++                const QList<QPointer<QQuickItem>> &watchers = touchInfo->watchers;
++                for (int i = 0; i < watchers.count(); ++i) {
++                    if (!watchers[i].isNull()) {
++                        touchIdsForItems[watchers[i].data()].append(touchInfo->id);
++                    }
++                }
++
++                return true;
++            }
++        }
++
++        return true;
++    });
++
++    // TODO: Consider what happens if an item calls any of TouchRegistry's public methods
++    // from the event handler callback.
++    m_inDispatchLoop = true;
++    auto it = touchIdsForItems.constBegin();
++    while (it != touchIdsForItems.constEnd()) {
++        QQuickItem *item = it.key();
++        const QList<int> &touchIds = it.value();
++        dispatchPointsToItem(event, touchIds, item);
++        ++it;
++    };
++    m_inDispatchLoop = false;
++}
++
++void TouchRegistry::freeEndedTouchInfos()
++{
++    m_touchInfoPool.forEach([&](Pool<TouchInfo>::Iterator &touchInfo) {
++        if (touchInfo->ended()) {
++            m_touchInfoPool.freeSlot(touchInfo);
++        }
++        return true;
++    });
++}
++
++/*
++   Extracts the touches with the given touchIds from event and send them in a
++   UnownedTouchEvent to the given item
++ */
++void TouchRegistry::dispatchPointsToItem(const QTouchEvent *event, const QList<int> &touchIds,
++        QQuickItem *item)
++{
++    Qt::TouchPointStates touchPointStates = 0;
++    QList<QTouchEvent::TouchPoint> touchPoints;
++
++    const QList<QTouchEvent::TouchPoint> &allTouchPoints = event->touchPoints();
++
++    QTransform windowToCandidateTransform = QQuickItemPrivate::get(item)->windowToItemTransform();
++    QMatrix4x4 windowToCandidateMatrix(windowToCandidateTransform);
++
++    for (int i = 0; i < allTouchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &originalTouchPoint = allTouchPoints[i];
++        if (touchIds.contains(originalTouchPoint.id())) {
++            QTouchEvent::TouchPoint touchPoint = originalTouchPoint;
++
++            translateTouchPointFromScreenToWindowCoords(touchPoint);
++
++            // Set the point's local coordinates to that of the item
++            touchPoint.setRect(windowToCandidateTransform.mapRect(touchPoint.sceneRect()));
++            touchPoint.setStartPos(windowToCandidateTransform.map(touchPoint.startScenePos()));
++            touchPoint.setLastPos(windowToCandidateTransform.map(touchPoint.lastScenePos()));
++            touchPoint.setVelocity(windowToCandidateMatrix.mapVector(touchPoint.velocity()).toVector2D());
++
++            touchPoints.append(touchPoint);
++            touchPointStates |= touchPoint.state();
++        }
++    }
++
++    QTouchEvent *eventForItem = new QTouchEvent(event->type(),
++                                                event->device(),
++                                                event->modifiers(),
++                                                touchPointStates,
++                                                touchPoints);
++    eventForItem->setWindow(event->window());
++    eventForItem->setTimestamp(event->timestamp());
++    eventForItem->setTarget(event->target());
++
++    UnownedTouchEvent unownedTouchEvent(eventForItem);
++
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "Sending unowned" << qPrintable(touchEventToString(eventForItem))
++        << "to" << item;
++    #endif
++
++    QCoreApplication::sendEvent(item, &unownedTouchEvent);
++}
++
++void TouchRegistry::translateTouchPointFromScreenToWindowCoords(QTouchEvent::TouchPoint &touchPoint)
++{
++    touchPoint.setScreenRect(touchPoint.sceneRect());
++    touchPoint.setStartScreenPos(touchPoint.startScenePos());
++    touchPoint.setLastScreenPos(touchPoint.lastScenePos());
++
++    touchPoint.setSceneRect(touchPoint.rect());
++    touchPoint.setStartScenePos(touchPoint.startPos());
++    touchPoint.setLastScenePos(touchPoint.lastPos());
++}
++
++bool TouchRegistry::eventFilter(QObject *watched, QEvent *event)
++{
++    Q_UNUSED(watched);
++
++    switch (event->type()) {
++    case QEvent::TouchBegin:
++    case QEvent::TouchUpdate:
++    case QEvent::TouchEnd:
++    case QEvent::TouchCancel:
++        update(static_cast<QTouchEvent*>(event));
++        break;
++    default:
++        // do nothing
++        break;
++    }
++
++    // Do not filter out the event. i.e., let it be handled further as
++    // we're just monitoring events
++    return false;
++}
++
++void TouchRegistry::addCandidateOwnerForTouch(int id, QQuickItem *candidate)
++{
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "addCandidateOwnerForTouch id" << id << "candidate" << candidate;
++    #endif
++
++    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
++    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
++
++    if (touchInfo->isOwned()) {
++        qWarning("TouchRegistry: trying to add candidate owner for a touch that's already owned");
++        return;
++    }
++
++    // TODO: Check if candidate already exists
++
++    CandidateInfo candidateInfo;
++    candidateInfo.undecided = true;
++    candidateInfo.item = candidate;
++    candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,
++                                                                 *m_timerFactory,
++                                                                 this);
++    connect(candidateInfo.inactivityTimer, &CandidateInactivityTimer::candidateDefaulted,
++            this, &TouchRegistry::rejectCandidateOwnerForTouch);
++
++    touchInfo->candidates.append(candidateInfo);
++}
++
++void TouchRegistry::addTouchWatcher(int touchId, QQuickItem *watcher)
++{
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "addTouchWatcher id" << touchId << "watcher" << watcher;
++    #endif
++
++    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(touchId);
++    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
++
++    // TODO: Check if watcher already exists
++
++    touchInfo->watchers.append(watcher);
++}
++
++void TouchRegistry::removeCandidateOwnerForTouch(int id, QQuickItem *candidate)
++{
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "removeCandidateOwnerForTouch id" << id << "candidate" << candidate;
++    #endif
++
++    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
++    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
++
++    int indexRemoved = -1;
++
++    // TODO: check if the candidate is in fact the owner of the touch
++
++    for (int i = 0; i < touchInfo->candidates.count() && indexRemoved == -1; ++i) {
++        CandidateInfo &candidateInfo = touchInfo->candidates[i];
++        if (candidateInfo.item == candidate) {
++            Q_ASSERT(i > 0 || candidateInfo.undecided);
++            if (i == 0 && !candidateInfo.undecided) {
++                qCritical("TouchRegistry: touch owner is being removed.");
++            }
++            delete candidateInfo.inactivityTimer;
++            candidateInfo.inactivityTimer = nullptr;
++            touchInfo->candidates.removeAt(i);
++            indexRemoved = i;
++        }
++    }
++
++    if (indexRemoved == 0) {
++        // the top candidate has been removed. if the new top candidate
++        // wants the touch let him know he's now the owner.
++        if (touchInfo->isOwned()) {
++            touchInfo->notifyCandidatesOfOwnershipResolution();
++        }
++    }
++
++    if (!m_inDispatchLoop && touchInfo->ended()) {
++        m_touchInfoPool.freeSlot(touchInfo);
++    }
++}
++
++void TouchRegistry::requestTouchOwnership(int id, QQuickItem *candidate)
++{
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "requestTouchOwnership id " << id << "candidate" << candidate;
++    #endif
++
++    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
++    if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
++
++    Q_ASSERT(!touchInfo->isOwned());
++
++    int candidateIndex = -1;
++    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
++        CandidateInfo &candidateInfo = touchInfo->candidates[i];
++        if (candidateInfo.item == candidate) {
++            candidateInfo.undecided = false;
++            delete candidateInfo.inactivityTimer;
++            candidateInfo.inactivityTimer = nullptr;
++            candidateIndex = i;
++            break;
++        }
++    }
++
++    // add it as a candidate if not present yet
++    if (candidateIndex < 0) {
++        CandidateInfo candidateInfo;
++        candidateInfo.undecided = false;
++        candidateInfo.item = candidate;
++        candidateInfo.inactivityTimer = nullptr;
++        touchInfo->candidates.append(candidateInfo);
++        // it's the last one
++        candidateIndex = touchInfo->candidates.count() - 1;
++    }
++
++    // If it's the top candidate it means it's now the owner. Let
++    // it know about it.
++    if (candidateIndex == 0) {
++        touchInfo->notifyCandidatesOfOwnershipResolution();
++    }
++}
++
++Pool<TouchRegistry::TouchInfo>::Iterator TouchRegistry::findTouchInfo(int id)
++{
++    Pool<TouchInfo>::Iterator touchInfo;
++
++    m_touchInfoPool.forEach([&](Pool<TouchInfo>::Iterator &someTouchInfo) -> bool {
++        if (someTouchInfo->id == id) {
++            touchInfo = someTouchInfo;
++            return false;
++        } else {
++            return true;
++        }
++    });
++
++    return touchInfo;
++}
++
++
++void TouchRegistry::rejectCandidateOwnerForTouch(int id, QQuickItem *candidate)
++{
++    // NB: It's technically possible that candidate is a dangling pointer at this point.
++    // Although that would most likely be due to a bug in our code.
++    // In any case, only dereference it after it's confirmed that it indeed exists.
++
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "rejectCandidateOwnerForTouch id" << id << "candidate" << (void*)candidate;
++    #endif
++
++    Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
++    if (!touchInfo) {
++        #if TOUCHREGISTRY_DEBUG
++        UG_DEBUG << "Failed to find TouchInfo for id" << id;
++        #endif
++        return;
++    }
++
++    int rejectedCandidateIndex = -1;
++
++    // Check if the given candidate is valid and still undecided
++    for (int i = 0; i < touchInfo->candidates.count() && rejectedCandidateIndex == -1; ++i) {
++        CandidateInfo &candidateInfo = touchInfo->candidates[i];
++        if (candidateInfo.item == candidate) {
++            Q_ASSERT(i > 0 || candidateInfo.undecided);
++            if (i == 0 && !candidateInfo.undecided) {
++                qCritical() << "TouchRegistry: Can't reject item (" << (void*)candidate
++                    << ") as it already owns touch" << id;
++                return;
++            } else {
++                // we found the guy and it's all fine.
++                rejectedCandidateIndex = i;
++            }
++        }
++    }
++
++    // If we reached this point it's because the given candidate exists and is indeed undecided.
++
++    Q_ASSERT(rejectedCandidateIndex >= 0 && rejectedCandidateIndex < touchInfo->candidates.size());
++
++    {
++        TouchOwnershipEvent lostOwnershipEvent(id, false /*gained*/);
++        QCoreApplication::sendEvent(candidate, &lostOwnershipEvent);
++    }
++
++    touchInfo->candidates.removeAt(rejectedCandidateIndex);
++
++    if (rejectedCandidateIndex == 0) {
++        // the top candidate has been removed. if the new top candidate
++        // wants the touch let him know he's now the owner.
++        if (touchInfo->isOwned()) {
++            touchInfo->notifyCandidatesOfOwnershipResolution();
++        }
++    }
++}
++
++////////////////////////////////////// TouchRegistry::TouchInfo ////////////////////////////////////
++
++TouchRegistry::TouchInfo::TouchInfo(int id)
++{
++    init(id);
++}
++
++void TouchRegistry::TouchInfo::reset()
++{
++    id = -1;
++
++    for (int i = 0; i < candidates.count(); ++i) {
++        CandidateInfo &candidate = candidates[i];
++        delete candidate.inactivityTimer;
++        candidate.inactivityTimer.clear(); // shoundn't be needed but anyway...
++    }
++}
++
++void TouchRegistry::TouchInfo::init(int id)
++{
++    this->id = id;
++    physicallyEnded = false;
++    candidates.clear();
++    watchers.clear();
++}
++
++bool TouchRegistry::TouchInfo::isOwned() const
++{
++    return !candidates.isEmpty() && !candidates.first().undecided;
++}
++
++bool TouchRegistry::TouchInfo::ended() const
++{
++    Q_ASSERT(isValid());
++    return physicallyEnded && (isOwned() || candidates.isEmpty());
++}
++
++void TouchRegistry::TouchInfo::notifyCandidatesOfOwnershipResolution()
++{
++    Q_ASSERT(isOwned());
++
++    #if TOUCHREGISTRY_DEBUG
++    UG_DEBUG << "sending TouchOwnershipEvent(id =" << id
++        << " gained) to candidate" << candidates[0].item;
++    #endif
++
++    TouchOwnershipEvent gainedOwnershipEvent(id, true /*gained*/);
++    QCoreApplication::sendEvent(candidates[0].item, &gainedOwnershipEvent);
++
++
++    TouchOwnershipEvent lostOwnershipEvent(id, false /*gained*/);
++    for (int i = 1; i < candidates.count(); ++i) {
++        #if TOUCHREGISTRY_DEBUG
++        UG_DEBUG << "sending TouchWonershipEvent(id =" << id << " lost) to candidate"
++            << candidates[i].item;
++        #endif
++        QCoreApplication::sendEvent(candidates[i].item, &lostOwnershipEvent);
++    }
++}
 === added file 'src/app/unity8/libs/UbuntuGestures/TouchRegistry.h'
 --- src/app/unity8/libs/UbuntuGestures/TouchRegistry.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/TouchRegistry.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,182 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UNITY_TOUCHREGISTRY_H
++#define UNITY_TOUCHREGISTRY_H
++
++#include <QQuickItem>
++#include <QObject>
++#include <QPointer>
++#include <QTouchEvent>
++#include <QVector>
++
++#include "UbuntuGesturesGlobal.h"
++#include "CandidateInactivityTimer.h"
++#include "Pool.h"
++
++namespace UbuntuGestures {
++    class AbstractTimerFactory;
++}
++
++/*
++  Where the ownership of touches is registered.
++
++  Singleton used for adding a touch point ownership model analogous to the one
++  described in the XInput 2.2 protocol[1] on top of the existing input dispatch logic in QQuickWindow.
++
++  It provides a much more flexible and powerful way of dealing with pointer ownership than the existing
++  mechanisms in Qt. Namely QQuickItem::grabTouchPoints, QuickItem::keepTouchGrab,
++  QQuickItem::setFiltersChildMouseEvents, QQuickItem::ungrabTouchPoints and QQuickItem::touchUngrabEvent.
++
++  Usage:
++
++  1- An item receives a a new touch point. If he's not sure whether he wants it yet, he calls:
++        TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, this);
++        touchEvent->ignore();
++     Ignoring the event is crucial so that it can be seen by other interested parties, which will
++     behave similarly.
++
++  2- That item will then start receiving UnownedTouchEvents for that touch from step 1. Once he's
++     made a decision he calls either:
++        TouchRegistry::instance()->requestTouchOwnership(touchId, this);
++     If he wants the touch point or:
++        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, this);
++     if he does not want it.
++
++  Candidates are put in a priority queue. The first one to call addCandidateOwnerForTouch() will
++  take precedence over the others for receiving ownership over the touch point (from now on called
++  simply top-candidate).
++
++  If the top-candidate calls requestTouchOwnership() he will immediately receive a
++  TouchOwnershipEvent(gained=true) for that touch point. He can then safely call
++  QQuickItem::grabTouchPoints to actually get the owned touch points. The other candidates
++  will receive TouchOwnershipEvent(gained=false) and will no longer receive UnownedTouchEvents
++  for that touch point. They will have to undo whatever action they were performing with that
++  touch point.
++
++  But if the top-candidate calls removeCandidateOwnerForTouch() instead, he's popped from the
++  candidacy queue and ownership is given to the new top-most candidate if he has already
++  made his decision, that is.
++
++  The TouchRegistry cannot enforce the results of this pointer ownership negotiation (i.e.,
++  who gets to grab the touch points) as that would clash with QQuickWindow's input event
++  dispatching logic. The candidates have to respect the decision and grab the touch points
++  themselves.
++
++  If an item wants ownership over touches as soon as he receives the TouchBegin for them, his step 1
++  would be instead:
++        TouchRegistry::instance()->requestTouchOwnership(touchId, this);
++        return true;
++  He would then be notified once ownership has been granted to him, from which point onwards he could
++  safely assume other TouchRegistry users wouldn't snatch this touch away from him.
++
++  Items oblivious to TouchRegistry will lose their touch points without warning, just like in plain Qt.
++
++  [1] - http://www.x.org/releases/X11R7.7/doc/inputproto/XI2proto.txt (see multitouch-ownership)
++ */
++class UBUNTUGESTURES_EXPORT TouchRegistry : public QObject
++{
++    Q_OBJECT
++public:
++    TouchRegistry(QObject *parent = nullptr);
++    // Useful for tests, where you should feed a fake timer
++    TouchRegistry(QObject *parent, UbuntuGestures::AbstractTimerFactory *timerFactory);
++
++    virtual ~TouchRegistry();
++
++    // Returns a pointer to the application's TouchRegistry instance.
++    // If no instance has been allocated, null is returned.
++    static TouchRegistry *instance() { return m_instance; }
++
++    void update(const QTouchEvent *event);
++
++    // Calls update() if the given event is a QTouchEvent
++    bool eventFilter(QObject *watched, QEvent *event) override;
++
++    // An item that might later request ownership over the given touch point.
++    // He will be kept informed about that touch point through UnownedTouchEvents
++    // All candidates must eventually decide whether they want to own the touch point
++    // or not. That decision is informed through requestTouchOwnership() or
++    // removeCandidateOwnerForTouch()
++    void addCandidateOwnerForTouch(int id, QQuickItem *candidate);
++
++    // The same as rejecting ownership of a touch
++    void removeCandidateOwnerForTouch(int id, QQuickItem *candidate);
++
++    // The candidate object wants to be the owner of the touch with the given id.
++    // If he's currently the oldest/top-most candidate, he will get an ownership
++    // event immediately. If not, he will get ownership if (or once) he becomes the
++    // top-most candidate.
++    void requestTouchOwnership(int id, QQuickItem *candidate);
++
++    // An item that has no interest (effective or potential) in owning a touch point
++    // but would nonetheless like to be kept up-to-date on its state.
++    void addTouchWatcher(int touchId, QQuickItem *watcherItem);
++
++private Q_SLOTS:
++    void rejectCandidateOwnerForTouch(int id, QQuickItem *candidate);
++
++private:
++    class CandidateInfo {
++    public:
++        bool undecided;
++        // TODO: Prune candidates that become null and resolve ownership accordingly.
++        QPointer<QQuickItem> item;
++        QPointer<UbuntuGestures::CandidateInactivityTimer> inactivityTimer;
++    };
++
++    class TouchInfo {
++    public:
++        TouchInfo() : id(-1) {}
++        TouchInfo(int id);
++        bool isValid() const { return id >= 0; }
++        void reset();
++        void init(int id);
++        int id;
++        bool physicallyEnded;
++        bool isOwned() const;
++        bool ended() const;
++        void notifyCandidatesOfOwnershipResolution();
++
++        // TODO optimize storage (s/QList/Pool)
++        QList<CandidateInfo> candidates;
++        QList<QPointer<QQuickItem>> watchers;
++    };
++
++    Pool<TouchInfo>::Iterator findTouchInfo(int id);
++
++    void deliverTouchUpdatesToUndecidedCandidatesAndWatchers(const QTouchEvent *event);
++
++    static void translateTouchPointFromScreenToWindowCoords(QTouchEvent::TouchPoint &touchPoint);
++
++    static void dispatchPointsToItem(const QTouchEvent *event, const QList<int> &touchIds,
++                                     QQuickItem *item);
++    void freeEndedTouchInfos();
++
++    Pool<TouchInfo> m_touchInfoPool;
++
++    // the singleton instance
++    static TouchRegistry *m_instance;
++
++    bool m_inDispatchLoop;
++
++    UbuntuGestures::AbstractTimerFactory *m_timerFactory;
++
++    friend class tst_TouchRegistry;
++    friend class tst_DirectionalDragArea;
++};
++
++#endif // UNITY_TOUCHREGISTRY_H
 === added file 'src/app/unity8/libs/UbuntuGestures/UbuntuGesturesGlobal.h'
 --- src/app/unity8/libs/UbuntuGestures/UbuntuGesturesGlobal.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/UbuntuGesturesGlobal.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,23 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <QtCore/QtGlobal>
++
++#if defined(UBUNTUGESTURES_LIBRARY)
++#  define UBUNTUGESTURES_EXPORT Q_DECL_EXPORT
++#else
++#  define UBUNTUGESTURES_EXPORT Q_DECL_IMPORT
++#endif
 === added file 'src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.cpp'
 --- src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,39 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "UnownedTouchEvent.h"
++
++QEvent::Type UnownedTouchEvent::m_unownedTouchEventType = (QEvent::Type)-1;
++
++UnownedTouchEvent::UnownedTouchEvent(QTouchEvent *touchEvent)
++    : QEvent(unownedTouchEventType())
++    , m_touchEvent(touchEvent)
++{
++}
++
++QEvent::Type UnownedTouchEvent::unownedTouchEventType()
++{
++    if (m_unownedTouchEventType == (QEvent::Type)-1) {
++        m_unownedTouchEventType = (QEvent::Type)registerEventType();
++    }
++
++    return m_unownedTouchEventType;
++}
++
++QTouchEvent *UnownedTouchEvent::touchEvent()
++{
++    return m_touchEvent.data();
++}
 === added file 'src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.h'
 --- src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/libs/UbuntuGestures/UnownedTouchEvent.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,45 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTU_UNOWNEDTOUCHEVENT_H
++#define UBUNTU_UNOWNEDTOUCHEVENT_H
++
++#include <QTouchEvent>
++#include <QScopedPointer>
++#include "UbuntuGesturesGlobal.h"
++
++/*
++ A touch event with touch points that do not belong the item receiving it.
++
++ See TouchRegistry::addCandidateOwnerForTouch and TouchRegistry::addTouchWatcher
++ */
++class UBUNTUGESTURES_EXPORT UnownedTouchEvent : public QEvent
++{
++public:
++    UnownedTouchEvent(QTouchEvent *touchEvent);
++    static Type unownedTouchEventType();
++
++    // TODO: It might be cleaner to store the information directly in UnownedTouchEvent
++    //       instead of carrying around a synthesized QTouchEvent. But the latter option
++    //       is very convenient.
++    QTouchEvent *touchEvent();
++
++private:
++    static Type m_unownedTouchEventType;
++    QScopedPointer<QTouchEvent> m_touchEvent;
++};
++
++#endif // UBUNTU_UNOWNEDTOUCHEVENT_H
 === added directory 'src/app/unity8/plugins'
 === added file 'src/app/unity8/plugins/CMakeLists.txt'
 --- src/app/unity8/plugins/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -0,0 +1,1 @@
++add_subdirectory(Ubuntu)
 === added directory 'src/app/unity8/plugins/Ubuntu'
 === added file 'src/app/unity8/plugins/Ubuntu/CMakeLists.txt'
 --- src/app/unity8/plugins/Ubuntu/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -0,0 +1,1 @@
++add_subdirectory(Gestures)
 === added directory 'src/app/unity8/plugins/Ubuntu/Gestures'
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,149 @@
++/*
++ * 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 "AxisVelocityCalculator.h"
++#include <QtCore/QElapsedTimer>
++
++using namespace UbuntuGestures;
++
++AxisVelocityCalculator::AxisVelocityCalculator(QObject *parent)
++    : AxisVelocityCalculator(SharedTimeSource(new RealTimeSource), parent)
++{
++}
++
++AxisVelocityCalculator::AxisVelocityCalculator(const SharedTimeSource &timeSource,
++                                               QObject *parent)
++    : QObject(parent)
++    , m_timeSource(timeSource)
++    , m_trackedPosition(0.0)
++{
++    reset();
++}
++
++AxisVelocityCalculator::~AxisVelocityCalculator()
++{
++}
++
++qreal AxisVelocityCalculator::trackedPosition() const
++{
++    return m_trackedPosition;
++}
++
++void AxisVelocityCalculator::setTrackedPosition(qreal newPosition)
++{
++    processMovement(newPosition - m_trackedPosition);
++
++    if (newPosition != m_trackedPosition) {
++        m_trackedPosition = newPosition;
++        Q_EMIT trackedPositionChanged(newPosition);
++    }
++}
++
++void AxisVelocityCalculator::updateIdleTime()
++{
++    processMovement(0);
++}
++
++void AxisVelocityCalculator::processMovement(qreal movement)
++{
++    if (m_samplesRead == -1) {
++        m_samplesRead = m_samplesWrite;
++    } else if (m_samplesRead == m_samplesWrite) {
++        /* the oldest value is going to be overwritten.
++           so now the oldest will be the next one. */
++        m_samplesRead = (m_samplesRead + 1) % MAX_SAMPLES;
++    }
++
++    m_samples[m_samplesWrite].mov = movement;
++    m_samples[m_samplesWrite].time = m_timeSource->msecsSinceReference();
++    m_samplesWrite = (m_samplesWrite + 1) % MAX_SAMPLES;
++}
++
++qreal AxisVelocityCalculator::calculate()
++{
++    if (numSamples() < MIN_SAMPLES_NEEDED) {
++        return 0.0;
++    }
++    updateIdleTime(); // consider the time elapsed since the last update and now
++
++    int lastIndex;
++    if (m_samplesWrite == 0) {
++        lastIndex = MAX_SAMPLES - 1;
++    } else {
++        lastIndex = m_samplesWrite - 1;
++    }
++
++    qint64 currTime = m_samples[lastIndex].time;
++
++    qreal totalTime = 0;
++    qreal totalDistance = 0;
++
++    int sampleIndex = (m_samplesRead + 1) % MAX_SAMPLES;
++    qint64 previousTime = m_samples[m_samplesRead].time;
++    while (sampleIndex != m_samplesWrite) {
++        // Skip this sample if it's too old
++        if (currTime - m_samples[sampleIndex].time <= AGE_OLDEST_SAMPLE) {
++            int deltaTime = m_samples[sampleIndex].time - previousTime;
++            totalDistance += m_samples[sampleIndex].mov;
++            totalTime += deltaTime;
++        }
++
++        previousTime = m_samples[sampleIndex].time;
++        sampleIndex = (sampleIndex + 1) % MAX_SAMPLES;
++    }
++
++    return totalDistance / totalTime;
++}
++
++void AxisVelocityCalculator::reset()
++{
++    m_samplesRead = -1;
++    m_samplesWrite = 0;
++}
++
++int AxisVelocityCalculator::numSamples() const
++{
++    if (m_samplesRead == -1) {
++        return 0;
++    } else {
++        if (m_samplesWrite == 0) {
++            /* consider only what's to the right of m_samplesRead (including himself) */
++            return MAX_SAMPLES - m_samplesRead;
++        } else if (m_samplesWrite == m_samplesRead) {
++            return MAX_SAMPLES; /* buffer is full */
++        } else if (m_samplesWrite < m_samplesRead) {
++            return (MAX_SAMPLES - m_samplesRead) + m_samplesWrite;
++        } else {
++            return m_samplesWrite - m_samplesRead;
++        }
++    }
++}
++
++void AxisVelocityCalculator::setTimeSource(const SharedTimeSource &timeSource)
++{
++    m_timeSource = timeSource;
++
++    if (numSamples() > 0) {
++        qWarning("AxisVelocityCalculator: changing time source while there are samples present.");
++        // Any existent samples are based on the old time source and are, therefore, incompatible
++        // with this new one.
++        reset();
++    }
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,146 @@
++/*
++ * 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>
++ */
++
++#ifndef VELOCITY_CALCULATOR_H
++#define VELOCITY_CALCULATOR_H
++
++#include "UbuntuGesturesQmlGlobal.h"
++#include <stdint.h>
++#include <QtCore/QObject>
++#include "TimeSource.h"
++
++/*
++  Estimates the current velocity of a finger based on recent movement along an axis
++
++  Taking an estimate from a reasonable number of samples, instead of only
++  from its last movement, removes wild variations in velocity caused
++  by the jitter normally present in input from a touchscreen.
++
++  Usage example:
++
++    AxisVelocityCalculator {
++        id: velocityCalculator
++        trackedPosition: myMouseArea.mouseX
++    }
++
++    MouseArea {
++        id: myMouseArea
++
++        onReleased: {
++            console.log("Drag velocity along the X axis before release was: "
++                        + velocityCalculator.calculate())
++        }
++    }
++ */
++class UBUNTUGESTURESQML_EXPORT AxisVelocityCalculator : public QObject
++{
++    Q_OBJECT
++
++    /*
++        Position whose movement will be tracked to calculate its velocity
++     */
++    Q_PROPERTY(qreal trackedPosition READ trackedPosition WRITE setTrackedPosition
++               NOTIFY trackedPositionChanged)
++public:
++
++    /*
++      Regular, simple, constructor
++     */
++    AxisVelocityCalculator(QObject *parent = 0);
++
++    /*
++      Constructor that takes a TimeSource
++     */
++    AxisVelocityCalculator(const UbuntuGestures::SharedTimeSource &timeSource, QObject *parent = 0);
++
++    virtual ~AxisVelocityCalculator();
++
++    qreal trackedPosition() const;
++    void setTrackedPosition(qreal value);
++
++    /*
++      Calculates the finger velocity, in axis units/millisecond
++    */
++    Q_INVOKABLE qreal calculate();
++
++    /*
++      Removes all stored movements from previous calls to setTrackedPosition()
++    */
++    Q_INVOKABLE void reset();
++
++    int numSamples() const;
++
++    /*
++        Replaces the TimeSource with the given one. Useful for testing purposes.
++     */
++    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
++
++    /*
++        The minimum amount of samples needed for a velocity calculation.
++     */
++    static const int MIN_SAMPLES_NEEDED = 2;
++
++    /*
++      Maximum number of movement samples stored
++    */
++    static const int MAX_SAMPLES = 50;
++
++    /*
++      Age of the oldest sample considered in the velocity calculations, in
++      milliseconds, compared to the most recent one.
++    */
++    static const int AGE_OLDEST_SAMPLE = 100;
++
++Q_SIGNALS:
++    void trackedPositionChanged(qreal value);
++
++private:
++
++    /*
++        Inform that trackedPosition remained motionless since the time it was
++        last changed.
++
++        It's the same as calling setTrackedPosition(trackedPosition())
++     */
++    void updateIdleTime();
++
++    /*
++      How much the finger has moved since processMovement() was last called.
++    */
++    void processMovement(qreal movement);
++
++    class Sample
++    {
++        public:
++            qreal mov; /* movement distance since last sample */
++            qint64 time; /* time, in milliseconds */
++    };
++
++    /* a circular buffer of samples */
++    Sample m_samples[MAX_SAMPLES];
++    int m_samplesRead; /* index of the oldest sample available. -1 if buffer is empty */
++    int m_samplesWrite; /* index where the next sample will be written */
++
++    UbuntuGestures::SharedTimeSource m_timeSource;
++
++    qreal m_trackedPosition;
++};
++
++#endif // VELOCITY_CALCULATOR_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/CMakeLists.txt'
 --- src/app/unity8/plugins/Ubuntu/Gestures/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/CMakeLists.txt	2015-03-20 16:26:56 +0000
@@ -0,0 +1,40 @@
++# in order to include Qt's private headers
++remove_definitions(-DQT_NO_KEYWORDS)
++
++set(UbuntuGesturesQml_SOURCES
++#    plugin.cpp
++    AxisVelocityCalculator.cpp
++    Direction.cpp
++    DirectionalDragArea.cpp
++    PressedOutsideNotifier.cpp
++    TimeSource.cpp
++    TouchDispatcher.cpp
++    TouchGate.cpp
++)
++
++add_definitions(-DUBUNTUGESTURESQML_LIBRARY)
++
++add_library(UbuntuGesturesQml STATIC ${UbuntuGesturesQml_SOURCES})
++target_link_libraries(UbuntuGesturesQml UbuntuGestures)
++
++qt5_use_modules(UbuntuGesturesQml Core Quick)
++
++# So that Foo.cpp can #include "Foo.moc"
++include_directories(${CMAKE_CURRENT_BINARY_DIR})
++
++include_directories(${unity8_SOURCE_DIR}/libs/UbuntuGestures)
++
++# There's no cmake var for v8 include path :-/ so create one
++LIST(GET Qt5Core_INCLUDE_DIRS 0 QtCoreDir0)
++SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/QtV8/${Qt5Core_VERSION_STRING}/QtV8)
++
++# DANGER! DANGER! Using Qt's private API!
++include_directories(
++    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
++    ${Qt5Quick_INCLUDE_DIRS}
++    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
++    ${Qt5V8_PRIVATE_INCLUDE_DIR}
++)
++
++#add_unity8_plugin(Ubuntu.Gestures 0.1 Ubuntu/Gestures TARGETS UbuntuGesturesQml)
++# TODO
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/Damper.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/Damper.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/Damper.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,87 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTU_GESTURES_DAMPER_H
++#define UBUNTU_GESTURES_DAMPER_H
++
++#include <QtCore/QPointF>
++
++/*
++  Decreases the oscillations of a value along an axis.
++ */
++template <class Type> class Damper {
++public:
++    Damper() : m_value(0), m_maxDelta(0) { }
++
++    // Maximum delta between the raw value and its dampened counterpart.
++    void setMaxDelta(Type maxDelta) {
++        if (maxDelta < 0) qFatal("Damper::maxDelta must be a positive number.");
++        m_maxDelta = maxDelta;
++    }
++    Type maxDelta() const { return m_maxDelta; }
++
++    void reset(Type value) {
++        m_value = value;
++    }
++
++    Type update(Type value) {
++        Type delta = value - m_value;
++        if (delta > 0 && delta > m_maxDelta) {
++            m_value += delta - m_maxDelta;
++        } else if (delta < 0 && delta < -m_maxDelta) {
++            m_value += delta + m_maxDelta;
++        }
++
++        return m_value;
++    }
++
++    Type value() const { return m_value; }
++
++private:
++    Type m_value;
++    Type m_maxDelta;
++};
++
++/*
++    A point that has its movement dampened.
++ */
++class DampedPointF {
++public:
++    void setMaxDelta(qreal maxDelta) {
++        m_x.setMaxDelta(maxDelta);
++        m_y.setMaxDelta(maxDelta);
++    }
++
++    qreal maxDelta() const { return m_x.maxDelta(); }
++
++    void reset(const QPointF &point) {
++        m_x.reset(point.x());
++        m_y.reset(point.y());
++    }
++
++    void update(const QPointF &point) {
++        m_x.update(point.x());
++        m_y.update(point.y());
++    }
++
++    qreal x() const { return m_x.value(); }
++    qreal y() const { return m_y.value(); }
++private:
++    Damper<qreal> m_x;
++    Damper<qreal> m_y;
++};
++
++#endif // UBUNTU_GESTURES_DAMPER_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/Direction.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/Direction.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/Direction.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,36 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "Direction.h"
++
++bool Direction::isHorizontal(Direction::Type type)
++{
++    return type == Direction::Leftwards
++        || type == Direction::Rightwards
++        || type == Direction::Horizontal;
++}
++
++bool Direction::isVertical(Direction::Type type)
++{
++    return type == Direction::Upwards || type == Direction::Downwards;
++}
++
++bool Direction::isPositive(Direction::Type type)
++{
++    return type == Rightwards
++        || type == Downwards
++        || type == Horizontal;
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/Direction.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/Direction.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/Direction.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,45 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef DIRECTION_H
++#define DIRECTION_H
++
++#include "UbuntuGesturesQmlGlobal.h"
++#include <QObject>
++
++/*
++    A Direction enum wrapper so that we can do things like "direction: Direction.Righwards"
++    from QML.
++ */
++class UBUNTUGESTURESQML_EXPORT Direction : public QObject {
++    Q_OBJECT
++    Q_ENUMS(Type)
++
++public:
++    enum Type {
++        Rightwards, // Along the positive direction of the X axis
++        Leftwards, // Along the negative direction of the X axis
++        Downwards, // Along the positive direction of the Y axis
++        Upwards, // Along the negative direction of the Y axis
++        Horizontal // Along the X axis, in any direction
++    };
++
++    Q_INVOKABLE static bool isHorizontal(Direction::Type type);
++    Q_INVOKABLE static bool isVertical(Direction::Type type);
++    Q_INVOKABLE static bool isPositive(Direction::Type type);
++};
++
++#endif // DIRECTION_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,886 @@
++/*
++ * Copyright (C) 2013-2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#define ACTIVETOUCHESINFO_DEBUG 0
++#define DIRECTIONALDRAGAREA_DEBUG 0
++
++#include "DirectionalDragArea.h"
++
++#include <QQuickWindow>
++#include <QtCore/qmath.h>
++#include <QDebug>
++
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-pedantic"
++#include <private/qquickwindow_p.h>
++#pragma GCC diagnostic pop
++
++// local
++#include "TouchOwnershipEvent.h"
++#include "TouchRegistry.h"
++#include "UnownedTouchEvent.h"
++
++using namespace UbuntuGestures;
++
++#if DIRECTIONALDRAGAREA_DEBUG
++#define ddaDebug(params) qDebug().nospace() << "[DDA(" << qPrintable(objectName()) << ")] " << params
++#include "DebugHelpers.h"
++
++namespace {
++const char *statusToString(DirectionalDragArea::Status status)
++{
++    if (status == DirectionalDragArea::WaitingForTouch) {
++        return "WaitingForTouch";
++    } else if (status == DirectionalDragArea::Undecided) {
++        return "Undecided";
++    } else {
++        return "Recognized";
++    }
++}
++
++} // namespace {
++#else // DIRECTIONALDRAGAREA_DEBUG
++#define ddaDebug(params) ((void)0)
++#endif // DIRECTIONALDRAGAREA_DEBUG
++
++
++DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)
++    : QQuickItem(parent)
++    , m_status(WaitingForTouch)
++    , m_sceneDistance(0)
++    , m_touchId(-1)
++    , m_direction(Direction::Rightwards)
++    , m_wideningAngle(0)
++    , m_wideningFactor(0)
++    , m_distanceThreshold(0)
++    , m_distanceThresholdSquared(0.)
++    , m_minSpeed(0)
++    , m_maxSilenceTime(200)
++    , m_silenceTime(0)
++    , m_compositionTime(60)
++    , m_numSamplesOnLastSpeedCheck(0)
++    , m_recognitionTimer(0)
++    , m_velocityCalculator(0)
++    , m_timeSource(new RealTimeSource)
++    , m_activeTouches(m_timeSource)
++{
++    setRecognitionTimer(new Timer(this));
++    m_recognitionTimer->setInterval(60);
++    m_recognitionTimer->setSingleShot(false);
++
++    m_velocityCalculator = new AxisVelocityCalculator(this);
++
++    connect(this, &QQuickItem::enabledChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
++    connect(this, &QQuickItem::visibleChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
++}
++
++Direction::Type DirectionalDragArea::direction() const
++{
++    return m_direction;
++}
++
++void DirectionalDragArea::setDirection(Direction::Type direction)
++{
++    if (direction != m_direction) {
++        m_direction = direction;
++        Q_EMIT directionChanged(m_direction);
++    }
++}
++
++void DirectionalDragArea::setMaxDeviation(qreal value)
++{
++    if (m_dampedScenePos.maxDelta() != value) {
++        m_dampedScenePos.setMaxDelta(value);
++        Q_EMIT maxDeviationChanged(value);
++    }
++}
++
++qreal DirectionalDragArea::wideningAngle() const
++{
++    return m_wideningAngle;
++}
++
++void DirectionalDragArea::setWideningAngle(qreal angle)
++{
++    if (angle == m_wideningAngle)
++        return;
++
++    m_wideningAngle = angle;
++
++    // wideningFactor = pow(cosine(angle), 2)
++    {
++        qreal angleRadians = angle * M_PI / 180.0;
++        m_wideningFactor = qCos(angleRadians);
++        m_wideningFactor = m_wideningFactor * m_wideningFactor;
++    }
++
++    Q_EMIT wideningAngleChanged(angle);
++}
++
++void DirectionalDragArea::setDistanceThreshold(qreal value)
++{
++    if (m_distanceThreshold != value) {
++        m_distanceThreshold = value;
++        m_distanceThresholdSquared = m_distanceThreshold * m_distanceThreshold;
++        Q_EMIT distanceThresholdChanged(value);
++    }
++}
++
++void DirectionalDragArea::setMinSpeed(qreal value)
++{
++    if (m_minSpeed != value) {
++        m_minSpeed = value;
++        Q_EMIT minSpeedChanged(value);
++    }
++}
++
++void DirectionalDragArea::setMaxSilenceTime(int value)
++{
++    if (m_maxSilenceTime != value) {
++        m_maxSilenceTime = value;
++        Q_EMIT maxSilenceTimeChanged(value);
++    }
++}
++
++void DirectionalDragArea::setCompositionTime(int value)
++{
++    if (m_compositionTime != value) {
++        m_compositionTime = value;
++        Q_EMIT compositionTimeChanged(value);
++    }
++}
++
++void DirectionalDragArea::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
++{
++    int interval = 0;
++    bool timerWasRunning = false;
++    bool wasSingleShot = false;
++
++    // can be null when called from the constructor
++    if (m_recognitionTimer) {
++        interval = m_recognitionTimer->interval();
++        timerWasRunning = m_recognitionTimer->isRunning();
++        if (m_recognitionTimer->parent() == this) {
++            delete m_recognitionTimer;
++        }
++    }
++
++    m_recognitionTimer = timer;
++    timer->setInterval(interval);
++    timer->setSingleShot(wasSingleShot);
++    connect(timer, &UbuntuGestures::AbstractTimer::timeout,
++            this, &DirectionalDragArea::checkSpeed);
++    if (timerWasRunning) {
++        m_recognitionTimer->start();
++    }
++}
++
++void DirectionalDragArea::setTimeSource(const SharedTimeSource &timeSource)
++{
++    m_timeSource = timeSource;
++    m_velocityCalculator->setTimeSource(timeSource);
++    m_activeTouches.m_timeSource = timeSource;
++}
++
++qreal DirectionalDragArea::distance() const
++{
++    if (Direction::isHorizontal(m_direction)) {
++        return m_previousPos.x() - m_startPos.x();
++    } else {
++        return m_previousPos.y() - m_startPos.y();
++    }
++}
++
++void DirectionalDragArea::updateSceneDistance()
++{
++    QPointF totalMovement = m_previousScenePos - m_startScenePos;
++    m_sceneDistance = projectOntoDirectionVector(totalMovement);
++}
++
++qreal DirectionalDragArea::sceneDistance() const
++{
++    return m_sceneDistance;
++}
++
++qreal DirectionalDragArea::touchX() const
++{
++    return m_previousPos.x();
++}
++
++qreal DirectionalDragArea::touchY() const
++{
++    return m_previousPos.y();
++}
++
++qreal DirectionalDragArea::touchSceneX() const
++{
++    return m_previousScenePos.x();
++}
++
++qreal DirectionalDragArea::touchSceneY() const
++{
++    return m_previousScenePos.y();
++}
++
++bool DirectionalDragArea::event(QEvent *event)
++{
++    if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
++        touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
++        return true;
++    } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {
++        unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));
++        return true;
++    } else {
++        return QQuickItem::event(event);
++    }
++}
++
++void DirectionalDragArea::touchOwnershipEvent(TouchOwnershipEvent *event)
++{
++    if (event->gained()) {
++        QVector<int> ids;
++        ids.append(event->touchId());
++        ddaDebug("grabbing touch");
++        grabTouchPoints(ids);
++
++        // Work around for Qt bug. If we grab a touch that is being used for mouse pointer
++        // emulation it will cause the emulation logic to go nuts.
++        // Thus we have to also grab the mouse in this case.
++        //
++        // The fix for this bug has landed in Qt 5.4 (https://codereview.qt-project.org/96887)
++        // TODO: Remove this workaround once we start using Qt 5.4
++        if (window()) {
++            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(window());
++            if (windowPrivate->touchMouseId == event->touchId() && window()->mouseGrabberItem()) {
++                ddaDebug("removing mouse grabber");
++                window()->mouseGrabberItem()->ungrabMouse();
++            }
++        }
++    } else {
++        // We still wanna know when it ends for keeping the composition time window up-to-date
++        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
++
++        setStatus(WaitingForTouch);
++    }
++}
++
++void DirectionalDragArea::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)
++{
++    QTouchEvent *event = unownedTouchEvent->touchEvent();
++
++    Q_ASSERT(!event->touchPointStates().testFlag(Qt::TouchPointPressed));
++
++    ddaDebug("Unowned " << m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
++
++    switch (m_status) {
++        case WaitingForTouch:
++            // do nothing
++            break;
++        case Undecided:
++            Q_ASSERT(isEnabled() && isVisible());
++            unownedTouchEvent_undecided(unownedTouchEvent);
++            break;
++        default: // Recognized:
++            // do nothing
++            break;
++    }
++
++    m_activeTouches.update(event);
++}
++
++void DirectionalDragArea::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)
++{
++    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(unownedTouchEvent->touchEvent());
++    if (!touchPoint) {
++        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << m_touchId
++            << "missing from UnownedTouchEvent without first reaching state Qt::TouchPointReleased. "
++               "Considering it as released.";
++
++        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++        setStatus(WaitingForTouch);
++        return;
++    }
++
++    const QPointF &touchScenePos = touchPoint->scenePos();
++
++    if (touchPoint->state() == Qt::TouchPointReleased) {
++        // touch has ended before recognition concluded
++        ddaDebug("Touch has ended before recognition concluded");
++        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++        emitSignalIfTapped();
++        setStatus(WaitingForTouch);
++        return;
++    }
++
++    m_previousDampedScenePos.setX(m_dampedScenePos.x());
++    m_previousDampedScenePos.setY(m_dampedScenePos.y());
++    m_dampedScenePos.update(touchScenePos);
++    updateVelocityCalculator(touchScenePos);
++
++    if (!pointInsideAllowedArea()) {
++        ddaDebug("Rejecting gesture because touch point is outside allowed area.");
++        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++        // We still wanna know when it ends for keeping the composition time window up-to-date
++        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
++        setStatus(WaitingForTouch);
++        return;
++    }
++
++    if (!movingInRightDirection()) {
++        ddaDebug("Rejecting gesture because touch point is moving in the wrong direction.");
++        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++        // We still wanna know when it ends for keeping the composition time window up-to-date
++        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
++        setStatus(WaitingForTouch);
++        return;
++    }
++
++    setPreviousPos(touchPoint->pos());
++    setPreviousScenePos(touchScenePos);
++
++    if (isWithinTouchCompositionWindow()) {
++        // There's still time for some new touch to appear and ruin our party as it would be combined
++        // with our m_touchId one and therefore deny the possibility of a single-finger gesture.
++        ddaDebug("Sill within composition window. Let's wait more.");
++        return;
++    }
++
++    if (movedFarEnough(touchScenePos)) {
++        TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
++        setStatus(Recognized);
++    } else {
++        ddaDebug("Didn't move far enough yet. Let's wait more.");
++    }
++}
++
++void DirectionalDragArea::touchEvent(QTouchEvent *event)
++{
++    // TODO: Consider when more than one touch starts in the same event (although it's not possible
++    //       with Mir's android-input). Have to track them all. Consider it a plus/bonus.
++
++    ddaDebug(m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
++
++    if (!isEnabled() || !isVisible()) {
++        QQuickItem::touchEvent(event);
++        return;
++    }
++
++    switch (m_status) {
++        case WaitingForTouch:
++            touchEvent_absent(event);
++            break;
++        case Undecided:
++            touchEvent_undecided(event);
++            break;
++        default: // Recognized:
++            touchEvent_recognized(event);
++            break;
++    }
++
++    m_activeTouches.update(event);
++}
++
++void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)
++{
++    // TODO: accept/reject is for the whole event, not per touch id. See how that affects us.
++
++    if (!event->touchPointStates().testFlag(Qt::TouchPointPressed)) {
++        // Nothing to see here. No touch starting in this event.
++        return;
++    }
++
++    // to be proven wrong, if that's the case
++    bool allGood = true;
++
++    if (isWithinTouchCompositionWindow()) {
++        // too close to the last touch start. So we consider them as starting roughly at the same time.
++        // Can't be a single-touch gesture.
++        ddaDebug("A new touch point came in but we're still within time composition window. Ignoring it.");
++        allGood = false;
++    }
++
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++
++    const QTouchEvent::TouchPoint *newTouchPoint = nullptr;
++    for (int i = 0; i < touchPoints.count() && allGood; ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            if (newTouchPoint) {
++                // more than one touch starting in this QTouchEvent. Can't be a single-touch gesture
++                allGood = false;
++            } else {
++                // that's our candidate
++                m_touchId = touchPoint.id();
++                newTouchPoint = &touchPoint;
++            }
++        }
++    }
++
++    if (allGood) {
++        Q_ASSERT(newTouchPoint);
++
++        m_startPos = newTouchPoint->pos();
++        m_startScenePos = newTouchPoint->scenePos();
++        m_touchId = newTouchPoint->id();
++        m_dampedScenePos.reset(m_startScenePos);
++        m_velocityCalculator->setTrackedPosition(0.);
++        m_velocityCalculator->reset();
++        m_numSamplesOnLastSpeedCheck = 0;
++        m_silenceTime = 0;
++        setPreviousPos(m_startPos);
++        setPreviousScenePos(m_startScenePos);
++        updateSceneDirectionVector();
++
++        if (recognitionIsDisabled()) {
++            // Behave like a dumb TouchArea
++            ddaDebug("Gesture recognition is disabled. Requesting touch ownership immediately.");
++            TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
++            setStatus(Recognized);
++            event->accept();
++        } else {
++            // just monitor the touch points for now.
++            TouchRegistry::instance()->addCandidateOwnerForTouch(m_touchId, this);
++
++            setStatus(Undecided);
++            // Let the item below have it. We will monitor it and grab it later if a gesture
++            // gets recognized.
++            event->ignore();
++        }
++    } else {
++        watchPressedTouchPoints(touchPoints);
++        event->ignore();
++    }
++}
++
++void DirectionalDragArea::touchEvent_undecided(QTouchEvent *event)
++{
++    Q_ASSERT(event->type() == QEvent::TouchBegin);
++    Q_ASSERT(fetchTargetTouchPoint(event) == nullptr);
++
++    // We're not interested in new touch points. We already have our candidate (m_touchId).
++    // But we do want to know when those new touches end for keeping the composition time
++    // window up-to-date
++    event->ignore();
++    watchPressedTouchPoints(event->touchPoints());
++
++    if (event->touchPointStates().testFlag(Qt::TouchPointPressed) && isWithinTouchCompositionWindow()) {
++        // multi-finger drags are not accepted
++        ddaDebug("Multi-finger drags are not accepted");
++
++        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++        // We still wanna know when it ends for keeping the composition time window up-to-date
++        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
++
++        setStatus(WaitingForTouch);
++    }
++}
++
++void DirectionalDragArea::touchEvent_recognized(QTouchEvent *event)
++{
++    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
++
++    if (!touchPoint) {
++        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << m_touchId
++            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
++               "Considering it as released.";
++        setStatus(WaitingForTouch);
++    } else {
++        setPreviousPos(touchPoint->pos());
++        setPreviousScenePos(touchPoint->scenePos());
++
++        if (touchPoint->state() == Qt::TouchPointReleased) {
++            emitSignalIfTapped();
++            setStatus(WaitingForTouch);
++        }
++    }
++}
++
++void DirectionalDragArea::watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints)
++{
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            TouchRegistry::instance()->addTouchWatcher(touchPoint.id(), this);
++        }
++    }
++}
++
++bool DirectionalDragArea::recognitionIsDisabled() const
++{
++    return distanceThreshold() <= 0 && compositionTime() <= 0;
++}
++
++void DirectionalDragArea::emitSignalIfTapped()
++{
++    qint64 touchDuration = m_timeSource->msecsSinceReference() - m_activeTouches.touchStartTime(m_touchId);
++    if (touchDuration <= maxTapDuration()) {
++        Q_EMIT tapped();
++    }
++}
++
++const QTouchEvent::TouchPoint *DirectionalDragArea::fetchTargetTouchPoint(QTouchEvent *event)
++{
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++    const QTouchEvent::TouchPoint *touchPoint = 0;
++    for (int i = 0; i < touchPoints.size(); ++i) {
++        if (touchPoints.at(i).id() == m_touchId) {
++            touchPoint = &touchPoints.at(i);
++            break;
++        }
++    }
++    return touchPoint;
++}
++
++bool DirectionalDragArea::pointInsideAllowedArea() const
++{
++    // NB: Using squared values to avoid computing the square root to find
++    // the length totalMovement
++
++    QPointF totalMovement(m_dampedScenePos.x() - m_startScenePos.x(),
++                          m_dampedScenePos.y() - m_startScenePos.y());
++
++    qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
++                                totalMovement.y() * totalMovement.y();
++
++    if (squaredTotalMovSize == 0.) {
++        // didn't move
++        return true;
++    }
++
++    qreal projectedMovement = projectOntoDirectionVector(totalMovement);
++
++
++    qreal cosineAngleSquared = (projectedMovement * projectedMovement) / squaredTotalMovSize;
++
++    // Same as:
++    // angle_between_movement_vector_and_gesture_direction_vector <= widening_angle
++    return cosineAngleSquared >= m_wideningFactor;
++}
++
++bool DirectionalDragArea::movingInRightDirection() const
++{
++    if (m_direction == Direction::Horizontal) {
++        return true;
++    } else {
++        QPointF movementVector(m_dampedScenePos.x() - m_previousDampedScenePos.x(),
++                               m_dampedScenePos.y() - m_previousDampedScenePos.y());
++
++        qreal scalarProjection = projectOntoDirectionVector(movementVector);
++
++        return scalarProjection >= 0.;
++    }
++}
++
++bool DirectionalDragArea::movedFarEnough(const QPointF &point) const
++{
++    if (m_distanceThreshold <= 0.) {
++        // distance threshold check is disabled
++        return true;
++    } else {
++        QPointF totalMovement(point.x() - m_startScenePos.x(),
++                              point.y() - m_startScenePos.y());
++
++        qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
++                                    totalMovement.y() * totalMovement.y();
++
++        return squaredTotalMovSize > m_distanceThresholdSquared;
++    }
++}
++
++void DirectionalDragArea::checkSpeed()
++{
++    Q_ASSERT(m_status == Undecided);
++
++    if (m_velocityCalculator->numSamples() >= AxisVelocityCalculator::MIN_SAMPLES_NEEDED) {
++        qreal speed = qFabs(m_velocityCalculator->calculate());
++        qreal minSpeedMsecs = m_minSpeed / 1000.0;
++
++        if (speed < minSpeedMsecs) {
++            ddaDebug("Rejecting gesture because it's below minimum speed.");
++            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
++            setStatus(WaitingForTouch);
++        }
++    }
++
++    if (m_velocityCalculator->numSamples() == m_numSamplesOnLastSpeedCheck) {
++        m_silenceTime += m_recognitionTimer->interval();
++
++        if (m_silenceTime > m_maxSilenceTime) {
++            ddaDebug("Rejecting gesture because its silence time has been exceeded.");
++            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
++            setStatus(WaitingForTouch);
++        }
++    } else {
++        m_silenceTime = 0;
++    }
++    m_numSamplesOnLastSpeedCheck = m_velocityCalculator->numSamples();
++}
++
++void DirectionalDragArea::giveUpIfDisabledOrInvisible()
++{
++    if (!isEnabled() || !isVisible()) {
++        if (m_status == Undecided) {
++            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
++            // We still wanna know when it ends for keeping the composition time window up-to-date
++            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
++        }
++
++        if (m_status != WaitingForTouch) {
++            ddaDebug("Resetting status because got disabled or made invisible");
++            setStatus(WaitingForTouch);
++        }
++    }
++}
++
++void DirectionalDragArea::setStatus(DirectionalDragArea::Status newStatus)
++{
++    if (newStatus == m_status)
++        return;
++
++    DirectionalDragArea::Status oldStatus = m_status;
++
++    if (oldStatus == Undecided) {
++        m_recognitionTimer->stop();
++    }
++
++    m_status = newStatus;
++    Q_EMIT statusChanged(m_status);
++
++    ddaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));
++
++    switch (newStatus) {
++        case WaitingForTouch:
++            Q_EMIT draggingChanged(false);
++            break;
++        case Undecided:
++            m_recognitionTimer->start();
++            Q_EMIT draggingChanged(true);
++            break;
++        case Recognized:
++            if (oldStatus == WaitingForTouch)
++                Q_EMIT draggingChanged(true);
++            break;
++        default:
++            // no-op
++            break;
++    }
++}
++
++void DirectionalDragArea::setPreviousPos(const QPointF &point)
++{
++    bool xChanged = m_previousPos.x() != point.x();
++    bool yChanged = m_previousPos.y() != point.y();
++
++    m_previousPos = point;
++
++    if (xChanged) {
++        Q_EMIT touchXChanged(point.x());
++        if (Direction::isHorizontal(m_direction))
++            Q_EMIT distanceChanged(distance());
++    }
++
++    if (yChanged) {
++        Q_EMIT touchYChanged(point.y());
++        if (Direction::isVertical(m_direction))
++            Q_EMIT distanceChanged(distance());
++    }
++}
++
++void DirectionalDragArea::setPreviousScenePos(const QPointF &point)
++{
++    bool xChanged = m_previousScenePos.x() != point.x();
++    bool yChanged = m_previousScenePos.y() != point.y();
++
++    if (!xChanged && !yChanged)
++        return;
++
++    qreal oldSceneDistance = sceneDistance();
++    m_previousScenePos = point;
++    updateSceneDistance();
++
++    if (oldSceneDistance != sceneDistance()) {
++        Q_EMIT sceneDistanceChanged(sceneDistance());
++    }
++
++    if (xChanged) {
++        Q_EMIT touchSceneXChanged(point.x());
++    }
++
++    if (yChanged) {
++        Q_EMIT touchSceneYChanged(point.y());
++    }
++}
++
++void DirectionalDragArea::updateVelocityCalculator(const QPointF &scenePos)
++{
++    QPointF totalSceneMovement = scenePos - m_startScenePos;
++
++    qreal scalarProjection = projectOntoDirectionVector(totalSceneMovement);
++
++    m_velocityCalculator->setTrackedPosition(scalarProjection);
++}
++
++bool DirectionalDragArea::isWithinTouchCompositionWindow()
++{
++    return
++        compositionTime() > 0 &&
++        !m_activeTouches.isEmpty() &&
++        m_timeSource->msecsSinceReference() <=
++            m_activeTouches.mostRecentStartTime() + (qint64)compositionTime();
++}
++
++//**************************  ActiveTouchesInfo **************************
++
++DirectionalDragArea::ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
++    : m_timeSource(timeSource)
++{
++}
++
++void DirectionalDragArea::ActiveTouchesInfo::update(QTouchEvent *event)
++{
++    if (!(event->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))) {
++        // nothing to update
++        #if ACTIVETOUCHESINFO_DEBUG
++        qDebug("[DDA::ActiveTouchesInfo] Nothing to Update");
++        #endif
++        return;
++    }
++
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            addTouchPoint(touchPoint.id());
++        } else if (touchPoint.state() == Qt::TouchPointReleased) {
++            removeTouchPoint(touchPoint.id());
++        }
++    }
++}
++
++#if ACTIVETOUCHESINFO_DEBUG
++QString DirectionalDragArea::ActiveTouchesInfo::toString()
++{
++    QString string = "(";
++
++    {
++        QTextStream stream(&string);
++        m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
++            stream << "(id=" << touchInfo->id << ",startTime=" << touchInfo->startTime << ")";
++            return true;
++        });
++    }
++
++    string.append(")");
++
++    return string;
++}
++#endif // ACTIVETOUCHESINFO_DEBUG
++
++void DirectionalDragArea::ActiveTouchesInfo::addTouchPoint(int touchId)
++{
++    ActiveTouchInfo &activeTouchInfo = m_touchInfoPool.getEmptySlot();
++    activeTouchInfo.id = touchId;
++    activeTouchInfo.startTime = m_timeSource->msecsSinceReference();
++
++    #if ACTIVETOUCHESINFO_DEBUG
++    qDebug() << "[DDA::ActiveTouchesInfo]" << qPrintable(toString());
++    #endif
++}
++
++qint64 DirectionalDragArea::ActiveTouchesInfo::touchStartTime(int touchId)
++{
++    qint64 result = -1;
++
++    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
++        if (touchId == touchInfo->id) {
++            result = touchInfo->startTime;
++            return false;
++        } else {
++            return true;
++        }
++    });
++
++    Q_ASSERT(result != -1);
++    return result;
++}
++
++void DirectionalDragArea::ActiveTouchesInfo::removeTouchPoint(int touchId)
++{
++    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
++        if (touchId == touchInfo->id) {
++            m_touchInfoPool.freeSlot(touchInfo);
++            return false;
++        } else {
++            return true;
++        }
++    });
++
++    #if ACTIVETOUCHESINFO_DEBUG
++    qDebug() << "[DDA::ActiveTouchesInfo]" << qPrintable(toString());
++    #endif
++}
++
++qint64 DirectionalDragArea::ActiveTouchesInfo::mostRecentStartTime()
++{
++    Q_ASSERT(!m_touchInfoPool.isEmpty());
++
++    qint64 highestStartTime = -1;
++
++    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &activeTouchInfo) {
++        if (activeTouchInfo->startTime > highestStartTime) {
++            highestStartTime = activeTouchInfo->startTime;
++        }
++        return true;
++    });
++
++    return highestStartTime;
++}
++
++void DirectionalDragArea::updateSceneDirectionVector()
++{
++    QPointF localOrigin(0., 0.);
++    QPointF localDirection;
++    switch (m_direction) {
++        case Direction::Upwards:
++            localDirection.rx() = 0.;
++            localDirection.ry() = -1.;
++            break;
++        case Direction::Downwards:
++            localDirection.rx() = 0.;
++            localDirection.ry() = 1;
++            break;
++        case Direction::Leftwards:
++            localDirection.rx() = -1.;
++            localDirection.ry() = 0.;
++            break;
++        default: // Direction::Rightwards || Direction.Horizontal
++            localDirection.rx() = 1.;
++            localDirection.ry() = 0.;
++            break;
++    }
++    QPointF sceneOrigin = mapToScene(localOrigin);
++    QPointF sceneDirection = mapToScene(localDirection);
++    m_sceneDirectionVector = sceneDirection - sceneOrigin;
++}
++
++qreal DirectionalDragArea::projectOntoDirectionVector(const QPointF &sceneVector) const
++{
++    // same as dot product as m_sceneDirectionVector is a unit vector
++    return  sceneVector.x() * m_sceneDirectionVector.x() +
++            sceneVector.y() * m_sceneDirectionVector.y();
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,308 @@
++/*
++ * Copyright (C) 2013,2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef DIRECTIONAL_DRAG_AREA_H
++#define DIRECTIONAL_DRAG_AREA_H
++
++#include <QtQuick/QQuickItem>
++#include "AxisVelocityCalculator.h"
++#include "UbuntuGesturesQmlGlobal.h"
++#include "Damper.h"
++#include "Direction.h"
++
++// lib UbuntuGestures
++#include <Pool.h>
++#include <Timer.h>
++
++class TouchOwnershipEvent;
++class UnownedTouchEvent;
++
++/*
++ An area that detects axis-aligned single-finger drag gestures
++
++ If a drag deviates too much from the components' direction recognition will
++ fail. It will also fail if the drag or flick is too short. E.g. a noisy or
++ fidgety click
++
++ See doc/DirectionalDragArea.svg
++ */
++class UBUNTUGESTURESQML_EXPORT DirectionalDragArea : public QQuickItem {
++    Q_OBJECT
++
++    // The direction in which the gesture should move in order to be recognized.
++    Q_PROPERTY(Direction::Type direction READ direction WRITE setDirection NOTIFY directionChanged)
++
++    // The distance travelled by the finger along the axis specified by
++    // DirectionalDragArea's direction.
++    Q_PROPERTY(qreal distance READ distance NOTIFY distanceChanged)
++
++    // The distance travelled by the finger along the axis specified by
++    // DirectionalDragArea's direction in scene coordinates
++    Q_PROPERTY(qreal sceneDistance READ sceneDistance NOTIFY sceneDistanceChanged)
++
++    // Position of the touch point performing the drag relative to this item.
++    Q_PROPERTY(qreal touchX READ touchX NOTIFY touchXChanged)
++    Q_PROPERTY(qreal touchY READ touchY NOTIFY touchYChanged)
++
++    // Position of the touch point performing the drag, in scene's coordinate system
++    Q_PROPERTY(qreal touchSceneX READ touchSceneX NOTIFY touchSceneXChanged)
++    Q_PROPERTY(qreal touchSceneY READ touchSceneY NOTIFY touchSceneYChanged)
++
++    // The current status of the directional drag gesture area.
++    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
++
++    // Whether a drag gesture is taking place
++    // This will be true as long as status is Undecided or Recognized
++    // When a gesture gets rejected, dragging turns to false.
++    Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
++
++    /////
++    // stuff that will be set in stone at some point
++
++    // How far the touch point can move away from its expected position before
++    // it causes a rejection in the gesture recognition. This is to compensate
++    // for both noise in the touch input signal and for the natural irregularities
++    // in the finger movement.
++    // Proper value is likely device-specific.
++    Q_PROPERTY(qreal maxDeviation READ maxDeviation WRITE setMaxDeviation NOTIFY maxDeviationChanged)
++
++    // Widening angle, in degrees
++    // It's roughly the maximum angle a touch point can make relative to the
++    // axis defined by the compoment's direction for it to be recognized as a
++    // directional drag.
++    Q_PROPERTY(qreal wideningAngle READ wideningAngle WRITE setWideningAngle
++               NOTIFY wideningAngleChanged)
++
++    // How far a touch point has to move from its initial position in order for
++    // it to be recognized as a directional drag.
++    Q_PROPERTY(qreal distanceThreshold READ distanceThreshold WRITE setDistanceThreshold
++               NOTIFY distanceThresholdChanged)
++
++    // Minimum speed a gesture needs to have in order to be recognized as a
++    // directional drag.
++    // In pixels per second
++    Q_PROPERTY(qreal minSpeed READ minSpeed WRITE setMinSpeed NOTIFY minSpeedChanged)
++
++    // A gesture will be rejected if more than maxSilenceTime milliseconds has
++    // passed since we last got an input event from it (during Undecided state).
++    //
++    // Silence (i.e., lack of new input events) doesn't necessarily mean that the user's
++    // finger is still (zero drag speed). In some cases the finger might be moving but
++    // the driver's high noise filtering might cause those silence periods, specially
++    // in the moments succeeding a press (talking about Galaxy Nexus here).
++    Q_PROPERTY(int maxSilenceTime READ maxSilenceTime
++                                  WRITE setMaxSilenceTime
++                                  NOTIFY maxSilenceTimeChanged)
++
++    //
++    /////
++
++    // Maximum time (in milliseconds) after the start of a given touch point where
++    // subsequent touch starts are grouped with the first one into an N-touches gesture
++    // (e.g. a two-fingers tap or drag).
++    Q_PROPERTY(int compositionTime READ compositionTime
++                                   WRITE setCompositionTime
++                                   NOTIFY compositionTimeChanged)
++
++    Q_ENUMS(Direction)
++    Q_ENUMS(Status)
++public:
++    DirectionalDragArea(QQuickItem *parent = 0);
++
++    Direction::Type direction() const;
++    void setDirection(Direction::Type);
++
++    // Describes the state of the directional drag gesture.
++    enum Status {
++        // Waiting for a new touch point to land on this area. No gesture is being processed
++        // or tracked.
++        WaitingForTouch,
++
++        // A touch point has landed on this area but it's not know yet whether it is
++        // performing a drag in the correct direction.
++        // If it's decided that the touch point is not performing a directional drag gesture,
++        // it will be rejected/ignored and status will return to WaitingForTouch.
++        Undecided, //Recognizing,
++
++        // There's a touch point in this area and it performed a drag in the correct
++        // direction.
++        //
++        // Once recognized, the gesture state will move back to WaitingForTouch only once
++        // that touch point ends. The gesture will remain in the Recognized state even if
++        // the touch point starts moving in other directions or halts.
++        Recognized,
++    };
++    Status status() const { return m_status; }
++
++    qreal distance() const;
++    qreal sceneDistance() const;
++    void updateSceneDistance();
++
++    qreal touchX() const;
++    qreal touchY() const;
++
++    qreal touchSceneX() const;
++    qreal touchSceneY() const;
++
++    bool dragging() const { return (m_status == Undecided) || (m_status == Recognized); }
++
++    qreal maxDeviation() const { return m_dampedScenePos.maxDelta(); }
++    void setMaxDeviation(qreal value);
++
++    qreal wideningAngle() const;
++    void setWideningAngle(qreal value);
++
++    qreal distanceThreshold() const { return m_distanceThreshold; }
++    void setDistanceThreshold(qreal value);
++
++    qreal minSpeed() const { return m_minSpeed; }
++    void setMinSpeed(qreal value);
++
++    int maxSilenceTime() const { return m_maxSilenceTime; }
++    void setMaxSilenceTime(int value);
++
++    int compositionTime() const { return m_compositionTime; }
++    void setCompositionTime(int value);
++
++    // Replaces the existing Timer with the given one.
++    //
++    // Useful for providing a fake timer when testing.
++    void setRecognitionTimer(UbuntuGestures::AbstractTimer *timer);
++
++    // Useful for testing, where a fake time source can be supplied
++    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
++
++    bool event(QEvent *e) override;
++
++    // Maximum time, in milliseconds, between a press and a release, for a touch
++    // sequence to be considered a tap.
++    int maxTapDuration() const { return 300; }
++
++Q_SIGNALS:
++    void directionChanged(Direction::Type direction);
++    void statusChanged(Status value);
++    void draggingChanged(bool value);
++    void distanceChanged(qreal value);
++    void sceneDistanceChanged(qreal value);
++    void maxDeviationChanged(qreal value);
++    void wideningAngleChanged(qreal value);
++    void distanceThresholdChanged(qreal value);
++    void minSpeedChanged(qreal value);
++    void maxSilenceTimeChanged(int value);
++    void compositionTimeChanged(int value);
++    void touchXChanged(qreal value);
++    void touchYChanged(qreal value);
++    void touchSceneXChanged(qreal value);
++    void touchSceneYChanged(qreal value);
++
++    // TODO: I would rather not have such signal as it has nothing to do with drag gestures.
++    // Remove when no longer used or move its implementation to the QML code that uses it
++    // See maxTapDuration()
++    void tapped();
++
++protected:
++    virtual void touchEvent(QTouchEvent *event);
++
++private Q_SLOTS:
++    void checkSpeed();
++    void giveUpIfDisabledOrInvisible();
++
++private:
++    void touchEvent_absent(QTouchEvent *event);
++    void touchEvent_undecided(QTouchEvent *event);
++    void touchEvent_recognized(QTouchEvent *event);
++    bool pointInsideAllowedArea() const;
++    bool movingInRightDirection() const;
++    bool movedFarEnough(const QPointF &point) const;
++    const QTouchEvent::TouchPoint *fetchTargetTouchPoint(QTouchEvent *event);
++    void setStatus(Status newStatus);
++    void setPreviousPos(const QPointF &point);
++    void setPreviousScenePos(const QPointF &point);
++    void updateVelocityCalculator(const QPointF &point);
++    bool isWithinTouchCompositionWindow();
++    void updateSceneDirectionVector();
++    // returns the scalar projection between the given vector (in scene coordinates)
++    // and m_sceneDirectionVector
++    qreal projectOntoDirectionVector(const QPointF &sceneVector) const;
++    void touchOwnershipEvent(TouchOwnershipEvent *event);
++    void unownedTouchEvent(UnownedTouchEvent *event);
++    void unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent);
++    void watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints);
++    bool recognitionIsDisabled() const;
++    void emitSignalIfTapped();
++
++    Status m_status;
++
++    QPointF m_startPos;
++    QPointF m_startScenePos;
++    QPointF m_previousPos;
++    QPointF m_previousScenePos;
++    qreal m_sceneDistance;
++    int m_touchId;
++
++    // A movement damper is used in some of the gesture recognition calculations
++    // to get rid of noise or small oscillations in the touch position.
++    DampedPointF m_dampedScenePos;
++    QPointF m_previousDampedScenePos;
++
++    // Unit vector in scene coordinates describing the direction of the gesture recognition
++    QPointF m_sceneDirectionVector;
++
++    Direction::Type m_direction;
++    qreal m_wideningAngle; // in degrees
++    qreal m_wideningFactor; // it's pow(cosine(m_wideningAngle), 2)
++    qreal m_distanceThreshold;
++    qreal m_distanceThresholdSquared; // it's pow(m_distanceThreshold, 2)
++    qreal m_minSpeed;
++    int m_maxSilenceTime; // in milliseconds
++    int m_silenceTime; // in milliseconds
++    int m_compositionTime; // in milliseconds
++    int m_numSamplesOnLastSpeedCheck;
++    UbuntuGestures::AbstractTimer *m_recognitionTimer;
++    AxisVelocityCalculator *m_velocityCalculator;
++
++    UbuntuGestures::SharedTimeSource m_timeSource;
++
++    // Information about an active touch point
++    struct ActiveTouchInfo {
++        ActiveTouchInfo() : id(-1), startTime(-1) {}
++        bool isValid() const { return id != -1; }
++        void reset() { id = -1; }
++        int id;
++        qint64 startTime;
++    };
++    class ActiveTouchesInfo {
++    public:
++        ActiveTouchesInfo(const UbuntuGestures::SharedTimeSource &timeSource);
++        void update(QTouchEvent *event);
++        qint64 touchStartTime(int id);
++        bool isEmpty() const { return m_touchInfoPool.isEmpty(); }
++        qint64 mostRecentStartTime();
++        UbuntuGestures::SharedTimeSource m_timeSource;
++    private:
++        void addTouchPoint(int touchId);
++        void removeTouchPoint(int touchId);
++        #if ACTIVETOUCHESINFO_DEBUG
++        QString toString();
++        #endif
++
++        Pool<ActiveTouchInfo> m_touchInfoPool;
++    } m_activeTouches;
++
++    friend class tst_DirectionalDragArea;
++};
++
++#endif // DIRECTIONAL_DRAG_AREA_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/Gestures.qmltypes'
 --- src/app/unity8/plugins/Ubuntu/Gestures/Gestures.qmltypes	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/Gestures.qmltypes	2015-03-20 16:26:56 +0000
@@ -0,0 +1,168 @@
++import QtQuick.tooling 1.1
++
++// This file describes the plugin-supplied types contained in the library.
++// It is used for QML tooling purposes only.
++//
++// This file was auto-generated by:
++// 'qmlplugindump -notrelocatable Ubuntu.Gestures 0.1 plugins'
++
++Module {
++    Component {
++        name: "AxisVelocityCalculator"
++        prototype: "QObject"
++        exports: ["Ubuntu.Gestures/AxisVelocityCalculator 0.1"]
++        exportMetaObjectRevisions: [0]
++        Property { name: "trackedPosition"; type: "double" }
++        Signal {
++            name: "trackedPositionChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Method { name: "calculate"; type: "double" }
++        Method { name: "reset" }
++    }
++    Component {
++        name: "Direction"
++        prototype: "QObject"
++        exports: ["Ubuntu.Gestures/Direction 0.1"]
++        isCreatable: false
++        isSingleton: true
++        exportMetaObjectRevisions: [0]
++        Enum {
++            name: "Type"
++            values: {
++                "Rightwards": 0,
++                "Leftwards": 1,
++                "Downwards": 2,
++                "Upwards": 3,
++                "Horizontal": 4
++            }
++        }
++        Method {
++            name: "isHorizontal"
++            type: "bool"
++            Parameter { name: "type"; type: "Direction::Type" }
++        }
++        Method {
++            name: "isVertical"
++            type: "bool"
++            Parameter { name: "type"; type: "Direction::Type" }
++        }
++        Method {
++            name: "isPositive"
++            type: "bool"
++            Parameter { name: "type"; type: "Direction::Type" }
++        }
++    }
++    Component {
++        name: "DirectionalDragArea"
++        defaultProperty: "data"
++        prototype: "QQuickItem"
++        exports: ["Ubuntu.Gestures/DirectionalDragArea 0.1"]
++        exportMetaObjectRevisions: [0]
++        Enum {
++            name: "Status"
++            values: {
++                "WaitingForTouch": 0,
++                "Undecided": 1,
++                "Recognized": 2
++            }
++        }
++        Property { name: "direction"; type: "Direction::Type" }
++        Property { name: "distance"; type: "double"; isReadonly: true }
++        Property { name: "sceneDistance"; type: "double"; isReadonly: true }
++        Property { name: "touchX"; type: "double"; isReadonly: true }
++        Property { name: "touchY"; type: "double"; isReadonly: true }
++        Property { name: "touchSceneX"; type: "double"; isReadonly: true }
++        Property { name: "touchSceneY"; type: "double"; isReadonly: true }
++        Property { name: "status"; type: "Status"; isReadonly: true }
++        Property { name: "dragging"; type: "bool"; isReadonly: true }
++        Property { name: "maxDeviation"; type: "double" }
++        Property { name: "wideningAngle"; type: "double" }
++        Property { name: "distanceThreshold"; type: "double" }
++        Property { name: "minSpeed"; type: "double" }
++        Property { name: "maxSilenceTime"; type: "int" }
++        Property { name: "compositionTime"; type: "int" }
++        Signal {
++            name: "directionChanged"
++            Parameter { name: "direction"; type: "Direction::Type" }
++        }
++        Signal {
++            name: "statusChanged"
++            Parameter { name: "value"; type: "Status" }
++        }
++        Signal {
++            name: "draggingChanged"
++            Parameter { name: "value"; type: "bool" }
++        }
++        Signal {
++            name: "distanceChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "sceneDistanceChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "maxDeviationChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "wideningAngleChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "distanceThresholdChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "minSpeedChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "maxSilenceTimeChanged"
++            Parameter { name: "value"; type: "int" }
++        }
++        Signal {
++            name: "compositionTimeChanged"
++            Parameter { name: "value"; type: "int" }
++        }
++        Signal {
++            name: "touchXChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "touchYChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "touchSceneXChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal {
++            name: "touchSceneYChanged"
++            Parameter { name: "value"; type: "double" }
++        }
++        Signal { name: "tapped" }
++    }
++    Component {
++        name: "PressedOutsideNotifier"
++        defaultProperty: "data"
++        prototype: "QQuickItem"
++        exports: ["Ubuntu.Gestures/PressedOutsideNotifier 0.1"]
++        exportMetaObjectRevisions: [0]
++        Signal { name: "pressedOutside" }
++    }
++    Component {
++        name: "TouchGate"
++        defaultProperty: "data"
++        prototype: "QQuickItem"
++        exports: ["Ubuntu.Gestures/TouchGate 0.1"]
++        exportMetaObjectRevisions: [0]
++        Property { name: "targetItem"; type: "QQuickItem"; isPointer: true }
++        Signal {
++            name: "targetItemChanged"
++            Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
++        }
++        Signal { name: "pressed" }
++    }
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,119 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "PressedOutsideNotifier.h"
++
++#include <QMouseEvent>
++
++PressedOutsideNotifier::PressedOutsideNotifier(QQuickItem *parent)
++    : QQuickItem(parent)
++{
++    connect(this, &QQuickItem::enabledChanged,
++            this, &PressedOutsideNotifier::setupOrTearDownEventFiltering);
++
++    m_signalEmissionTimer.setSingleShot(true);
++    m_signalEmissionTimer.setInterval(0); // times out on the next iteration of the event loop
++    connect(&m_signalEmissionTimer, &QTimer::timeout,
++            this, &PressedOutsideNotifier::pressedOutside);
++}
++
++bool PressedOutsideNotifier::eventFilter(QObject *watched, QEvent *event)
++{
++    Q_UNUSED(watched);
++    Q_ASSERT(watched == m_filteredWindow);
++
++    // We are already going to emit pressedOutside() anyway, thus no need
++    // for new checks.
++    // This case takes place when a QTouchEvent comes in and isn't handled by any item,
++    // causing QQuickWindow to synthesize a QMouseEvent out of it, which would
++    // be filtered by us as well and count as a second press, which is wrong.
++    if (m_signalEmissionTimer.isActive()) {
++        return false;
++    }
++
++    switch (event->type()) {
++    case QEvent::MouseButtonPress: {
++        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
++        QPointF p = mapFromScene(mouseEvent->windowPos());
++        if (!contains(p)) {
++            m_signalEmissionTimer.start();
++        }
++        break;
++    }
++    case QEvent::TouchBegin:
++        processFilteredTouchBegin(static_cast<QTouchEvent*>(event));
++    default:
++        break;
++    }
++
++    // let the event be handled further
++    return false;
++}
++
++void PressedOutsideNotifier::itemChange(ItemChange change, const ItemChangeData &value)
++{
++    if (change == QQuickItem::ItemSceneChange) {
++        setupOrTearDownEventFiltering();
++    }
++
++    QQuickItem::itemChange(change, value);
++}
++
++void PressedOutsideNotifier::setupOrTearDownEventFiltering()
++{
++    if (isEnabled() && window()) {
++        setupEventFiltering();
++    } else if (m_filteredWindow) {
++        tearDownEventFiltering();
++    }
++}
++
++void PressedOutsideNotifier::setupEventFiltering()
++{
++    QQuickWindow *currentWindow = window();
++    Q_ASSERT(currentWindow != nullptr);
++
++    if (currentWindow == m_filteredWindow)
++        return;
++
++    if (m_filteredWindow) {
++        m_filteredWindow->removeEventFilter(this);
++    }
++
++    currentWindow->installEventFilter(this);
++    m_filteredWindow = currentWindow;
++}
++
++void PressedOutsideNotifier::tearDownEventFiltering()
++{
++    m_filteredWindow->removeEventFilter(this);
++    m_filteredWindow.clear();
++}
++
++void PressedOutsideNotifier::processFilteredTouchBegin(QTouchEvent *event)
++{
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            QPointF p = mapFromScene(touchPoint.pos());
++            if (!contains(p)) {
++                m_signalEmissionTimer.start();
++                return;
++            }
++        }
++    }
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,62 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef PRESSED_OUTSIDE_NOTIFIER_H
++#define PRESSED_OUTSIDE_NOTIFIER_H
++
++#include <QQuickItem>
++
++#include <QQuickWindow>
++#include <QPointer>
++#include <QTimer>
++
++#include "UbuntuGesturesGlobal.h"
++
++/*
++   Notifies when a point, mouse or touch, is pressed outside its area.
++
++   Only enable it while needed.
++ */
++class UBUNTUGESTURES_EXPORT PressedOutsideNotifier : public QQuickItem {
++    Q_OBJECT
++
++public:
++    PressedOutsideNotifier(QQuickItem * parent = nullptr);
++
++    // From QObject
++    bool eventFilter(QObject *watched, QEvent *event) override;
++
++Q_SIGNALS:
++    void pressedOutside();
++
++protected:
++    void itemChange(ItemChange change, const ItemChangeData &value) override;
++
++private Q_SLOTS:
++    void setupOrTearDownEventFiltering();
++
++private:
++    void setupEventFiltering();
++    void tearDownEventFiltering();
++    void processFilteredTouchBegin(QTouchEvent *event);
++
++    QPointer<QQuickWindow> m_filteredWindow;
++
++    // Emits pressedOutside() signal on timeout
++    QTimer m_signalEmissionTimer;
++};
++
++#endif // PRESSED_OUTSIDE_NOTIFIER_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,49 @@
++/*
++ * 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();
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/TimeSource.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,54 @@
++/*
++ * 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>
++ */
++
++#ifndef UBUNTUGESTURES_TIMESOURCE_H
++#define UBUNTUGESTURES_TIMESOURCE_H
++
++#include "UbuntuGesturesQmlGlobal.h"
++#include <QSharedPointer>
++
++namespace UbuntuGestures {
++/*
++    Interface for a time source.
++ */
++class UBUNTUGESTURESQML_EXPORT TimeSource {
++public:
++    virtual ~TimeSource() {}
++    /* Returns the current time in milliseconds since some reference time in the past. */
++    virtual qint64 msecsSinceReference() = 0;
++};
++typedef QSharedPointer<TimeSource> SharedTimeSource;
++
++/*
++    Implementation of a time source
++ */
++class RealTimeSourcePrivate;
++class RealTimeSource : public TimeSource {
++public:
++    RealTimeSource();
++    virtual ~RealTimeSource();
++    qint64 msecsSinceReference() override;
++private:
++    RealTimeSourcePrivate *d;
++};
++
++} // namespace UbuntuGestures
++
++#endif // UBUNTUGESTURES_TIMESOURCE_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,367 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "TouchDispatcher.h"
++
++#include <QGuiApplication>
++#include <QScopedPointer>
++#include <QStyleHints>
++
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-pedantic"
++#include <private/qquickitem_p.h>
++#pragma GCC diagnostic pop
++
++#define TOUCHDISPATCHER_DEBUG 0
++
++#if TOUCHDISPATCHER_DEBUG
++#include <DebugHelpers.h>
++#endif
++
++TouchDispatcher::TouchDispatcher()
++    : m_status(NoActiveTouch)
++    , m_touchMouseId(-1)
++    , m_touchMousePressTimestamp(0)
++{
++}
++
++void TouchDispatcher::setTargetItem(QQuickItem *target)
++{
++    if (target != m_targetItem) {
++        m_targetItem = target;
++        if (m_status != NoActiveTouch) {
++            qWarning("[TouchDispatcher] Changing target item in the middle of a touch stream");
++            m_status = TargetRejectedTouches;
++        }
++    }
++}
++
++void TouchDispatcher::dispatch(QEvent::Type eventType,
++                               QTouchDevice *device,
++                               Qt::KeyboardModifiers modifiers,
++                               const QList<QTouchEvent::TouchPoint> &touchPoints,
++                               QWindow *window,
++                               ulong timestamp)
++{
++    if (m_targetItem.isNull()) {
++        qWarning("[TouchDispatcher] Cannot dispatch touch event because target item is null");
++        return;
++    }
++
++    if (eventType == QEvent::TouchBegin) {
++        dispatchTouchBegin(device, modifiers, touchPoints, window, timestamp);
++
++    } else if (eventType == QEvent::TouchUpdate || eventType == QEvent::TouchEnd) {
++
++        if (m_status == DeliveringTouchEvents) {
++            dispatchAsTouch(eventType, device, modifiers, touchPoints, window, timestamp);
++        } else if (m_status == DeliveringMouseEvents) {
++            dispatchAsMouse(device, modifiers, touchPoints, timestamp);
++        } else {
++            Q_ASSERT(m_status == TargetRejectedTouches);
++            #if TOUCHDISPATCHER_DEBUG
++            qDebug() << "[TouchDispatcher] Not dispatching touch event to" << m_targetItem.data()
++                << "because it already rejected the touch stream.";
++            #endif
++            // Do nothing
++        }
++
++        if (eventType == QEvent::TouchEnd) {
++            m_status = NoActiveTouch;
++            m_touchMouseId = -1;
++        }
++
++    } else {
++        // Should never happen
++        qCritical() << "[TouchDispatcher] Unexpected event type" << eventType;
++        Q_ASSERT(false);
++        return;
++    }
++}
++
++void TouchDispatcher::dispatchTouchBegin(
++            QTouchDevice *device,
++            Qt::KeyboardModifiers modifiers,
++            const QList<QTouchEvent::TouchPoint> &touchPoints,
++            QWindow *window,
++            ulong timestamp)
++{
++    Q_ASSERT(m_status == NoActiveTouch);
++    QQuickItem *targetItem = m_targetItem.data();
++
++    if (!targetItem->isEnabled() || !targetItem->isVisible()) {
++        #if TOUCHDISPATCHER_DEBUG
++        qDebug() << "[TouchDispatcher] Cannot dispatch touch event to" << targetItem
++            << "because it's disabled or invisible.";
++        #endif
++        return;
++    }
++
++    // Map touch points to targetItem coordinates
++    QList<QTouchEvent::TouchPoint> targetTouchPoints = touchPoints;
++    transformTouchPoints(targetTouchPoints, QQuickItemPrivate::get(targetItem)->windowToItemTransform());
++
++    QScopedPointer<QTouchEvent> touchEvent(
++            createQTouchEvent(QEvent::TouchBegin, device, modifiers, targetTouchPoints, window, timestamp));
++
++
++    #if TOUCHDISPATCHER_DEBUG
++    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(touchEvent.data()))
++            << "to" << targetItem;
++    #endif
++    QCoreApplication::sendEvent(targetItem, touchEvent.data());
++
++
++    if (touchEvent->isAccepted()) {
++        #if TOUCHDISPATCHER_DEBUG
++        qDebug() << "[TouchDispatcher] Item accepted the touch event.";
++        #endif
++        m_status = DeliveringTouchEvents;
++    } else if (targetItem->acceptedMouseButtons() & Qt::LeftButton) {
++        #if TOUCHDISPATCHER_DEBUG
++        qDebug() << "[TouchDispatcher] Item rejected the touch event. Trying a QMouseEvent";
++        #endif
++        // NB: Arbitrarily chose the first touch point to emulate the mouse pointer
++        QScopedPointer<QMouseEvent> mouseEvent(
++                touchToMouseEvent(QEvent::MouseButtonPress, targetTouchPoints.at(0), timestamp,
++                                  modifiers, false /* transformNeeded */));
++        Q_ASSERT(targetTouchPoints.at(0).state() == Qt::TouchPointPressed);
++
++        #if TOUCHDISPATCHER_DEBUG
++        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
++                << "to" << m_targetItem.data();
++        #endif
++        QCoreApplication::sendEvent(targetItem, mouseEvent.data());
++        if (mouseEvent->isAccepted()) {
++            #if TOUCHDISPATCHER_DEBUG
++            qDebug() << "[TouchDispatcher] Item accepted the QMouseEvent.";
++            #endif
++            m_status = DeliveringMouseEvents;
++            m_touchMouseId = targetTouchPoints.at(0).id();
++
++            if (checkIfDoubleClicked(timestamp)) {
++                QScopedPointer<QMouseEvent> doubleClickEvent(
++                        touchToMouseEvent(QEvent::MouseButtonDblClick, targetTouchPoints.at(0), timestamp,
++                                          modifiers, false /* transformNeeded */));
++                #if TOUCHDISPATCHER_DEBUG
++                qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(doubleClickEvent.data()))
++                        << "to" << m_targetItem.data();
++                #endif
++                QCoreApplication::sendEvent(targetItem, doubleClickEvent.data());
++            }
++
++        } else {
++            #if TOUCHDISPATCHER_DEBUG
++            qDebug() << "[TouchDispatcher] Item rejected the QMouseEvent.";
++            #endif
++            m_status = TargetRejectedTouches;
++        }
++    } else {
++        #if TOUCHDISPATCHER_DEBUG
++        qDebug() << "[TouchDispatcher] Item rejected the touch event and does not accept mouse buttons.";
++        #endif
++        m_status = TargetRejectedTouches;
++    }
++}
++
++void TouchDispatcher::dispatchAsTouch(QEvent::Type eventType,
++        QTouchDevice *device,
++        Qt::KeyboardModifiers modifiers,
++        const QList<QTouchEvent::TouchPoint> &touchPoints,
++        QWindow *window,
++        ulong timestamp)
++{
++    QQuickItem *targetItem = m_targetItem.data();
++
++    // Map touch points to targetItem coordinates
++    QList<QTouchEvent::TouchPoint> targetTouchPoints = touchPoints;
++    transformTouchPoints(targetTouchPoints, QQuickItemPrivate::get(targetItem)->windowToItemTransform());
++
++    QScopedPointer<QTouchEvent> eventForTargetItem(
++            createQTouchEvent(eventType, device, modifiers, targetTouchPoints, window, timestamp));
++
++
++    #if TOUCHDISPATCHER_DEBUG
++    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(eventForTargetItem.data()))
++            << "to" << targetItem;
++    #endif
++    QCoreApplication::sendEvent(targetItem, eventForTargetItem.data());
++}
++
++void TouchDispatcher::dispatchAsMouse(
++        QTouchDevice * /*device*/,
++        Qt::KeyboardModifiers modifiers,
++        const QList<QTouchEvent::TouchPoint> &touchPoints,
++        ulong timestamp)
++{
++    // TODO: Detect double clicks in order to synthesize QEvent::MouseButtonDblClick events accordingly
++
++    Q_ASSERT(!touchPoints.isEmpty());
++
++    const QTouchEvent::TouchPoint *touchMouse = nullptr;
++
++    if (m_touchMouseId != -1) {
++        for (int i = 0; i < touchPoints.count() && !touchMouse; ++i) {
++            const auto &touchPoint = touchPoints.at(i);
++            if (touchPoint.id() == m_touchMouseId) {
++                touchMouse = &touchPoint;
++            }
++        }
++
++        Q_ASSERT(touchMouse);
++        if (!touchMouse) {
++            // should not happen, but deal with it just in case.
++            qWarning("[TouchDispatcher] Didn't find touch with id %d, used for mouse pointer emulation.",
++                    m_touchMouseId);
++            m_touchMouseId = touchPoints.at(0).id();
++            touchMouse = &touchPoints.at(0);
++        }
++    } else {
++        // Try to find a new touch for mouse emulation
++        for (int i = 0; i < touchPoints.count() && !touchMouse; ++i) {
++            const auto &touchPoint = touchPoints.at(i);
++            if (touchPoint.state() == Qt::TouchPointPressed) {
++                touchMouse = &touchPoint;
++                m_touchMouseId = touchMouse->id();
++            }
++        }
++    }
++
++    if (touchMouse) {
++        QEvent::Type eventType;
++        if (touchMouse->state() == Qt::TouchPointPressed) {
++            eventType = QEvent::MouseButtonPress;
++        } if (touchMouse->state() == Qt::TouchPointReleased) {
++            eventType = QEvent::MouseButtonRelease;
++            m_touchMouseId = -1;
++        } else {
++            eventType = QEvent::MouseMove;
++        }
++
++        QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(eventType, *touchMouse, timestamp, modifiers,
++                    true /* transformNeeded */));
++
++        #if TOUCHDISPATCHER_DEBUG
++        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
++                << "to" << m_targetItem.data();
++        #endif
++        QCoreApplication::sendEvent(m_targetItem.data(), mouseEvent.data());
++    }
++}
++
++QTouchEvent *TouchDispatcher::createQTouchEvent(QEvent::Type eventType,
++        QTouchDevice *device,
++        Qt::KeyboardModifiers modifiers,
++        const QList<QTouchEvent::TouchPoint> &touchPoints,
++        QWindow *window,
++        ulong timestamp)
++{
++    Qt::TouchPointStates eventStates = 0;
++    for (int i = 0; i < touchPoints.count(); i++)
++        eventStates |= touchPoints[i].state();
++    // if all points have the same state, set the event type accordingly
++    switch (eventStates) {
++        case Qt::TouchPointPressed:
++            eventType = QEvent::TouchBegin;
++            break;
++        case Qt::TouchPointReleased:
++            eventType = QEvent::TouchEnd;
++            break;
++        default:
++            eventType = QEvent::TouchUpdate;
++            break;
++    }
++
++    QTouchEvent *touchEvent = new QTouchEvent(eventType);
++    touchEvent->setWindow(window);
++    touchEvent->setTarget(m_targetItem.data());
++    touchEvent->setDevice(device);
++    touchEvent->setModifiers(modifiers);
++    touchEvent->setTouchPoints(touchPoints);
++    touchEvent->setTouchPointStates(eventStates);
++    touchEvent->setTimestamp(timestamp);
++    touchEvent->accept();
++    return touchEvent;
++}
++
++// NB: From QQuickWindow
++void TouchDispatcher::transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform)
++{
++    QMatrix4x4 transformMatrix(transform);
++    for (int i=0; i<touchPoints.count(); i++) {
++        QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
++        touchPoint.setRect(transform.mapRect(touchPoint.sceneRect()));
++        touchPoint.setStartPos(transform.map(touchPoint.startScenePos()));
++        touchPoint.setLastPos(transform.map(touchPoint.lastScenePos()));
++        touchPoint.setVelocity(transformMatrix.mapVector(touchPoint.velocity()).toVector2D());
++    }
++}
++
++// Copied with minor modifications from qtdeclarative/src/quick/items/qquickwindow.cpp
++QMouseEvent *TouchDispatcher::touchToMouseEvent(
++        QEvent::Type type, const QTouchEvent::TouchPoint &p,
++        ulong timestamp, Qt::KeyboardModifiers modifiers,
++        bool transformNeeded)
++{
++    QQuickItem *item = m_targetItem.data();
++
++    // The touch point local position and velocity are not yet transformed.
++    QMouseEvent *me = new QMouseEvent(type, transformNeeded ? item->mapFromScene(p.scenePos()) : p.pos(),
++                                      p.scenePos(), p.screenPos(), Qt::LeftButton,
++                                      (type == QEvent::MouseButtonRelease ? Qt::NoButton : Qt::LeftButton),
++                                      modifiers);
++    me->setAccepted(true);
++    me->setTimestamp(timestamp);
++    QVector2D transformedVelocity = p.velocity();
++    if (transformNeeded) {
++        QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++        QMatrix4x4 transformMatrix(itemPrivate->windowToItemTransform());
++        transformedVelocity = transformMatrix.mapVector(p.velocity()).toVector2D();
++    }
++
++    // Add these later if needed:
++    //QGuiApplicationPrivate::setMouseEventCapsAndVelocity(me, event->device()->capabilities(), transformedVelocity);
++    //QGuiApplicationPrivate::setMouseEventSource(me, Qt::MouseEventSynthesizedByQt);
++    return me;
++}
++
++/*
++    Copied from qquickwindow.cpp which has:
++    Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies)
++    Under GPL 3.0 license.
++*/
++bool TouchDispatcher::checkIfDoubleClicked(ulong newPressEventTimestamp)
++{
++    bool doubleClicked;
++
++    if (m_touchMousePressTimestamp == 0) {
++        // just initialize the variable
++        m_touchMousePressTimestamp = newPressEventTimestamp;
++        doubleClicked = false;
++    } else {
++        ulong timeBetweenPresses = newPressEventTimestamp - m_touchMousePressTimestamp;
++        ulong doubleClickInterval = static_cast<ulong>(qApp->styleHints()->
++                mouseDoubleClickInterval());
++        doubleClicked = timeBetweenPresses < doubleClickInterval;
++        if (doubleClicked) {
++            m_touchMousePressTimestamp = 0;
++        } else {
++            m_touchMousePressTimestamp = newPressEventTimestamp;
++        }
++    }
++
++    return doubleClicked;
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/TouchDispatcher.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,89 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTU_TOUCH_DISPATCHER_H
++#define UBUNTU_TOUCH_DISPATCHER_H
++
++#include "UbuntuGesturesQmlGlobal.h"
++
++#include <QPointer>
++#include <QQuickItem>
++
++/*
++   Dispatches touches to the given target, converting the touch point
++   coordinates accordingly.
++
++   Also takes care of synthesizing mouse events in case the target
++   doesn't work with touch events.
++ */
++class UBUNTUGESTURESQML_EXPORT TouchDispatcher {
++public:
++    TouchDispatcher();
++
++    void setTargetItem(QQuickItem *target);
++    QQuickItem *targetItem() { return m_targetItem; }
++
++    void dispatch(QEvent::Type eventType,
++            QTouchDevice *device,
++            Qt::KeyboardModifiers modifiers,
++            const QList<QTouchEvent::TouchPoint> &touchPoints,
++            QWindow *window,
++            ulong timestamp);
++private:
++    void dispatchTouchBegin(
++            QTouchDevice *device,
++            Qt::KeyboardModifiers modifiers,
++            const QList<QTouchEvent::TouchPoint> &touchPoints,
++            QWindow *window,
++            ulong timestamp);
++    void dispatchAsTouch(QEvent::Type eventType,
++            QTouchDevice *device,
++            Qt::KeyboardModifiers modifiers,
++            const QList<QTouchEvent::TouchPoint> &touchPoints,
++            QWindow *window,
++            ulong timestamp);
++    void dispatchAsMouse(
++            QTouchDevice *device,
++            Qt::KeyboardModifiers modifiers,
++            const QList<QTouchEvent::TouchPoint> &touchPoints,
++            ulong timestamp);
++
++    static void transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform);
++    QTouchEvent *createQTouchEvent(QEvent::Type eventType,
++            QTouchDevice *device,
++            Qt::KeyboardModifiers modifiers,
++            const QList<QTouchEvent::TouchPoint> &touchPoints,
++            QWindow *window,
++            ulong timestamp);
++    QMouseEvent *touchToMouseEvent(QEvent::Type type, const QTouchEvent::TouchPoint &p,
++            ulong timestamp, Qt::KeyboardModifiers modifiers, bool transformNeeded = true);
++
++    bool checkIfDoubleClicked(ulong newPressEventTimestamp);
++
++    QPointer<QQuickItem> m_targetItem;
++
++    enum {
++        NoActiveTouch,
++        DeliveringTouchEvents,
++        DeliveringMouseEvents,
++        TargetRejectedTouches
++    } m_status;
++
++    int m_touchMouseId;
++    ulong m_touchMousePressTimestamp;
++};
++
++#endif // UBUNTU_TOUCH_DISPATCHER_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,253 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "TouchGate.h"
++
++#include <QCoreApplication>
++#include <QDebug>
++
++#include <TouchOwnershipEvent.h>
++#include <TouchRegistry.h>
++
++#if TOUCHGATE_DEBUG
++#include <DebugHelpers.h>
++#endif
++
++bool TouchGate::event(QEvent *e)
++{
++    if (e->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
++        touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(e));
++        return true;
++    } else {
++        return QQuickItem::event(e);
++    }
++}
++
++void TouchGate::touchEvent(QTouchEvent *event)
++{
++    #if TOUCHGATE_DEBUG
++    qDebug() << "[TouchGate] got touch event" << qPrintable(touchEventToString(event));
++    #endif
++    event->accept();
++
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++    bool goodToGo = true;
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
++
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            Q_ASSERT(!m_touchInfoMap.contains(touchPoint.id()));
++            m_touchInfoMap[touchPoint.id()].ownership = OwnershipRequested;
++            m_touchInfoMap[touchPoint.id()].ended = false;
++            TouchRegistry::instance()->requestTouchOwnership(touchPoint.id(), this);
++
++            Q_EMIT pressed();
++        }
++
++        goodToGo &= m_touchInfoMap.contains(touchPoint.id())
++            && m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted;
++
++        if (touchPoint.state() == Qt::TouchPointReleased && m_touchInfoMap.contains(touchPoint.id())) {
++            m_touchInfoMap[touchPoint.id()].ended = true;
++        }
++
++    }
++
++    if (goodToGo) {
++        if (m_storedEvents.isEmpty()) {
++            // let it pass through
++            dispatchTouchEventToTarget(event);
++        } else {
++            // Retain the event to ensure TouchGate dispatches them in order.
++            // Otherwise the current event would come before the stored ones, which are older.
++            #if TOUCHGATE_DEBUG
++            qDebug("[TouchGate] Storing event because thouches %s are still pending ownership.",
++                qPrintable(oldestPendingTouchIdsString()));
++            #endif
++            storeTouchEvent(event);
++        }
++    } else {
++        // Retain events that have unowned touches
++        storeTouchEvent(event);
++    }
++}
++
++void TouchGate::touchOwnershipEvent(TouchOwnershipEvent *event)
++{
++    // TODO: Optimization: batch those actions as TouchOwnershipEvents
++    //       might come one right after the other.
++
++    Q_ASSERT(m_touchInfoMap.contains(event->touchId()));
++
++    TouchInfo &touchInfo = m_touchInfoMap[event->touchId()];
++
++    if (event->gained()) {
++        #if TOUCHGATE_DEBUG
++        qDebug() << "[TouchGate] Got ownership of touch " << event->touchId();
++        #endif
++        touchInfo.ownership = OwnershipGranted;
++    } else {
++        #if TOUCHGATE_DEBUG
++        qDebug() << "[TouchGate] Lost ownership of touch " << event->touchId();
++        #endif
++        m_touchInfoMap.remove(event->touchId());
++        removeTouchFromStoredEvents(event->touchId());
++    }
++
++    dispatchFullyOwnedEvents();
++}
++
++bool TouchGate::isTouchPointOwned(int touchId) const
++{
++    return m_touchInfoMap[touchId].ownership == OwnershipGranted;
++}
++
++void TouchGate::storeTouchEvent(const QTouchEvent *event)
++{
++    #if TOUCHGATE_DEBUG
++    qDebug() << "[TouchGate] Storing" << qPrintable(touchEventToString(event));
++    #endif
++
++    TouchEvent clonedEvent(event);
++    m_storedEvents.append(std::move(clonedEvent));
++}
++
++void TouchGate::removeTouchFromStoredEvents(int touchId)
++{
++    int i = 0;
++    while (i < m_storedEvents.count()) {
++        TouchEvent &event = m_storedEvents[i];
++        bool removed = event.removeTouch(touchId);
++
++        if (removed && event.touchPoints.isEmpty()) {
++            m_storedEvents.removeAt(i);
++        } else {
++            ++i;
++        }
++    }
++}
++
++void TouchGate::dispatchFullyOwnedEvents()
++{
++    while (!m_storedEvents.isEmpty() && eventIsFullyOwned(m_storedEvents.first())) {
++        TouchEvent event = m_storedEvents.takeFirst();
++        dispatchTouchEventToTarget(event);
++    }
++}
++
++#if TOUCHGATE_DEBUG
++QString TouchGate::oldestPendingTouchIdsString()
++{
++    Q_ASSERT(!m_storedEvents.isEmpty());
++
++    QString str;
++
++    const auto &touchPoints = m_storedEvents.first().touchPoints;
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        if (!isTouchPointOwned(touchPoints[i].id())) {
++            if (!str.isEmpty()) {
++                str.append(", ");
++            }
++            str.append(QString::number(touchPoints[i].id()));
++        }
++    }
++
++    return str;
++}
++#endif
++
++bool TouchGate::eventIsFullyOwned(const TouchGate::TouchEvent &event) const
++{
++    for (int i = 0; i < event.touchPoints.count(); ++i) {
++        if (!isTouchPointOwned(event.touchPoints[i].id())) {
++            return false;
++        }
++    }
++
++    return true;
++}
++
++void TouchGate::setTargetItem(QQuickItem *item)
++{
++    // TODO: changing the target item while dispatch of touch events is taking place will
++    //       create a mess
++
++    if (item == m_dispatcher.targetItem())
++        return;
++
++    m_dispatcher.setTargetItem(item);
++    Q_EMIT targetItemChanged(item);
++}
++
++void TouchGate::dispatchTouchEventToTarget(const TouchEvent &event)
++{
++    removeTouchInfoForEndedTouches(event.touchPoints);
++    m_dispatcher.dispatch(event.eventType,
++            event.device,
++            event.modifiers,
++            event.touchPoints,
++            event.window,
++            event.timestamp);
++}
++
++void TouchGate::dispatchTouchEventToTarget(QTouchEvent* event)
++{
++    removeTouchInfoForEndedTouches(event->touchPoints());
++    m_dispatcher.dispatch(event->type(),
++            event->device(),
++            event->modifiers(),
++            event->touchPoints(),
++            event->window(),
++            event->timestamp());
++}
++
++void TouchGate::removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints)
++{
++    for (int i = 0; i < touchPoints.size(); ++i) {\
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++
++        if (touchPoint.state() == Qt::TouchPointReleased) {
++            Q_ASSERT(m_touchInfoMap.contains(touchPoint.id()));
++            Q_ASSERT(m_touchInfoMap[touchPoint.id()].ended);
++            Q_ASSERT(m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted);
++            m_touchInfoMap.remove(touchPoint.id());
++        }
++    }
++}
++
++TouchGate::TouchEvent::TouchEvent(const QTouchEvent *event)
++    : eventType(event->type())
++    , device(event->device())
++    , modifiers(event->modifiers())
++    , touchPoints(event->touchPoints())
++    , target(qobject_cast<QQuickItem*>(event->target()))
++    , window(event->window())
++    , timestamp(event->timestamp())
++{
++}
++
++bool TouchGate::TouchEvent::removeTouch(int touchId)
++{
++    bool removed = false;
++    for (int i = 0; i < touchPoints.count() && !removed; ++i) {
++        if (touchPoints[i].id() == touchId) {
++            touchPoints.removeAt(i);
++            removed = true;
++        }
++    }
++
++    return removed;
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/TouchGate.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,112 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef UBUNTU_TOUCH_GATE_H
++#define UBUNTU_TOUCH_GATE_H
++
++#include "UbuntuGesturesQmlGlobal.h"
++#include "TouchDispatcher.h"
++
++#include <QQuickItem>
++#include <QList>
++#include <QMap>
++
++#define TOUCHGATE_DEBUG 0
++
++class TouchOwnershipEvent;
++
++/*
++  Blocks the passage of events until ownership over the related touch points is granted.
++
++  Blocked touch events won't be discarded. Instead they will be buffered until ownership
++  is granted. If ownership is given to another item, the event buffer is cleared.
++
++  A TouchGate is useful as a mediator for items that do not understand, or gracefully handle,
++  touch canceling. By having a TouchGate in front of them you guarantee that only owned touches (i.e.,
++  touches that won't be canceled later) reaches them.
++ */
++class UBUNTUGESTURESQML_EXPORT TouchGate : public QQuickItem {
++    Q_OBJECT
++
++    // Item that's going to receive the touch events that make it through the gate.
++    Q_PROPERTY(QQuickItem* targetItem READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
++
++public:
++    bool event(QEvent *e) override;
++
++    QQuickItem *targetItem() { return m_dispatcher.targetItem(); }
++    void setTargetItem(QQuickItem *item);
++
++Q_SIGNALS:
++    void targetItemChanged(QQuickItem *item);
++
++    void pressed();
++
++protected:
++    void touchEvent(QTouchEvent *event) override;
++private:
++    class TouchEvent {
++    public:
++        TouchEvent(const QTouchEvent *event);
++
++        bool removeTouch(int touchId);
++
++        QEvent::Type eventType;
++        QTouchDevice *device;
++        Qt::KeyboardModifiers modifiers;
++        QList<QTouchEvent::TouchPoint> touchPoints;
++        QQuickItem *target;
++        QWindow *window;
++        ulong timestamp;
++    };
++
++    void touchOwnershipEvent(TouchOwnershipEvent *event);
++    bool isTouchPointOwned(int touchId) const;
++    void storeTouchEvent(const QTouchEvent *event);
++    void removeTouchFromStoredEvents(int touchId);
++    void dispatchFullyOwnedEvents();
++    bool eventIsFullyOwned(const TouchEvent &event) const;
++
++    void dispatchTouchEventToTarget(const TouchEvent &event);
++    void dispatchTouchEventToTarget(QTouchEvent* event);
++
++    void removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints);
++
++    #if TOUCHGATE_DEBUG
++    QString oldestPendingTouchIdsString();
++    #endif
++
++    QList<TouchEvent> m_storedEvents;
++
++    enum {
++        OwnershipUndefined,
++        OwnershipRequested,
++        OwnershipGranted,
++    };
++    class TouchInfo {
++    public:
++        TouchInfo() {ownership = OwnershipUndefined; ended = false;}
++        int ownership;
++        bool ended;
++    };
++    QMap<int, TouchInfo> m_touchInfoMap;
++
++    TouchDispatcher m_dispatcher;
++
++    friend class tst_TouchGate;
++};
++
++#endif // UBUNTU_TOUCH_GATE_H
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/UbuntuGesturesQmlGlobal.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,23 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <QtCore/QtGlobal>
++
++#if defined(UBUNTUGESTURESQML_LIBRARY)
++#  define UBUNTUGESTURESQML_EXPORT Q_DECL_EXPORT
++#else
++#  define UBUNTUGESTURESQML_EXPORT Q_DECL_IMPORT
++#endif
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/plugin.cpp'
 --- src/app/unity8/plugins/Ubuntu/Gestures/plugin.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/plugin.cpp	2015-03-20 16:26:56 +0000
@@ -0,0 +1,39 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "plugin.h"
++#include "AxisVelocityCalculator.h"
++#include "Direction.h"
++#include "DirectionalDragArea.h"
++#include "PressedOutsideNotifier.h"
++#include "TouchGate.h"
++
++#include <qqml.h>
++
++static QObject* directionSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
++  Q_UNUSED(engine);
++  Q_UNUSED(scriptEngine);
++  return new Direction;
++}
++
++void UbuntuGesturesQmlPlugin::registerTypes(const char *uri)
++{
++    qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);
++    qmlRegisterType<DirectionalDragArea>(uri, 0, 1, "DirectionalDragArea");
++    qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");
++    qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");
++    qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");
++}
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/plugin.h'
 --- src/app/unity8/plugins/Ubuntu/Gestures/plugin.h	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/plugin.h	2015-03-20 16:26:56 +0000
@@ -0,0 +1,31 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef PLUGIN_H
++#define PLUGIN_H
++
++#include <QtQml/QQmlExtensionPlugin>
++
++class UbuntuGesturesQmlPlugin : public QQmlExtensionPlugin
++{
++    Q_OBJECT
++    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
++public:
++    void registerTypes(const char *uri);
++};
++
++
++#endif
 === added file 'src/app/unity8/plugins/Ubuntu/Gestures/qmldir'
 --- src/app/unity8/plugins/Ubuntu/Gestures/qmldir	1970-01-01 00:00:00 +0000
 +++ src/app/unity8/plugins/Ubuntu/Gestures/qmldir	2015-03-20 16:26:56 +0000
@@ -0,0 +1,3 @@
++module Ubuntu.Gestures
++plugin UbuntuGesturesQml
++typeinfo Gestures.qmltypes
 === added file 'src/app/webbrowser/BottomEdgeHandle.qml'
 --- src/app/webbrowser/BottomEdgeHandle.qml	1970-01-01 00:00:00 +0000
 +++ src/app/webbrowser/BottomEdgeHandle.qml	2015-03-20 16:26:56 +0000
@@ -0,0 +1,36 @@
++/*
++ * Copyright 2014-2015 Canonical Ltd.
++ *
++ * This file is part of webbrowser-app.
++ *
++ * webbrowser-app 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.
++ *
++ * webbrowser-app is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.0
++import Ubuntu.Gestures 0.1
++
++DirectionalDragArea {
++    direction: Direction.Upwards
++
++    // default values taken from unity8’s EdgeDragArea component
++    maxDeviation: units.gu(3)
++    wideningAngle: 50
++    distanceThreshold: units.gu(1.5)
++    minSpeed: 0
++    maxSilenceTime: 200
++    compositionTime: 60
++
++    readonly property real dragFraction: dragging ? Math.min(1.0, Math.max(0.0, sceneDistance / parent.height)) : 0.0
++    readonly property var thresholds: [0.05, 0.18, 0.36, 0.54, 1.0]
++    readonly property int stage: thresholds.map(function(t) { return dragFraction <= t }).indexOf(true)
++}
 === modified file 'src/app/webbrowser/Browser.qml'
 --- src/app/webbrowser/Browser.qml	2015-02-05 13:09:42 +0000
 +++ src/app/webbrowser/Browser.qml	2015-03-20 16:26:56 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright 2013-2014 Canonical Ltd.
++ * Copyright 2013-2015 Canonical Ltd.
+  *
   * This file is part of webbrowser-app.
+  *
@@ -17,6 +17,7 @@
   */
  import QtQuick 2.0
++import QtQuick.Window 2.0
  import com.canonical.Oxide 1.4 as Oxide
  import Ubuntu.Components 1.1
  import webbrowserapp.private 0.1
@@ -78,19 +79,33 @@
+     ]
      Item {
--        id: mainView
--
          anchors.fill: parent
--        visible: !historyViewContainer.visible && !tabsViewContainer.visible
++
++        TabChrome {
++            id: invisibleTabChrome
++            visible: false
++            anchors {
++                top: parent.top
++                left: parent.left
++                right: parent.right
++            }
++        }
++
++        Rectangle {
++            // Background for the recent view
++            anchors.fill: invisibleTabChrome
++            visible: recentView.visible
++            color: "#312f2c"
++        }
          FocusScope {
              id: tabContainer
              anchors {
                  left: parent.left
                  right: parent.right
--                top: chrome.bottom
++                top: recentView.visible ? invisibleTabChrome.bottom : chrome.bottom
+             }
--            height: parent.height - chrome.visibleHeight - osk.height
++            height: parent.height - osk.height - (recentView.visible ? invisibleTabChrome.height : chrome.visibleHeight)
+         }
          Loader {
@@ -124,6 +139,8 @@
          Chrome {
              id: chrome
++            visible: !recentView.visible
++
              webview: browser.currentWebview
              searchUrl: browser.searchEngine ? browser.searchEngine.template : ""
@@ -181,12 +198,17 @@
                      objectName: "tabs"
                      text: i18n.tr("Open tabs")
                      iconName: "browser-tabs"
--                    onTriggered: tabsViewComponent.createObject(tabsViewContainer)
++                    enabled: formFactor != "mobile"
++                    onTriggered: {
++                        recentView.state = "shown"
++                        recentToolbar.state = "shown"
++                    }
                  },
                  Action {
                      objectName: "newtab"