Unity 8

Merge lp:~dandrader/unity8/runningAppsEndClose into lp:unity8

runningAppsEndClose
Merge into trunk

Proposed by Daniel d'Andrada on 2013-11-20

Status:

Superseded

Proposed branch:

lp:~dandrader/unity8/runningAppsEndClose

Merge into:

lp:unity8

Diff against target:

1251 lines (+607/-131)

15 files modified

Dash/Apps/RunningApplicationsGrid.qml (+18/-11)
Dash/DashApps.qml (+0/-1)
Dash/GenericScopeView.qml (+0/-1)
plugins/Ubuntu/Gestures/CMakeLists.txt (+1/-0)
plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp (+118/-0)
plugins/Ubuntu/Gestures/PressedOutsideNotifier.h (+62/-0)
plugins/Ubuntu/Gestures/plugin.cpp (+2/-0)
tests/plugins/Ubuntu/Gestures/CMakeLists.txt (+21/-18)
tests/plugins/Ubuntu/Gestures/GestureTest.cpp (+44/-0)
tests/plugins/Ubuntu/Gestures/GestureTest.h (+44/-0)
tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp (+67/-99)
tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.cpp (+146/-0)
tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.qml (+61/-0)
tests/qmltests/CMakeLists.txt (+3/-1)
tests/qmltests/Dash/Apps/tst_RunningApplicationsGrid.qml (+20/-0)

To merge this branch:

bzr merge lp:~dandrader/unity8/runningAppsEndClose

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2013-11-21
Michał Sawicz		2013-11-20	Needs Information on 2013-11-20
Review via email: mp+196006@code.launchpad.net

This proposal has been superseded by a proposal from 2013-11-22.

Commit message

Dash: disable app termination mode on click outside thumbnails

To leave the termination mode you can now just mouse/touch press anywhere
outside the running applications' thumbnails

The other way, which still works, is long-pressing a thumbnail once more.

Description of the change

Fixes bug 1193414.

InverseMouseArea is not fit for this job (e.g. doesn't work with touches when in topMostMode), thus I created a simple, light-weight, PressedOutsideNotifier that suites perfectly our needs.

Most of the diff is about tests and some test refactoring.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-20:

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-20

542. By Albert Astals Cid on 2013-11-20

Do not include the QtQml megaheader

Include only qqml.h which is what we need in these files.

Approved by PS Jenkins bot, Michał Sawicz.

Revision history for this message

Michał Sawicz (saviq) wrote on 2013-11-20:

tst_PressedOutsideNotifier.qml: bad whitespace in line 37

BUT... Isn't InverseMouseArea supposed to do the same thing?

review: Needs Information

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-21

543. By Launchpad Translations on behalf of unity-team on 2013-11-21: Launchpad automatic translations update.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-21:

> tst_PressedOutsideNotifier.qml: bad whitespace in line 37

Fixed.

> BUT... Isn't InverseMouseArea supposed to do the same thing?

Kind-of, but it's hindered by all the promises its API makes (it's a bit of a mess IMHO) and doesn't really work for that case. Have you read the description?

e.g.: It would have, for instance, to monitor touch events and translate them to mouse events himself because it's a Inverse*Mouse*Area. When its topMost property is on it listens for input events at a level before QQuickWindow is able to synthesize touch events out of mouse events.

Thus instead of trying to have it working for our case it's easier to come up with something concise and simple designed to fit perfectly with our needs. Since we're not a library, we're free to do this kind of things, which is good.

I don't see the point in striving to use InverseMouseArea just for the sake of using it because it already exists. If it's about improving InverseMouseArea itself, I'm not too hopeful.

Revision history for this message

Albert Astals Cid (aacid) wrote on 2013-11-21:

> e.g.: It would have, for instance, to monitor touch events and translate them
> to mouse events himself because it's a Inverse*Mouse*Area. When its topMost
> property is on it listens for input events at a level before QQuickWindow is
> able to synthesize touch events out of mouse events.

But didn't you have a patch for Qt to fix that?

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-21:

> > e.g.: It would have, for instance, to monitor touch events and translate
> them
> > to mouse events himself because it's a Inverse*Mouse*Area. When its topMost
> > property is on it listens for input events at a level before QQuickWindow is
> > able to synthesize touch events out of mouse events.
>
> But didn't you have a patch for Qt to fix that?

No. That's a different topic. But maybe InverseMouseArea does it to workaround that bug.

Revision history for this message

Albert Astals Cid (aacid) wrote on 2013-11-21:

> > > e.g.: It would have, for instance, to monitor touch events and translate
> > them
> > > to mouse events himself because it's a Inverse*Mouse*Area. When its
> topMost
> > > property is on it listens for input events at a level before QQuickWindow
> is
> > > able to synthesize touch events out of mouse events.
> >
> > But didn't you have a patch for Qt to fix that?
>
> No. That's a different topic. But maybe InverseMouseArea does it to workaround
> that bug.

Oh, it was my understanding that you where making the synthezised events go properly through the event stack again and thus they'd be caught by the InverseMouseArea and everything would just work.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-21:

> > > > e.g.: It would have, for instance, to monitor touch events and translate
> > > them
> > > > to mouse events himself because it's a Inverse*Mouse*Area. When its
> > topMost
> > > > property is on it listens for input events at a level before
> QQuickWindow
> > is
> > > > able to synthesize touch events out of mouse events.
> > >
> > > But didn't you have a patch for Qt to fix that?
> >
> > No. That's a different topic. But maybe InverseMouseArea does it to
> workaround
> > that bug.
>
> Oh, it was my understanding that you where making the synthezised events go
> properly through the event stack again and thus they'd be caught by the
> InverseMouseArea and everything would just work.

A topMost InverseMouseArea listens for events at QGuiApplication level (a bad idea, IMHO). synthesized mouse events from QQuickWindow will never to that high up, and they shouldn't.

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-21

544. By Omer Akram on 2013-11-21

make the non working code in the screen unlocker helper work.

Approved by PS Jenkins bot, Christopher Lee, Michael Zanetti.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-21:

> > > > > e.g.: It would have, for instance, to monitor touch events and
> translate
> > > > them
> > > > > to mouse events himself because it's a Inverse*Mouse*Area. When its
> > > topMost
> > > > > property is on it listens for input events at a level before
> > QQuickWindow
> > > is
> > > > > able to synthesize touch events out of mouse events.
> > > >
> > > > But didn't you have a patch for Qt to fix that?
> > >
> > > No. That's a different topic. But maybe InverseMouseArea does it to
> > workaround
> > > that bug.
> >
> > Oh, it was my understanding that you where making the synthezised events go
> > properly through the event stack again and thus they'd be caught by the
> > InverseMouseArea and everything would just work.
>
> A topMost InverseMouseArea listens for events at QGuiApplication level (a bad
> idea, IMHO). synthesized mouse events from QQuickWindow will never to that
> high up, and they shouldn't.

And even if it listened at the right level (rootItem), it still wouldn't work if there a touch-aware item in the scene that accepts the touches. In that situation QQuickWindow wound't synthesize mouse events out of the touch events because there's no need to.

Revision history for this message

Albert Astals Cid (aacid) wrote on 2013-11-21:

ok, in my opinion we should still fix InverseMouseArea to do what we want, i mean, what about all the other people out there that want to do exactly this? InverseMouseArea is supposed to do it, so why not fix it and then use it?

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-21:

> And even if it listened at the right level (rootItem), it still wouldn't work
> if there a touch-aware item in the scene that accepts the touches. In that
> situation QQuickWindow wound't synthesize mouse events out of the touch events
> because there's no need to.

Ah, and for listening at the "right level", that's when you would need my fix.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-21:

> ok, in my opinion we should still fix InverseMouseArea to do what we want, i
> mean, what about all the other people out there that want to do exactly this?
> InverseMouseArea is supposed to do it, so why not fix it and then use it?

Can't we do both?

1 - fix our UI *now*, which is what matters to the final user and people trying to sell our phone demoing it.
2 - Fix InverseMouseArea, so that application developer have better building blocks to build their ubuntu apps.

The thing is that item 2 requires much work because InverseMouseArea is meant to cover much more cases and has a more complex API. And we might have to sit around until my QQuickItem event dispatch fix is available in ubuntu repos, translating into even more time.

Item 1 is what the bug that this patch fixes is all about.
Item 2 is a bonus.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-21:

FAILED: Continuous integration, rev:538
http://jenkins.qa.ubuntu.com/job/unity8-ci/1693/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/958/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty-touch/942/console
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-trusty/354
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-trusty-amd64-ci/216/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-trusty-armhf-ci/217/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-trusty-i386-ci/216/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/958/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/942/console

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-21

545. By Nicolas d'Offay on 2013-11-21

Search history is now persistent across all scopes and remains in QML. Fixes: https://bugs.launchpad.net/bugs/1226221.

Approved by PS Jenkins bot, Albert Astals Cid.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-21:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-21:

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-21

546. By Albert Astals Cid on 2013-11-21

Don't do stuff if our parent context is gone

We'll be gone soon too (and crash probably) so don't do anything.
This looks a bit like a workaround, wait for 5.2 better painting/dispatching
loop to see if this is not needed anymore, we find a better way to do it,
or we decide this is fine.

Approved by PS Jenkins bot, Nick Dedekind.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-21:

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

review: Approve (continuous-integration)

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-21

547. By Michael Zanetti on 2013-11-21

drop all references to LighDM from the Lockscreen

This should make it generic enough to allow reusing it for SIM PIN entry
.

Approved by PS Jenkins bot, Mirco Müller.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-21:

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

review: Approve (continuous-integration)

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-21

548. By Lars Karlitski on 2013-11-21

Allow setting different indicator positions for different profiles.

Approved by PS Jenkins bot, Nick Dedekind.

Revision history for this message

Michał Sawicz (saviq) wrote on 2013-11-21:

Please split out the unrelated refactoring changes into a separate MP.

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-22

549. By Mirco Müller on 2013-11-21

Fixes bug #1200569. Fixes: https://bugs.launchpad.net/bugs/1200569.

Approved by PS Jenkins bot, Michael Zanetti.

550. By Daniel d'Andrada on 2013-11-22

Refactor Ubuntu.Gesture tests to share common logic

Take the common part out of tst_DirectionalDragArea and put
it into a separate base class, GestureTest, so that it can
be shared with other, future, tests.

In CMakeLists.txt, create a macro out of DirectionalDragArea build script
to be used by future tests with similar requirements and structure.

Also add the "m_" prefix to member variables.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-22:

> Please split out the unrelated refactoring changes into a separate MP.

And there it is:
https://code.launchpad.net/~dandrader/unity8/gestureTestsBaseClass/+merge/196256

lp:~dandrader/unity8/runningAppsEndClose updated on 2013-11-29

551. By Daniel d'Andrada on 2013-11-22

More GestureTest and tst_DirectionalDragArea refactoring

- Move more stuff to GestureTest base class
- add tryFoo make command
- Let the qml file dictate the scene/window size, not the c++ code

552. By Daniel d'Andrada on 2013-11-22

Some string-related improvements

- Use QString instead of raw char array
- s/QLatin1String/QStringLiteral to optimize code

553. By Daniel d'Andrada on 2013-11-22

Dash: disable app termination mode on click outside thumbnails

To leave the termination mode you can now just mouse/touch press anywhere
outside the running applications' thumbnails

The other way, which still works, is long-pressing a thumbnail once more.

554. By Daniel d'Andrada on 2013-11-29

Put canEnableTerminationMode stuff back

To cover a minor "visual glitch" in a specific corner case

555. By Daniel d'Andrada on 2013-11-29

Add a Q_ASSERT to state that we really don't expect it to be null

as opposed to "we forget to handle the null case"

Unmerged revisions

Preview Diff

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

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mohammad Rakibul Hasan

Unity Team

 === modified file 'Dash/Apps/RunningApplicationsGrid.qml'
 --- Dash/Apps/RunningApplicationsGrid.qml	2013-10-02 11:01:49 +0000
 +++ Dash/Apps/RunningApplicationsGrid.qml	2013-11-22 10:45:28 +0000
@@ -17,6 +17,8 @@
  import QtQuick 2.0
  import "../../Components"
++import Ubuntu.Gestures 0.1
++
  ResponsiveFlowView {
      id: root
      clip: true
@@ -50,13 +52,6 @@
+         }
+     }
--    property bool canEnableTerminationMode: true
--
--    onCanEnableTerminationModeChanged: {
--        if (!canEnableTerminationMode)
--            terminationModeEnabled = false
--    }
--
      // when false, it means it's on activation mode
      property bool terminationModeEnabled: false
@@ -78,10 +73,7 @@
+             }
              application: model
              onRequestedActivationMode: { root.terminationModeEnabled = false }
--            onRequestedTerminationMode: {
--                if (canEnableTerminationMode)
--                    root.terminationModeEnabled = true
--            }
++            onRequestedTerminationMode: { root.terminationModeEnabled = true }
              onRequestedApplicationTermination: {
                  shell.applicationManager.stopApplication(model.appId)
+             }
@@ -100,4 +92,19 @@
      move: Transition {
          NumberAnimation { properties: "x,y"; duration: 400; easing.type: Easing.OutCubic }
+     }
++
++    MouseArea {
++        anchors.fill: parent
++        z: -1 // behind all RunningApplicationTiles
++        enabled: root.terminationModeEnabled
++        onPressed: { root.terminationModeEnabled = false; }
++    }
++
++    PressedOutsideNotifier {
++        anchors.fill: parent
++        enabled: root.terminationModeEnabled
++        onPressedOutside: {
++            root.terminationModeEnabled = false;
++        }
++    }
+ }
 === modified file 'Dash/DashApps.qml'
 --- Dash/DashApps.qml	2013-11-11 10:24:51 +0000
 +++ Dash/DashApps.qml	2013-11-22 10:45:28 +0000
@@ -44,7 +44,6 @@
          property var firstModel: mainStageApplicationsModel
          property var secondModel: sideStageApplicationModel
--        property bool canEnableTerminationMode: scopeView.isCurrent
          model: dummyVisibilityModifier
          filterRole: 0
 === modified file 'Dash/GenericScopeView.qml'
 --- Dash/GenericScopeView.qml	2013-11-19 14:33:40 +0000
 +++ Dash/GenericScopeView.qml	2013-11-22 10:45:28 +0000
@@ -151,7 +151,6 @@
                          // TODO: the running apps grid doesn't support standard scope results model yet
                          item.firstModel = Qt.binding(function() { return results.firstModel })
                          item.secondModel = Qt.binding(function() { return results.secondModel })
--                        item.canEnableTerminationMode = Qt.binding(function() { return scopeView.isCurrent })
                      } else {
                          item.model = Qt.binding(function() { return results })
+                     }
 === modified file 'plugins/Ubuntu/Gestures/CMakeLists.txt'
 --- plugins/Ubuntu/Gestures/CMakeLists.txt	2013-10-22 15:56:37 +0000
 +++ plugins/Ubuntu/Gestures/CMakeLists.txt	2013-11-22 10:45:28 +0000
@@ -6,6 +6,7 @@
      AxisVelocityCalculator.cpp
      Direction.cpp
      DirectionalDragArea.cpp
++    PressedOutsideNotifier.cpp
      TimeSource.cpp
+ )
 === added file 'plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp'
 --- plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Ubuntu/Gestures/PressedOutsideNotifier.cpp	2013-11-22 10:45:28 +0000
@@ -0,0 +1,118 @@
++/*
++ * 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();
++
++    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 'plugins/Ubuntu/Gestures/PressedOutsideNotifier.h'
 --- plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	1970-01-01 00:00:00 +0000
 +++ plugins/Ubuntu/Gestures/PressedOutsideNotifier.h	2013-11-22 10:45:28 +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
 === modified file 'plugins/Ubuntu/Gestures/plugin.cpp'
 --- plugins/Ubuntu/Gestures/plugin.cpp	2013-06-17 13:45:28 +0000
 +++ plugins/Ubuntu/Gestures/plugin.cpp	2013-11-22 10:45:28 +0000
@@ -18,6 +18,7 @@
  #include "AxisVelocityCalculator.h"
  #include "Direction.h"
  #include "DirectionalDragArea.h"
++#include "PressedOutsideNotifier.h"
  #include <qqml.h>
@@ -32,4 +33,5 @@
      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");
+ }
 === modified file 'tests/plugins/Ubuntu/Gestures/CMakeLists.txt'
 --- tests/plugins/Ubuntu/Gestures/CMakeLists.txt	2013-06-11 18:22:43 +0000
 +++ tests/plugins/Ubuntu/Gestures/CMakeLists.txt	2013-11-22 10:45:28 +0000
@@ -1,33 +1,33 @@
--########## tst_DirectionalDragArea
++include(QmlTest)
  include_directories(
      ${CMAKE_SOURCE_DIR}/plugins/Ubuntu/Gestures
      ${CMAKE_CURRENT_BINARY_DIR}
+     )
--set(testCommand
--      LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/plugins/Ubuntu/Gestures
--      ${CMAKE_CURRENT_BINARY_DIR}/DirectionalDragAreaTestExec
--      -o ${CMAKE_BINARY_DIR}/DirectionalDragAreaTest.xml,xunitxml
--      -o -,txt)
--
--add_custom_target(testDirectionalDragArea ${testCommand})
--add_dependencies(qmluitests testDirectionalDragArea)
--add_dependencies(testDirectionalDragArea DirectionalDragAreaTestExec UbutunGesturesTestQmlFiles)
--
--add_executable(DirectionalDragAreaTestExec tst_DirectionalDragArea.cpp)
--qt5_use_modules(DirectionalDragAreaTestExec Test Core Qml Gui Quick)
--target_link_libraries(DirectionalDragAreaTestExec UbuntuGestureQml)
--
--add_definitions(-DUBUNTU_GESTURES_PLUGIN_DIR="${CMAKE_BINARY_DIR}/plugins")
--
  file(GLOB qmlFiles *.qml)
  add_custom_target(UbuntuGesturesTestQmlFiles ALL
      COMMAND cp ${qmlFiles} ${CMAKE_CURRENT_BINARY_DIR}
      DEPENDS ${qmlFiles}
+ )
--########## other tests
++add_definitions(-DUBUNTU_GESTURES_PLUGIN_DIR="${CMAKE_BINARY_DIR}/plugins")
++
++macro(add_gesture_ui_test CLASSNAME)
++    set(testCommand
++          LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/plugins/Ubuntu/Gestures
++          ${CMAKE_CURRENT_BINARY_DIR}/${CLASSNAME}TestExec
++          -o ${CMAKE_BINARY_DIR}/${CLASSNAME}Test.xml,xunitxml
++          -o -,txt)
++
++    add_custom_target(test${CLASSNAME} ${testCommand})
++    add_dependencies(qmluitests test${CLASSNAME})
++    add_dependencies(test${CLASSNAME} ${CLASSNAME}TestExec UbuntuGesturesTestQmlFiles)
++
++    add_executable(${CLASSNAME}TestExec tst_${CLASSNAME}.cpp GestureTest.cpp)
++    qt5_use_modules(${CLASSNAME}TestExec Test Core Qml Gui Quick)
++    target_link_libraries(${CLASSNAME}TestExec UbuntuGestureQml)
++endmacro(add_gesture_ui_test)
  macro(add_gesture_test CLASSNAME)
      set(testCommand
@@ -43,5 +43,8 @@
      target_link_libraries(${CLASSNAME}TestExec UbuntuGestureQml)
  endmacro(add_gesture_test)
++add_gesture_ui_test(DirectionalDragArea)
++add_gesture_ui_test(PressedOutsideNotifier)
++add_manual_qml_test(. PressedOutsideNotifier IMPORT_PATHS ${CMAKE_BINARY_DIR}/plugins)
  add_gesture_test(Damper)
  add_gesture_test(AxisVelocityCalculator)
 === added file 'tests/plugins/Ubuntu/Gestures/GestureTest.cpp'
 --- tests/plugins/Ubuntu/Gestures/GestureTest.cpp	1970-01-01 00:00:00 +0000
 +++ tests/plugins/Ubuntu/Gestures/GestureTest.cpp	2013-11-22 10:45:28 +0000
@@ -0,0 +1,44 @@
++/*
++ * 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 "GestureTest.h"
++
++#include <qpa/qwindowsysteminterface.h>
++#include <QQmlEngine>
++#include <QQuickView>
++
++void GestureTest::initTestCase()
++{
++    if (!m_device) {
++        m_device = new QTouchDevice;
++        m_device->setType(QTouchDevice::TouchScreen);
++        QWindowSystemInterface::registerTouchDevice(m_device);
++    }
++}
++
++void GestureTest::init()
++{
++    m_view = new QQuickView(0);
++    m_view->setResizeMode(QQuickView::SizeRootObjectToView);
++    m_view->resize(600, 600);
++    m_view->engine()->addImportPath(QLatin1String(UBUNTU_GESTURES_PLUGIN_DIR));
++}
++
++void GestureTest::cleanup()
++{
++    delete m_view;
++    m_view = nullptr;
++}
 === added file 'tests/plugins/Ubuntu/Gestures/GestureTest.h'
 --- tests/plugins/Ubuntu/Gestures/GestureTest.h	1970-01-01 00:00:00 +0000
 +++ tests/plugins/Ubuntu/Gestures/GestureTest.h	2013-11-22 10:45:28 +0000
@@ -0,0 +1,44 @@
++/*
++ * 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 GESTURETEST_H
++#endif // GESTURETEST_H
++
++#include <QObject>
++
++class QQuickView;
++class QTouchDevice;
++
++/*
++    The common stuff among tests come here
++ */
++class GestureTest : public QObject
++{
++    Q_OBJECT
++public:
++    GestureTest() : QObject(), m_device(nullptr), m_view(nullptr) {}
++
++protected Q_SLOTS:
++    void initTestCase(); // will be called before the first test function is executed
++    virtual void init(); // called right before each and every test function is executed
++    virtual void cleanup(); // called right after each and every test function is executed
++
++protected:
++    QTouchDevice *m_device;
++    QQuickView *m_view;
++};
++
++#define GESTURETEST_H
 === modified file 'tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp'
 --- tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2013-10-23 12:25:40 +0000
 +++ tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2013-11-22 10:45:28 +0000
@@ -16,13 +16,14 @@
  #include <QtTest/QtTest>
  #include <QtCore/QObject>
--#include <qpa/qwindowsysteminterface.h>
  #include <QtQuick/QQuickView>
  #include <QtQml/QQmlEngine>
  #include <QPointer>
  #include <DirectionalDragArea.h>
++#include "GestureTest.h"
++
  using namespace UbuntuGestures;
  class FakeTimer : public AbstractTimer
@@ -61,15 +62,11 @@
      qint64 m_msecsSinceReference;
  };
--class tst_DirectionalDragArea: public QObject
++class tst_DirectionalDragArea: public GestureTest
+ {
      Q_OBJECT
  public:
--    tst_DirectionalDragArea() : device(0) { }
  private Q_SLOTS:
--    void initTestCase(); // will be called before the first test function is executed
--    void cleanupTestCase(); // will be called after the last test function was executed.
--
      void init(); // called right before each and every test function is executed
      void cleanup(); // called right after each and every test function is executed
@@ -87,36 +84,18 @@
      void ignoreOldFinger();
  private:
--    QQuickView *createView();
      void passTime(qint64 timeSpan);
--    QQuickView *view;
--    QTouchDevice *device;
      FakeTimer *fakeTimer;
      QSharedPointer<FakeTimeSource> fakeTimeSource;
  };
--void tst_DirectionalDragArea::initTestCase()
--{
--    if (!device) {
--        device = new QTouchDevice;
--        device->setType(QTouchDevice::TouchScreen);
--        QWindowSystemInterface::registerTouchDevice(device);
--    }
--
--    view = 0;
--}
--
--void tst_DirectionalDragArea::cleanupTestCase()
--{
--}
--
  void tst_DirectionalDragArea::init()
+ {
--    view = createView();
--    view->setSource(QUrl::fromLocalFile("edgeDragExample.qml"));
--    view->show();
--    QVERIFY(QTest::qWaitForWindowExposed(view));
--    QVERIFY(view->rootObject() != 0);
++    GestureTest::init();
++    m_view->setSource(QUrl::fromLocalFile("edgeDragExample.qml"));
++    m_view->show();
++    QVERIFY(QTest::qWaitForWindowExposed(m_view));
++    QVERIFY(m_view->rootObject() != 0);
      qApp->processEvents();
      fakeTimeSource.reset(new FakeTimeSource);
@@ -125,23 +104,12 @@
  void tst_DirectionalDragArea::cleanup()
+ {
--    delete view;
--    view = 0;
--
      delete fakeTimer;
      fakeTimer = 0;
      fakeTimeSource.reset();
--}
--
--QQuickView *tst_DirectionalDragArea::createView()
--{
--    QQuickView *window = new QQuickView(0);
--    window->setResizeMode(QQuickView::SizeRootObjectToView);
--    window->resize(600, 600);
--    window->engine()->addImportPath(QLatin1String(UBUNTU_GESTURES_PLUGIN_DIR));
--
--    return window;
++
++    GestureTest::cleanup();
+ }
  void tst_DirectionalDragArea::passTime(qint64 timeSpan)
@@ -217,14 +185,14 @@
      QFETCH(bool, expectGestureRecognition);
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>(dragAreaObjectName);
++        m_view->rootObject()->findChild<DirectionalDragArea*>(dragAreaObjectName);
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
      QSignalSpy draggingSpy(edgeDragArea, SIGNAL(draggingChanged(bool)));
--    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
++    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
      QPointF touchPoint = initialTouchPos;
      qreal desiredDragDistance = edgeDragArea->distanceThreshold()*dragDistanceFactor;
@@ -235,7 +203,7 @@
      int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
      int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
--    QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
      QCOMPARE(draggingSpy.count(), 1);
      QCOMPARE(edgeDragArea->dragging(), true);
@@ -245,13 +213,13 @@
          // in order to make it easier to leave it by dragging at an angle
          // slightly bigger than the widening angle
          touchPoint += createTouchDeviation(edgeDragArea);
--        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+     }
      for (int i = 0; i < totalMovementSteps; ++i) {
          touchPoint += touchMovement;
          passTime(movementTimeStepMs);
--        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+     }
      if (expectGestureRecognition)
@@ -262,7 +230,7 @@
          QCOMPARE(draggingSpy.count(), 2);
+     }
--    QTest::touchEvent(view, device).release(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
      QCOMPARE(draggingSpy.count(), 2);
      QCOMPARE(edgeDragArea->dragging(), false);
@@ -326,12 +294,12 @@
  void tst_DirectionalDragArea::dragWithShortDirectionChange()
+ {
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
--    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
++    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
      QPointF touchPoint = initialTouchPos;
      qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0;
@@ -341,32 +309,32 @@
      int touchStepTimeMs = (touchStepDistance / (edgeDragArea->minSpeed() * 5.0f)) * 1000.0f;
      QPointF touchMovement = dragDirectionVector * touchStepDistance;
--    QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
      // Move a bit in the proper direction
      for (int i=0; i < 3; ++i) {
          touchPoint += touchMovement;
          passTime(touchStepTimeMs);
--        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+     }
      // Then a sudden and small movement to the opposite direction
      touchPoint -= touchMovement*0.2;
      passTime(touchStepTimeMs*0.2);
--    QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
      // And then resume movment in the correct direction until it crosses the distance and time
      // thresholds.
      do {
          touchPoint += touchMovement;
          passTime(touchStepTimeMs);
--        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
      } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance
              || fakeTimeSource->m_msecsSinceReference < (edgeDragArea->compositionTime() * 1.5f));
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
--    QTest::touchEvent(view, device).release(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
+ }
  /*
@@ -380,7 +348,7 @@
      QFETCH(int, expectedStatusAfterSpeedCheck);
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
@@ -391,7 +359,7 @@
      edgeDragArea->setMinSpeed(minSpeed);
--    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
++    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
      QPointF touchPoint = initialTouchPos;
      QPointF dragDirectionVector(1.0, 0.0);
@@ -399,13 +367,13 @@
      qreal distanceStep = (speed / 1000.0f) * timeStepMsecs;
      QPointF touchMovement = dragDirectionVector * distanceStep;
--    QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
      // Move for a while to ensure our speed check is performed a couple of times
      for (int i=0; i < 20; ++i) {
          touchPoint += touchMovement;
          passTime(timeStepMsecs);
--        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+     }
      QCOMPARE((int)edgeDragArea->status(), expectedStatusAfterSpeedCheck);
@@ -429,7 +397,7 @@
  void tst_DirectionalDragArea::recognitionTimerUsage()
+ {
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
@@ -439,7 +407,7 @@
      int timeStepMs = 5; // some arbitrary small value.
--    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
++    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
      QPointF touchPoint = initialTouchPos;
      QPointF dragDirectionVector(1.0, 0.0);
@@ -448,7 +416,7 @@
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
      QVERIFY(!fakeTimer->isRunning());
--    QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
      QVERIFY(fakeTimer->isRunning());
@@ -461,7 +429,7 @@
          touchPoint += touchMovement;
          passTime(timeStepMs);
--        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+     }
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
@@ -475,7 +443,7 @@
  void tst_DirectionalDragArea::maxSilenceTime()
+ {
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
@@ -483,10 +451,10 @@
      // Make sure this property is not disabled
      edgeDragArea->setMaxSilenceTime(100);
--    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
++    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
      QPointF touchPoint = initialTouchPos;
--    QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
      QVERIFY(fakeTimer->isRunning());
@@ -506,20 +474,20 @@
  void tst_DirectionalDragArea::sceneXAndX()
+ {
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
--    QPointF touchScenePos(view->width() - (edgeDragArea->width()/2.0f), view->height()/2.0f);
++    QPointF touchScenePos(m_view->width() - (edgeDragArea->width()/2.0f), m_view->height()/2.0f);
--    QTest::touchEvent(view, device).press(0, touchScenePos.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchScenePos.toPoint());
      QSignalSpy touchXSpy(edgeDragArea, SIGNAL(touchXChanged(qreal)));
      QSignalSpy touchSceneXSpy(edgeDragArea, SIGNAL(touchSceneXChanged(qreal)));
--    touchScenePos.rx() = view->width() / 2;
--    QTest::touchEvent(view, device).move(0, touchScenePos.toPoint());
++    touchScenePos.rx() = m_view->width() / 2;
++    QTest::touchEvent(m_view, m_device).move(0, touchScenePos.toPoint());
      QCOMPARE(touchXSpy.count(), 1);
      QCOMPARE(touchSceneXSpy.count(), 1);
@@ -534,20 +502,20 @@
  void tst_DirectionalDragArea::sceneYAndY()
+ {
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("vnDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("vnDragArea");
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
--    QPointF touchScenePos(view->width()/2.0f, view->height() - (edgeDragArea->height()/2.0f));
++    QPointF touchScenePos(m_view->width()/2.0f, m_view->height() - (edgeDragArea->height()/2.0f));
--    QTest::touchEvent(view, device).press(0, touchScenePos.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchScenePos.toPoint());
      QSignalSpy touchYSpy(edgeDragArea, SIGNAL(touchYChanged(qreal)));
      QSignalSpy touchSceneYSpy(edgeDragArea, SIGNAL(touchSceneYChanged(qreal)));
--    touchScenePos.ry() = view->height() / 2;
--    QTest::touchEvent(view, device).move(0, touchScenePos.toPoint());
++    touchScenePos.ry() = m_view->height() / 2;
++    QTest::touchEvent(m_view, m_device).move(0, touchScenePos.toPoint());
      QCOMPARE(touchYSpy.count(), 1);
      QCOMPARE(touchSceneYSpy.count(), 1);
@@ -564,27 +532,27 @@
  void tst_DirectionalDragArea::twoFingerTap()
+ {
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
      QVERIFY(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
      // Make touches evenly spaced along the edgeDragArea
--    QPoint touchAPos(edgeDragArea->width()/2.0f, view->height()*0.33f);
--    QPoint touchBPos(edgeDragArea->width()/2.0f, view->height()*0.66f);
++    QPoint touchAPos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
++    QPoint touchBPos(edgeDragArea->width()/2.0f, m_view->height()*0.66f);
      qint64 timeStepMsecs = 5; // some arbitrary, small value
      // Perform the first two-finger tap
      // NB: using move() instead of stationary() becasue in the latter you cannot provide
      //     the touch position and therefore it's left with some garbage numbers.
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .press(0, touchAPos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
      passTime(timeStepMsecs);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .move(0, touchAPos)
          .press(1, touchBPos);
@@ -593,14 +561,14 @@
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
      passTime(timeStepMsecs);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .release(0, touchAPos)
          .move(1, touchBPos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
      passTime(timeStepMsecs);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .release(1, touchBPos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
@@ -608,27 +576,27 @@
      // Perform the second two-finger tap
      passTime(timeStepMsecs);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .press(0, touchAPos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
      passTime(timeStepMsecs);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .move(0, touchAPos)
          .press(1, touchBPos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
      passTime(timeStepMsecs);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .release(0, touchAPos)
          .move(1, touchBPos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
      passTime(timeStepMsecs);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .release(1, touchBPos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
@@ -642,7 +610,7 @@
   */
  void tst_DirectionalDragArea::movingDDA()
+ {
--    QQuickItem *rightwardsLauncher =  view->rootObject()->findChild<QQuickItem*>("rightwardsLauncher");
++    QQuickItem *rightwardsLauncher =  m_view->rootObject()->findChild<QQuickItem*>("rightwardsLauncher");
      Q_ASSERT(rightwardsLauncher != 0);
      DirectionalDragArea *edgeDragArea =
@@ -651,7 +619,7 @@
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
--    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
++    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
      QPointF touchPoint = initialTouchPos;
      qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
@@ -662,7 +630,7 @@
      int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
      int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
--    QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
      // Move it far ahead along the direction of the gesture
      // rightwardsLauncher is a parent of our DirectionalDragArea. So moving it will move our DDA
@@ -671,12 +639,12 @@
      for (int i = 0; i < totalMovementSteps; ++i) {
          touchPoint += touchMovement;
          passTime(movementTimeStepMs);
--        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+     }
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
--    QTest::touchEvent(view, device).release(0, touchPoint.toPoint());
++    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
+ }
  /*
@@ -686,16 +654,16 @@
  void tst_DirectionalDragArea::ignoreOldFinger()
+ {
      DirectionalDragArea *edgeDragArea =
--        view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
++        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
      Q_ASSERT(edgeDragArea != 0);
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
      // Make touches evenly spaced along the edgeDragArea
--    QPoint touch0Pos(edgeDragArea->width()/2.0f, view->height()*0.33f);
--    QPoint touch1Pos(edgeDragArea->width()/2.0f, view->height()*0.66f);
++    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
++    QPoint touch1Pos(edgeDragArea->width()/2.0f, m_view->height()*0.66f);
--    QTest::touchEvent(view, device).press(0, touch0Pos);
++    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
@@ -712,7 +680,7 @@
      int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
      int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .move(0, touch0Pos)
          .press(1, touch1Pos);
@@ -721,14 +689,14 @@
      for (int i = 0; i < totalMovementSteps; ++i) {
          touch1Pos += touchMovement.toPoint();
          passTime(movementTimeStepMs);
--        QTest::touchEvent(view, device)
++        QTest::touchEvent(m_view, m_device)
              .move(0, touch0Pos)
              .move(1, touch1Pos);
+     }
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
--    QTest::touchEvent(view, device)
++    QTest::touchEvent(m_view, m_device)
          .move(0, touch0Pos)
          .release(1, touch1Pos);
 === added file 'tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.cpp'
 --- tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.cpp	1970-01-01 00:00:00 +0000
 +++ tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.cpp	2013-11-22 10:45:28 +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 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 "GestureTest.h"
++
++#include <PressedOutsideNotifier.h>
++
++#include <QQuickItem>
++#include <QQuickView>
++#include <QtTest>
++
++class tst_PressedOutsideNotifier: public GestureTest
++{
++    Q_OBJECT
++private Q_SLOTS:
++    void init(); // called right before each and every test function is executed
++
++    void touchOutsideAreaTriggersSignal();
++    void touchInsideAreaHasNoEffect();
++    void mousePressOutsideAreaTriggersSignal();
++    void mousePresssInsideAreaHasNoEffect();
++    void nothingHappensWhileDisabled();
++
++private:
++    QQuickItem *m_blueRect;
++    PressedOutsideNotifier *m_notifier;
++};
++
++void tst_PressedOutsideNotifier::init()
++{
++    GestureTest::init();
++    m_view->setSource(QUrl::fromLocalFile("tst_PressedOutsideNotifier.qml"));
++    m_view->show();
++    QVERIFY(QTest::qWaitForWindowExposed(m_view));
++    QVERIFY(m_view->rootObject() != 0);
++    qApp->processEvents();
++
++    m_blueRect = m_view->rootObject()->findChild<QQuickItem*>("blueRect");
++    Q_ASSERT(m_blueRect != nullptr);
++
++    m_notifier =
++        m_view->rootObject()->findChild<PressedOutsideNotifier*>("pressedOutsideNotifier");
++    Q_ASSERT(m_notifier != nullptr);
++}
++
++void tst_PressedOutsideNotifier::touchOutsideAreaTriggersSignal()
++{
++    QPoint touch0 = QPoint(m_blueRect->x() - 50, m_blueRect->y() - 50);
++
++    QSignalSpy pressedOutsideSpy(m_notifier, SIGNAL(pressedOutside()));
++
++    QTest::touchEvent(m_view, m_device)
++        .press(0, touch0);
++
++    qApp->processEvents();
++
++    QCOMPARE(pressedOutsideSpy.count(), 1);
++
++    QTest::touchEvent(m_view, m_device)
++        .release(0, touch0);
++}
++
++void tst_PressedOutsideNotifier::touchInsideAreaHasNoEffect()
++{
++    QPoint touch0 = QPoint(m_blueRect->x() + m_blueRect->width()*0.5,
++                           m_blueRect->y() + m_blueRect->height()*0.5);
++
++    QSignalSpy pressedOutsideSpy(m_notifier, SIGNAL(pressedOutside()));
++
++    QTest::touchEvent(m_view, m_device)
++        .press(0, touch0);
++
++    qApp->processEvents();
++
++    QCOMPARE(pressedOutsideSpy.count(), 0);
++
++    QTest::touchEvent(m_view, m_device)
++        .release(0, touch0);
++}
++
++void tst_PressedOutsideNotifier::mousePressOutsideAreaTriggersSignal()
++{
++    QPoint mousePos = QPoint(m_blueRect->x() - 50, m_blueRect->y() - 50);
++
++    QSignalSpy pressedOutsideSpy(m_notifier, SIGNAL(pressedOutside()));
++
++    QTest::mousePress(m_view, Qt::LeftButton, 0 /*modifiers*/, mousePos);
++
++    qApp->processEvents();
++
++    QCOMPARE(pressedOutsideSpy.count(), 1);
++
++    QTest::mouseRelease(m_view, Qt::LeftButton, 0 /*modifiers*/, mousePos);
++}
++
++void tst_PressedOutsideNotifier::mousePresssInsideAreaHasNoEffect()
++{
++    QPoint mousePos = QPoint(m_blueRect->x() + m_blueRect->width()*0.5,
++                             m_blueRect->y() + m_blueRect->height()*0.5);
++
++    QSignalSpy pressedOutsideSpy(m_notifier, SIGNAL(pressedOutside()));
++
++    QTest::mousePress(m_view, Qt::LeftButton, 0 /*modifiers*/, mousePos);
++
++    qApp->processEvents();
++
++    QCOMPARE(pressedOutsideSpy.count(), 0);
++
++    QTest::mouseRelease(m_view, Qt::LeftButton, 0 /*modifiers*/, mousePos);
++}
++
++void tst_PressedOutsideNotifier::nothingHappensWhileDisabled()
++{
++    QPoint touch0 = QPoint(m_blueRect->x() - 50, m_blueRect->y() - 50);
++
++    QSignalSpy pressedOutsideSpy(m_notifier, SIGNAL(pressedOutside()));
++
++    m_notifier->setEnabled(false);
++
++    QTest::touchEvent(m_view, m_device)
++        .press(0, touch0);
++
++    qApp->processEvents();
++
++    QCOMPARE(pressedOutsideSpy.count(), 0);
++
++    QTest::touchEvent(m_view, m_device)
++        .release(0, touch0);
++}
++
++QTEST_MAIN(tst_PressedOutsideNotifier)
++
++#include "tst_PressedOutsideNotifier.moc"
 === added file 'tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.qml'
 --- tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.qml	1970-01-01 00:00:00 +0000
 +++ tests/plugins/Ubuntu/Gestures/tst_PressedOutsideNotifier.qml	2013-11-22 10:45:28 +0000
@@ -0,0 +1,61 @@
++/*
++ * Copyright (C) 2013 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.0
++import Ubuntu.Gestures 0.1
++
++/*
++  NB: If you change positions or sizes here make sure
++      tst_PressedOutsideNotifier.cpp is updated accordingly
++ */
++
++Rectangle {
++    width: 600
++    height: 600
++    color: "white"
++
++    Rectangle {
++        id: blueRect
++        objectName: "blueRect"
++        color: "blue"
++        x: 100
++        y: 100
++        width: 200
++        height: 200
++
++        Timer {
++            id: resetColorTimer
++            interval: 300
++            repeat: false
++            onTriggered: {
++                blueRect.color = "blue";
++            }
++        }
++
++        function blinkRed() {
++            blueRect.color = "red";
++            resetColorTimer.start();
++        }
++
++        PressedOutsideNotifier {
++            objectName: "pressedOutsideNotifier"
++            anchors.fill: parent
++            onPressedOutside: {
++                blueRect.blinkRed();
++            }
++        }
++    }
++}
 === modified file 'tests/qmltests/CMakeLists.txt'
 --- tests/qmltests/CMakeLists.txt	2013-11-19 09:43:35 +0000
 +++ tests/qmltests/CMakeLists.txt	2013-11-22 10:45:28 +0000
@@ -46,7 +46,9 @@
  add_qml_test(Dash GenericScopeView IMPORT_PATHS ${CMAKE_BINARY_DIR}/plugins ${qmltest_DEFAULT_IMPORT_PATHS})
  add_qml_test(Dash FilterGrids IMPORT_PATHS ${qmltest_DEFAULT_IMPORT_PATHS} ${CMAKE_BINARY_DIR}/plugins ${CMAKE_CURRENT_SOURCE_DIR}/plugins
                                             ${CMAKE_BINARY_DIR}/tests/mocks)
--add_qml_test(Dash/Apps RunningApplicationsGrid IMPORT_PATHS ${qmltest_DEFAULT_IMPORT_PATHS} ${CMAKE_BINARY_DIR}/tests/mocks)
++add_qml_test(Dash/Apps RunningApplicationsGrid IMPORT_PATHS ${qmltest_DEFAULT_IMPORT_PATHS}
++                                                            ${CMAKE_BINARY_DIR}/tests/mocks
++                                                            ${CMAKE_BINARY_DIR}/plugins)
  add_qml_test(Dash/Apps AppPreview IMPORT_PATHS ${qmltest_DEFAULT_IMPORT_PATHS} ${CMAKE_BINARY_DIR}/tests/mocks)
  add_qml_test(Dash/Movie MoviePreview IMPORT_PATHS ${qmltest_DEFAULT_IMPORT_PATHS} ${CMAKE_BINARY_DIR}/tests/mocks)
  add_qml_test(Greeter Lockscreen IMPORT_PATHS ${CMAKE_BINARY_DIR}/plugins ${qmltest_DEFAULT_IMPORT_PATHS}
 === modified file 'tests/qmltests/Dash/Apps/tst_RunningApplicationsGrid.qml'
 --- tests/qmltests/Dash/Apps/tst_RunningApplicationsGrid.qml	2013-10-25 07:59:15 +0000
 +++ tests/qmltests/Dash/Apps/tst_RunningApplicationsGrid.qml	2013-11-22 10:45:28 +0000
@@ -239,5 +239,25 @@
              return findChild(runningApplicationsGrid, "runningAppTile Calendar")
                      != undefined
+         }
++
++        // While in termination mode, if you click outside any of the tiles, the
++        // termination mode is disabled (i.e. we switch back to activation mode).
++        function test_clickOutsideTilesDisablesTerminationMode() {
++            runningApplicationsGrid.terminationModeEnabled = true
++
++            var calendarTile = findChild(runningApplicationsGrid, "runningAppTile Calendar")
++            verify(calendarTile != undefined)
++
++            verify(runningApplicationsGrid.terminationModeEnabled);
++
++            // Click on the bottom right corner of the grid, where there's no
++            // RunningApplicationTile lying around
++            mouseClick(runningApplicationsGrid,
++                       runningApplicationsGrid.width - 1, runningApplicationsGrid.height - 1);
++
++            wait(0) // spin event loop to ensure that any pending signal emission went through
++
++            verify(!runningApplicationsGrid.terminationModeEnabled);
++        }
+     }
+ }