1
=== modified file 'libs/UbuntuGestures/CMakeLists.txt'
2
--- libs/UbuntuGestures/CMakeLists.txt	2014-10-01 13:20:32 +0000
3
+++ libs/UbuntuGestures/CMakeLists.txt	2015-04-10 21:17:56 +0000
4
@@ -5,6 +5,7 @@
5
5
    CandidateInactivityTimer.cpp
5
    CandidateInactivityTimer.cpp
6
6
    DebugHelpers.cpp
6
    DebugHelpers.cpp
7
7
    Timer.cpp
7
    Timer.cpp
8
8
    TimeSource.cpp
9
8
    TouchOwnershipEvent.cpp
9
    TouchOwnershipEvent.cpp
10
9
    TouchRegistry.cpp
10
    TouchRegistry.cpp
11
10
    UnownedTouchEvent.cpp
11
    UnownedTouchEvent.cpp
12
11
12
13
=== modified file 'libs/UbuntuGestures/CandidateInactivityTimer.h'
14
--- libs/UbuntuGestures/CandidateInactivityTimer.h	2014-10-01 13:20:32 +0000
15
+++ libs/UbuntuGestures/CandidateInactivityTimer.h	2015-04-10 21:17:56 +0000
16
@@ -32,7 +32,7 @@
17
32
                             AbstractTimerFactory &timerFactory,
32
                             AbstractTimerFactory &timerFactory,
18
33
                             QObject *parent = nullptr);
33
                             QObject *parent = nullptr);
19
34
34
21
35
    const int durationMs = 350;
35
    const int durationMs = 1000;
22
36
36
23
37
Q_SIGNALS:
37
Q_SIGNALS:
24
38
    void candidateDefaulted(int touchId, QQuickItem *candidate);
38
    void candidateDefaulted(int touchId, QQuickItem *candidate);
25
39
39
26
=== renamed file 'plugins/Ubuntu/Gestures/TimeSource.cpp' => 'libs/UbuntuGestures/TimeSource.cpp'
27
=== renamed file 'plugins/Ubuntu/Gestures/TimeSource.h' => 'libs/UbuntuGestures/TimeSource.h'
28
--- plugins/Ubuntu/Gestures/TimeSource.h	2014-10-01 13:20:32 +0000
29
+++ libs/UbuntuGestures/TimeSource.h	2015-04-10 21:17:56 +0000
30
@@ -1,5 +1,5 @@
31
1
/*
1
/*
33
2
 * Copyright (C) 2013 - Canonical Ltd.
2
 * Copyright (C) 2013,2015 Canonical Ltd.
34
3
 *
3
 *
35
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
36
5
 * under the terms of the GNU Lesser General Public License, as
5
 * under the terms of the GNU Lesser General Public License, as
37
@@ -21,14 +21,14 @@
38
21
#ifndef UBUNTUGESTURES_TIMESOURCE_H
21
#ifndef UBUNTUGESTURES_TIMESOURCE_H
39
22
#define UBUNTUGESTURES_TIMESOURCE_H
22
#define UBUNTUGESTURES_TIMESOURCE_H
40
23
23
42
24
#include "UbuntuGesturesQmlGlobal.h"
24
#include "UbuntuGesturesGlobal.h"
43
25
#include <QSharedPointer>
25
#include <QSharedPointer>
44
26
26
45
27
namespace UbuntuGestures {
27
namespace UbuntuGestures {
46
28
/*
28
/*
47
29
    Interface for a time source.
29
    Interface for a time source.
48
30
 */
30
 */
50
31
class UBUNTUGESTURESQML_EXPORT TimeSource {
31
class UBUNTUGESTURES_EXPORT TimeSource {
51
32
public:
32
public:
52
33
    virtual ~TimeSource() {}
33
    virtual ~TimeSource() {}
53
34
    /* Returns the current time in milliseconds since some reference time in the past. */
34
    /* Returns the current time in milliseconds since some reference time in the past. */
54
@@ -40,7 +40,7 @@
55
40
    Implementation of a time source
40
    Implementation of a time source
56
41
 */
41
 */
57
42
class RealTimeSourcePrivate;
42
class RealTimeSourcePrivate;
59
43
class RealTimeSource : public TimeSource {
43
class UBUNTUGESTURES_EXPORT RealTimeSource : public TimeSource {
60
44
public:
44
public:
61
45
    RealTimeSource();
45
    RealTimeSource();
62
46
    virtual ~RealTimeSource();
46
    virtual ~RealTimeSource();
63
@@ -49,6 +49,16 @@
64
49
    RealTimeSourcePrivate *d;
49
    RealTimeSourcePrivate *d;
65
50
};
50
};
66
51
51
67
52
/*
68
53
    A fake time source, useful for tests
69
54
 */
70
55
class FakeTimeSource : public TimeSource {
71
56
public:
72
57
    FakeTimeSource() { m_msecsSinceReference = 0; }
73
58
    qint64 msecsSinceReference() override { return m_msecsSinceReference; }
74
59
    qint64 m_msecsSinceReference;
75
60
};
76
61
77
52
} // namespace UbuntuGestures
62
} // namespace UbuntuGestures
78
53
63
79
54
#endif // UBUNTUGESTURES_TIMESOURCE_H
64
#endif // UBUNTUGESTURES_TIMESOURCE_H
80
55
65
81
=== modified file 'libs/UbuntuGestures/Timer.cpp'
82
--- libs/UbuntuGestures/Timer.cpp	2014-10-01 13:20:32 +0000
83
+++ libs/UbuntuGestures/Timer.cpp	2015-04-10 21:17:56 +0000
84
@@ -1,5 +1,5 @@
85
1
/*
1
/*
87
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014-2015 Canonical, Ltd.
88
3
 *
3
 *
89
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
90
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
91
@@ -58,11 +58,34 @@
92
58
58
93
59
/////////////////////////////////// FakeTimer //////////////////////////////////
59
/////////////////////////////////// FakeTimer //////////////////////////////////
94
60
60
96
61
FakeTimer::FakeTimer(QObject *parent)
61
FakeTimer::FakeTimer(const SharedTimeSource &timeSource, QObject *parent)
97
62
    : UbuntuGestures::AbstractTimer(parent)
62
    : UbuntuGestures::AbstractTimer(parent)
98
63
    , m_interval(0)
63
    , m_interval(0)
99
64
    , m_singleShot(false)
64
    , m_singleShot(false)
101
65
{
65
    , m_timeSource(timeSource)
102
66
{
103
67
}
104
68
105
69
void FakeTimer::update()
106
70
{
107
71
    if (!isRunning()) {
108
72
        return;
109
73
    }
110
74
111
75
    if (m_nextTimeoutTime <= m_timeSource->msecsSinceReference()) {
112
76
        if (isSingleShot()) {
113
77
            stop();
114
78
        } else {
115
79
            m_nextTimeoutTime += interval();
116
80
        }
117
81
        Q_EMIT timeout();
118
82
    }
119
83
}
120
84
121
85
void FakeTimer::start()
122
86
{
123
87
    AbstractTimer::start();
124
88
    m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)interval();
125
66
}
89
}
126
67
90
127
68
int FakeTimer::interval() const
91
int FakeTimer::interval() const
128
@@ -87,23 +110,53 @@
129
87
110
130
88
/////////////////////////////////// FakeTimerFactory //////////////////////////////////
111
/////////////////////////////////// FakeTimerFactory //////////////////////////////////
131
89
112
132
113
FakeTimerFactory::FakeTimerFactory()
133
114
{
134
115
    m_timeSource.reset(new FakeTimeSource);
135
116
}
136
117
137
118
FakeTimerFactory::~FakeTimerFactory()
138
119
{
139
120
    for (int i = 0; i < timers.count(); ++i) {
140
121
        FakeTimer *timer = timers[i].data();
141
122
        if (timer) {
142
123
            delete timer;
143
124
        }
144
125
    }
145
126
}
146
127
147
128
void FakeTimerFactory::updateTime(qint64 targetTime)
148
129
{
149
130
    qint64 minTimeoutTime = targetTime;
150
131
151
132
    for (int i = 0; i < timers.count(); ++i) {
152
133
        FakeTimer *timer = timers[i].data();
153
134
        if (timer && timer->isRunning() && timer->nextTimeoutTime() < minTimeoutTime) {
154
135
            minTimeoutTime = timer->nextTimeoutTime();
155
136
        }
156
137
    }
157
138
158
139
    m_timeSource->m_msecsSinceReference = minTimeoutTime;
159
140
160
141
    for (int i = 0; i < timers.count(); ++i) {
161
142
        FakeTimer *timer = timers[i].data();
162
143
        if (timer) {
163
144
            timer->update();
164
145
        }
165
146
    }
166
147
167
148
    if (m_timeSource->msecsSinceReference() < targetTime) {
168
149
        updateTime(targetTime);
169
150
    }
170
151
}
171
152
172
90
AbstractTimer *FakeTimerFactory::createTimer(QObject *parent)
153
AbstractTimer *FakeTimerFactory::createTimer(QObject *parent)
173
91
{
154
{
175
92
    FakeTimer *fakeTimer = new FakeTimer(parent);
155
    FakeTimer *fakeTimer = new FakeTimer(m_timeSource, parent);
176
93
156
177
94
    timers.append(fakeTimer);
157
    timers.append(fakeTimer);
178
95
158
179
96
    return fakeTimer;
159
    return fakeTimer;
180
97
}
160
}
181
98
161
182
99
void FakeTimerFactory::makeRunningTimersTimeout()
183
100
{
184
101
    for (int i = 0; i < timers.count(); ++i) {
185
102
        FakeTimer *timer = timers[i].data();
186
103
        if (timer && timer->isRunning()) {
187
104
            timer->emitTimeout();
188
105
        }
189
106
    }
190
107
}
191
108
192
109
} // namespace UbuntuGestures
162
} // namespace UbuntuGestures
193
110
163
194
=== modified file 'libs/UbuntuGestures/Timer.h'
195
--- libs/UbuntuGestures/Timer.h	2014-10-01 13:20:32 +0000
196
+++ libs/UbuntuGestures/Timer.h	2015-04-10 21:17:56 +0000
197
@@ -18,6 +18,7 @@
198
18
#define UBUNTUGESTURES_TIMER_H
18
#define UBUNTUGESTURES_TIMER_H
199
19
19
200
20
#include "UbuntuGesturesGlobal.h"
20
#include "UbuntuGesturesGlobal.h"
201
21
#include "TimeSource.h"
202
21
22
203
22
#include <QObject>
23
#include <QObject>
204
23
#include <QPointer>
24
#include <QPointer>
205
@@ -66,17 +67,21 @@
206
66
{
67
{
207
67
    Q_OBJECT
68
    Q_OBJECT
208
68
public:
69
public:
210
69
    FakeTimer(QObject *parent = nullptr);
70
    FakeTimer(const SharedTimeSource &timeSource, QObject *parent = nullptr);
211
70
71
213
71
    virtual void emitTimeout() { Q_EMIT timeout(); }
72
    void update();
214
73
    qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }
215
72
74
216
73
    int interval() const override;
75
    int interval() const override;
217
74
    void setInterval(int msecs) override;
76
    void setInterval(int msecs) override;
218
77
    void start() override;
219
75
    bool isSingleShot() const override;
78
    bool isSingleShot() const override;
220
76
    void setSingleShot(bool value) override;
79
    void setSingleShot(bool value) override;
221
77
private:
80
private:
222
78
    int m_interval;
81
    int m_interval;
223
79
    bool m_singleShot;
82
    bool m_singleShot;
224
83
    SharedTimeSource m_timeSource;
225
84
    qint64 m_nextTimeoutTime;
226
80
};
85
};
227
81
86
228
82
class UBUNTUGESTURES_EXPORT AbstractTimerFactory
87
class UBUNTUGESTURES_EXPORT AbstractTimerFactory
229
@@ -95,9 +100,16 @@
230
95
class UBUNTUGESTURES_EXPORT FakeTimerFactory : public AbstractTimerFactory
100
class UBUNTUGESTURES_EXPORT FakeTimerFactory : public AbstractTimerFactory
231
96
{
101
{
232
97
public:
102
public:
233
103
    FakeTimerFactory();
234
104
    virtual ~FakeTimerFactory();
235
105
236
106
    void updateTime(qint64 msecsSinceReference);
237
107
    QSharedPointer<TimeSource> timeSource() { return m_timeSource; }
238
108
239
98
    AbstractTimer *createTimer(QObject *parent = nullptr) override;
109
    AbstractTimer *createTimer(QObject *parent = nullptr) override;
240
99
    void makeRunningTimersTimeout();
241
100
    QList<QPointer<FakeTimer>> timers;
110
    QList<QPointer<FakeTimer>> timers;
242
111
private:
243
112
    QSharedPointer<FakeTimeSource> m_timeSource;
244
101
};
113
};
245
102
114
246
103
} // namespace UbuntuGestures
115
} // namespace UbuntuGestures
247
104
116
248
=== modified file 'libs/UbuntuGestures/TouchRegistry.cpp'
249
--- libs/UbuntuGestures/TouchRegistry.cpp	2014-10-01 13:20:32 +0000
250
+++ libs/UbuntuGestures/TouchRegistry.cpp	2015-04-10 21:17:56 +0000
251
@@ -1,5 +1,5 @@
252
1
/*
1
/*
254
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014-2015 Canonical, Ltd.
255
3
 *
3
 *
256
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
257
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
258
@@ -95,10 +95,6 @@
259
95
    //       for each point and there should not be many active points at any given moment.
95
    //       for each point and there should not be many active points at any given moment.
260
96
    //       But having three nested for-loops does scare.
96
    //       But having three nested for-loops does scare.
261
97
97
262
98
    // TODO: Don't send it to the object that is already receiving the regular event
263
99
    // because QQuickWindow is sending it to him (i.e., he's the touch owner from Qt's point of view)
264
100
    // Problem is, we cannnot easily get this information.
265
101
266
102
    const QList<QTouchEvent::TouchPoint> &updatedTouchPoints = event->touchPoints();
98
    const QList<QTouchEvent::TouchPoint> &updatedTouchPoints = event->touchPoints();
267
103
99
268
104
    // Maps an item to the touches in this event he should be informed about.
100
    // Maps an item to the touches in this event he should be informed about.
269
@@ -118,7 +114,9 @@
270
118
                    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
114
                    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
271
119
                        CandidateInfo &candidate = touchInfo->candidates[i];
115
                        CandidateInfo &candidate = touchInfo->candidates[i];
272
120
                        Q_ASSERT(!candidate.item.isNull());
116
                        Q_ASSERT(!candidate.item.isNull());
274
121
                        touchIdsForItems[candidate.item.data()].append(touchInfo->id);
117
                        if (candidate.state != CandidateInfo::InterimOwner) {
275
118
                            touchIdsForItems[candidate.item.data()].append(touchInfo->id);
276
119
                        }
277
122
                    }
120
                    }
278
123
                }
121
                }
279
124
122
280
@@ -260,7 +258,7 @@
281
260
    // TODO: Check if candidate already exists
258
    // TODO: Check if candidate already exists
282
261
259
283
262
    CandidateInfo candidateInfo;
260
    CandidateInfo candidateInfo;
285
263
    candidateInfo.undecided = true;
261
    candidateInfo.state = CandidateInfo::Undecided;
286
264
    candidateInfo.item = candidate;
262
    candidateInfo.item = candidate;
287
265
    candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,
263
    candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,
288
266
                                                                 *m_timerFactory,
264
                                                                 *m_timerFactory,
289
@@ -301,8 +299,8 @@
290
301
    for (int i = 0; i < touchInfo->candidates.count() && indexRemoved == -1; ++i) {
299
    for (int i = 0; i < touchInfo->candidates.count() && indexRemoved == -1; ++i) {
291
302
        CandidateInfo &candidateInfo = touchInfo->candidates[i];
300
        CandidateInfo &candidateInfo = touchInfo->candidates[i];
292
303
        if (candidateInfo.item == candidate) {
301
        if (candidateInfo.item == candidate) {
295
304
            Q_ASSERT(i > 0 || candidateInfo.undecided);
302
            Q_ASSERT(i > 0 || candidateInfo.state == CandidateInfo::Undecided);
296
305
            if (i == 0 && !candidateInfo.undecided) {
303
            if (i == 0 && candidateInfo.state != CandidateInfo::Undecided) {
297
306
                qCritical("TouchRegistry: touch owner is being removed.");
304
                qCritical("TouchRegistry: touch owner is being removed.");
298
307
            }
305
            }
299
308
            delete candidateInfo.inactivityTimer;
306
            delete candidateInfo.inactivityTimer;
300
@@ -340,7 +338,7 @@
301
340
    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
338
    for (int i = 0; i < touchInfo->candidates.count(); ++i) {
302
341
        CandidateInfo &candidateInfo = touchInfo->candidates[i];
339
        CandidateInfo &candidateInfo = touchInfo->candidates[i];
303
342
        if (candidateInfo.item == candidate) {
340
        if (candidateInfo.item == candidate) {
305
343
            candidateInfo.undecided = false;
341
            candidateInfo.state = CandidateInfo::Requested;
306
344
            delete candidateInfo.inactivityTimer;
342
            delete candidateInfo.inactivityTimer;
307
345
            candidateInfo.inactivityTimer = nullptr;
343
            candidateInfo.inactivityTimer = nullptr;
308
346
            candidateIndex = i;
344
            candidateIndex = i;
309
@@ -351,7 +349,7 @@
310
351
    // add it as a candidate if not present yet
349
    // add it as a candidate if not present yet
311
352
    if (candidateIndex < 0) {
350
    if (candidateIndex < 0) {
312
353
        CandidateInfo candidateInfo;
351
        CandidateInfo candidateInfo;
314
354
        candidateInfo.undecided = false;
352
        candidateInfo.state = CandidateInfo::InterimOwner;
315
355
        candidateInfo.item = candidate;
353
        candidateInfo.item = candidate;
316
356
        candidateInfo.inactivityTimer = nullptr;
354
        candidateInfo.inactivityTimer = nullptr;
317
357
        touchInfo->candidates.append(candidateInfo);
355
        touchInfo->candidates.append(candidateInfo);
318
@@ -407,8 +405,8 @@
319
407
    for (int i = 0; i < touchInfo->candidates.count() && rejectedCandidateIndex == -1; ++i) {
405
    for (int i = 0; i < touchInfo->candidates.count() && rejectedCandidateIndex == -1; ++i) {
320
408
        CandidateInfo &candidateInfo = touchInfo->candidates[i];
406
        CandidateInfo &candidateInfo = touchInfo->candidates[i];
321
409
        if (candidateInfo.item == candidate) {
407
        if (candidateInfo.item == candidate) {
324
410
            Q_ASSERT(i > 0 || candidateInfo.undecided);
408
            Q_ASSERT(i > 0 || candidateInfo.state == CandidateInfo::Undecided);
325
411
            if (i == 0 && !candidateInfo.undecided) {
409
            if (i == 0 && candidateInfo.state != CandidateInfo::Undecided) {
326
412
                qCritical() << "TouchRegistry: Can't reject item (" << (void*)candidate
410
                qCritical() << "TouchRegistry: Can't reject item (" << (void*)candidate
327
413
                    << ") as it already owns touch" << id;
411
                    << ") as it already owns touch" << id;
328
414
                return;
412
                return;
329
@@ -467,7 +465,7 @@
330
467
465
331
468
bool TouchRegistry::TouchInfo::isOwned() const
466
bool TouchRegistry::TouchInfo::isOwned() const
332
469
{
467
{
334
470
    return !candidates.isEmpty() && !candidates.first().undecided;
468
    return !candidates.isEmpty() && candidates.first().state != CandidateInfo::Undecided;
335
471
}
469
}
336
472
470
337
473
bool TouchRegistry::TouchInfo::ended() const
471
bool TouchRegistry::TouchInfo::ended() const
338
474
472
339
=== modified file 'libs/UbuntuGestures/TouchRegistry.h'
340
--- libs/UbuntuGestures/TouchRegistry.h	2014-10-02 12:47:07 +0000
341
+++ libs/UbuntuGestures/TouchRegistry.h	2015-04-10 21:17:56 +0000
342
@@ -79,9 +79,11 @@
343
79
  If an item wants ownership over touches as soon as he receives the TouchBegin for them, his step 1
79
  If an item wants ownership over touches as soon as he receives the TouchBegin for them, his step 1
344
80
  would be instead:
80
  would be instead:
345
81
        TouchRegistry::instance()->requestTouchOwnership(touchId, this);
81
        TouchRegistry::instance()->requestTouchOwnership(touchId, this);
349
82
        return true;
82
        touchEvent->accept();
350
83
  He would then be notified once ownership has been granted to him, from which point onwards he could
83
  He won't get any UnownedTouchEvent for that touch as he is already the interim owner (ie, QQuickWindow
351
84
  safely assume other TouchRegistry users wouldn't snatch this touch away from him.
84
  will keep sending touch updates to him already). Eventually he will be notified once ownership has
352
85
  been granted to him (from TouchRegistry perspective), from which point onwards he could safely assume
353
86
  other TouchRegistry users wouldn't snatch this touch away from him.
354
85
87
355
86
  Items oblivious to TouchRegistry will lose their touch points without warning, just like in plain Qt.
88
  Items oblivious to TouchRegistry will lose their touch points without warning, just like in plain Qt.
356
87
89
357
@@ -132,7 +134,19 @@
358
132
private:
134
private:
359
133
    class CandidateInfo {
135
    class CandidateInfo {
360
134
    public:
136
    public:
362
135
        bool undecided;
137
        enum {
363
138
            // A candidate owner that doesn't yet know for sure whether he wants the touch point
364
139
            // (gesture recognition is stilll going on)
365
140
            Undecided = 0,
366
141
            // A candidate owner that wants the touch but hasn't been granted it yet,
367
142
            // most likely because there's an undecided candidate with higher priority
368
143
            Requested = 1,
369
144
            // An item that is the interim owner of the touch, receiving QTouchEvents of it
370
145
            // from QQuickWindow. Ie, it's the actual touch owner from Qt's point of view.
371
146
            // It wants to keep its touch ownership but hasn't been granted it by TouchRegistry
372
147
            // yet because of undecided candidates higher up.
373
148
            InterimOwner = 2
374
149
        } state;
375
136
        // TODO: Prune candidates that become null and resolve ownership accordingly.
150
        // TODO: Prune candidates that become null and resolve ownership accordingly.
376
137
        QPointer<QQuickItem> item;
151
        QPointer<QQuickItem> item;
377
138
        QPointer<UbuntuGestures::CandidateInactivityTimer> inactivityTimer;
152
        QPointer<UbuntuGestures::CandidateInactivityTimer> inactivityTimer;
378
139
153
379
=== modified file 'plugins/Ubuntu/Gestures/CMakeLists.txt'
380
--- plugins/Ubuntu/Gestures/CMakeLists.txt	2014-10-17 11:01:53 +0000
381
+++ plugins/Ubuntu/Gestures/CMakeLists.txt	2015-04-10 21:17:56 +0000
382
@@ -4,10 +4,10 @@
383
4
set(UbuntuGesturesQml_SOURCES
4
set(UbuntuGesturesQml_SOURCES
384
5
    plugin.cpp
5
    plugin.cpp
385
6
    AxisVelocityCalculator.cpp
6
    AxisVelocityCalculator.cpp
386
7
    Damper.cpp
387
7
    Direction.cpp
8
    Direction.cpp
388
8
    DirectionalDragArea.cpp
9
    DirectionalDragArea.cpp
389
9
    PressedOutsideNotifier.cpp
10
    PressedOutsideNotifier.cpp
390
10
    TimeSource.cpp
391
11
    TouchDispatcher.cpp
11
    TouchDispatcher.cpp
392
12
    TouchGate.cpp
12
    TouchGate.cpp
393
13
)
13
)
394
14
14
395
=== added file 'plugins/Ubuntu/Gestures/Damper.cpp'
396
--- plugins/Ubuntu/Gestures/Damper.cpp	1970-01-01 00:00:00 +0000
397
+++ plugins/Ubuntu/Gestures/Damper.cpp	2015-04-10 21:17:56 +0000
398
@@ -0,0 +1,24 @@
399
1
/*
400
2
 * Copyright (C) 2015 Canonical, Ltd.
401
3
 *
402
4
 * This program is free software; you can redistribute it and/or modify
403
5
 * it under the terms of the GNU General Public License as published by
404
6
 * the Free Software Foundation; version 3.
405
7
 *
406
8
 * This program is distributed in the hope that it will be useful,
407
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
408
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
409
11
 * GNU General Public License for more details.
410
12
 *
411
13
 * You should have received a copy of the GNU General Public License
412
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
413
15
 */
414
16
415
17
#include "Damper.h"
416
18
#include <QDebug>
417
19
418
20
QDebug operator<<(QDebug dbg, const DampedPointF &p)
419
21
{
420
22
    dbg.nospace() << "(" << p.x() << ", " << p.y() << ")";
421
23
    return dbg.space();
422
24
}
423
0
25
424
=== modified file 'plugins/Ubuntu/Gestures/Damper.h'
425
--- plugins/Ubuntu/Gestures/Damper.h	2013-08-06 13:18:34 +0000
426
+++ plugins/Ubuntu/Gestures/Damper.h	2015-04-10 21:17:56 +0000
427
@@ -84,4 +84,6 @@
428
84
    Damper<qreal> m_y;
84
    Damper<qreal> m_y;
429
85
};
85
};
430
86
86
431
87
QDebug operator<<(QDebug dbg, const DampedPointF &p);
432
88
433
87
#endif // UBUNTU_GESTURES_DAMPER_H
89
#endif // UBUNTU_GESTURES_DAMPER_H
434
88
90
435
=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
436
--- plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2014-12-09 11:00:37 +0000
437
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2015-04-10 21:17:56 +0000
438
@@ -1,5 +1,5 @@
439
1
/*
1
/*
441
2
 * Copyright (C) 2013-2014 Canonical, Ltd.
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
442
3
 *
3
 *
443
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
444
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
445
@@ -21,6 +21,7 @@
446
21
21
447
22
#include <QQuickWindow>
22
#include <QQuickWindow>
448
23
#include <QtCore/qmath.h>
23
#include <QtCore/qmath.h>
449
24
#include <QScreen>
450
24
#include <QDebug>
25
#include <QDebug>
451
25
26
452
26
#pragma GCC diagnostic push
27
#pragma GCC diagnostic push
453
@@ -33,6 +34,8 @@
454
33
#include "TouchRegistry.h"
34
#include "TouchRegistry.h"
455
34
#include "UnownedTouchEvent.h"
35
#include "UnownedTouchEvent.h"
456
35
36
457
37
#include "DirectionalDragArea_p.h"
458
38
459
36
using namespace UbuntuGestures;
39
using namespace UbuntuGestures;
460
37
40
461
38
#if DIRECTIONALDRAGAREA_DEBUG
41
#if DIRECTIONALDRAGAREA_DEBUG
462
@@ -40,11 +43,11 @@
463
40
#include "DebugHelpers.h"
43
#include "DebugHelpers.h"
464
41
44
465
42
namespace {
45
namespace {
467
43
const char *statusToString(DirectionalDragArea::Status status)
46
const char *statusToString(DirectionalDragAreaPrivate::Status status)
468
44
{
47
{
470
45
    if (status == DirectionalDragArea::WaitingForTouch) {
48
    if (status == DirectionalDragAreaPrivate::WaitingForTouch) {
471
46
        return "WaitingForTouch";
49
        return "WaitingForTouch";
473
47
    } else if (status == DirectionalDragArea::Undecided) {
50
    } else if (status == DirectionalDragAreaPrivate::Undecided) {
474
48
        return "Undecided";
51
        return "Undecided";
475
49
    } else {
52
    } else {
476
50
        return "Recognized";
53
        return "Recognized";
477
@@ -56,205 +59,156 @@
478
56
#define ddaDebug(params) ((void)0)
59
#define ddaDebug(params) ((void)0)
479
57
#endif // DIRECTIONALDRAGAREA_DEBUG
60
#endif // DIRECTIONALDRAGAREA_DEBUG
480
58
61
481
59
482
60
DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)
62
DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)
483
61
    : QQuickItem(parent)
63
    : QQuickItem(parent)
501
62
    , m_status(WaitingForTouch)
64
    , d(new DirectionalDragAreaPrivate(this))
485
63
    , m_sceneDistance(0)
486
64
    , m_touchId(-1)
487
65
    , m_direction(Direction::Rightwards)
488
66
    , m_wideningAngle(0)
489
67
    , m_wideningFactor(0)
490
68
    , m_distanceThreshold(0)
491
69
    , m_distanceThresholdSquared(0.)
492
70
    , m_minSpeed(0)
493
71
    , m_maxSilenceTime(200)
494
72
    , m_silenceTime(0)
495
73
    , m_compositionTime(60)
496
74
    , m_numSamplesOnLastSpeedCheck(0)
497
75
    , m_recognitionTimer(0)
498
76
    , m_velocityCalculator(0)
499
77
    , m_timeSource(new RealTimeSource)
500
78
    , m_activeTouches(m_timeSource)
502
79
{
65
{
511
80
    setRecognitionTimer(new Timer(this));
66
    d->setRecognitionTimer(new Timer(this));
512
81
    m_recognitionTimer->setInterval(60);
67
    d->recognitionTimer->setInterval(d->maxTime);
513
82
    m_recognitionTimer->setSingleShot(false);
68
    d->recognitionTimer->setSingleShot(true);
514
83
69
515
84
    m_velocityCalculator = new AxisVelocityCalculator(this);
70
    connect(this, &QQuickItem::enabledChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);
516
85
71
    connect(this, &QQuickItem::visibleChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);
509
86
    connect(this, &QQuickItem::enabledChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
510
87
    connect(this, &QQuickItem::visibleChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
517
88
}
72
}
518
89
73
519
90
Direction::Type DirectionalDragArea::direction() const
74
Direction::Type DirectionalDragArea::direction() const
520
91
{
75
{
522
92
    return m_direction;
76
    return d->direction;
523
93
}
77
}
524
94
78
525
95
void DirectionalDragArea::setDirection(Direction::Type direction)
79
void DirectionalDragArea::setDirection(Direction::Type direction)
526
96
{
80
{
597
97
    if (direction != m_direction) {
81
    if (direction != d->direction) {
598
98
        m_direction = direction;
82
        d->direction = direction;
599
99
        Q_EMIT directionChanged(m_direction);
83
        Q_EMIT directionChanged(d->direction);
600
100
    }
84
    }
601
101
}
85
}
602
102
86
603
103
void DirectionalDragArea::setMaxDeviation(qreal value)
87
void DirectionalDragAreaPrivate::setDistanceThreshold(qreal value)
604
104
{
88
{
605
105
    if (m_dampedScenePos.maxDelta() != value) {
89
    if (distanceThreshold != value) {
606
106
        m_dampedScenePos.setMaxDelta(value);
90
        distanceThreshold = value;
607
107
        Q_EMIT maxDeviationChanged(value);
91
        distanceThresholdSquared = distanceThreshold * distanceThreshold;
608
108
    }
92
    }
609
109
}
93
}
610
110
94
611
111
qreal DirectionalDragArea::wideningAngle() const
95
void DirectionalDragAreaPrivate::setMaxTime(int value)
612
112
{
96
{
613
113
    return m_wideningAngle;
97
    if (maxTime != value) {
614
114
}
98
        maxTime = value;
615
115
99
        recognitionTimer->setInterval(maxTime);
616
116
void DirectionalDragArea::setWideningAngle(qreal angle)
100
    }
617
117
{
101
}
618
118
    if (angle == m_wideningAngle)
102
619
119
        return;
103
void DirectionalDragAreaPrivate::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
550
120
551
121
    m_wideningAngle = angle;
552
122
553
123
    // wideningFactor = pow(cosine(angle), 2)
554
124
    {
555
125
        qreal angleRadians = angle * M_PI / 180.0;
556
126
        m_wideningFactor = qCos(angleRadians);
557
127
        m_wideningFactor = m_wideningFactor * m_wideningFactor;
558
128
    }
559
129
560
130
    Q_EMIT wideningAngleChanged(angle);
561
131
}
562
132
563
133
void DirectionalDragArea::setDistanceThreshold(qreal value)
564
134
{
565
135
    if (m_distanceThreshold != value) {
566
136
        m_distanceThreshold = value;
567
137
        m_distanceThresholdSquared = m_distanceThreshold * m_distanceThreshold;
568
138
        Q_EMIT distanceThresholdChanged(value);
569
139
    }
570
140
}
571
141
572
142
void DirectionalDragArea::setMinSpeed(qreal value)
573
143
{
574
144
    if (m_minSpeed != value) {
575
145
        m_minSpeed = value;
576
146
        Q_EMIT minSpeedChanged(value);
577
147
    }
578
148
}
579
149
580
150
void DirectionalDragArea::setMaxSilenceTime(int value)
581
151
{
582
152
    if (m_maxSilenceTime != value) {
583
153
        m_maxSilenceTime = value;
584
154
        Q_EMIT maxSilenceTimeChanged(value);
585
155
    }
586
156
}
587
157
588
158
void DirectionalDragArea::setCompositionTime(int value)
589
159
{
590
160
    if (m_compositionTime != value) {
591
161
        m_compositionTime = value;
592
162
        Q_EMIT compositionTimeChanged(value);
593
163
    }
594
164
}
595
165
596
166
void DirectionalDragArea::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
620
167
{
104
{
621
168
    int interval = 0;
105
    int interval = 0;
622
169
    bool timerWasRunning = false;
106
    bool timerWasRunning = false;
623
170
    bool wasSingleShot = false;
107
    bool wasSingleShot = false;
624
171
108
625
172
    // can be null when called from the constructor
109
    // can be null when called from the constructor
631
173
    if (m_recognitionTimer) {
110
    if (recognitionTimer) {
632
174
        interval = m_recognitionTimer->interval();
111
        interval = recognitionTimer->interval();
633
175
        timerWasRunning = m_recognitionTimer->isRunning();
112
        timerWasRunning = recognitionTimer->isRunning();
634
176
        if (m_recognitionTimer->parent() == this) {
113
        if (recognitionTimer->parent() == this) {
635
177
            delete m_recognitionTimer;
114
            delete recognitionTimer;
636
178
        }
115
        }
637
179
    }
116
    }
638
180
117
640
181
    m_recognitionTimer = timer;
118
    recognitionTimer = timer;
641
182
    timer->setInterval(interval);
119
    timer->setInterval(interval);
642
183
    timer->setSingleShot(wasSingleShot);
120
    timer->setSingleShot(wasSingleShot);
643
184
    connect(timer, &UbuntuGestures::AbstractTimer::timeout,
121
    connect(timer, &UbuntuGestures::AbstractTimer::timeout,
645
185
            this, &DirectionalDragArea::checkSpeed);
122
            this, &DirectionalDragAreaPrivate::rejectGesture);
646
186
    if (timerWasRunning) {
123
    if (timerWasRunning) {
648
187
        m_recognitionTimer->start();
124
        recognitionTimer->start();
649
188
    }
125
    }
650
189
}
126
}
651
190
127
653
191
void DirectionalDragArea::setTimeSource(const SharedTimeSource &timeSource)
128
void DirectionalDragAreaPrivate::setTimeSource(const SharedTimeSource &timeSource)
654
192
{
129
{
658
193
    m_timeSource = timeSource;
130
    this->timeSource = timeSource;
659
194
    m_velocityCalculator->setTimeSource(timeSource);
131
    activeTouches.m_timeSource = timeSource;
657
195
    m_activeTouches.m_timeSource = timeSource;
660
196
}
132
}
661
197
133
662
198
qreal DirectionalDragArea::distance() const
134
qreal DirectionalDragArea::distance() const
663
199
{
135
{
666
200
    if (Direction::isHorizontal(m_direction)) {
136
    if (Direction::isHorizontal(d->direction)) {
667
201
        return m_previousPos.x() - m_startPos.x();
137
        return d->publicPos.x() - d->startPos.x();
668
202
    } else {
138
    } else {
670
203
        return m_previousPos.y() - m_startPos.y();
139
        return d->publicPos.y() - d->startPos.y();
671
204
    }
140
    }
672
205
}
141
}
673
206
142
675
207
void DirectionalDragArea::updateSceneDistance()
143
void DirectionalDragAreaPrivate::updateSceneDistance()
676
208
{
144
{
679
209
    QPointF totalMovement = m_previousScenePos - m_startScenePos;
145
    QPointF totalMovement = publicScenePos - startScenePos;
680
210
    m_sceneDistance = projectOntoDirectionVector(totalMovement);
146
    sceneDistance = projectOntoDirectionVector(totalMovement);
681
211
}
147
}
682
212
148
683
213
qreal DirectionalDragArea::sceneDistance() const
149
qreal DirectionalDragArea::sceneDistance() const
684
214
{
150
{
686
215
    return m_sceneDistance;
151
    return d->sceneDistance;
687
216
}
152
}
688
217
153
689
218
qreal DirectionalDragArea::touchX() const
154
qreal DirectionalDragArea::touchX() const
690
219
{
155
{
692
220
    return m_previousPos.x();
156
    return d->publicPos.x();
693
221
}
157
}
694
222
158
695
223
qreal DirectionalDragArea::touchY() const
159
qreal DirectionalDragArea::touchY() const
696
224
{
160
{
698
225
    return m_previousPos.y();
161
    return d->publicPos.y();
699
226
}
162
}
700
227
163
701
228
qreal DirectionalDragArea::touchSceneX() const
164
qreal DirectionalDragArea::touchSceneX() const
702
229
{
165
{
704
230
    return m_previousScenePos.x();
166
    return d->publicScenePos.x();
705
231
}
167
}
706
232
168
707
233
qreal DirectionalDragArea::touchSceneY() const
169
qreal DirectionalDragArea::touchSceneY() const
708
234
{
170
{
710
235
    return m_previousScenePos.y();
171
    return d->publicScenePos.y();
711
172
}
712
173
713
174
bool DirectionalDragArea::dragging() const
714
175
{
715
176
    return d->status == DirectionalDragAreaPrivate::Recognized;
716
177
}
717
178
718
179
bool DirectionalDragArea::immediateRecognition() const
719
180
{
720
181
    return d->immediateRecognition;
721
182
}
722
183
723
184
void DirectionalDragArea::setImmediateRecognition(bool enabled)
724
185
{
725
186
    if (d->immediateRecognition != enabled) {
726
187
        d->immediateRecognition = enabled;
727
188
        Q_EMIT immediateRecognitionChanged(enabled);
728
189
    }
729
236
}
190
}
730
237
191
731
238
bool DirectionalDragArea::event(QEvent *event)
192
bool DirectionalDragArea::event(QEvent *event)
732
239
{
193
{
733
240
    if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
194
    if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
735
241
        touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
195
        d->touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
736
242
        return true;
196
        return true;
737
243
    } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {
197
    } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {
739
244
        unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));
198
        d->unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));
740
245
        return true;
199
        return true;
741
246
    } else {
200
    } else {
742
247
        return QQuickItem::event(event);
201
        return QQuickItem::event(event);
743
248
    }
202
    }
744
249
}
203
}
745
250
204
747
251
void DirectionalDragArea::touchOwnershipEvent(TouchOwnershipEvent *event)
205
void DirectionalDragAreaPrivate::touchOwnershipEvent(TouchOwnershipEvent *event)
748
252
{
206
{
749
253
    if (event->gained()) {
207
    if (event->gained()) {
750
254
        QVector<int> ids;
208
        QVector<int> ids;
751
255
        ids.append(event->touchId());
209
        ids.append(event->touchId());
752
256
        ddaDebug("grabbing touch");
210
        ddaDebug("grabbing touch");
754
257
        grabTouchPoints(ids);
211
        q->grabTouchPoints(ids);
755
258
212
756
259
        // Work around for Qt bug. If we grab a touch that is being used for mouse pointer
213
        // Work around for Qt bug. If we grab a touch that is being used for mouse pointer
757
260
        // emulation it will cause the emulation logic to go nuts.
214
        // emulation it will cause the emulation logic to go nuts.
758
@@ -262,35 +216,35 @@
759
262
        //
216
        //
760
263
        // The fix for this bug has landed in Qt 5.4 (https://codereview.qt-project.org/96887)
217
        // The fix for this bug has landed in Qt 5.4 (https://codereview.qt-project.org/96887)
761
264
        // TODO: Remove this workaround once we start using Qt 5.4
218
        // TODO: Remove this workaround once we start using Qt 5.4
765
265
        if (window()) {
219
        if (q->window()) {
766
266
            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(window());
220
            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(q->window());
767
267
            if (windowPrivate->touchMouseId == event->touchId() && window()->mouseGrabberItem()) {
221
            if (windowPrivate->touchMouseId == event->touchId() && q->window()->mouseGrabberItem()) {
768
268
                ddaDebug("removing mouse grabber");
222
                ddaDebug("removing mouse grabber");
770
269
                window()->mouseGrabberItem()->ungrabMouse();
223
                q->window()->mouseGrabberItem()->ungrabMouse();
771
270
            }
224
            }
772
271
        }
225
        }
773
272
    } else {
226
    } else {
774
273
        // We still wanna know when it ends for keeping the composition time window up-to-date
227
        // We still wanna know when it ends for keeping the composition time window up-to-date
776
274
        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
228
        TouchRegistry::instance()->addTouchWatcher(touchId, q);
777
275
229
778
276
        setStatus(WaitingForTouch);
230
        setStatus(WaitingForTouch);
779
277
    }
231
    }
780
278
}
232
}
781
279
233
783
280
void DirectionalDragArea::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)
234
void DirectionalDragAreaPrivate::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)
784
281
{
235
{
785
282
    QTouchEvent *event = unownedTouchEvent->touchEvent();
236
    QTouchEvent *event = unownedTouchEvent->touchEvent();
786
283
237
787
284
    Q_ASSERT(!event->touchPointStates().testFlag(Qt::TouchPointPressed));
238
    Q_ASSERT(!event->touchPointStates().testFlag(Qt::TouchPointPressed));
788
285
239
790
286
    ddaDebug("Unowned " << m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
240
    ddaDebug("Unowned " << timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
791
287
241
793
288
    switch (m_status) {
242
    switch (status) {
794
289
        case WaitingForTouch:
243
        case WaitingForTouch:
795
290
            // do nothing
244
            // do nothing
796
291
            break;
245
            break;
797
292
        case Undecided:
246
        case Undecided:
799
293
            Q_ASSERT(isEnabled() && isVisible());
247
            Q_ASSERT(q->isEnabled() && q->isVisible());
800
294
            unownedTouchEvent_undecided(unownedTouchEvent);
248
            unownedTouchEvent_undecided(unownedTouchEvent);
801
295
            break;
249
            break;
802
296
        default: // Recognized:
250
        default: // Recognized:
803
@@ -298,18 +252,18 @@
804
298
            break;
252
            break;
805
299
    }
253
    }
806
300
254
808
301
    m_activeTouches.update(event);
255
    activeTouches.update(event);
809
302
}
256
}
810
303
257
812
304
void DirectionalDragArea::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)
258
void DirectionalDragAreaPrivate::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)
813
305
{
259
{
814
306
    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(unownedTouchEvent->touchEvent());
260
    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(unownedTouchEvent->touchEvent());
815
307
    if (!touchPoint) {
261
    if (!touchPoint) {
817
308
        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << m_touchId
262
        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << touchId
818
309
            << "missing from UnownedTouchEvent without first reaching state Qt::TouchPointReleased. "
263
            << "missing from UnownedTouchEvent without first reaching state Qt::TouchPointReleased. "
819
310
               "Considering it as released.";
264
               "Considering it as released.";
820
311
265
822
312
        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
266
        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
823
313
        setStatus(WaitingForTouch);
267
        setStatus(WaitingForTouch);
824
314
        return;
268
        return;
825
315
    }
269
    }
826
@@ -319,48 +273,42 @@
827
319
    if (touchPoint->state() == Qt::TouchPointReleased) {
273
    if (touchPoint->state() == Qt::TouchPointReleased) {
828
320
        // touch has ended before recognition concluded
274
        // touch has ended before recognition concluded
829
321
        ddaDebug("Touch has ended before recognition concluded");
275
        ddaDebug("Touch has ended before recognition concluded");
849
322
        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
276
        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
850
323
        emitSignalIfTapped();
277
        setStatus(WaitingForTouch);
851
324
        setStatus(WaitingForTouch);
278
        return;
852
325
        return;
279
    }
853
326
    }
280
854
327
281
    previousDampedScenePos.setX(dampedScenePos.x());
855
328
    m_previousDampedScenePos.setX(m_dampedScenePos.x());
282
    previousDampedScenePos.setY(dampedScenePos.y());
856
329
    m_previousDampedScenePos.setY(m_dampedScenePos.y());
283
    dampedScenePos.update(touchScenePos);
838
330
    m_dampedScenePos.update(touchScenePos);
839
331
    updateVelocityCalculator(touchScenePos);
840
332
841
333
    if (!pointInsideAllowedArea()) {
842
334
        ddaDebug("Rejecting gesture because touch point is outside allowed area.");
843
335
        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
844
336
        // We still wanna know when it ends for keeping the composition time window up-to-date
845
337
        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
846
338
        setStatus(WaitingForTouch);
847
339
        return;
848
340
    }
857
341
284
858
342
    if (!movingInRightDirection()) {
285
    if (!movingInRightDirection()) {
859
343
        ddaDebug("Rejecting gesture because touch point is moving in the wrong direction.");
286
        ddaDebug("Rejecting gesture because touch point is moving in the wrong direction.");
861
344
        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
287
        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
862
345
        // We still wanna know when it ends for keeping the composition time window up-to-date
288
        // We still wanna know when it ends for keeping the composition time window up-to-date
864
346
        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
289
        TouchRegistry::instance()->addTouchWatcher(touchId, q);
865
347
        setStatus(WaitingForTouch);
290
        setStatus(WaitingForTouch);
866
348
        return;
291
        return;
867
349
    }
292
    }
868
350
293
869
351
    setPreviousPos(touchPoint->pos());
870
352
    setPreviousScenePos(touchScenePos);
871
353
872
354
    if (isWithinTouchCompositionWindow()) {
294
    if (isWithinTouchCompositionWindow()) {
873
355
        // There's still time for some new touch to appear and ruin our party as it would be combined
295
        // There's still time for some new touch to appear and ruin our party as it would be combined
875
356
        // with our m_touchId one and therefore deny the possibility of a single-finger gesture.
296
        // with our touchId one and therefore deny the possibility of a single-finger gesture.
876
357
        ddaDebug("Sill within composition window. Let's wait more.");
297
        ddaDebug("Sill within composition window. Let's wait more.");
877
358
        return;
298
        return;
878
359
    }
299
    }
879
360
300
882
361
    if (movedFarEnough(touchScenePos)) {
301
    if (movedFarEnoughAlongGestureAxis()) {
883
362
        TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
302
        TouchRegistry::instance()->requestTouchOwnership(touchId, q);
884
363
        setStatus(Recognized);
303
        setStatus(Recognized);
885
304
        setPublicPos(touchPoint->pos());
886
305
        setPublicScenePos(touchScenePos);
887
306
    } else if (isPastMaxDistance()) {
888
307
        ddaDebug("Rejecting gesture because it went farther than maxDistance without getting recognized.");
889
308
        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
890
309
        // We still wanna know when it ends for keeping the composition time window up-to-date
891
310
        TouchRegistry::instance()->addTouchWatcher(touchId, q);
892
311
        setStatus(WaitingForTouch);
893
364
    } else {
312
    } else {
894
365
        ddaDebug("Didn't move far enough yet. Let's wait more.");
313
        ddaDebug("Didn't move far enough yet. Let's wait more.");
895
366
    }
314
    }
896
@@ -371,29 +319,29 @@
897
371
    // TODO: Consider when more than one touch starts in the same event (although it's not possible
319
    // TODO: Consider when more than one touch starts in the same event (although it's not possible
898
372
    //       with Mir's android-input). Have to track them all. Consider it a plus/bonus.
320
    //       with Mir's android-input). Have to track them all. Consider it a plus/bonus.
899
373
321
901
374
    ddaDebug(m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
322
    ddaDebug(d->timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
902
375
323
903
376
    if (!isEnabled() || !isVisible()) {
324
    if (!isEnabled() || !isVisible()) {
904
377
        QQuickItem::touchEvent(event);
325
        QQuickItem::touchEvent(event);
905
378
        return;
326
        return;
906
379
    }
327
    }
907
380
328
911
381
    switch (m_status) {
329
    switch (d->status) {
912
382
        case WaitingForTouch:
330
        case DirectionalDragAreaPrivate::WaitingForTouch:
913
383
            touchEvent_absent(event);
331
            d->touchEvent_absent(event);
914
384
            break;
332
            break;
917
385
        case Undecided:
333
        case DirectionalDragAreaPrivate::Undecided:
918
386
            touchEvent_undecided(event);
334
            d->touchEvent_undecided(event);
919
387
            break;
335
            break;
920
388
        default: // Recognized:
336
        default: // Recognized:
922
389
            touchEvent_recognized(event);
337
            d->touchEvent_recognized(event);
923
390
            break;
338
            break;
924
391
    }
339
    }
925
392
340
927
393
    m_activeTouches.update(event);
341
    d->activeTouches.update(event);
928
394
}
342
}
929
395
343
931
396
void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)
344
void DirectionalDragAreaPrivate::touchEvent_absent(QTouchEvent *event)
932
397
{
345
{
933
398
    // TODO: accept/reject is for the whole event, not per touch id. See how that affects us.
346
    // TODO: accept/reject is for the whole event, not per touch id. See how that affects us.
934
399
347
935
@@ -423,36 +371,41 @@
936
423
                allGood = false;
371
                allGood = false;
937
424
            } else {
372
            } else {
938
425
                // that's our candidate
373
                // that's our candidate
940
426
                m_touchId = touchPoint.id();
374
                touchId = touchPoint.id();
941
427
                newTouchPoint = &touchPoint;
375
                newTouchPoint = &touchPoint;
942
428
            }
376
            }
943
429
        }
377
        }
944
430
    }
378
    }
945
431
379
946
432
    if (allGood) {
380
    if (allGood) {
947
381
        allGood = sanityCheckRecognitionProperties();
948
382
        if (!allGood) {
949
383
            qWarning("DirectionalDragArea: recognition properties are wrongly set. Gesture recognition"
950
384
                " is impossible");
951
385
        }
952
386
    }
953
387
954
388
    if (allGood) {
955
433
        Q_ASSERT(newTouchPoint);
389
        Q_ASSERT(newTouchPoint);
956
434
390
967
435
        m_startPos = newTouchPoint->pos();
391
        startPos = newTouchPoint->pos();
968
436
        m_startScenePos = newTouchPoint->scenePos();
392
        startScenePos = newTouchPoint->scenePos();
969
437
        m_touchId = newTouchPoint->id();
393
        touchId = newTouchPoint->id();
970
438
        m_dampedScenePos.reset(m_startScenePos);
394
        dampedScenePos.reset(startScenePos);
971
439
        m_velocityCalculator->setTrackedPosition(0.);
395
        setPublicPos(startPos);
972
440
        m_velocityCalculator->reset();
396
        
973
441
        m_numSamplesOnLastSpeedCheck = 0;
397
        setPublicScenePos(startScenePos);
964
442
        m_silenceTime = 0;
965
443
        setPreviousPos(m_startPos);
966
444
        setPreviousScenePos(m_startScenePos);
974
445
        updateSceneDirectionVector();
398
        updateSceneDirectionVector();
975
446
399
976
447
        if (recognitionIsDisabled()) {
400
        if (recognitionIsDisabled()) {
977
448
            // Behave like a dumb TouchArea
401
            // Behave like a dumb TouchArea
978
449
            ddaDebug("Gesture recognition is disabled. Requesting touch ownership immediately.");
402
            ddaDebug("Gesture recognition is disabled. Requesting touch ownership immediately.");
980
450
            TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
403
            TouchRegistry::instance()->requestTouchOwnership(touchId, q);
981
451
            setStatus(Recognized);
404
            setStatus(Recognized);
982
452
            event->accept();
405
            event->accept();
983
453
        } else {
406
        } else {
984
454
            // just monitor the touch points for now.
407
            // just monitor the touch points for now.
986
455
            TouchRegistry::instance()->addCandidateOwnerForTouch(m_touchId, this);
408
            TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, q);
987
456
409
988
457
            setStatus(Undecided);
410
            setStatus(Undecided);
989
458
            // Let the item below have it. We will monitor it and grab it later if a gesture
411
            // Let the item below have it. We will monitor it and grab it later if a gesture
990
@@ -465,12 +418,11 @@
991
465
    }
418
    }
992
466
}
419
}
993
467
420
995
468
void DirectionalDragArea::touchEvent_undecided(QTouchEvent *event)
421
void DirectionalDragAreaPrivate::touchEvent_undecided(QTouchEvent *event)
996
469
{
422
{
997
470
    Q_ASSERT(event->type() == QEvent::TouchBegin);
998
471
    Q_ASSERT(fetchTargetTouchPoint(event) == nullptr);
423
    Q_ASSERT(fetchTargetTouchPoint(event) == nullptr);
999
472
424
1001
473
    // We're not interested in new touch points. We already have our candidate (m_touchId).
425
    // We're not interested in new touch points. We already have our candidate (touchId).
1002
474
    // But we do want to know when those new touches end for keeping the composition time
426
    // But we do want to know when those new touches end for keeping the composition time
1003
475
    // window up-to-date
427
    // window up-to-date
1004
476
    event->ignore();
428
    event->ignore();
1005
@@ -480,63 +432,60 @@
1006
480
        // multi-finger drags are not accepted
432
        // multi-finger drags are not accepted
1007
481
        ddaDebug("Multi-finger drags are not accepted");
433
        ddaDebug("Multi-finger drags are not accepted");
1008
482
434
1010
483
        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
435
        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
1011
484
        // We still wanna know when it ends for keeping the composition time window up-to-date
436
        // We still wanna know when it ends for keeping the composition time window up-to-date
1013
485
        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
437
        TouchRegistry::instance()->addTouchWatcher(touchId, q);
1014
486
438
1015
487
        setStatus(WaitingForTouch);
439
        setStatus(WaitingForTouch);
1016
488
    }
440
    }
1017
489
}
441
}
1018
490
442
1020
491
void DirectionalDragArea::touchEvent_recognized(QTouchEvent *event)
443
void DirectionalDragAreaPrivate::touchEvent_recognized(QTouchEvent *event)
1021
492
{
444
{
1022
493
    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
445
    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
1023
494
446
1024
495
    if (!touchPoint) {
447
    if (!touchPoint) {
1026
496
        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << m_touchId
448
        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << touchId
1027
497
            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
449
            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
1028
498
               "Considering it as released.";
450
               "Considering it as released.";
1029
499
        setStatus(WaitingForTouch);
451
        setStatus(WaitingForTouch);
1030
500
    } else {
452
    } else {
1033
501
        setPreviousPos(touchPoint->pos());
453
        setPublicPos(touchPoint->pos());
1034
502
        setPreviousScenePos(touchPoint->scenePos());
454
        setPublicScenePos(touchPoint->scenePos());
1035
503
455
1036
504
        if (touchPoint->state() == Qt::TouchPointReleased) {
456
        if (touchPoint->state() == Qt::TouchPointReleased) {
1037
505
            emitSignalIfTapped();
1038
506
            setStatus(WaitingForTouch);
457
            setStatus(WaitingForTouch);
1039
507
        }
458
        }
1040
508
    }
459
    }
1041
509
}
460
}
1042
510
461
1044
511
void DirectionalDragArea::watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints)
462
void DirectionalDragAreaPrivate::watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints)
1045
512
{
463
{
1046
513
    for (int i = 0; i < touchPoints.count(); ++i) {
464
    for (int i = 0; i < touchPoints.count(); ++i) {
1047
514
        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
465
        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
1048
515
        if (touchPoint.state() == Qt::TouchPointPressed) {
466
        if (touchPoint.state() == Qt::TouchPointPressed) {
1050
516
            TouchRegistry::instance()->addTouchWatcher(touchPoint.id(), this);
467
            TouchRegistry::instance()->addTouchWatcher(touchPoint.id(), q);
1051
517
        }
468
        }
1052
518
    }
469
    }
1053
519
}
470
}
1054
520
471
1069
521
bool DirectionalDragArea::recognitionIsDisabled() const
472
bool DirectionalDragAreaPrivate::recognitionIsDisabled() const
1070
522
{
473
{
1071
523
    return distanceThreshold() <= 0 && compositionTime() <= 0;
474
    return immediateRecognition || (distanceThreshold <= 0 && compositionTime <= 0);
1072
524
}
475
}
1073
525
476
1074
526
void DirectionalDragArea::emitSignalIfTapped()
477
bool DirectionalDragAreaPrivate::sanityCheckRecognitionProperties()
1075
527
{
478
{
1076
528
    qint64 touchDuration = m_timeSource->msecsSinceReference() - m_activeTouches.touchStartTime(m_touchId);
479
    return recognitionIsDisabled()
1077
529
    if (touchDuration <= maxTapDuration()) {
480
        || (distanceThreshold < maxDistance && compositionTime < maxTime);
1078
530
        Q_EMIT tapped();
481
}
1079
531
    }
482
1080
532
}
483
const QTouchEvent::TouchPoint *DirectionalDragAreaPrivate::fetchTargetTouchPoint(QTouchEvent *event)
1067
533
1068
534
const QTouchEvent::TouchPoint *DirectionalDragArea::fetchTargetTouchPoint(QTouchEvent *event)
1081
535
{
484
{
1082
536
    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
485
    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
1083
537
    const QTouchEvent::TouchPoint *touchPoint = 0;
486
    const QTouchEvent::TouchPoint *touchPoint = 0;
1084
538
    for (int i = 0; i < touchPoints.size(); ++i) {
487
    for (int i = 0; i < touchPoints.size(); ++i) {
1086
539
        if (touchPoints.at(i).id() == m_touchId) {
488
        if (touchPoints.at(i).id() == touchId) {
1087
540
            touchPoint = &touchPoints.at(i);
489
            touchPoint = &touchPoints.at(i);
1088
541
            break;
490
            break;
1089
542
        }
491
        }
1090
@@ -544,39 +493,13 @@
1091
544
    return touchPoint;
493
    return touchPoint;
1092
545
}
494
}
1093
546
495
1123
547
bool DirectionalDragArea::pointInsideAllowedArea() const
496
bool DirectionalDragAreaPrivate::movingInRightDirection() const
1124
548
{
497
{
1125
549
    // NB: Using squared values to avoid computing the square root to find
498
    if (direction == Direction::Horizontal) {
1097
550
    // the length totalMovement
1098
551
1099
552
    QPointF totalMovement(m_dampedScenePos.x() - m_startScenePos.x(),
1100
553
                          m_dampedScenePos.y() - m_startScenePos.y());
1101
554
1102
555
    qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
1103
556
                                totalMovement.y() * totalMovement.y();
1104
557
1105
558
    if (squaredTotalMovSize == 0.) {
1106
559
        // didn't move
1107
560
        return true;
1108
561
    }
1109
562
1110
563
    qreal projectedMovement = projectOntoDirectionVector(totalMovement);
1111
564
1112
565
1113
566
    qreal cosineAngleSquared = (projectedMovement * projectedMovement) / squaredTotalMovSize;
1114
567
1115
568
    // Same as:
1116
569
    // angle_between_movement_vector_and_gesture_direction_vector <= widening_angle
1117
570
    return cosineAngleSquared >= m_wideningFactor;
1118
571
}
1119
572
1120
573
bool DirectionalDragArea::movingInRightDirection() const
1121
574
{
1122
575
    if (m_direction == Direction::Horizontal) {
1126
576
        return true;
499
        return true;
1127
577
    } else {
500
    } else {
1130
578
        QPointF movementVector(m_dampedScenePos.x() - m_previousDampedScenePos.x(),
501
        QPointF movementVector(dampedScenePos.x() - previousDampedScenePos.x(),
1131
579
                               m_dampedScenePos.y() - m_previousDampedScenePos.y());
502
                               dampedScenePos.y() - previousDampedScenePos.y());
1132
580
503
1133
581
        qreal scalarProjection = projectOntoDirectionVector(movementVector);
504
        qreal scalarProjection = projectOntoDirectionVector(movementVector);
1134
582
505
1135
@@ -584,96 +507,93 @@
1136
584
    }
507
    }
1137
585
}
508
}
1138
586
509
1140
587
bool DirectionalDragArea::movedFarEnough(const QPointF &point) const
510
bool DirectionalDragAreaPrivate::movedFarEnoughAlongGestureAxis() const
1141
588
{
511
{
1143
589
    if (m_distanceThreshold <= 0.) {
512
    if (distanceThreshold <= 0.) {
1144
590
        // distance threshold check is disabled
513
        // distance threshold check is disabled
1145
591
        return true;
514
        return true;
1146
592
    } else {
515
    } else {
1193
593
        QPointF totalMovement(point.x() - m_startScenePos.x(),
516
        QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),
1194
594
                              point.y() - m_startScenePos.y());
517
                              dampedScenePos.y() - startScenePos.y());
1195
595
518
1196
596
        qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
519
        qreal scalarProjection = projectOntoDirectionVector(totalMovement);
1197
597
                                    totalMovement.y() * totalMovement.y();
520
1198
598
521
        ddaDebug(" movedFarEnoughAlongGestureAxis: scalarProjection=" << scalarProjection
1199
599
        return squaredTotalMovSize > m_distanceThresholdSquared;
522
            << ", distanceThreshold=" << distanceThreshold);
1200
600
    }
523
1201
601
}
524
        if (direction == Direction::Horizontal) {
1202
602
525
            return qAbs(scalarProjection) > distanceThreshold;
1203
603
void DirectionalDragArea::checkSpeed()
526
        } else {
1204
604
{
527
            return scalarProjection > distanceThreshold;
1205
605
    Q_ASSERT(m_status == Undecided);
528
        }
1206
606
529
    }
1207
607
    if (m_velocityCalculator->numSamples() >= AxisVelocityCalculator::MIN_SAMPLES_NEEDED) {
530
}
1208
608
        qreal speed = qFabs(m_velocityCalculator->calculate());
531
1209
609
        qreal minSpeedMsecs = m_minSpeed / 1000.0;
532
bool DirectionalDragAreaPrivate::isPastMaxDistance() const
1210
610
533
{
1211
611
        if (speed < minSpeedMsecs) {
534
    QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),
1212
612
            ddaDebug("Rejecting gesture because it's below minimum speed.");
535
                          dampedScenePos.y() - startScenePos.y());
1213
613
            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
536
1214
614
            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
537
    qreal squaredDistance = totalMovement.x()*totalMovement.x() + totalMovement.y()*totalMovement.y();
1215
615
            setStatus(WaitingForTouch);
538
    return squaredDistance > maxDistance*maxDistance;
1216
616
        }
539
}
1217
617
    }
540
1218
618
541
void DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible()
1219
619
    if (m_velocityCalculator->numSamples() == m_numSamplesOnLastSpeedCheck) {
542
{
1220
620
        m_silenceTime += m_recognitionTimer->interval();
543
    if (!q->isEnabled() || !q->isVisible()) {
1221
621
544
        if (status == Undecided) {
1222
622
        if (m_silenceTime > m_maxSilenceTime) {
545
            TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
1177
623
            ddaDebug("Rejecting gesture because its silence time has been exceeded.");
1178
624
            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
1179
625
            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
1180
626
            setStatus(WaitingForTouch);
1181
627
        }
1182
628
    } else {
1183
629
        m_silenceTime = 0;
1184
630
    }
1185
631
    m_numSamplesOnLastSpeedCheck = m_velocityCalculator->numSamples();
1186
632
}
1187
633
1188
634
void DirectionalDragArea::giveUpIfDisabledOrInvisible()
1189
635
{
1190
636
    if (!isEnabled() || !isVisible()) {
1191
637
        if (m_status == Undecided) {
1192
638
            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
1223
639
            // We still wanna know when it ends for keeping the composition time window up-to-date
546
            // We still wanna know when it ends for keeping the composition time window up-to-date
1225
640
            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
547
            TouchRegistry::instance()->addTouchWatcher(touchId, q);
1226
641
        }
548
        }
1227
642
549
1229
643
        if (m_status != WaitingForTouch) {
550
        if (status != WaitingForTouch) {
1230
644
            ddaDebug("Resetting status because got disabled or made invisible");
551
            ddaDebug("Resetting status because got disabled or made invisible");
1231
645
            setStatus(WaitingForTouch);
552
            setStatus(WaitingForTouch);
1232
646
        }
553
        }
1233
647
    }
554
    }
1234
648
}
555
}
1235
649
556
1239
650
void DirectionalDragArea::setStatus(DirectionalDragArea::Status newStatus)
557
void DirectionalDragAreaPrivate::rejectGesture()
1240
651
{
558
{
1241
652
    if (newStatus == m_status)
559
    if (status == Undecided) {
1242
560
        ddaDebug("Rejecting gesture because it's taking too long to drag beyond the threshold.");
1243
561
1244
562
        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
1245
563
        // We still wanna know when it ends for keeping the composition time window up-to-date
1246
564
        TouchRegistry::instance()->addTouchWatcher(touchId, q);
1247
565
1248
566
        setStatus(WaitingForTouch);
1249
567
    }
1250
568
}
1251
569
1252
570
void DirectionalDragAreaPrivate::setStatus(Status newStatus)
1253
571
{
1254
572
    if (newStatus == status)
1255
653
        return;
573
        return;
1256
654
574
1258
655
    DirectionalDragArea::Status oldStatus = m_status;
575
    Status oldStatus = status;
1259
656
576
1260
657
    if (oldStatus == Undecided) {
577
    if (oldStatus == Undecided) {
1262
658
        m_recognitionTimer->stop();
578
        recognitionTimer->stop();
1263
659
    }
579
    }
1264
660
580
1267
661
    m_status = newStatus;
581
    status = newStatus;
1268
662
    Q_EMIT statusChanged(m_status);
582
    Q_EMIT statusChanged(status);
1269
663
583
1270
664
    ddaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));
584
    ddaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));
1271
665
585
1272
666
    switch (newStatus) {
586
    switch (newStatus) {
1273
667
        case WaitingForTouch:
587
        case WaitingForTouch:
1275
668
            Q_EMIT draggingChanged(false);
588
            if (oldStatus == Recognized) {
1276
589
                Q_EMIT q->draggingChanged(false);
1277
590
            }
1278
669
            break;
591
            break;
1279
670
        case Undecided:
592
        case Undecided:
1282
671
            m_recognitionTimer->start();
593
            recognitionTimer->start();
1281
672
            Q_EMIT draggingChanged(true);
1283
673
            break;
594
            break;
1284
674
        case Recognized:
595
        case Recognized:
1287
675
            if (oldStatus == WaitingForTouch)
596
            Q_EMIT q->draggingChanged(true);
1286
676
                Q_EMIT draggingChanged(true);
1288
677
            break;
597
            break;
1289
678
        default:
598
        default:
1290
679
            // no-op
599
            // no-op
1291
@@ -681,77 +601,126 @@
1292
681
    }
601
    }
1293
682
}
602
}
1294
683
603
1296
684
void DirectionalDragArea::setPreviousPos(const QPointF &point)
604
void DirectionalDragAreaPrivate::setPublicPos(const QPointF &point)
1297
685
{
605
{
1302
686
    bool xChanged = m_previousPos.x() != point.x();
606
    bool xChanged = publicPos.x() != point.x();
1303
687
    bool yChanged = m_previousPos.y() != point.y();
607
    bool yChanged = publicPos.y() != point.y();
1304
688
608
1305
689
    m_previousPos = point;
609
    // Public position should not get updated while the gesture is still being recognized
1306
610
    // (ie, Undecided status).
1307
611
    Q_ASSERT(status == WaitingForTouch || status == Recognized);
1308
612
1309
613
    if (status == Recognized && !recognitionIsDisabled()) {
1310
614
        // When the gesture finally gets recognized, the finger will likely be
1311
615
        // reasonably far from the edge. If we made the contentX immediately
1312
616
        // follow the finger position it would be visually unpleasant as it
1313
617
        // would appear right next to the user's finger out of nowhere (ie,
1314
618
        // it would jump). Instead, we make contentX go towards the user's
1315
619
        // finger in several steps. ie., in an animated way.
1316
620
        QPointF delta = point - publicPos;
1317
621
        // the trick is not to go all the way (1.0) as it would cause a sudden jump
1318
622
        publicPos.rx() += 0.4 * delta.x();
1319
623
        publicPos.ry() += 0.4 * delta.y();
1320
624
    } else {
1321
625
        // no smoothing when initializing or if gesture recognition was immediate as there will
1322
626
        // be no jump.
1323
627
        publicPos = point;
1324
628
    }
1325
690
629
1326
691
    if (xChanged) {
630
    if (xChanged) {
1330
692
        Q_EMIT touchXChanged(point.x());
631
        Q_EMIT q->touchXChanged(publicPos.x());
1331
693
        if (Direction::isHorizontal(m_direction))
632
        if (Direction::isHorizontal(direction))
1332
694
            Q_EMIT distanceChanged(distance());
633
            Q_EMIT q->distanceChanged(q->distance());
1333
695
    }
634
    }
1334
696
635
1335
697
    if (yChanged) {
636
    if (yChanged) {
1339
698
        Q_EMIT touchYChanged(point.y());
637
        Q_EMIT q->touchYChanged(publicPos.y());
1340
699
        if (Direction::isVertical(m_direction))
638
        if (Direction::isVertical(direction))
1341
700
            Q_EMIT distanceChanged(distance());
639
            Q_EMIT q->distanceChanged(q->distance());
1342
701
    }
640
    }
1343
702
}
641
}
1344
703
642
1346
704
void DirectionalDragArea::setPreviousScenePos(const QPointF &point)
643
void DirectionalDragAreaPrivate::setPublicScenePos(const QPointF &point)
1347
705
{
644
{
1350
706
    bool xChanged = m_previousScenePos.x() != point.x();
645
    bool xChanged = publicScenePos.x() != point.x();
1351
707
    bool yChanged = m_previousScenePos.y() != point.y();
646
    bool yChanged = publicScenePos.y() != point.y();
1352
708
647
1353
709
    if (!xChanged && !yChanged)
648
    if (!xChanged && !yChanged)
1354
710
        return;
649
        return;
1355
711
650
1358
712
    qreal oldSceneDistance = sceneDistance();
651
    // Public position should not get updated while the gesture is still being recognized
1359
713
    m_previousScenePos = point;
652
    // (ie, Undecided status).
1360
653
    Q_ASSERT(status == WaitingForTouch || status == Recognized);
1361
654
1362
655
    qreal oldSceneDistance = sceneDistance;
1363
656
1364
657
    if (status == Recognized && !recognitionIsDisabled()) {
1365
658
        // When the gesture finally gets recognized, the finger will likely be
1366
659
        // reasonably far from the edge. If we made the contentX immediately
1367
660
        // follow the finger position it would be visually unpleasant as it
1368
661
        // would appear right next to the user's finger out of nowhere (ie,
1369
662
        // it would jump). Instead, we make contentX go towards the user's
1370
663
        // finger in several steps. ie., in an animated way.
1371
664
        QPointF delta = point - publicScenePos;
1372
665
        // the trick is not to go all the way (1.0) as it would cause a sudden jump
1373
666
        publicScenePos.rx() += 0.4 * delta.x();
1374
667
        publicScenePos.ry() += 0.4 * delta.y();
1375
668
    } else {
1376
669
        // no smoothing when initializing or if gesture recognition was immediate as there will
1377
670
        // be no jump.
1378
671
        publicScenePos = point;
1379
672
    }
1380
673
1381
714
    updateSceneDistance();
674
    updateSceneDistance();
1382
715
675
1385
716
    if (oldSceneDistance != sceneDistance()) {
676
    if (oldSceneDistance != sceneDistance) {
1386
717
        Q_EMIT sceneDistanceChanged(sceneDistance());
677
        Q_EMIT q->sceneDistanceChanged(sceneDistance);
1387
718
    }
678
    }
1388
719
679
1389
720
    if (xChanged) {
680
    if (xChanged) {
1391
721
        Q_EMIT touchSceneXChanged(point.x());
681
        Q_EMIT q->touchSceneXChanged(publicScenePos.x());
1392
722
    }
682
    }
1393
723
683
1394
724
    if (yChanged) {
684
    if (yChanged) {
1396
725
        Q_EMIT touchSceneYChanged(point.y());
685
        Q_EMIT q->touchSceneYChanged(publicScenePos.y());
1397
726
    }
686
    }
1398
727
}
687
}
1399
728
688
1410
729
void DirectionalDragArea::updateVelocityCalculator(const QPointF &scenePos)
689
bool DirectionalDragAreaPrivate::isWithinTouchCompositionWindow()
1401
730
{
1402
731
    QPointF totalSceneMovement = scenePos - m_startScenePos;
1403
732
1404
733
    qreal scalarProjection = projectOntoDirectionVector(totalSceneMovement);
1405
734
1406
735
    m_velocityCalculator->setTrackedPosition(scalarProjection);
1407
736
}
1408
737
1409
738
bool DirectionalDragArea::isWithinTouchCompositionWindow()
1411
739
{
690
{
1412
740
    return
691
    return
1417
741
        compositionTime() > 0 &&
692
        compositionTime > 0 &&
1418
742
        !m_activeTouches.isEmpty() &&
693
        !activeTouches.isEmpty() &&
1419
743
        m_timeSource->msecsSinceReference() <=
694
        timeSource->msecsSinceReference() <=
1420
744
            m_activeTouches.mostRecentStartTime() + (qint64)compositionTime();
695
            activeTouches.mostRecentStartTime() + (qint64)compositionTime;
1421
696
}
1422
697
1423
698
void DirectionalDragArea::itemChange(ItemChange change, const ItemChangeData &value)
1424
699
{
1425
700
    if (change == QQuickItem::ItemSceneChange) { 
1426
701
        if (value.window != nullptr) {
1427
702
            // TODO: Handle window->screen() changes (ie window changing screens)
1428
703
            qreal pixelsPerMm = value.window->screen()->physicalDotsPerInch() / 25.4;
1429
704
            d->setPixelsPerMm(pixelsPerMm);
1430
705
        }
1431
706
    }
1432
707
}
1433
708
1434
709
void DirectionalDragAreaPrivate::setPixelsPerMm(qreal pixelsPerMm)
1435
710
{
1436
711
    dampedScenePos.setMaxDelta(1. * pixelsPerMm);
1437
712
    setDistanceThreshold(4. * pixelsPerMm);
1438
713
    maxDistance = 10. * pixelsPerMm;
1439
745
}
714
}
1440
746
715
1441
747
//**************************  ActiveTouchesInfo **************************
716
//**************************  ActiveTouchesInfo **************************
1442
748
717
1444
749
DirectionalDragArea::ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
718
ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
1445
750
    : m_timeSource(timeSource)
719
    : m_timeSource(timeSource)
1446
751
{
720
{
1447
752
}
721
}
1448
753
722
1450
754
void DirectionalDragArea::ActiveTouchesInfo::update(QTouchEvent *event)
723
void ActiveTouchesInfo::update(QTouchEvent *event)
1451
755
{
724
{
1452
756
    if (!(event->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))) {
725
    if (!(event->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))) {
1453
757
        // nothing to update
726
        // nothing to update
1454
@@ -773,7 +742,7 @@
1455
773
}
742
}
1456
774
743
1457
775
#if ACTIVETOUCHESINFO_DEBUG
744
#if ACTIVETOUCHESINFO_DEBUG
1459
776
QString DirectionalDragArea::ActiveTouchesInfo::toString()
745
QString ActiveTouchesInfo::toString()
1460
777
{
746
{
1461
778
    QString string = "(";
747
    QString string = "(";
1462
779
748
1463
@@ -791,7 +760,7 @@
1464
791
}
760
}
1465
792
#endif // ACTIVETOUCHESINFO_DEBUG
761
#endif // ACTIVETOUCHESINFO_DEBUG
1466
793
762
1468
794
void DirectionalDragArea::ActiveTouchesInfo::addTouchPoint(int touchId)
763
void ActiveTouchesInfo::addTouchPoint(int touchId)
1469
795
{
764
{
1470
796
    ActiveTouchInfo &activeTouchInfo = m_touchInfoPool.getEmptySlot();
765
    ActiveTouchInfo &activeTouchInfo = m_touchInfoPool.getEmptySlot();
1471
797
    activeTouchInfo.id = touchId;
766
    activeTouchInfo.id = touchId;
1472
@@ -802,7 +771,7 @@
1473
802
    #endif
771
    #endif
1474
803
}
772
}
1475
804
773
1477
805
qint64 DirectionalDragArea::ActiveTouchesInfo::touchStartTime(int touchId)
774
qint64 ActiveTouchesInfo::touchStartTime(int touchId)
1478
806
{
775
{
1479
807
    qint64 result = -1;
776
    qint64 result = -1;
1480
808
777
1481
@@ -819,7 +788,7 @@
1482
819
    return result;
788
    return result;
1483
820
}
789
}
1484
821
790
1486
822
void DirectionalDragArea::ActiveTouchesInfo::removeTouchPoint(int touchId)
791
void ActiveTouchesInfo::removeTouchPoint(int touchId)
1487
823
{
792
{
1488
824
    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
793
    m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
1489
825
        if (touchId == touchInfo->id) {
794
        if (touchId == touchInfo->id) {
1490
@@ -835,7 +804,7 @@
1491
835
    #endif
804
    #endif
1492
836
}
805
}
1493
837
806
1495
838
qint64 DirectionalDragArea::ActiveTouchesInfo::mostRecentStartTime()
807
qint64 ActiveTouchesInfo::mostRecentStartTime()
1496
839
{
808
{
1497
840
    Q_ASSERT(!m_touchInfoPool.isEmpty());
809
    Q_ASSERT(!m_touchInfoPool.isEmpty());
1498
841
810
1499
@@ -851,11 +820,11 @@
1500
851
    return highestStartTime;
820
    return highestStartTime;
1501
852
}
821
}
1502
853
822
1504
854
void DirectionalDragArea::updateSceneDirectionVector()
823
void DirectionalDragAreaPrivate::updateSceneDirectionVector()
1505
855
{
824
{
1506
856
    QPointF localOrigin(0., 0.);
825
    QPointF localOrigin(0., 0.);
1507
857
    QPointF localDirection;
826
    QPointF localDirection;
1509
858
    switch (m_direction) {
827
    switch (direction) {
1510
859
        case Direction::Upwards:
828
        case Direction::Upwards:
1511
860
            localDirection.rx() = 0.;
829
            localDirection.rx() = 0.;
1512
861
            localDirection.ry() = -1.;
830
            localDirection.ry() = -1.;
1513
@@ -873,14 +842,31 @@
1514
873
            localDirection.ry() = 0.;
842
            localDirection.ry() = 0.;
1515
874
            break;
843
            break;
1516
875
    }
844
    }
1527
876
    QPointF sceneOrigin = mapToScene(localOrigin);
845
    QPointF sceneOrigin = q->mapToScene(localOrigin);
1528
877
    QPointF sceneDirection = mapToScene(localDirection);
846
    QPointF sceneDirection = q->mapToScene(localDirection);
1529
878
    m_sceneDirectionVector = sceneDirection - sceneOrigin;
847
    sceneDirectionVector = sceneDirection - sceneOrigin;
1530
879
}
848
}
1531
880
849
1532
881
qreal DirectionalDragArea::projectOntoDirectionVector(const QPointF &sceneVector) const
850
qreal DirectionalDragAreaPrivate::projectOntoDirectionVector(const QPointF &sceneVector) const
1533
882
{
851
{
1534
883
    // same as dot product as m_sceneDirectionVector is a unit vector
852
    // same as dot product as sceneDirectionVector is a unit vector
1535
884
    return  sceneVector.x() * m_sceneDirectionVector.x() +
853
    return  sceneVector.x() * sceneDirectionVector.x() +
1536
885
            sceneVector.y() * m_sceneDirectionVector.y();
854
            sceneVector.y() * sceneDirectionVector.y();
1537
855
}
1538
856
1539
857
DirectionalDragAreaPrivate::DirectionalDragAreaPrivate(DirectionalDragArea *q)
1540
858
    : q(q)
1541
859
    , status(WaitingForTouch)
1542
860
    , sceneDistance(0)
1543
861
    , touchId(-1)
1544
862
    , direction(Direction::Rightwards)
1545
863
    , distanceThreshold(0)
1546
864
    , distanceThresholdSquared(0.)
1547
865
    , maxTime(400)
1548
866
    , compositionTime(60)
1549
867
    , immediateRecognition(false)
1550
868
    , recognitionTimer(nullptr)
1551
869
    , timeSource(new RealTimeSource)
1552
870
    , activeTouches(timeSource)
1553
871
{
1554
886
}
872
}
1555
887
873
1556
=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.h'
1557
--- plugins/Ubuntu/Gestures/DirectionalDragArea.h	2014-10-01 13:20:32 +0000
1558
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.h	2015-04-10 21:17:56 +0000
1559
@@ -18,7 +18,6 @@
1560
18
#define DIRECTIONAL_DRAG_AREA_H
18
#define DIRECTIONAL_DRAG_AREA_H
1561
19
19
1562
20
#include <QtQuick/QQuickItem>
20
#include <QtQuick/QQuickItem>
1563
21
#include "AxisVelocityCalculator.h"
1564
22
#include "UbuntuGesturesQmlGlobal.h"
21
#include "UbuntuGesturesQmlGlobal.h"
1565
23
#include "Damper.h"
22
#include "Damper.h"
1566
24
#include "Direction.h"
23
#include "Direction.h"
1567
@@ -29,6 +28,7 @@
1568
29
28
1569
30
class TouchOwnershipEvent;
29
class TouchOwnershipEvent;
1570
31
class UnownedTouchEvent;
30
class UnownedTouchEvent;
1571
31
class DirectionalDragAreaPrivate;
1572
32
32
1573
33
/*
33
/*
1574
34
 An area that detects axis-aligned single-finger drag gestures
34
 An area that detects axis-aligned single-finger drag gestures
1575
@@ -61,95 +61,28 @@
1576
61
    Q_PROPERTY(qreal touchSceneX READ touchSceneX NOTIFY touchSceneXChanged)
61
    Q_PROPERTY(qreal touchSceneX READ touchSceneX NOTIFY touchSceneXChanged)
1577
62
    Q_PROPERTY(qreal touchSceneY READ touchSceneY NOTIFY touchSceneYChanged)
62
    Q_PROPERTY(qreal touchSceneY READ touchSceneY NOTIFY touchSceneYChanged)
1578
63
63
1579
64
    // The current status of the directional drag gesture area.
1580
65
    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
1581
66
1582
67
    // Whether a drag gesture is taking place
64
    // Whether a drag gesture is taking place
1583
68
    // This will be true as long as status is Undecided or Recognized
1584
69
    // When a gesture gets rejected, dragging turns to false.
1585
70
    Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
65
    Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
1586
71
66
1634
72
    /////
67
    // Whether a gesture should be Recognized as soon a touch lands on the area.
1635
73
    // stuff that will be set in stone at some point
68
    // With this property enabled it will work pretty much like a MultiPointTouchArea,
1636
74
69
    // just with a different API.
1637
75
    // How far the touch point can move away from its expected position before
70
    //
1638
76
    // it causes a rejection in the gesture recognition. This is to compensate
71
    // It's false by default. In most cases you will not want that enabled.
1639
77
    // for both noise in the touch input signal and for the natural irregularities
72
    Q_PROPERTY(bool immediateRecognition
1640
78
    // in the finger movement.
73
            READ immediateRecognition
1641
79
    // Proper value is likely device-specific.
74
            WRITE setImmediateRecognition
1642
80
    Q_PROPERTY(qreal maxDeviation READ maxDeviation WRITE setMaxDeviation NOTIFY maxDeviationChanged)
75
            NOTIFY immediateRecognitionChanged)
1596
81
1597
82
    // Widening angle, in degrees
1598
83
    // It's roughly the maximum angle a touch point can make relative to the
1599
84
    // axis defined by the compoment's direction for it to be recognized as a
1600
85
    // directional drag.
1601
86
    Q_PROPERTY(qreal wideningAngle READ wideningAngle WRITE setWideningAngle
1602
87
               NOTIFY wideningAngleChanged)
1603
88
1604
89
    // How far a touch point has to move from its initial position in order for
1605
90
    // it to be recognized as a directional drag.
1606
91
    Q_PROPERTY(qreal distanceThreshold READ distanceThreshold WRITE setDistanceThreshold
1607
92
               NOTIFY distanceThresholdChanged)
1608
93
1609
94
    // Minimum speed a gesture needs to have in order to be recognized as a
1610
95
    // directional drag.
1611
96
    // In pixels per second
1612
97
    Q_PROPERTY(qreal minSpeed READ minSpeed WRITE setMinSpeed NOTIFY minSpeedChanged)
1613
98
1614
99
    // A gesture will be rejected if more than maxSilenceTime milliseconds has
1615
100
    // passed since we last got an input event from it (during Undecided state).
1616
101
    //
1617
102
    // Silence (i.e., lack of new input events) doesn't necessarily mean that the user's
1618
103
    // finger is still (zero drag speed). In some cases the finger might be moving but
1619
104
    // the driver's high noise filtering might cause those silence periods, specially
1620
105
    // in the moments succeeding a press (talking about Galaxy Nexus here).
1621
106
    Q_PROPERTY(int maxSilenceTime READ maxSilenceTime
1622
107
                                  WRITE setMaxSilenceTime
1623
108
                                  NOTIFY maxSilenceTimeChanged)
1624
109
1625
110
    //
1626
111
    /////
1627
112
1628
113
    // Maximum time (in milliseconds) after the start of a given touch point where
1629
114
    // subsequent touch starts are grouped with the first one into an N-touches gesture
1630
115
    // (e.g. a two-fingers tap or drag).
1631
116
    Q_PROPERTY(int compositionTime READ compositionTime
1632
117
                                   WRITE setCompositionTime
1633
118
                                   NOTIFY compositionTimeChanged)
1643
119
76
1644
120
    Q_ENUMS(Direction)
77
    Q_ENUMS(Direction)
1645
121
    Q_ENUMS(Status)
1646
122
public:
78
public:
1647
123
    DirectionalDragArea(QQuickItem *parent = 0);
79
    DirectionalDragArea(QQuickItem *parent = 0);
1648
124
80
1649
125
    Direction::Type direction() const;
81
    Direction::Type direction() const;
1650
126
    void setDirection(Direction::Type);
82
    void setDirection(Direction::Type);
1651
127
83
1652
128
    // Describes the state of the directional drag gesture.
1653
129
    enum Status {
1654
130
        // Waiting for a new touch point to land on this area. No gesture is being processed
1655
131
        // or tracked.
1656
132
        WaitingForTouch,
1657
133
1658
134
        // A touch point has landed on this area but it's not know yet whether it is
1659
135
        // performing a drag in the correct direction.
1660
136
        // If it's decided that the touch point is not performing a directional drag gesture,
1661
137
        // it will be rejected/ignored and status will return to WaitingForTouch.
1662
138
        Undecided, //Recognizing,
1663
139
1664
140
        // There's a touch point in this area and it performed a drag in the correct
1665
141
        // direction.
1666
142
        //
1667
143
        // Once recognized, the gesture state will move back to WaitingForTouch only once
1668
144
        // that touch point ends. The gesture will remain in the Recognized state even if
1669
145
        // the touch point starts moving in other directions or halts.
1670
146
        Recognized,
1671
147
    };
1672
148
    Status status() const { return m_status; }
1673
149
1674
150
    qreal distance() const;
84
    qreal distance() const;
1675
151
    qreal sceneDistance() const;
85
    qreal sceneDistance() const;
1676
152
    void updateSceneDistance();
1677
153
86
1678
154
    qreal touchX() const;
87
    qreal touchX() const;
1679
155
    qreal touchY() const;
88
    qreal touchY() const;
1680
@@ -157,152 +90,30 @@
1681
157
    qreal touchSceneX() const;
90
    qreal touchSceneX() const;
1682
158
    qreal touchSceneY() const;
91
    qreal touchSceneY() const;
1683
159
92
1711
160
    bool dragging() const { return (m_status == Undecided) || (m_status == Recognized); }
93
    bool dragging() const;
1712
161
94
1713
162
    qreal maxDeviation() const { return m_dampedScenePos.maxDelta(); }
95
    bool immediateRecognition() const;
1714
163
    void setMaxDeviation(qreal value);
96
    void setImmediateRecognition(bool enabled);
1688
164
1689
165
    qreal wideningAngle() const;
1690
166
    void setWideningAngle(qreal value);
1691
167
1692
168
    qreal distanceThreshold() const { return m_distanceThreshold; }
1693
169
    void setDistanceThreshold(qreal value);
1694
170
1695
171
    qreal minSpeed() const { return m_minSpeed; }
1696
172
    void setMinSpeed(qreal value);
1697
173
1698
174
    int maxSilenceTime() const { return m_maxSilenceTime; }
1699
175
    void setMaxSilenceTime(int value);
1700
176
1701
177
    int compositionTime() const { return m_compositionTime; }
1702
178
    void setCompositionTime(int value);
1703
179
1704
180
    // Replaces the existing Timer with the given one.
1705
181
    //
1706
182
    // Useful for providing a fake timer when testing.
1707
183
    void setRecognitionTimer(UbuntuGestures::AbstractTimer *timer);
1708
184
1709
185
    // Useful for testing, where a fake time source can be supplied
1710
186
    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
1715
187
97
1716
188
    bool event(QEvent *e) override;
98
    bool event(QEvent *e) override;
1717
189
99
1718
190
    // Maximum time, in milliseconds, between a press and a release, for a touch
1719
191
    // sequence to be considered a tap.
1720
192
    int maxTapDuration() const { return 300; }
1721
193
1722
194
Q_SIGNALS:
100
Q_SIGNALS:
1723
195
    void directionChanged(Direction::Type direction);
101
    void directionChanged(Direction::Type direction);
1724
196
    void statusChanged(Status value);
1725
197
    void draggingChanged(bool value);
102
    void draggingChanged(bool value);
1726
198
    void distanceChanged(qreal value);
103
    void distanceChanged(qreal value);
1727
199
    void sceneDistanceChanged(qreal value);
104
    void sceneDistanceChanged(qreal value);
1728
200
    void maxDeviationChanged(qreal value);
1729
201
    void wideningAngleChanged(qreal value);
1730
202
    void distanceThresholdChanged(qreal value);
1731
203
    void minSpeedChanged(qreal value);
1732
204
    void maxSilenceTimeChanged(int value);
1733
205
    void compositionTimeChanged(int value);
1734
206
    void touchXChanged(qreal value);
105
    void touchXChanged(qreal value);
1735
207
    void touchYChanged(qreal value);
106
    void touchYChanged(qreal value);
1736
208
    void touchSceneXChanged(qreal value);
107
    void touchSceneXChanged(qreal value);
1737
209
    void touchSceneYChanged(qreal value);
108
    void touchSceneYChanged(qreal value);
1743
210
109
    void immediateRecognitionChanged(bool value);
1739
211
    // TODO: I would rather not have such signal as it has nothing to do with drag gestures.
1740
212
    // Remove when no longer used or move its implementation to the QML code that uses it
1741
213
    // See maxTapDuration()
1742
214
    void tapped();
1744
215
110
1745
216
protected:
111
protected:
1746
217
    virtual void touchEvent(QTouchEvent *event);
112
    virtual void touchEvent(QTouchEvent *event);
1835
218
113
    virtual void itemChange(ItemChange change, const ItemChangeData &value);
1836
219
private Q_SLOTS:
114
1837
220
    void checkSpeed();
115
public: // so tests can access it
1838
221
    void giveUpIfDisabledOrInvisible();
116
    DirectionalDragAreaPrivate *d;
1751
222
1752
223
private:
1753
224
    void touchEvent_absent(QTouchEvent *event);
1754
225
    void touchEvent_undecided(QTouchEvent *event);
1755
226
    void touchEvent_recognized(QTouchEvent *event);
1756
227
    bool pointInsideAllowedArea() const;
1757
228
    bool movingInRightDirection() const;
1758
229
    bool movedFarEnough(const QPointF &point) const;
1759
230
    const QTouchEvent::TouchPoint *fetchTargetTouchPoint(QTouchEvent *event);
1760
231
    void setStatus(Status newStatus);
1761
232
    void setPreviousPos(const QPointF &point);
1762
233
    void setPreviousScenePos(const QPointF &point);
1763
234
    void updateVelocityCalculator(const QPointF &point);
1764
235
    bool isWithinTouchCompositionWindow();
1765
236
    void updateSceneDirectionVector();
1766
237
    // returns the scalar projection between the given vector (in scene coordinates)
1767
238
    // and m_sceneDirectionVector
1768
239
    qreal projectOntoDirectionVector(const QPointF &sceneVector) const;
1769
240
    void touchOwnershipEvent(TouchOwnershipEvent *event);
1770
241
    void unownedTouchEvent(UnownedTouchEvent *event);
1771
242
    void unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent);
1772
243
    void watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints);
1773
244
    bool recognitionIsDisabled() const;
1774
245
    void emitSignalIfTapped();
1775
246
1776
247
    Status m_status;
1777
248
1778
249
    QPointF m_startPos;
1779
250
    QPointF m_startScenePos;
1780
251
    QPointF m_previousPos;
1781
252
    QPointF m_previousScenePos;
1782
253
    qreal m_sceneDistance;
1783
254
    int m_touchId;
1784
255
1785
256
    // A movement damper is used in some of the gesture recognition calculations
1786
257
    // to get rid of noise or small oscillations in the touch position.
1787
258
    DampedPointF m_dampedScenePos;
1788
259
    QPointF m_previousDampedScenePos;
1789
260
1790
261
    // Unit vector in scene coordinates describing the direction of the gesture recognition
1791
262
    QPointF m_sceneDirectionVector;
1792
263
1793
264
    Direction::Type m_direction;
1794
265
    qreal m_wideningAngle; // in degrees
1795
266
    qreal m_wideningFactor; // it's pow(cosine(m_wideningAngle), 2)
1796
267
    qreal m_distanceThreshold;
1797
268
    qreal m_distanceThresholdSquared; // it's pow(m_distanceThreshold, 2)
1798
269
    qreal m_minSpeed;
1799
270
    int m_maxSilenceTime; // in milliseconds
1800
271
    int m_silenceTime; // in milliseconds
1801
272
    int m_compositionTime; // in milliseconds
1802
273
    int m_numSamplesOnLastSpeedCheck;
1803
274
    UbuntuGestures::AbstractTimer *m_recognitionTimer;
1804
275
    AxisVelocityCalculator *m_velocityCalculator;
1805
276
1806
277
    UbuntuGestures::SharedTimeSource m_timeSource;
1807
278
1808
279
    // Information about an active touch point
1809
280
    struct ActiveTouchInfo {
1810
281
        ActiveTouchInfo() : id(-1), startTime(-1) {}
1811
282
        bool isValid() const { return id != -1; }
1812
283
        void reset() { id = -1; }
1813
284
        int id;
1814
285
        qint64 startTime;
1815
286
    };
1816
287
    class ActiveTouchesInfo {
1817
288
    public:
1818
289
        ActiveTouchesInfo(const UbuntuGestures::SharedTimeSource &timeSource);
1819
290
        void update(QTouchEvent *event);
1820
291
        qint64 touchStartTime(int id);
1821
292
        bool isEmpty() const { return m_touchInfoPool.isEmpty(); }
1822
293
        qint64 mostRecentStartTime();
1823
294
        UbuntuGestures::SharedTimeSource m_timeSource;
1824
295
    private:
1825
296
        void addTouchPoint(int touchId);
1826
297
        void removeTouchPoint(int touchId);
1827
298
        #if ACTIVETOUCHESINFO_DEBUG
1828
299
        QString toString();
1829
300
        #endif
1830
301
1831
302
        Pool<ActiveTouchInfo> m_touchInfoPool;
1832
303
    } m_activeTouches;
1833
304
1834
305
    friend class tst_DirectionalDragArea;
1839
306
};
117
};
1840
307
118
1841
308
#endif // DIRECTIONAL_DRAG_AREA_H
119
#endif // DIRECTIONAL_DRAG_AREA_H
1842
309
120
1843
=== added file 'plugins/Ubuntu/Gestures/DirectionalDragArea_p.h'
1844
--- plugins/Ubuntu/Gestures/DirectionalDragArea_p.h	1970-01-01 00:00:00 +0000
1845
+++ plugins/Ubuntu/Gestures/DirectionalDragArea_p.h	2015-04-10 21:17:56 +0000
1846
@@ -0,0 +1,167 @@
1847
1
/*
1848
2
 * Copyright (C) 2015 Canonical, Ltd.
1849
3
 *
1850
4
 * This program is free software; you can redistribute it and/or modify
1851
5
 * it under the terms of the GNU General Public License as published by
1852
6
 * the Free Software Foundation; version 3.
1853
7
 *
1854
8
 * This program is distributed in the hope that it will be useful,
1855
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1856
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1857
11
 * GNU General Public License for more details.
1858
12
 *
1859
13
 * You should have received a copy of the GNU General Public License
1860
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1861
15
 */
1862
16
1863
17
#ifndef DIRECTIONAL_DRAG_AREA_PRIV_H
1864
18
#define DIRECTIONAL_DRAG_AREA_PRIV_H
1865
19
1866
20
// Information about an active touch point
1867
21
struct UBUNTUGESTURESQML_EXPORT ActiveTouchInfo {
1868
22
    ActiveTouchInfo() : id(-1), startTime(-1) {}
1869
23
    bool isValid() const { return id != -1; }
1870
24
    void reset() { id = -1; }
1871
25
    int id;
1872
26
    qint64 startTime;
1873
27
};
1874
28
class UBUNTUGESTURESQML_EXPORT ActiveTouchesInfo {
1875
29
public:
1876
30
    ActiveTouchesInfo(const UbuntuGestures::SharedTimeSource &timeSource);
1877
31
    void update(QTouchEvent *event);
1878
32
    qint64 touchStartTime(int id);
1879
33
    bool isEmpty() const { return m_touchInfoPool.isEmpty(); }
1880
34
    qint64 mostRecentStartTime();
1881
35
    UbuntuGestures::SharedTimeSource m_timeSource;
1882
36
private:
1883
37
    void addTouchPoint(int touchId);
1884
38
    void removeTouchPoint(int touchId);
1885
39
    #if ACTIVETOUCHESINFO_DEBUG
1886
40
    QString toString();
1887
41
    #endif
1888
42
1889
43
    Pool<ActiveTouchInfo> m_touchInfoPool;
1890
44
};
1891
45
1892
46
class UBUNTUGESTURESQML_EXPORT DirectionalDragAreaPrivate : public QObject {
1893
47
    Q_OBJECT
1894
48
1895
49
    Q_ENUMS(Status)
1896
50
public:
1897
51
    DirectionalDragAreaPrivate(DirectionalDragArea *q);
1898
52
1899
53
public Q_SLOTS:
1900
54
    void giveUpIfDisabledOrInvisible();
1901
55
    void rejectGesture();
1902
56
1903
57
public:
1904
58
    // Describes the state of the directional drag gesture.
1905
59
    enum Status {
1906
60
        // Waiting for a new touch point to land on this area. No gesture is being processed
1907
61
        // or tracked.
1908
62
        WaitingForTouch,
1909
63
1910
64
        // A touch point has landed on this area but it's not know yet whether it is
1911
65
        // performing a drag in the correct direction.
1912
66
        // If it's decided that the touch point is not performing a directional drag gesture,
1913
67
        // it will be rejected/ignored and status will return to WaitingForTouch.
1914
68
        Undecided, //Recognizing,
1915
69
1916
70
        // There's a touch point in this area and it performed a drag in the correct
1917
71
        // direction.
1918
72
        //
1919
73
        // Once recognized, the gesture state will move back to WaitingForTouch only once
1920
74
        // that touch point ends. The gesture will remain in the Recognized state even if
1921
75
        // the touch point starts moving in other directions or halts.
1922
76
        Recognized,
1923
77
    };
1924
78
1925
79
    void touchEvent_absent(QTouchEvent *event);
1926
80
    void touchEvent_undecided(QTouchEvent *event);
1927
81
    void touchEvent_recognized(QTouchEvent *event);
1928
82
    bool movingInRightDirection() const;
1929
83
    bool movedFarEnoughAlongGestureAxis() const;
1930
84
    bool isPastMaxDistance() const;
1931
85
    const QTouchEvent::TouchPoint *fetchTargetTouchPoint(QTouchEvent *event);
1932
86
    void setStatus(Status newStatus);
1933
87
    void setPublicPos(const QPointF &point);
1934
88
    void setPublicScenePos(const QPointF &point);
1935
89
    bool isWithinTouchCompositionWindow();
1936
90
    void updateSceneDirectionVector();
1937
91
    // returns the scalar projection between the given vector (in scene coordinates)
1938
92
    // and m_sceneDirectionVector
1939
93
    qreal projectOntoDirectionVector(const QPointF &sceneVector) const;
1940
94
    void touchOwnershipEvent(TouchOwnershipEvent *event);
1941
95
    void unownedTouchEvent(UnownedTouchEvent *event);
1942
96
    void unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent);
1943
97
    void watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints);
1944
98
    bool recognitionIsDisabled() const;
1945
99
    bool sanityCheckRecognitionProperties();
1946
100
    void updateSceneDistance();
1947
101
    void setMaxTime(int value);
1948
102
    void setDistanceThreshold(qreal value);
1949
103
    void setPixelsPerMm(qreal pixelsPerMm);
1950
104
    QString objectName() const { return q->objectName(); }
1951
105
1952
106
    // Replaces the existing Timer with the given one.
1953
107
    //
1954
108
    // Useful for providing a fake timer when testing.
1955
109
    void setRecognitionTimer(UbuntuGestures::AbstractTimer *timer);
1956
110
1957
111
    // Useful for testing, where a fake time source can be supplied
1958
112
    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
1959
113
1960
114
    DirectionalDragArea *q;
1961
115
1962
116
    // The current status of the directional drag gesture area.
1963
117
    Status status;
1964
118
1965
119
    QPointF startPos;
1966
120
    QPointF startScenePos;
1967
121
    qreal sceneDistance;
1968
122
    int touchId;
1969
123
1970
124
    // The touch position exposed in the public API.
1971
125
    // It only starts to move once the gesture gets recognized.
1972
126
    QPointF publicPos;
1973
127
    QPointF publicScenePos;
1974
128
1975
129
    // A movement damper is used in some of the gesture recognition calculations
1976
130
    // to get rid of noise or small oscillations in the touch position.
1977
131
    DampedPointF dampedScenePos;
1978
132
    QPointF previousDampedScenePos;
1979
133
1980
134
    // Unit vector in scene coordinates describing the direction of the gesture recognition
1981
135
    QPointF sceneDirectionVector;
1982
136
1983
137
    Direction::Type direction;
1984
138
1985
139
    // How far a touch point has to move from its initial position along the gesture axis in order
1986
140
    // for it to be recognized as a directional drag.
1987
141
    qreal distanceThreshold;
1988
142
    qreal distanceThresholdSquared; // it's pow(distanceThreshold, 2)
1989
143
1990
144
    // Maximum time (in milliseconds) the gesture can take to go beyond the distance threshold
1991
145
    int maxTime;
1992
146
1993
147
    // Maximum distance the gesture can go without crossing the axis-aligned distance threshold
1994
148
    qreal maxDistance;
1995
149
1996
150
    // Maximum time (in milliseconds) after the start of a given touch point where
1997
151
    // subsequent touch starts are grouped with the first one into an N-touches gesture
1998
152
    // (e.g. a two-fingers tap or drag).
1999
153
    int compositionTime;
2000
154
2001
155
    bool immediateRecognition;
2002
156
2003
157
    UbuntuGestures::AbstractTimer *recognitionTimer;
2004
158
2005
159
    UbuntuGestures::SharedTimeSource timeSource;
2006
160
2007
161
    ActiveTouchesInfo activeTouches;
2008
162
2009
163
Q_SIGNALS:
2010
164
    void statusChanged(Status value);
2011
165
};
2012
166
2013
167
#endif // DIRECTIONAL_DRAG_AREA_PRIV_H
2014
0
168
2015
=== modified file 'plugins/Ubuntu/Gestures/TouchDispatcher.cpp'
2016
--- plugins/Ubuntu/Gestures/TouchDispatcher.cpp	2014-11-03 15:21:46 +0000
2017
+++ plugins/Ubuntu/Gestures/TouchDispatcher.cpp	2015-04-10 21:17:56 +0000
2018
@@ -1,5 +1,5 @@
2019
1
/*
1
/*
2021
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014-2015 Canonical, Ltd.
2022
3
 *
3
 *
2023
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
2024
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
2025
@@ -28,8 +28,11 @@
2026
28
#define TOUCHDISPATCHER_DEBUG 0
28
#define TOUCHDISPATCHER_DEBUG 0
2027
29
29
2028
30
#if TOUCHDISPATCHER_DEBUG
30
#if TOUCHDISPATCHER_DEBUG
2029
31
#define ugDebug(params) qDebug().nospace() << "[TouchDispatcher(" << this << ")] " << params
2030
31
#include <DebugHelpers.h>
32
#include <DebugHelpers.h>
2032
32
#endif
33
#else // TOUCHDISPATCHER_DEBUG
2033
34
#define ugDebug(params) ((void)0)
2034
35
#endif // TOUCHDISPATCHER_DEBUG
2035
33
36
2036
34
TouchDispatcher::TouchDispatcher()
37
TouchDispatcher::TouchDispatcher()
2037
35
    : m_status(NoActiveTouch)
38
    : m_status(NoActiveTouch)
2038
@@ -44,13 +47,12 @@
2039
44
        m_targetItem = target;
47
        m_targetItem = target;
2040
45
        if (m_status != NoActiveTouch) {
48
        if (m_status != NoActiveTouch) {
2041
46
            qWarning("[TouchDispatcher] Changing target item in the middle of a touch stream");
49
            qWarning("[TouchDispatcher] Changing target item in the middle of a touch stream");
2043
47
            m_status = TargetRejectedTouches;
50
            setStatus(TargetRejectedTouches);
2044
48
        }
51
        }
2045
49
    }
52
    }
2046
50
}
53
}
2047
51
54
2050
52
void TouchDispatcher::dispatch(QEvent::Type eventType,
55
void TouchDispatcher::dispatch(QTouchDevice *device,
2049
53
                               QTouchDevice *device,
2051
54
                               Qt::KeyboardModifiers modifiers,
56
                               Qt::KeyboardModifiers modifiers,
2052
55
                               const QList<QTouchEvent::TouchPoint> &touchPoints,
57
                               const QList<QTouchEvent::TouchPoint> &touchPoints,
2053
56
                               QWindow *window,
58
                               QWindow *window,
2054
@@ -61,6 +63,8 @@
2055
61
        return;
63
        return;
2056
62
    }
64
    }
2057
63
65
2058
66
    QEvent::Type eventType = resolveEventType(touchPoints);
2059
67
2060
64
    if (eventType == QEvent::TouchBegin) {
68
    if (eventType == QEvent::TouchBegin) {
2061
65
        dispatchTouchBegin(device, modifiers, touchPoints, window, timestamp);
69
        dispatchTouchBegin(device, modifiers, touchPoints, window, timestamp);
2062
66
70
2063
@@ -72,15 +76,13 @@
2064
72
            dispatchAsMouse(device, modifiers, touchPoints, timestamp);
76
            dispatchAsMouse(device, modifiers, touchPoints, timestamp);
2065
73
        } else {
77
        } else {
2066
74
            Q_ASSERT(m_status == TargetRejectedTouches);
78
            Q_ASSERT(m_status == TargetRejectedTouches);
2071
75
            #if TOUCHDISPATCHER_DEBUG
79
            ugDebug("Not dispatching touch event to " << m_targetItem.data()
2072
76
            qDebug() << "[TouchDispatcher] Not dispatching touch event to" << m_targetItem.data()
80
                << "because it already rejected the touch stream.");
2069
77
                << "because it already rejected the touch stream.";
2070
78
            #endif
2073
79
            // Do nothing
81
            // Do nothing
2074
80
        }
82
        }
2075
81
83
2076
82
        if (eventType == QEvent::TouchEnd) {
84
        if (eventType == QEvent::TouchEnd) {
2078
83
            m_status = NoActiveTouch;
85
            setStatus(NoActiveTouch);
2079
84
            m_touchMouseId = -1;
86
            m_touchMouseId = -1;
2080
85
        }
87
        }
2081
86
88
2082
@@ -103,10 +105,7 @@
2083
103
    QQuickItem *targetItem = m_targetItem.data();
105
    QQuickItem *targetItem = m_targetItem.data();
2084
104
106
2085
105
    if (!targetItem->isEnabled() || !targetItem->isVisible()) {
107
    if (!targetItem->isEnabled() || !targetItem->isVisible()) {
2090
106
        #if TOUCHDISPATCHER_DEBUG
108
        ugDebug("Cannot dispatch touch event to " << targetItem << " because it's disabled or invisible.");
2087
107
        qDebug() << "[TouchDispatcher] Cannot dispatch touch event to" << targetItem
2088
108
            << "because it's disabled or invisible.";
2089
109
        #endif
2091
110
        return;
109
        return;
2092
111
    }
110
    }
2093
112
111
2094
@@ -118,62 +117,46 @@
2095
118
            createQTouchEvent(QEvent::TouchBegin, device, modifiers, targetTouchPoints, window, timestamp));
117
            createQTouchEvent(QEvent::TouchBegin, device, modifiers, targetTouchPoints, window, timestamp));
2096
119
118
2097
120
119
2102
121
    #if TOUCHDISPATCHER_DEBUG
120
    ugDebug("dispatching " << qPrintable(touchEventToString(touchEvent.data()))
2103
122
    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(touchEvent.data()))
121
            << " to " << targetItem);
2100
123
            << "to" << targetItem;
2101
124
    #endif
2104
125
    QCoreApplication::sendEvent(targetItem, touchEvent.data());
122
    QCoreApplication::sendEvent(targetItem, touchEvent.data());
2105
126
123
2106
127
124
2107
128
    if (touchEvent->isAccepted()) {
125
    if (touchEvent->isAccepted()) {
2112
129
        #if TOUCHDISPATCHER_DEBUG
126
        ugDebug("Item accepted the touch event.");
2113
130
        qDebug() << "[TouchDispatcher] Item accepted the touch event.";
127
        setStatus(DeliveringTouchEvents);
2110
131
        #endif
2111
132
        m_status = DeliveringTouchEvents;
2114
133
    } else if (targetItem->acceptedMouseButtons() & Qt::LeftButton) {
128
    } else if (targetItem->acceptedMouseButtons() & Qt::LeftButton) {
2118
134
        #if TOUCHDISPATCHER_DEBUG
129
        ugDebug("Item rejected the touch event. Trying a QMouseEvent");
2116
135
        qDebug() << "[TouchDispatcher] Item rejected the touch event. Trying a QMouseEvent";
2117
136
        #endif
2119
137
        // NB: Arbitrarily chose the first touch point to emulate the mouse pointer
130
        // NB: Arbitrarily chose the first touch point to emulate the mouse pointer
2120
138
        QScopedPointer<QMouseEvent> mouseEvent(
131
        QScopedPointer<QMouseEvent> mouseEvent(
2121
139
                touchToMouseEvent(QEvent::MouseButtonPress, targetTouchPoints.at(0), timestamp,
132
                touchToMouseEvent(QEvent::MouseButtonPress, targetTouchPoints.at(0), timestamp,
2122
140
                                  modifiers, false /* transformNeeded */));
133
                                  modifiers, false /* transformNeeded */));
2123
141
        Q_ASSERT(targetTouchPoints.at(0).state() == Qt::TouchPointPressed);
134
        Q_ASSERT(targetTouchPoints.at(0).state() == Qt::TouchPointPressed);
2124
142
135
2129
143
        #if TOUCHDISPATCHER_DEBUG
136
        ugDebug("dispatching " << qPrintable(mouseEventToString(mouseEvent.data()))
2130
144
        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
137
                << " to " << m_targetItem.data());
2127
145
                << "to" << m_targetItem.data();
2128
146
        #endif
2131
147
        QCoreApplication::sendEvent(targetItem, mouseEvent.data());
138
        QCoreApplication::sendEvent(targetItem, mouseEvent.data());
2132
148
        if (mouseEvent->isAccepted()) {
139
        if (mouseEvent->isAccepted()) {
2137
149
            #if TOUCHDISPATCHER_DEBUG
140
            ugDebug("Item accepted the QMouseEvent.");
2138
150
            qDebug() << "[TouchDispatcher] Item accepted the QMouseEvent.";
141
            setStatus(DeliveringMouseEvents);
2135
151
            #endif
2136
152
            m_status = DeliveringMouseEvents;
2139
153
            m_touchMouseId = targetTouchPoints.at(0).id();
142
            m_touchMouseId = targetTouchPoints.at(0).id();
2140
154
143
2141
155
            if (checkIfDoubleClicked(timestamp)) {
144
            if (checkIfDoubleClicked(timestamp)) {
2142
156
                QScopedPointer<QMouseEvent> doubleClickEvent(
145
                QScopedPointer<QMouseEvent> doubleClickEvent(
2143
157
                        touchToMouseEvent(QEvent::MouseButtonDblClick, targetTouchPoints.at(0), timestamp,
146
                        touchToMouseEvent(QEvent::MouseButtonDblClick, targetTouchPoints.at(0), timestamp,
2144
158
                                          modifiers, false /* transformNeeded */));
147
                                          modifiers, false /* transformNeeded */));
2149
159
                #if TOUCHDISPATCHER_DEBUG
148
                ugDebug("dispatching " << qPrintable(mouseEventToString(doubleClickEvent.data()))
2150
160
                qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(doubleClickEvent.data()))
149
                        << " to " << m_targetItem.data());
2147
161
                        << "to" << m_targetItem.data();
2148
162
                #endif
2151
163
                QCoreApplication::sendEvent(targetItem, doubleClickEvent.data());
150
                QCoreApplication::sendEvent(targetItem, doubleClickEvent.data());
2152
164
            }
151
            }
2153
165
152
2154
166
        } else {
153
        } else {
2159
167
            #if TOUCHDISPATCHER_DEBUG
154
            ugDebug("Item rejected the QMouseEvent.");
2160
168
            qDebug() << "[TouchDispatcher] Item rejected the QMouseEvent.";
155
            setStatus(TargetRejectedTouches);
2157
169
            #endif
2158
170
            m_status = TargetRejectedTouches;
2161
171
        }
156
        }
2162
172
    } else {
157
    } else {
2167
173
        #if TOUCHDISPATCHER_DEBUG
158
        ugDebug("Item rejected the touch event and does not accept mouse buttons.");
2168
174
        qDebug() << "[TouchDispatcher] Item rejected the touch event and does not accept mouse buttons.";
159
        setStatus(TargetRejectedTouches);
2165
175
        #endif
2166
176
        m_status = TargetRejectedTouches;
2169
177
    }
160
    }
2170
178
}
161
}
2171
179
162
2172
@@ -194,10 +177,8 @@
2173
194
            createQTouchEvent(eventType, device, modifiers, targetTouchPoints, window, timestamp));
177
            createQTouchEvent(eventType, device, modifiers, targetTouchPoints, window, timestamp));
2174
195
178
2175
196
179
2180
197
    #if TOUCHDISPATCHER_DEBUG
180
    ugDebug("dispatching " << qPrintable(touchEventToString(eventForTargetItem.data()))
2181
198
    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(eventForTargetItem.data()))
181
            << " to " << targetItem);
2178
199
            << "to" << targetItem;
2179
200
    #endif
2182
201
    QCoreApplication::sendEvent(targetItem, eventForTargetItem.data());
182
    QCoreApplication::sendEvent(targetItem, eventForTargetItem.data());
2183
202
}
183
}
2184
203
184
2185
@@ -254,10 +235,8 @@
2186
254
        QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(eventType, *touchMouse, timestamp, modifiers,
235
        QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(eventType, *touchMouse, timestamp, modifiers,
2187
255
                    true /* transformNeeded */));
236
                    true /* transformNeeded */));
2188
256
237
2193
257
        #if TOUCHDISPATCHER_DEBUG
238
        ugDebug("dispatching " << qPrintable(mouseEventToString(mouseEvent.data()))
2194
258
        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
239
                << " to " << m_targetItem.data());
2191
259
                << "to" << m_targetItem.data();
2192
260
        #endif
2195
261
        QCoreApplication::sendEvent(m_targetItem.data(), mouseEvent.data());
240
        QCoreApplication::sendEvent(m_targetItem.data(), mouseEvent.data());
2196
262
    }
241
    }
2197
263
}
242
}
2198
@@ -365,3 +344,59 @@
2199
365
344
2200
366
    return doubleClicked;
345
    return doubleClicked;
2201
367
}
346
}
2202
347
2203
348
void TouchDispatcher::setStatus(Status status)
2204
349
{
2205
350
    if (status != m_status) {
2206
351
        #if TOUCHDISPATCHER_DEBUG
2207
352
        switch (status) {
2208
353
        case NoActiveTouch:
2209
354
            ugDebug("status = NoActiveTouch");
2210
355
            break;
2211
356
        case DeliveringTouchEvents:
2212
357
            ugDebug("status = DeliveringTouchEvents");
2213
358
            break;
2214
359
        case DeliveringMouseEvents:
2215
360
            ugDebug("status = DeliveringMouseEvents");
2216
361
            break;
2217
362
        case TargetRejectedTouches:
2218
363
            ugDebug("status = TargetRejectedTouches");
2219
364
            break;
2220
365
        default:
2221
366
            ugDebug("status = " << status);
2222
367
            break;
2223
368
        }
2224
369
        #endif
2225
370
        m_status = status;
2226
371
    }
2227
372
}
2228
373
2229
374
void TouchDispatcher::reset()
2230
375
{
2231
376
    setStatus(NoActiveTouch);
2232
377
    m_touchMouseId = -1;
2233
378
    m_touchMousePressTimestamp =0;
2234
379
}
2235
380
2236
381
QEvent::Type TouchDispatcher::resolveEventType(const QList<QTouchEvent::TouchPoint> &touchPoints)
2237
382
{
2238
383
    QEvent::Type eventType;
2239
384
2240
385
    Qt::TouchPointStates eventStates = 0;
2241
386
    for (int i = 0; i < touchPoints.count(); i++)
2242
387
        eventStates |= touchPoints[i].state();
2243
388
2244
389
    switch (eventStates) {
2245
390
        case Qt::TouchPointPressed:
2246
391
            eventType = QEvent::TouchBegin;
2247
392
            break;
2248
393
        case Qt::TouchPointReleased:
2249
394
            eventType = QEvent::TouchEnd;
2250
395
            break;
2251
396
        default:
2252
397
            eventType = QEvent::TouchUpdate;
2253
398
            break;
2254
399
    }
2255
400
2256
401
    return eventType;
2257
402
}
2258
368
403
2259
=== modified file 'plugins/Ubuntu/Gestures/TouchDispatcher.h'
2260
--- plugins/Ubuntu/Gestures/TouchDispatcher.h	2014-11-03 15:21:46 +0000
2261
+++ plugins/Ubuntu/Gestures/TouchDispatcher.h	2015-04-10 21:17:56 +0000
2262
@@ -1,5 +1,5 @@
2263
1
/*
1
/*
2265
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014-2015 Canonical, Ltd.
2266
3
 *
3
 *
2267
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
2268
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
2269
@@ -36,12 +36,20 @@
2270
36
    void setTargetItem(QQuickItem *target);
36
    void setTargetItem(QQuickItem *target);
2271
37
    QQuickItem *targetItem() { return m_targetItem; }
37
    QQuickItem *targetItem() { return m_targetItem; }
2272
38
38
2275
39
    void dispatch(QEvent::Type eventType,
39
    void dispatch(QTouchDevice *device,
2274
40
            QTouchDevice *device,
2276
41
            Qt::KeyboardModifiers modifiers,
40
            Qt::KeyboardModifiers modifiers,
2277
42
            const QList<QTouchEvent::TouchPoint> &touchPoints,
41
            const QList<QTouchEvent::TouchPoint> &touchPoints,
2278
43
            QWindow *window,
42
            QWindow *window,
2279
44
            ulong timestamp);
43
            ulong timestamp);
2280
44
2281
45
    void reset();
2282
46
2283
47
    enum Status {
2284
48
        NoActiveTouch,
2285
49
        DeliveringTouchEvents,
2286
50
        DeliveringMouseEvents,
2287
51
        TargetRejectedTouches
2288
52
    };
2289
45
private:
53
private:
2290
46
    void dispatchTouchBegin(
54
    void dispatchTouchBegin(
2291
47
            QTouchDevice *device,
55
            QTouchDevice *device,
2292
@@ -73,14 +81,13 @@
2293
73
81
2294
74
    bool checkIfDoubleClicked(ulong newPressEventTimestamp);
82
    bool checkIfDoubleClicked(ulong newPressEventTimestamp);
2295
75
83
2296
84
    void setStatus(Status status);
2297
85
2298
86
    static QEvent::Type resolveEventType(const QList<QTouchEvent::TouchPoint> &touchPoints);
2299
87
2300
76
    QPointer<QQuickItem> m_targetItem;
88
    QPointer<QQuickItem> m_targetItem;
2301
77
89
2308
78
    enum {
90
    Status m_status;
2303
79
        NoActiveTouch,
2304
80
        DeliveringTouchEvents,
2305
81
        DeliveringMouseEvents,
2306
82
        TargetRejectedTouches
2307
83
    } m_status;
2309
84
91
2310
85
    int m_touchMouseId;
92
    int m_touchMouseId;
2311
86
    ulong m_touchMousePressTimestamp;
93
    ulong m_touchMousePressTimestamp;
2312
87
94
2313
=== modified file 'plugins/Ubuntu/Gestures/TouchGate.cpp'
2314
--- plugins/Ubuntu/Gestures/TouchGate.cpp	2015-01-28 12:59:21 +0000
2315
+++ plugins/Ubuntu/Gestures/TouchGate.cpp	2015-04-10 21:17:56 +0000
2316
@@ -1,5 +1,5 @@
2317
1
/*
1
/*
2319
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014-2015 Canonical, Ltd.
2320
3
 *
3
 *
2321
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
2322
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
2323
@@ -23,8 +23,18 @@
2324
23
#include <TouchRegistry.h>
23
#include <TouchRegistry.h>
2325
24
24
2326
25
#if TOUCHGATE_DEBUG
25
#if TOUCHGATE_DEBUG
2327
26
#define ugDebug(params) qDebug().nospace() << "[TouchGate(" << (void*)this << ")] " << params
2328
26
#include <DebugHelpers.h>
27
#include <DebugHelpers.h>
2330
27
#endif
28
#else // TOUCHGATE_DEBUG
2331
29
#define ugDebug(params) ((void)0)
2332
30
#endif // TOUCHGATE_DEBUG
2333
31
2334
32
TouchGate::TouchGate(QQuickItem *parent)
2335
33
    : QQuickItem(parent)
2336
34
{
2337
35
    connect(this, &QQuickItem::enabledChanged,
2338
36
            this, &TouchGate::onEnabledChanged);
2339
37
}
2340
28
38
2341
29
bool TouchGate::event(QEvent *e)
39
bool TouchGate::event(QEvent *e)
2342
30
{
40
{
2343
@@ -38,13 +48,12 @@
2344
38
48
2345
39
void TouchGate::touchEvent(QTouchEvent *event)
49
void TouchGate::touchEvent(QTouchEvent *event)
2346
40
{
50
{
2350
41
    #if TOUCHGATE_DEBUG
51
    ugDebug("got touch event" << qPrintable(touchEventToString(event)));
2348
42
    qDebug() << "[TouchGate] got touch event" << qPrintable(touchEventToString(event));
2349
43
    #endif
2351
44
    event->accept();
52
    event->accept();
2352
45
53
2353
46
    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
54
    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
2355
47
    bool goodToGo = true;
55
    QList<QTouchEvent::TouchPoint> validTouchPoints;
2356
56
    bool ownsAllTouches = true;
2357
48
    for (int i = 0; i < touchPoints.count(); ++i) {
57
    for (int i = 0; i < touchPoints.count(); ++i) {
2358
49
        const QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
58
        const QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
2359
50
59
2360
@@ -57,31 +66,41 @@
2361
57
            Q_EMIT pressed();
66
            Q_EMIT pressed();
2362
58
        }
67
        }
2363
59
68
2369
60
        goodToGo &= m_touchInfoMap.contains(touchPoint.id())
69
        if (m_touchInfoMap.contains(touchPoint.id())) {
2370
61
            && m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted;
70
            validTouchPoints.append(touchPoint);
2371
62
71
2372
63
        if (touchPoint.state() == Qt::TouchPointReleased && m_touchInfoMap.contains(touchPoint.id())) {
72
            ownsAllTouches &= m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted;
2373
64
            m_touchInfoMap[touchPoint.id()].ended = true;
73
2374
74
            if (touchPoint.state() == Qt::TouchPointReleased) {
2375
75
                m_touchInfoMap[touchPoint.id()].ended = true;
2376
76
            }
2377
65
        }
77
        }
2378
66
78
2379
67
    }
79
    }
2380
68
80
2382
69
    if (goodToGo) {
81
    if (validTouchPoints.isEmpty()) {
2383
82
        // nothing to do.
2384
83
        return;
2385
84
    }
2386
85
2387
86
    if (ownsAllTouches) {
2388
70
        if (m_storedEvents.isEmpty()) {
87
        if (m_storedEvents.isEmpty()) {
2389
71
            // let it pass through
88
            // let it pass through
2391
72
            dispatchTouchEventToTarget(event);
89
            removeTouchInfoForEndedTouches(validTouchPoints);
2392
90
            m_dispatcher.dispatch(event->device(), event->modifiers(), validTouchPoints,
2393
91
                    event->window(), event->timestamp());
2394
73
        } else {
92
        } else {
2395
74
            // Retain the event to ensure TouchGate dispatches them in order.
93
            // Retain the event to ensure TouchGate dispatches them in order.
2396
75
            // Otherwise the current event would come before the stored ones, which are older.
94
            // Otherwise the current event would come before the stored ones, which are older.
2402
76
            #if TOUCHGATE_DEBUG
95
            ugDebug("Storing event because thouches " << qPrintable(oldestPendingTouchIdsString())
2403
77
            qDebug("[TouchGate] Storing event because thouches %s are still pending ownership.",
96
                    << " are still pending ownership.");
2404
78
                qPrintable(oldestPendingTouchIdsString()));
97
            storeTouchEvent(event->device(), event->modifiers(), validTouchPoints,
2405
79
            #endif
98
                    event->window(), event->timestamp());
2401
80
            storeTouchEvent(event);
2406
81
        }
99
        }
2407
82
    } else {
100
    } else {
2408
83
        // Retain events that have unowned touches
101
        // Retain events that have unowned touches
2410
84
        storeTouchEvent(event);
102
        storeTouchEvent(event->device(), event->modifiers(), validTouchPoints,
2411
103
                event->window(), event->timestamp());
2412
85
    }
104
    }
2413
86
}
105
}
2414
87
106
2415
@@ -90,24 +109,23 @@
2416
90
    // TODO: Optimization: batch those actions as TouchOwnershipEvents
109
    // TODO: Optimization: batch those actions as TouchOwnershipEvents
2417
91
    //       might come one right after the other.
110
    //       might come one right after the other.
2418
92
111
2428
93
    Q_ASSERT(m_touchInfoMap.contains(event->touchId()));
112
    if (m_touchInfoMap.contains(event->touchId())) {
2429
94
113
        TouchInfo &touchInfo = m_touchInfoMap[event->touchId()];
2430
95
    TouchInfo &touchInfo = m_touchInfoMap[event->touchId()];
114
2431
96
115
        if (event->gained()) {
2432
97
    if (event->gained()) {
116
            ugDebug("Got ownership of touch " << event->touchId());
2433
98
        #if TOUCHGATE_DEBUG
117
            touchInfo.ownership = OwnershipGranted;
2434
99
        qDebug() << "[TouchGate] Got ownership of touch " << event->touchId();
118
        } else {
2435
100
        #endif
119
            ugDebug("Lost ownership of touch " << event->touchId());
2436
101
        touchInfo.ownership = OwnershipGranted;
120
            m_touchInfoMap.remove(event->touchId());
2437
121
            removeTouchFromStoredEvents(event->touchId());
2438
122
        }
2439
123
2440
124
        dispatchFullyOwnedEvents();
2441
102
    } else {
125
    } else {
2447
103
        #if TOUCHGATE_DEBUG
126
        // Ignore it. It probably happened because the TouchGate got disabled
2448
104
        qDebug() << "[TouchGate] Lost ownership of touch " << event->touchId();
127
        // between the time it requested ownership and the time it got it.
2444
105
        #endif
2445
106
        m_touchInfoMap.remove(event->touchId());
2446
107
        removeTouchFromStoredEvents(event->touchId());
2449
108
    }
128
    }
2450
109
2451
110
    dispatchFullyOwnedEvents();
2452
111
}
129
}
2453
112
130
2454
113
bool TouchGate::isTouchPointOwned(int touchId) const
131
bool TouchGate::isTouchPointOwned(int touchId) const
2455
@@ -115,14 +133,15 @@
2456
115
    return m_touchInfoMap[touchId].ownership == OwnershipGranted;
133
    return m_touchInfoMap[touchId].ownership == OwnershipGranted;
2457
116
}
134
}
2458
117
135
2460
118
void TouchGate::storeTouchEvent(const QTouchEvent *event)
136
void TouchGate::storeTouchEvent(QTouchDevice *device,
2461
137
            Qt::KeyboardModifiers modifiers,
2462
138
            const QList<QTouchEvent::TouchPoint> &touchPoints,
2463
139
            QWindow *window,
2464
140
            ulong timestamp)
2465
119
{
141
{
2472
120
    #if TOUCHGATE_DEBUG
142
    ugDebug("Storing" << touchPoints);
2473
121
    qDebug() << "[TouchGate] Storing" << qPrintable(touchEventToString(event));
143
    TouchEvent event(device, modifiers, touchPoints, window, timestamp);
2474
122
    #endif
144
    m_storedEvents.append(std::move(event));
2469
123
2470
124
    TouchEvent clonedEvent(event);
2471
125
    m_storedEvents.append(std::move(clonedEvent));
2475
126
}
145
}
2476
127
146
2477
128
void TouchGate::removeTouchFromStoredEvents(int touchId)
147
void TouchGate::removeTouchFromStoredEvents(int touchId)
2478
@@ -195,25 +214,13 @@
2479
195
void TouchGate::dispatchTouchEventToTarget(const TouchEvent &event)
214
void TouchGate::dispatchTouchEventToTarget(const TouchEvent &event)
2480
196
{
215
{
2481
197
    removeTouchInfoForEndedTouches(event.touchPoints);
216
    removeTouchInfoForEndedTouches(event.touchPoints);
2484
198
    m_dispatcher.dispatch(event.eventType,
217
    m_dispatcher.dispatch(event.device,
2483
199
            event.device,
2485
200
            event.modifiers,
218
            event.modifiers,
2486
201
            event.touchPoints,
219
            event.touchPoints,
2487
202
            event.window,
220
            event.window,
2488
203
            event.timestamp);
221
            event.timestamp);
2489
204
}
222
}
2490
205
223
2491
206
void TouchGate::dispatchTouchEventToTarget(QTouchEvent* event)
2492
207
{
2493
208
    removeTouchInfoForEndedTouches(event->touchPoints());
2494
209
    m_dispatcher.dispatch(event->type(),
2495
210
            event->device(),
2496
211
            event->modifiers(),
2497
212
            event->touchPoints(),
2498
213
            event->window(),
2499
214
            event->timestamp());
2500
215
}
2501
216
2502
217
void TouchGate::removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints)
224
void TouchGate::removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints)
2503
218
{
225
{
2504
219
    for (int i = 0; i < touchPoints.size(); ++i) {\
226
    for (int i = 0; i < touchPoints.size(); ++i) {\
2505
@@ -228,14 +235,31 @@
2506
228
    }
235
    }
2507
229
}
236
}
2508
230
237
2517
231
TouchGate::TouchEvent::TouchEvent(const QTouchEvent *event)
238
void TouchGate::onEnabledChanged()
2518
232
    : eventType(event->type())
239
{
2519
233
    , device(event->device())
240
    ugDebug(" enabled = " << isEnabled());
2520
234
    , modifiers(event->modifiers())
241
    if (!isEnabled()) {
2521
235
    , touchPoints(event->touchPoints())
242
        reset();
2522
236
    , target(qobject_cast<QQuickItem*>(event->target()))
243
    }
2523
237
    , window(event->window())
244
}
2524
238
    , timestamp(event->timestamp())
245
2525
246
void TouchGate::reset()
2526
247
{
2527
248
    m_storedEvents.clear();
2528
249
    m_touchInfoMap.clear();
2529
250
    m_dispatcher.reset();
2530
251
}
2531
252
2532
253
TouchGate::TouchEvent::TouchEvent(QTouchDevice *device,
2533
254
            Qt::KeyboardModifiers modifiers,
2534
255
            const QList<QTouchEvent::TouchPoint> &touchPoints,
2535
256
            QWindow *window,
2536
257
            ulong timestamp)
2537
258
    : device(device)
2538
259
    , modifiers(modifiers)
2539
260
    , touchPoints(touchPoints)
2540
261
    , window(window)
2541
262
    , timestamp(timestamp)
2542
239
{
263
{
2543
240
}
264
}
2544
241
265
2545
242
266
2546
=== modified file 'plugins/Ubuntu/Gestures/TouchGate.h'
2547
--- plugins/Ubuntu/Gestures/TouchGate.h	2015-01-28 12:59:21 +0000
2548
+++ plugins/Ubuntu/Gestures/TouchGate.h	2015-04-10 21:17:56 +0000
2549
@@ -45,6 +45,8 @@
2550
45
    Q_PROPERTY(QQuickItem* targetItem READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
45
    Q_PROPERTY(QQuickItem* targetItem READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
2551
46
46
2552
47
public:
47
public:
2553
48
    TouchGate(QQuickItem *parent = nullptr);
2554
49
2555
48
    bool event(QEvent *e) override;
50
    bool event(QEvent *e) override;
2556
49
51
2557
50
    QQuickItem *targetItem() { return m_dispatcher.targetItem(); }
52
    QQuickItem *targetItem() { return m_dispatcher.targetItem(); }
2558
@@ -57,31 +59,42 @@
2559
57
59
2560
58
protected:
60
protected:
2561
59
    void touchEvent(QTouchEvent *event) override;
61
    void touchEvent(QTouchEvent *event) override;
2562
62
2563
63
private Q_SLOTS:
2564
64
    void onEnabledChanged();
2565
65
2566
60
private:
66
private:
2567
67
    void reset();
2568
68
2569
61
    class TouchEvent {
69
    class TouchEvent {
2570
62
    public:
70
    public:
2572
63
        TouchEvent(const QTouchEvent *event);
71
        TouchEvent(QTouchDevice *device,
2573
72
            Qt::KeyboardModifiers modifiers,
2574
73
            const QList<QTouchEvent::TouchPoint> &touchPoints,
2575
74
            QWindow *window,
2576
75
            ulong timestamp);
2577
64
76
2578
65
        bool removeTouch(int touchId);
77
        bool removeTouch(int touchId);
2579
66
78
2580
67
        QEvent::Type eventType;
2581
68
        QTouchDevice *device;
79
        QTouchDevice *device;
2582
69
        Qt::KeyboardModifiers modifiers;
80
        Qt::KeyboardModifiers modifiers;
2583
70
        QList<QTouchEvent::TouchPoint> touchPoints;
81
        QList<QTouchEvent::TouchPoint> touchPoints;
2584
71
        QQuickItem *target;
2585
72
        QWindow *window;
82
        QWindow *window;
2586
73
        ulong timestamp;
83
        ulong timestamp;
2587
74
    };
84
    };
2588
75
85
2589
76
    void touchOwnershipEvent(TouchOwnershipEvent *event);
86
    void touchOwnershipEvent(TouchOwnershipEvent *event);
2590
77
    bool isTouchPointOwned(int touchId) const;
87
    bool isTouchPointOwned(int touchId) const;
2592
78
    void storeTouchEvent(const QTouchEvent *event);
88
    void storeTouchEvent(QTouchDevice *device,
2593
89
            Qt::KeyboardModifiers modifiers,
2594
90
            const QList<QTouchEvent::TouchPoint> &touchPoints,
2595
91
            QWindow *window,
2596
92
            ulong timestamp);
2597
79
    void removeTouchFromStoredEvents(int touchId);
93
    void removeTouchFromStoredEvents(int touchId);
2598
80
    void dispatchFullyOwnedEvents();
94
    void dispatchFullyOwnedEvents();
2599
81
    bool eventIsFullyOwned(const TouchEvent &event) const;
95
    bool eventIsFullyOwned(const TouchEvent &event) const;
2600
82
96
2601
83
    void dispatchTouchEventToTarget(const TouchEvent &event);
97
    void dispatchTouchEventToTarget(const TouchEvent &event);
2602
84
    void dispatchTouchEventToTarget(QTouchEvent* event);
2603
85
98
2604
86
    void removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints);
99
    void removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints);
2605
87
100
2606
88
101
2607
=== modified file 'qml/Components/DragHandle.qml'
2608
--- qml/Components/DragHandle.qml	2014-12-05 17:06:36 +0000
2609
+++ qml/Components/DragHandle.qml	2015-04-10 21:17:56 +0000
2610
@@ -43,16 +43,8 @@
2611
43
  }
43
  }
2612
44
44
2613
45
 */
45
 */
2615
46
EdgeDragArea {
46
DirectionalDragArea {
2616
47
    id: dragArea
47
    id: dragArea
2617
48
    objectName: "dragHandle"
2618
49
2619
50
    // Disable gesture recognition by default when hinting is used as
2620
51
    // it conflicts with the hinting idea.
2621
52
    distanceThreshold: hintDisplacement > 0 ? 0 : defaultDistanceThreshold
2622
53
    maxSilenceTime: hintDisplacement > 0 ? 60*60*1000 : defaultMaxSilenceTime
2623
54
    maxDeviation: hintDisplacement > 0 ? 999999 : defaultMaxDeviation
2624
55
    compositionTime: hintDisplacement > 0 ? 0 : defaultCompositionTime
2625
56
48
2626
57
    property bool stretch: false
49
    property bool stretch: false
2627
58
50
2628
@@ -68,6 +60,9 @@
2629
68
    }
60
    }
2630
69
61
2631
70
    property real hintDisplacement: 0
62
    property real hintDisplacement: 0
2632
63
2633
64
    immediateRecognition: hintDisplacement > 0
2634
65
2635
71
    property var overrideStartValue: undefined
66
    property var overrideStartValue: undefined
2636
72
    SmoothedAnimation {
67
    SmoothedAnimation {
2637
73
        id: hintingAnimation
68
        id: hintingAnimation
2638
@@ -98,7 +93,6 @@
2639
98
    // Private stuff
93
    // Private stuff
2640
99
    QtObject {
94
    QtObject {
2641
100
        id: d
95
        id: d
2642
101
        property var previousStatus: DirectionalDragArea.WaitingForTouch
2643
102
        property real startValue
96
        property real startValue
2644
103
        property real minValue: {
97
        property real minValue: {
2645
104
            if (direction == Direction.Horizontal) {
98
            if (direction == Direction.Horizontal) {
2646
@@ -183,7 +177,7 @@
2647
183
    }
177
    }
2648
184
178
2649
185
    onDistanceChanged: {
179
    onDistanceChanged: {
2651
186
        if (status === DirectionalDragArea.Recognized) {
180
        if (dragging) {
2652
187
            // don't go the whole distance in order to smooth out the movement
181
            // don't go the whole distance in order to smooth out the movement
2653
188
            var step = distance * 0.3;
182
            var step = distance * 0.3;
2654
189
183
2655
@@ -193,31 +187,22 @@
2656
193
        }
187
        }
2657
194
    }
188
    }
2658
195
189
2661
196
    onStatusChanged: {
190
    onDraggingChanged: {
2662
197
        if (status === DirectionalDragArea.WaitingForTouch) {
191
        if (dragging) {
2663
192
            dragEvaluator.reset();
2664
193
            if (overrideStartValue !== undefined) {
2665
194
                d.startValue = overrideStartValue;
2666
195
            } else {
2667
196
                d.startValue = parent[d.targetProp];
2668
197
            }
2669
198
2670
199
            if (hintDisplacement > 0) {
2671
200
                hintingAnimation.targetValue = d.startValue;
2672
201
                hintingAnimation.start();
2673
202
            }
2674
203
        } else {
2675
198
            hintingAnimation.stop();
204
            hintingAnimation.stop();
2696
199
            if (d.previousStatus === DirectionalDragArea.Recognized) {
205
            d.onFinishedRecognizedGesture();
2677
200
                d.onFinishedRecognizedGesture();
2678
201
            } else /* d.previousStatus === DirectionalDragArea.Undecided */ {
2679
202
                // Gesture was rejected.
2680
203
                d.rollbackDrag();
2681
204
            }
2682
205
        } else /* Undecided || Recognized */ {
2683
206
            if (d.previousStatus === DirectionalDragArea.WaitingForTouch) {
2684
207
                dragEvaluator.reset();
2685
208
                if (overrideStartValue !== undefined) {
2686
209
                    d.startValue = overrideStartValue;
2687
210
                } else {
2688
211
                    d.startValue = parent[d.targetProp];
2689
212
                }
2690
213
2691
214
                if (hintDisplacement > 0) {
2692
215
                    hintingAnimation.targetValue = d.startValue;
2693
216
                    hintingAnimation.start();
2694
217
                }
2695
218
            }
2697
219
        }
206
        }
2698
220
2699
221
        d.previousStatus = status;
2700
222
    }
207
    }
2701
223
}
208
}
2702
224
209
2703
=== removed file 'qml/Components/EdgeDragArea.qml'
2704
--- qml/Components/EdgeDragArea.qml	2014-10-01 13:20:32 +0000
2705
+++ qml/Components/EdgeDragArea.qml	1970-01-01 00:00:00 +0000
2706
@@ -1,46 +0,0 @@
2707
1
/*
2708
2
 * Copyright (C) 2013 Canonical, Ltd.
2709
3
 *
2710
4
 * This program is free software; you can redistribute it and/or modify
2711
5
 * it under the terms of the GNU General Public License as published by
2712
6
 * the Free Software Foundation; version 3.
2713
7
 *
2714
8
 * This program is distributed in the hope that it will be useful,
2715
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2716
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2717
11
 * GNU General Public License for more details.
2718
12
 *
2719
13
 * You should have received a copy of the GNU General Public License
2720
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2721
15
 */
2722
16
2723
17
import QtQuick 2.0
2724
18
import Ubuntu.Components 0.1
2725
19
import Ubuntu.Gestures 0.1
2726
20
2727
21
/*
2728
22
 A DirectionalDragArea wrapper that provides some well-chosen defaults
2729
23
 for its gesture recognition parameters.
2730
24
*/
2731
25
DirectionalDragArea {
2732
26
2733
27
    // TODO: Re-evaluate those or even the recognition heuristics itself once
2734
28
    // we have gesture cancelling/forwarding in place.
2735
29
    //
2736
30
    // The idea here is that it's better having lax rules than false negatives.
2737
31
    // False negatives are very frustrating to the user.
2738
32
    maxDeviation: defaultMaxDeviation
2739
33
    wideningAngle: defaultWideningAngle
2740
34
    distanceThreshold: defaultDistanceThreshold
2741
35
    minSpeed: defaultMinSpeed
2742
36
    maxSilenceTime: defaultMaxSilenceTime
2743
37
    compositionTime: defaultCompositionTime
2744
38
2745
39
    readonly property real defaultMaxDeviation: units.gu(3)
2746
40
    readonly property real defaultWideningAngle: 50
2747
41
    readonly property real defaultDistanceThreshold: units.gu(1.5)
2748
42
    // some people were getting false negatives with it enabled.
2749
43
    readonly property real defaultMinSpeed: units.gu(0)
2750
44
    readonly property int defaultMaxSilenceTime: 200
2751
45
    readonly property int defaultCompositionTime: 60
2752
46
}
2753
47
0
2754
=== modified file 'qml/Dash/Dash.qml'
2755
--- qml/Dash/Dash.qml	2015-02-17 08:26:20 +0000
2756
+++ qml/Dash/Dash.qml	2015-04-10 21:17:56 +0000
2757
@@ -140,7 +140,7 @@
2758
140
        // (as expected) but would also cause the dash content flickable to move a bit, because
140
        // (as expected) but would also cause the dash content flickable to move a bit, because
2759
141
        // that flickable was getting the touch events while overviewDragHandle was still undecided
141
        // that flickable was getting the touch events while overviewDragHandle was still undecided
2760
142
        // about whether that touch was indeed performing a directional drag gesture.
142
        // about whether that touch was indeed performing a directional drag gesture.
2762
143
        forceNonInteractive: overviewDragHandle.status != DirectionalDragArea.WaitingForTouch
143
        forceNonInteractive: overviewDragHandle.dragging
2763
144
144
2764
145
        enabled: bottomEdgeController.progress == 0
145
        enabled: bottomEdgeController.progress == 0
2765
146
    }
146
    }
2766
@@ -317,7 +317,7 @@
2767
317
        }
317
        }
2768
318
    }
318
    }
2769
319
319
2771
320
    EdgeDragArea {
320
    DirectionalDragArea {
2772
321
        id: overviewDragHandle
321
        id: overviewDragHandle
2773
322
        objectName: "overviewDragHandle"
322
        objectName: "overviewDragHandle"
2774
323
        z: 1
323
        z: 1
2775
@@ -333,21 +333,14 @@
2776
333
        height: units.gu(2)
333
        height: units.gu(2)
2777
334
334
2778
335
        onSceneDistanceChanged: {
335
        onSceneDistanceChanged: {
2780
336
            if (status == DirectionalDragArea.Recognized) {
336
            if (dragging) {
2781
337
                bottomEdgeController.enableAnimation = false;
337
                bottomEdgeController.enableAnimation = false;
2782
338
                bottomEdgeController.progress = Math.max(0, Math.min(1, sceneDistance / fullMovement));
338
                bottomEdgeController.progress = Math.max(0, Math.min(1, sceneDistance / fullMovement));
2783
339
            }
339
            }
2784
340
        }
340
        }
2785
341
341
2795
342
        property int previousStatus: -1
342
        onDraggingChanged: {
2796
343
        property int currentStatus: DirectionalDragArea.WaitingForTouch
343
            if (!dragging) {
2788
344
2789
345
        onStatusChanged: {
2790
346
            previousStatus = currentStatus;
2791
347
            currentStatus = status;
2792
348
2793
349
            if (status == DirectionalDragArea.WaitingForTouch &&
2794
350
                    previousStatus == DirectionalDragArea.Recognized) {
2797
351
                bottomEdgeController.enableAnimation = true;
344
                bottomEdgeController.enableAnimation = true;
2798
352
                bottomEdgeController.progress = (bottomEdgeController.progress > 0.2)  ? 1 : 0;
345
                bottomEdgeController.progress = (bottomEdgeController.progress > 0.2)  ? 1 : 0;
2799
353
            }
346
            }
2800
354
347
2801
=== modified file 'qml/Greeter/CoverPage.qml'
2802
--- qml/Greeter/CoverPage.qml	2015-02-17 15:54:17 +0000
2803
+++ qml/Greeter/CoverPage.qml	2015-04-10 21:17:56 +0000
2804
@@ -129,6 +129,7 @@
2805
129
129
2806
130
    DragHandle {
130
    DragHandle {
2807
131
        id: dragHandle
131
        id: dragHandle
2808
132
        objectName: "coverPageDragHandle"
2809
132
        anchors.fill: parent
133
        anchors.fill: parent
2810
133
        anchors.leftMargin: root.dragHandleLeftMargin
134
        anchors.leftMargin: root.dragHandleLeftMargin
2811
134
        enabled: root.draggable
135
        enabled: root.draggable
2812
135
136
2813
=== modified file 'qml/Launcher/Launcher.qml'
2814
--- qml/Launcher/Launcher.qml	2015-03-12 13:04:36 +0000
2815
+++ qml/Launcher/Launcher.qml	2015-04-10 21:17:56 +0000
2816
@@ -210,7 +210,7 @@
2817
210
            bottom: parent.bottom
210
            bottom: parent.bottom
2818
211
        }
211
        }
2819
212
        x: -width
212
        x: -width
2821
213
        visible: root.x > 0 || x > -width || dragArea.status === DirectionalDragArea.Undecided
213
        visible: root.x > 0 || x > -width
2822
214
        model: LauncherModel
214
        model: LauncherModel
2823
215
215
2824
216
        property bool animate: true
216
        property bool animate: true
2825
@@ -272,7 +272,7 @@
2826
272
        }
272
        }
2827
273
    }
273
    }
2828
274
274
2830
275
    EdgeDragArea {
275
    DirectionalDragArea {
2831
276
        id: dragArea
276
        id: dragArea
2832
277
        objectName: "launcherDragArea"
277
        objectName: "launcherDragArea"
2833
278
278
2834
@@ -284,19 +284,10 @@
2835
284
        height: root.height
284
        height: root.height
2836
285
285
2837
286
        onTouchXChanged: {
286
        onTouchXChanged: {
2839
287
            if (status !== DirectionalDragArea.Recognized || launcher.state == "visible")
287
            if (!dragging || launcher.state == "visible")
2840
288
                return;
288
                return;
2841
289
289
2852
290
            // When the gesture finally gets recognized, the finger will likely be
290
            panel.x = Math.min(0, touchX - panel.width) - root.x
2843
291
            // reasonably far from the edge. If we made the panel immediately
2844
292
            // follow the finger position it would be visually unpleasant as it
2845
293
            // would appear right next to the user's finger out of nowhere.
2846
294
            // Instead, we make the panel go towards the user's finger in several
2847
295
            // steps. ie., in an animated way.
2848
296
            var targetPanelX = Math.min(0, touchX - panel.width) - root.x
2849
297
            var delta = targetPanelX - panel.x
2850
298
            // the trick is not to go all the way (1.0) as it would cause a sudden jump
2851
299
            panel.x += 0.4 * delta
2853
300
        }
291
        }
2854
301
292
2855
302
        onDraggingChanged: {
293
        onDraggingChanged: {
2856
@@ -306,7 +297,8 @@
2857
306
                    if (distance > minimizeDistance) {
297
                    if (distance > minimizeDistance) {
2858
307
                        root.dash();
298
                        root.dash();
2859
308
                    }
299
                    }
2861
309
                } else {
300
                } else if (root.state === "") {
2862
301
                    // didn't drag far enough. rollback
2863
310
                    root.switchToNextState("")
302
                    root.switchToNextState("")
2864
311
                }
303
                }
2865
312
            }
304
            }
2866
313
305
2867
=== modified file 'qml/Panel/IndicatorsMenu.qml'
2868
--- qml/Panel/IndicatorsMenu.qml	2015-03-18 10:17:21 +0000
2869
+++ qml/Panel/IndicatorsMenu.qml	2015-04-10 21:17:56 +0000
2870
@@ -182,9 +182,18 @@
2871
182
        enabled: !root.shown && root.available
182
        enabled: !root.shown && root.available
2872
183
        autoCompleteDragThreshold: maxTotalDragDistance / 2
183
        autoCompleteDragThreshold: maxTotalDragDistance / 2
2873
184
        stretch: true
184
        stretch: true
2874
185
        distanceThreshold: enableHint ? 0 : minimizedPanelHeight
2875
186
185
2877
187
        onTapped: showTapped(Qt.point(touchSceneX, touchSceneY));
186
        onDraggingChanged: {
2878
187
            if (dragging) {
2879
188
                touchPressTime = new Date().getTime();
2880
189
            } else {
2881
190
                var touchReleaseTime = new Date().getTime();
2882
191
                if (touchReleaseTime - touchPressTime <= 300) {
2883
192
                    root.showTapped(Qt.point(touchSceneX, touchSceneY));
2884
193
                }
2885
194
            }
2886
195
        }
2887
196
        property var touchPressTime
2888
188
197
2889
189
        // using hint regulates minimum to hint displacement, but in fullscreen mode, we need to do it manually.
198
        // using hint regulates minimum to hint displacement, but in fullscreen mode, we need to do it manually.
2890
190
        overrideStartValue: enableHint ? minimizedPanelHeight : expandedPanelHeight + handle.height
199
        overrideStartValue: enableHint ? minimizedPanelHeight : expandedPanelHeight + handle.height
2891
@@ -200,6 +209,7 @@
2892
200
209
2893
201
    DragHandle {
210
    DragHandle {
2894
202
        id: __hideDragHandle
211
        id: __hideDragHandle
2895
212
        objectName: "hideDragHandle"
2896
203
        anchors.fill: handle
213
        anchors.fill: handle
2897
204
        direction: Direction.Upwards
214
        direction: Direction.Upwards
2898
205
        enabled: root.shown && root.available
215
        enabled: root.shown && root.available
2899
206
216
2900
=== modified file 'qml/Stages/PhoneStage.qml'
2901
--- qml/Stages/PhoneStage.qml	2015-02-18 18:29:03 +0000
2902
+++ qml/Stages/PhoneStage.qml	2015-04-10 21:17:56 +0000
2903
@@ -146,14 +146,13 @@
2904
146
        id: spreadView
146
        id: spreadView
2905
147
        objectName: "spreadView"
147
        objectName: "spreadView"
2906
148
        anchors.fill: parent
148
        anchors.fill: parent
2909
149
        interactive: (spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1)
149
        interactive: (spreadDragArea.dragging || phase > 1) && draggedDelegateCount === 0
2908
150
                     && draggedDelegateCount === 0
2910
151
        contentWidth: spreadRow.width - shift
150
        contentWidth: spreadRow.width - shift
2911
152
        contentX: -shift
151
        contentX: -shift
2912
153
152
2913
154
        // This indicates when the spreadView is active. That means, all the animations
153
        // This indicates when the spreadView is active. That means, all the animations
2914
155
        // are activated and tiles need to line up for the spread.
154
        // are activated and tiles need to line up for the spread.
2916
156
        readonly property bool active: shiftedContentX > 0 || spreadDragArea.status === DirectionalDragArea.Recognized || !root.focusFirstApp
155
        readonly property bool active: shiftedContentX > 0 || spreadDragArea.dragging || !root.focusFirstApp
2917
157
156
2918
158
        // The flickable needs to fill the screen in order to get touch events all over.
157
        // The flickable needs to fill the screen in order to get touch events all over.
2919
159
        // However, we don't want to the user to be able to scroll back all the way. For
158
        // However, we don't want to the user to be able to scroll back all the way. For
2920
@@ -450,7 +449,7 @@
2921
450
        }
449
        }
2922
451
    }
450
    }
2923
452
451
2925
453
    EdgeDragArea {
452
    DirectionalDragArea {
2926
454
        id: spreadDragArea
453
        id: spreadDragArea
2927
455
        objectName: "spreadDragArea"
454
        objectName: "spreadDragArea"
2928
456
        direction: Direction.Leftwards
455
        direction: Direction.Leftwards
2929
@@ -462,59 +461,50 @@
2930
462
        property var gesturePoints: new Array()
461
        property var gesturePoints: new Array()
2931
463
462
2932
464
        onTouchXChanged: {
463
        onTouchXChanged: {
2939
465
            if (!dragging) {
464
            if (dragging) {
2934
466
                // Initial touch. Let's reset the spreadView to the starting position.
2935
467
                spreadView.phase = 0;
2936
468
                spreadView.contentX = -spreadView.shift;
2937
469
            }
2938
470
            if (dragging && status == DirectionalDragArea.Recognized) {
2940
471
                // Gesture recognized. Let's move the spreadView with the finger
465
                // Gesture recognized. Let's move the spreadView with the finger
2941
472
                var dragX = Math.min(touchX + width, width); // Prevent dragging rightwards
466
                var dragX = Math.min(touchX + width, width); // Prevent dragging rightwards
2942
473
                dragX = -dragX + spreadDragArea.width - spreadView.shift;
467
                dragX = -dragX + spreadDragArea.width - spreadView.shift;
2943
474
                // Don't allow dragging further than the animation crossing with phase2's animation
468
                // Don't allow dragging further than the animation crossing with phase2's animation
2944
475
                var maxMovement =  spreadView.width * spreadView.positionMarker4 - spreadView.shift;
469
                var maxMovement =  spreadView.width * spreadView.positionMarker4 - spreadView.shift;
2945
470
2946
476
                spreadView.contentX = Math.min(dragX, maxMovement);
471
                spreadView.contentX = Math.min(dragX, maxMovement);
2947
472
            } else {
2948
473
                // Initial touch. Let's reset the spreadView to the starting position.
2949
474
                spreadView.phase = 0;
2950
475
                spreadView.contentX = -spreadView.shift;
2951
477
            }
476
            }
2952
477
2953
478
            gesturePoints.push(touchX);
478
            gesturePoints.push(touchX);
2954
479
        }
479
        }
2955
480
480
2956
481
        property int previousStatus: -1
2957
482
        property int currentStatus: DirectionalDragArea.WaitingForTouch
2958
483
2959
484
        onStatusChanged: {
2960
485
            previousStatus = currentStatus;
2961
486
            currentStatus = status;
2962
487
        }
2963
488
2964
489
        onDraggingChanged: {
481
        onDraggingChanged: {
2965
490
            if (dragging) {
482
            if (dragging) {
2966
491
                // A potential edge-drag gesture has started. Start recording it
483
                // A potential edge-drag gesture has started. Start recording it
2967
492
                gesturePoints = [];
484
                gesturePoints = [];
2993
493
                return;
485
            } else {
2994
494
            }
486
                // Ok. The user released. Find out if it was a one-way movement.
2995
495
487
                var oneWayFlick = true;
2996
496
            // Ok. The user released. Find out if it was a one-way movement.
488
                var smallestX = spreadDragArea.width;
2997
497
            var oneWayFlick = true;
489
                for (var i = 0; i < gesturePoints.length; i++) {
2998
498
            var smallestX = spreadDragArea.width;
490
                    if (gesturePoints[i] >= smallestX) {
2999
499
            for (var i = 0; i < gesturePoints.length; i++) {
491
                        oneWayFlick = false;
3000
500
                if (gesturePoints[i] >= smallestX) {
492
                        break;
3001
501
                    oneWayFlick = false;
493
                    }
3002
502
                    break;
494
                    smallestX = gesturePoints[i];
3003
503
                }
495
                }
3004
504
                smallestX = gesturePoints[i];
496
                gesturePoints = [];
3005
505
            }
497
3006
506
            gesturePoints = [];
498
                if (oneWayFlick && spreadView.shiftedContentX > units.gu(2) &&
3007
507
499
                        spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
3008
508
            if (previousStatus == DirectionalDragArea.Recognized &&
500
                    // If it was a short one-way movement, do the Alt+Tab switch
3009
509
                oneWayFlick && spreadView.shiftedContentX > units.gu(2) &&
501
                    // no matter if we didn't cross positionMarker1 yet.
3010
510
                    spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
502
                    spreadView.snapTo(1);
3011
511
                // If it was a short one-way movement, do the Alt+Tab switch
503
                } else if (!dragging) {
3012
512
                // no matter if we didn't cross positionMarker1 yet.
504
                    // otherwise snap to the closest snap position we can find
3013
513
                spreadView.snapTo(1);
505
                    // (might be back to start, to app 1 or to spread)
3014
514
            } else if (!dragging) {
506
                    spreadView.snap();
3015
515
                // otherwise snap to the closest snap position we can find
507
                }
2991
516
                // (might be back to start, to app 1 or to spread)
2992
517
                spreadView.snap();
3016
518
            }
508
            }
3017
519
        }
509
        }
3018
520
    }
510
    }
3019
521
511
3020
=== modified file 'qml/Stages/TabletStage.qml'
3021
--- qml/Stages/TabletStage.qml	2015-02-02 16:28:03 +0000
3022
+++ qml/Stages/TabletStage.qml	2015-04-10 21:17:56 +0000
3023
@@ -170,8 +170,7 @@
3024
170
    Flickable {
170
    Flickable {
3025
171
        id: spreadView
171
        id: spreadView
3026
172
        anchors.fill: parent
172
        anchors.fill: parent
3029
173
        interactive: (spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1)
173
        interactive: (spreadDragArea.dragging || phase > 1) && draggedDelegateCount === 0
3028
174
                     && draggedDelegateCount === 0
3030
175
        contentWidth: spreadRow.width - shift
174
        contentWidth: spreadRow.width - shift
3031
176
        contentX: -shift
175
        contentX: -shift
3032
177
176
3033
@@ -598,7 +597,7 @@
3034
598
        }
597
        }
3035
599
    }
598
    }
3036
600
599
3038
601
    EdgeDragArea {
600
    DirectionalDragArea {
3039
602
        id: spreadDragArea
601
        id: spreadDragArea
3040
603
        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
602
        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
3041
604
        width: root.dragAreaWidth
603
        width: root.dragAreaWidth
3042
@@ -624,26 +623,25 @@
3043
624
            if (dragging) {
623
            if (dragging) {
3044
625
                // Gesture recognized. Start recording this gesture
624
                // Gesture recognized. Start recording this gesture
3045
626
                gesturePoints = [];
625
                gesturePoints = [];
3061
627
                return;
626
            } else {
3062
628
            }
627
                // Ok. The user released. Find out if it was a one-way movement.
3063
629
628
                var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
3064
630
            // Ok. The user released. Find out if it was a one-way movement.
629
                gesturePoints = [];
3065
631
            var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
630
3066
632
            gesturePoints = [];
631
                if (oneWayFlick && spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
3067
633
632
                    // If it was a short one-way movement, do the Alt+Tab switch
3068
634
            if (oneWayFlick && spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
633
                    // no matter if we didn't cross positionMarker1 yet.
3054
635
                // If it was a short one-way movement, do the Alt+Tab switch
3055
636
                // no matter if we didn't cross positionMarker1 yet.
3056
637
                spreadView.snapTo(spreadView.nextInStack);
3057
638
            } else if (!dragging) {
3058
639
                if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker1) {
3059
640
                    spreadView.snap();
3060
641
                } else if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker2) {
3069
642
                    spreadView.snapTo(spreadView.nextInStack);
634
                    spreadView.snapTo(spreadView.nextInStack);
3070
643
                } else {
635
                } else {
3074
644
                    // otherwise snap to the closest snap position we can find
636
                    if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker1) {
3075
645
                    // (might be back to start, to app 1 or to spread)
637
                        spreadView.snap();
3076
646
                    spreadView.snap();
638
                    } else if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker2) {
3077
639
                        spreadView.snapTo(spreadView.nextInStack);
3078
640
                    } else {
3079
641
                        // otherwise snap to the closest snap position we can find
3080
642
                        // (might be back to start, to app 1 or to spread)
3081
643
                        spreadView.snap();
3082
644
                    }
3083
647
                }
645
                }
3084
648
            }
646
            }
3085
649
        }
647
        }
3086
650
648
3087
=== modified file 'qml/Tutorial/TutorialBottom.qml'
3088
--- qml/Tutorial/TutorialBottom.qml	2015-02-01 22:39:25 +0000
3089
+++ qml/Tutorial/TutorialBottom.qml	2015-04-10 21:17:56 +0000
3090
@@ -73,7 +73,7 @@
3091
73
        ]
73
        ]
3092
74
    }
74
    }
3093
75
75
3095
76
    EdgeDragArea {
76
    DirectionalDragArea {
3096
77
        id: dragArea
77
        id: dragArea
3097
78
        direction: Direction.Upwards
78
        direction: Direction.Upwards
3098
79
        anchors {
79
        anchors {
3099
80
80
3100
=== modified file 'tests/libs/UbuntuGestures/tst_TouchRegistry.cpp'
3101
--- tests/libs/UbuntuGestures/tst_TouchRegistry.cpp	2014-10-01 13:20:32 +0000
3102
+++ tests/libs/UbuntuGestures/tst_TouchRegistry.cpp	2015-04-10 21:17:56 +0000
3103
@@ -1,5 +1,5 @@
3104
1
/*
1
/*
3106
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014-2015 Canonical, Ltd.
3107
3
 *
3
 *
3108
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
3109
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
3110
@@ -66,6 +66,7 @@
3111
66
    void candidatesAndWatchers_2();
66
    void candidatesAndWatchers_2();
3112
67
    void rejectingTouchfterItsEnd();
67
    void rejectingTouchfterItsEnd();
3113
68
    void removeOldUndecidedCandidates();
68
    void removeOldUndecidedCandidates();
3114
69
    void interimOwnerWontGetUnownedTouchEvents();
3115
69
};
70
};
3116
70
71
3117
71
void tst_TouchRegistry::requestWithNoCandidates()
72
void tst_TouchRegistry::requestWithNoCandidates()
3118
@@ -742,7 +743,7 @@
3119
742
743
3120
743
    // Simulate that enough time has passed to cause the CandidateInactivityTimer to timeout,
744
    // Simulate that enough time has passed to cause the CandidateInactivityTimer to timeout,
3121
744
    // making TouchRegistry consider that undecidedCantidate defaulted.
745
    // making TouchRegistry consider that undecidedCantidate defaulted.
3123
745
    fakeTimerFactory->makeRunningTimersTimeout();
746
    fakeTimerFactory->updateTime(10000);
3124
746
747
3125
747
    QVERIFY(undecidedCandidate.ownedTouches.isEmpty());
748
    QVERIFY(undecidedCandidate.ownedTouches.isEmpty());
3126
748
    QVERIFY(undecidedCandidate.lostTouches.contains(0));
749
    QVERIFY(undecidedCandidate.lostTouches.contains(0));
3127
@@ -752,6 +753,71 @@
3128
752
    delete touchRegistry;
753
    delete touchRegistry;
3129
753
}
754
}
3130
754
755
3131
756
/*
3132
757
    An item that calls requestTouchOwnership() without first having called addCandidateOwnerForTouch()
3133
758
    is assumed to be the interim owner of the touch point, thus there's no point in sending
3134
759
    UnownedTouchEvents to him as he already gets proper QTouchEvents from QQuickWindow because
3135
760
    he didn't ignore the first QTouchEvent with that touch point.
3136
761
 */
3137
762
void tst_TouchRegistry::interimOwnerWontGetUnownedTouchEvents()
3138
763
{
3139
764
    FakeTimerFactory *fakeTimerFactory = new FakeTimerFactory;
3140
765
    TouchRegistry *touchRegistry = new TouchRegistry(nullptr, fakeTimerFactory);
3141
766
3142
767
    DummyCandidate undecidedCandidate;
3143
768
    undecidedCandidate.setObjectName("undecided");
3144
769
3145
770
    DummyCandidate interimOwner;
3146
771
    interimOwner.setObjectName("interimOwner");
3147
772
3148
773
    {
3149
774
        QList<QTouchEvent::TouchPoint> touchPoints;
3150
775
        touchPoints.append(QTouchEvent::TouchPoint(0));
3151
776
        touchPoints[0].setState(Qt::TouchPointPressed);
3152
777
        QTouchEvent touchEvent(QEvent::TouchBegin,
3153
778
                               0 /* device */,
3154
779
                               Qt::NoModifier,
3155
780
                               Qt::TouchPointPressed,
3156
781
                               touchPoints);
3157
782
        touchRegistry->update(&touchEvent);
3158
783
    }
3159
784
3160
785
    touchRegistry->addCandidateOwnerForTouch(0, &undecidedCandidate);
3161
786
    touchRegistry->requestTouchOwnership(0, &interimOwner);
3162
787
3163
788
    {
3164
789
        QList<QTouchEvent::TouchPoint> touchPoints;
3165
790
        touchPoints.append(QTouchEvent::TouchPoint(0));
3166
791
        touchPoints[0].setState(Qt::TouchPointMoved);
3167
792
        QTouchEvent touchEvent(QEvent::TouchUpdate,
3168
793
                               0 /* device */,
3169
794
                               Qt::NoModifier,
3170
795
                               Qt::TouchPointMoved,
3171
796
                               touchPoints);
3172
797
        touchRegistry->update(&touchEvent);
3173
798
    }
3174
799
3175
800
    QCOMPARE(undecidedCandidate.unownedTouchEvents.count(), 1);
3176
801
    QCOMPARE(interimOwner.unownedTouchEvents.count(), 0);
3177
802
3178
803
    {
3179
804
        QList<QTouchEvent::TouchPoint> touchPoints;
3180
805
        touchPoints.append(QTouchEvent::TouchPoint(0));
3181
806
        touchPoints[0].setState(Qt::TouchPointMoved);
3182
807
        QTouchEvent touchEvent(QEvent::TouchUpdate,
3183
808
                               0 /* device */,
3184
809
                               Qt::NoModifier,
3185
810
                               Qt::TouchPointMoved,
3186
811
                               touchPoints);
3187
812
        touchRegistry->update(&touchEvent);
3188
813
    }
3189
814
3190
815
    QCOMPARE(undecidedCandidate.unownedTouchEvents.count(), 2);
3191
816
    QCOMPARE(interimOwner.unownedTouchEvents.count(), 0);
3192
817
3193
818
    delete touchRegistry;
3194
819
}
3195
820
3196
755
////////////// TouchMemento //////////
821
////////////// TouchMemento //////////
3197
756
822
3198
757
TouchMemento::TouchMemento(const QTouchEvent *touchEvent)
823
TouchMemento::TouchMemento(const QTouchEvent *touchEvent)
3199
758
824
3200
=== modified file 'tests/plugins/Ubuntu/Gestures/CMakeLists.txt'
3201
--- tests/plugins/Ubuntu/Gestures/CMakeLists.txt	2014-10-17 11:01:53 +0000
3202
+++ tests/plugins/Ubuntu/Gestures/CMakeLists.txt	2015-04-10 21:17:56 +0000
3203
@@ -19,6 +19,7 @@
3204
19
)
19
)
3205
20
20
3206
21
add_definitions(-DUBUNTU_GESTURES_PLUGIN_DIR="${CMAKE_BINARY_DIR}/plugins")
21
add_definitions(-DUBUNTU_GESTURES_PLUGIN_DIR="${CMAKE_BINARY_DIR}/plugins")
3207
22
add_definitions(-DTESTS_UTILS_MODULES_DIR="${CMAKE_BINARY_DIR}/tests/utils/modules")
3208
22
23
3209
23
macro(add_gesture_ui_test CLASSNAME)
24
macro(add_gesture_ui_test CLASSNAME)
3210
24
    add_executable(${CLASSNAME}TestExec tst_${CLASSNAME}.cpp GestureTest.cpp)
25
    add_executable(${CLASSNAME}TestExec tst_${CLASSNAME}.cpp GestureTest.cpp)
3211
@@ -26,7 +27,8 @@
3212
26
    target_link_libraries(${CLASSNAME}TestExec UbuntuGesturesQml UbuntuGestures)
27
    target_link_libraries(${CLASSNAME}TestExec UbuntuGesturesQml UbuntuGestures)
3213
27
28
3214
28
    add_binary_qml_test(${CLASSNAME} ${CMAKE_BINARY_DIR}/plugins/Ubuntu/Gestures UbuntuGesturesTestQmlFiles "")
29
    add_binary_qml_test(${CLASSNAME} ${CMAKE_BINARY_DIR}/plugins/Ubuntu/Gestures UbuntuGesturesTestQmlFiles "")
3216
29
    add_manual_qml_test(. ${CLASSNAME} IMPORT_PATHS ${CMAKE_BINARY_DIR}/plugins)
30
    add_manual_qml_test(. ${CLASSNAME} IMPORT_PATHS ${CMAKE_BINARY_DIR}/plugins
3217
31
                                                    ${CMAKE_BINARY_DIR}/tests/utils/modules)
3218
30
endmacro(add_gesture_ui_test)
32
endmacro(add_gesture_ui_test)
3219
31
33
3220
32
macro(add_gesture_test CLASSNAME)
34
macro(add_gesture_test CLASSNAME)
3221
33
35
3222
=== modified file 'tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml'
3223
--- tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2014-02-11 20:21:24 +0000
3224
+++ tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2015-04-10 21:17:56 +0000
3225
@@ -37,8 +37,8 @@
3226
37
37
3227
38
    Rectangle {
38
    Rectangle {
3228
39
        id: dragAreaRect
39
        id: dragAreaRect
3231
40
        color: "yellow"
40
        opacity: dragArea.dragging ? 0.5 : 0.0
3232
41
        opacity: 0.0
41
        color: "green"
3233
42
        anchors.fill: dragArea
42
        anchors.fill: dragArea
3234
43
    }
43
    }
3235
44
44
3236
@@ -49,24 +49,10 @@
3237
49
        height: units.gu(5)
49
        height: units.gu(5)
3238
50
50
3239
51
        direction: Direction.Downwards
51
        direction: Direction.Downwards
3240
52
        maxDeviation: units.gu(2)
3241
53
        wideningAngle: 10
3242
54
        distanceThreshold: units.gu(4)
3243
55
52
3258
56
        onStatusChanged: {
53
        onDraggingChanged: {
3259
57
            switch (status) {
54
            if (dragging) {
3260
58
                case DirectionalDragArea.WaitingForTouch:
55
                launcher.y = Qt.binding(launcher.followDragArea)
3247
59
                    dragAreaRect.opacity = 0.0
3248
60
                    break;
3249
61
                case DirectionalDragArea.Undecided:
3250
62
                    dragAreaRect.color = "yellow"
3251
63
                    dragAreaRect.opacity = 0.3
3252
64
                    launcher.y = Qt.binding(launcher.followDragArea)
3253
65
                    break;
3254
66
                default: // DirectionalDragArea.Recognized:
3255
67
                    dragAreaRect.color = "green"
3256
68
                    dragAreaRect.opacity = 0.5
3257
69
                    break;
3261
70
            }
56
            }
3262
71
        }
57
        }
3263
72
58
3264
73
59
3265
=== modified file 'tests/plugins/Ubuntu/Gestures/GestureTest.cpp'
3266
--- tests/plugins/Ubuntu/Gestures/GestureTest.cpp	2014-11-03 15:21:46 +0000
3267
+++ tests/plugins/Ubuntu/Gestures/GestureTest.cpp	2015-04-10 21:17:56 +0000
3268
@@ -1,5 +1,5 @@
3269
1
/*
1
/*
3271
2
 * Copyright (C) 2013 Canonical, Ltd.
2
 * Copyright (C) 2013,2015 Canonical, Ltd.
3272
3
 *
3
 *
3273
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
3274
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
3275
@@ -21,8 +21,11 @@
3276
21
#include <QQuickView>
21
#include <QQuickView>
3277
22
#include <QtTest>
22
#include <QtTest>
3278
23
23
3279
24
#include <Timer.h>
3280
24
#include <TouchRegistry.h>
25
#include <TouchRegistry.h>
3281
25
26
3282
27
using namespace UbuntuGestures;
3283
28
3284
26
GestureTest::GestureTest(const QString &qmlFilename)
29
GestureTest::GestureTest(const QString &qmlFilename)
3285
27
    : QObject(), m_device(nullptr), m_view(nullptr), m_qmlFilename(qmlFilename)
30
    : QObject(), m_device(nullptr), m_view(nullptr), m_qmlFilename(qmlFilename)
3286
28
{
31
{
3287
@@ -40,14 +43,17 @@
3288
40
void GestureTest::init()
43
void GestureTest::init()
3289
41
{
44
{
3290
42
    m_view = new QQuickView;
45
    m_view = new QQuickView;
3292
43
    m_view->setResizeMode(QQuickView::SizeViewToRootObject);
46
    m_view->setResizeMode(QQuickView::SizeRootObjectToView);
3293
44
    m_view->engine()->addImportPath(QStringLiteral(UBUNTU_GESTURES_PLUGIN_DIR));
47
    m_view->engine()->addImportPath(QStringLiteral(UBUNTU_GESTURES_PLUGIN_DIR));
3294
48
    m_view->engine()->addImportPath(QStringLiteral(TESTS_UTILS_MODULES_DIR));
3295
45
    m_view->setSource(QUrl::fromLocalFile(m_qmlFilename));
49
    m_view->setSource(QUrl::fromLocalFile(m_qmlFilename));
3296
46
    m_view->show();
50
    m_view->show();
3297
47
    QVERIFY(QTest::qWaitForWindowExposed(m_view));
51
    QVERIFY(QTest::qWaitForWindowExposed(m_view));
3298
48
    QVERIFY(m_view->rootObject() != 0);
52
    QVERIFY(m_view->rootObject() != 0);
3299
49
53
3301
50
    m_touchRegistry = new TouchRegistry;
54
    m_fakeTimerFactory = new FakeTimerFactory;
3302
55
3303
56
    m_touchRegistry = new TouchRegistry(nullptr, m_fakeTimerFactory);
3304
51
    m_view->installEventFilter(m_touchRegistry);
57
    m_view->installEventFilter(m_touchRegistry);
3305
52
58
3306
53
    qApp->processEvents();
59
    qApp->processEvents();
3307
@@ -59,6 +65,10 @@
3308
59
    delete m_touchRegistry;
65
    delete m_touchRegistry;
3309
60
    m_touchRegistry = nullptr;
66
    m_touchRegistry = nullptr;
3310
61
67
3311
68
    // TouchRegistry will take down the timer factory along with him
3312
69
    // delete m_fakeTimerFactory;
3313
70
    m_fakeTimerFactory = nullptr;
3314
71
3315
62
    delete m_view;
72
    delete m_view;
3316
63
    m_view = nullptr;
73
    m_view = nullptr;
3317
64
}
74
}
3318
65
75
3319
=== modified file 'tests/plugins/Ubuntu/Gestures/GestureTest.h'
3320
--- tests/plugins/Ubuntu/Gestures/GestureTest.h	2014-11-03 15:21:46 +0000
3321
+++ tests/plugins/Ubuntu/Gestures/GestureTest.h	2015-04-10 21:17:56 +0000
3322
@@ -23,6 +23,9 @@
3323
23
class QQuickView;
23
class QQuickView;
3324
24
class QTouchDevice;
24
class QTouchDevice;
3325
25
25
3326
26
namespace UbuntuGestures {
3327
27
    class FakeTimerFactory;
3328
28
}
3329
26
class TouchRegistry;
29
class TouchRegistry;
3330
27
30
3331
28
// C++ std lib
31
// C++ std lib
3332
@@ -81,6 +84,7 @@
3333
81
    QTouchDevice *m_device;
84
    QTouchDevice *m_device;
3334
82
    QQuickView *m_view;
85
    QQuickView *m_view;
3335
83
    TouchRegistry *m_touchRegistry;
86
    TouchRegistry *m_touchRegistry;
3336
87
    UbuntuGestures::FakeTimerFactory *m_fakeTimerFactory;
3337
84
    QString m_qmlFilename;
88
    QString m_qmlFilename;
3338
85
};
89
};
3339
86
90
3340
87
91
3341
=== modified file 'tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml'
3342
--- tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2014-02-11 20:21:24 +0000
3343
+++ tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2015-04-10 21:17:56 +0000
3344
@@ -21,7 +21,7 @@
3345
21
Item {
21
Item {
3346
22
    id: root
22
    id: root
3347
23
23
3349
24
    function reset() { launcher.x = root.width }
24
    function reset() { launcher.x = Qt.binding(function(){return root.width;}); }
3350
25
25
3351
26
    Rectangle {
26
    Rectangle {
3352
27
        id: launcher
27
        id: launcher
3353
@@ -41,7 +41,8 @@
3354
41
41
3355
42
    Rectangle {
42
    Rectangle {
3356
43
        id: dragAreaRect
43
        id: dragAreaRect
3358
44
        opacity: 0.0
44
        opacity: dragArea.dragging ? 0.5 : 0.0
3359
45
        color: "green"
3360
45
        anchors.fill: dragArea
46
        anchors.fill: dragArea
3361
46
    }
47
    }
3362
47
48
3363
@@ -52,24 +53,10 @@
3364
52
        width: units.gu(5)
53
        width: units.gu(5)
3365
53
54
3366
54
        direction: Direction.Leftwards
55
        direction: Direction.Leftwards
3367
55
        maxDeviation: units.gu(2)
3368
56
        wideningAngle: 10
3369
57
        distanceThreshold: units.gu(4)
3370
58
56
3385
59
        onStatusChanged: {
57
        onDraggingChanged: {
3386
60
            switch (status) {
58
            if (dragging) {
3387
61
                case DirectionalDragArea.WaitingForTouch:
59
                launcher.x = Qt.binding(launcher.followDragArea)
3374
62
                    dragAreaRect.opacity = 0.0
3375
63
                    break;
3376
64
                case DirectionalDragArea.Undecided:
3377
65
                    dragAreaRect.color = "yellow"
3378
66
                    dragAreaRect.opacity = 0.3
3379
67
                    launcher.x = Qt.binding(launcher.followDragArea)
3380
68
                    break;
3381
69
                default: //case DirectionalDragArea.Recognized:
3382
70
                    dragAreaRect.color = "green"
3383
71
                    dragAreaRect.opacity = 0.5
3384
72
                    break;
3388
73
            }
60
            }
3389
74
        }
61
        }
3390
75
62
3391
76
63
3392
=== modified file 'tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml'
3393
--- tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2014-10-01 13:20:32 +0000
3394
+++ tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2015-04-10 21:17:56 +0000
3395
@@ -38,7 +38,8 @@
3396
38
38
3397
39
    Rectangle {
39
    Rectangle {
3398
40
        id: dragAreaRect
40
        id: dragAreaRect
3400
41
        opacity: 0.0
41
        opacity: dragArea.dragging ? 0.5 : 0.0
3401
42
        color: "green"
3402
42
        anchors.fill: dragArea
43
        anchors.fill: dragArea
3403
43
    }
44
    }
3404
44
45
3405
@@ -52,25 +53,10 @@
3406
52
        width: units.gu(5)
53
        width: units.gu(5)
3407
53
54
3408
54
        direction: Direction.Rightwards
55
        direction: Direction.Rightwards
3409
55
        maxDeviation: units.gu(2)
3410
56
        wideningAngle: 10
3411
57
        distanceThreshold: units.gu(4)
3412
58
        minSpeed: 50
3413
59
56
3428
60
        onStatusChanged: {
57
        onDraggingChanged: {
3429
61
            switch (status) {
58
            if (dragging) {
3430
62
                case DirectionalDragArea.WaitingForTouch:
59
                launcher.x = Qt.binding(launcher.followDragArea)
3417
63
                    dragAreaRect.opacity = 0.0
3418
64
                    break;
3419
65
                case DirectionalDragArea.Undecided:
3420
66
                    dragAreaRect.color = "yellow"
3421
67
                    dragAreaRect.opacity = 0.3
3422
68
                    launcher.x = Qt.binding(launcher.followDragArea)
3423
69
                    break;
3424
70
                default: //case DirectionalDragArea.Recognized:
3425
71
                    dragAreaRect.color = "green"
3426
72
                    dragAreaRect.opacity = 0.5
3427
73
                    break;
3431
74
            }
60
            }
3432
75
        }
61
        }
3433
76
62
3434
77
63
3435
=== modified file 'tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml'
3436
--- tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2014-02-11 20:21:24 +0000
3437
+++ tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2015-04-10 21:17:56 +0000
3438
@@ -21,7 +21,7 @@
3439
21
Item {
21
Item {
3440
22
    id: root
22
    id: root
3441
23
23
3443
24
    function reset() { launcher.y = root.height }
24
    function reset() { launcher.y = Qt.binding(function(){return root.height;}); }
3444
25
25
3445
26
    Rectangle {
26
    Rectangle {
3446
27
        id: launcher
27
        id: launcher
3447
@@ -41,7 +41,8 @@
3448
41
41
3449
42
    Rectangle {
42
    Rectangle {
3450
43
        id: dragAreaRect
43
        id: dragAreaRect
3452
44
        opacity: 0.0
44
        opacity: dragArea.dragging ? 0.5 : 0.0
3453
45
        color: "green"
3454
45
        anchors.fill: dragArea
46
        anchors.fill: dragArea
3455
46
    }
47
    }
3456
47
48
3457
@@ -52,24 +53,10 @@
3458
52
        height: units.gu(5)
53
        height: units.gu(5)
3459
53
54
3460
54
        direction: Direction.Upwards
55
        direction: Direction.Upwards
3461
55
        maxDeviation: units.gu(2)
3462
56
        wideningAngle: 10
3463
57
        distanceThreshold: units.gu(4)
3464
58
56
3479
59
        onStatusChanged: {
57
        onDraggingChanged: {
3480
60
            switch (status) {
58
            if (dragging) {
3481
61
                case DirectionalDragArea.WaitingForTouch:
59
                launcher.y = Qt.binding(launcher.followDragArea)
3468
62
                    dragAreaRect.opacity = 0.0
3469
63
                    break;
3470
64
                case DirectionalDragArea.Undecided:
3471
65
                    dragAreaRect.color = "yellow"
3472
66
                    dragAreaRect.opacity = 0.3
3473
67
                    launcher.y = Qt.binding(launcher.followDragArea)
3474
68
                    break;
3475
69
                default: //case DirectionalDragArea.Recognized:
3476
70
                    dragAreaRect.color = "green"
3477
71
                    dragAreaRect.opacity = 0.5
3478
72
                    break;
3482
73
            }
60
            }
3483
74
        }
61
        }
3484
75
62
3485
76
63
3486
=== modified file 'tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp'
3487
--- tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2015-02-18 13:51:39 +0000
3488
+++ tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2015-04-10 21:17:56 +0000
3489
@@ -1,5 +1,5 @@
3490
1
/*
1
/*
3492
2
 * Copyright (C) 2013-2014 Canonical, Ltd.
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
3493
3
 *
3
 *
3494
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
3495
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
3496
@@ -20,51 +20,38 @@
3497
20
#include <QtQml/QQmlEngine>
20
#include <QtQml/QQmlEngine>
3498
21
#include <QPointer>
21
#include <QPointer>
3499
22
#include <private/qquickmousearea_p.h>
22
#include <private/qquickmousearea_p.h>
3503
23
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
23
#include <private/qquickwindow_p.h>
3501
24
    #include <private/qquickwindow_p.h>
3502
25
#endif
3504
26
24
3505
27
25
3506
28
#include <DirectionalDragArea.h>
26
#include <DirectionalDragArea.h>
3507
27
#include <DirectionalDragArea_p.h>
3508
29
#include <TouchRegistry.h>
28
#include <TouchRegistry.h>
3509
30
29
3510
31
#include "GestureTest.h"
30
#include "GestureTest.h"
3511
32
31
3512
33
using namespace UbuntuGestures;
32
using namespace UbuntuGestures;
3513
34
33
3517
35
34
// Because QSignalSpy(directionalDragArea, SIGNAL(DirectionalDragArea::Status)) simply
3518
36
class ComplexFakeTimer : public FakeTimer
35
// doesn't work
3519
37
{
36
class StatusSpy : public QObject {
3520
38
    Q_OBJECT
37
    Q_OBJECT
3521
39
public:
38
public:
3538
40
    ComplexFakeTimer(const SharedTimeSource &timeSource, QObject *parent = 0)
39
    StatusSpy(DirectionalDragArea *edgeDragArea) {
3539
41
        : FakeTimer(parent),
40
        m_recognized = false;
3540
42
          m_timeSource(timeSource)
41
        connect(edgeDragArea->d, &DirectionalDragAreaPrivate::statusChanged,
3541
43
    {}
42
                this, &StatusSpy::onStatusChanged);
3542
44
43
    }
3543
45
    void start() override {
44
    bool recognized() {
3544
46
        AbstractTimer::start();
45
        return m_recognized;
3545
47
        m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)interval();
46
    }
3546
48
    }
47
3547
49
48
private Q_SLOTS:
3548
50
    void emitTimeout() {
49
    void onStatusChanged(DirectionalDragAreaPrivate::Status status) {
3549
51
        m_nextTimeoutTime += interval();
50
        m_recognized |= status == DirectionalDragAreaPrivate::Recognized;
3550
52
        Q_EMIT timeout();
51
    }
3535
53
    }
3536
54
3537
55
    qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }
3551
56
52
3552
57
private:
53
private:
3563
58
    SharedTimeSource m_timeSource;
54
    bool m_recognized;
3554
59
    qint64 m_nextTimeoutTime;
3555
60
};
3556
61
3557
62
class FakeTimeSource : public UbuntuGestures::TimeSource
3558
63
{
3559
64
public:
3560
65
    FakeTimeSource() { m_msecsSinceReference = 0; }
3561
66
    virtual qint64 msecsSinceReference() {return m_msecsSinceReference;}
3562
67
    qint64 m_msecsSinceReference;
3564
68
};
55
};
3565
69
56
3566
70
/*
57
/*
3567
@@ -98,15 +85,9 @@
3568
98
    tst_DirectionalDragArea();
85
    tst_DirectionalDragArea();
3569
99
private Q_SLOTS:
86
private Q_SLOTS:
3570
100
    void init(); // called right before each and every test function is executed
87
    void init(); // called right before each and every test function is executed
3571
101
    void cleanup(); // called right after each and every test function is executed
3572
102
88
3573
103
    void edgeDrag();
3574
104
    void edgeDrag_data();
3575
105
    void dragWithShortDirectionChange();
89
    void dragWithShortDirectionChange();
3576
106
    void minSpeed();
3577
107
    void minSpeed_data();
3578
108
    void recognitionTimerUsage();
90
    void recognitionTimerUsage();
3579
109
    void maxSilenceTime();
3580
110
    void sceneXAndX();
91
    void sceneXAndX();
3581
111
    void sceneYAndY();
92
    void sceneYAndY();
3582
112
    void twoFingerTap();
93
    void twoFingerTap();
3583
@@ -122,14 +103,24 @@
3584
122
    void immediateRecognitionWhenConstraintsDisabled();
103
    void immediateRecognitionWhenConstraintsDisabled();
3585
123
    void withdrawTouchOwnershipCandidacyIfDisabledDuringRecognition();
104
    void withdrawTouchOwnershipCandidacyIfDisabledDuringRecognition();
3586
124
    void withdrawTouchOwnershipCandidacyIfDisabledDuringRecognition_data();
105
    void withdrawTouchOwnershipCandidacyIfDisabledDuringRecognition_data();
3587
125
    void tappedSignal();
3588
126
    void tappedSignal_data();
3589
127
    void gettingTouchOwnershipMakesMouseAreaBehindGetCanceled();
106
    void gettingTouchOwnershipMakesMouseAreaBehindGetCanceled();
3590
107
    void interleavedTouches();
3591
108
    void makoRightEdgeDrag();
3592
109
    void makoRightEdgeDrag_verticalDownwards();
3593
110
    void makoLeftEdgeDrag_slowStart();
3594
111
    void makoLeftEdgeDrag_movesSlightlyBackwardsOnStart();
3595
128
112
3596
129
private:
113
private:
3597
114
    // QTest::touchEvent takes QPoint instead of QPointF and I don't want to
3598
115
    // lose precision due to rounding.
3599
116
    // Besides, those helper functions lead to more compact code.
3600
117
    void sendTouchPress(qint64 timestamp, int id, QPointF pos);
3601
118
    void sendTouchUpdate(qint64 timestamp, int id, QPointF pos);
3602
119
    void sendTouchRelease(qint64 timestamp, int id, QPointF pos);
3603
120
    void sendTouch(qint64 timestamp, int id, QPointF pos,
3604
121
            Qt::TouchPointState pointState, QEvent::Type eventType);
3605
122
3606
130
    void passTime(qint64 timeSpanMs);
123
    void passTime(qint64 timeSpanMs);
3607
131
    ComplexFakeTimer *fakeTimer;
3608
132
    QSharedPointer<FakeTimeSource> fakeTimeSource;
3609
133
};
124
};
3610
134
125
3611
135
tst_DirectionalDragArea::tst_DirectionalDragArea()
126
tst_DirectionalDragArea::tst_DirectionalDragArea()
3612
@@ -148,36 +139,49 @@
3613
148
    m_view->resize(m_view->rootObject()->width(), m_view->rootObject()->height());
139
    m_view->resize(m_view->rootObject()->width(), m_view->rootObject()->height());
3614
149
    QTRY_COMPARE(m_view->width(), (int)m_view->rootObject()->width());
140
    QTRY_COMPARE(m_view->width(), (int)m_view->rootObject()->width());
3615
150
    QTRY_COMPARE(m_view->height(), (int)m_view->rootObject()->height());
141
    QTRY_COMPARE(m_view->height(), (int)m_view->rootObject()->height());
3629
151
142
}
3630
152
    fakeTimeSource.reset(new FakeTimeSource);
143
3631
153
    fakeTimer = new ComplexFakeTimer(fakeTimeSource);
144
void tst_DirectionalDragArea::sendTouchPress(qint64 timestamp, int id, QPointF pos)
3632
154
}
145
{
3633
155
146
    sendTouch(timestamp, id, pos, Qt::TouchPointPressed, QEvent::TouchBegin);
3634
156
void tst_DirectionalDragArea::cleanup()
147
}
3635
157
{
148
3636
158
    delete fakeTimer;
149
void tst_DirectionalDragArea::sendTouchUpdate(qint64 timestamp, int id, QPointF pos)
3637
159
    fakeTimer = 0;
150
{
3638
160
151
    sendTouch(timestamp, id, pos, Qt::TouchPointMoved, QEvent::TouchUpdate);
3639
161
    fakeTimeSource.reset();
152
}
3640
162
153
3641
163
    GestureTest::cleanup();
154
void tst_DirectionalDragArea::sendTouchRelease(qint64 timestamp, int id, QPointF pos)
3642
155
{
3643
156
    sendTouch(timestamp, id, pos, Qt::TouchPointReleased, QEvent::TouchEnd);
3644
157
}
3645
158
3646
159
void tst_DirectionalDragArea::sendTouch(qint64 timestamp, int id, QPointF pos,
3647
160
                                 Qt::TouchPointState pointState, QEvent::Type eventType)
3648
161
{
3649
162
    m_fakeTimerFactory->updateTime(timestamp);
3650
163
3651
164
    QTouchEvent::TouchPoint point;
3652
165
3653
166
    point.setState(pointState);
3654
167
    point.setId(id);
3655
168
    point.setScenePos(pos);
3656
169
    point.setPos(pos);
3657
170
3658
171
    QList<QTouchEvent::TouchPoint> points;
3659
172
    points << point;
3660
173
3661
174
    QTouchEvent touchEvent(eventType, m_device, Qt::NoModifier, Qt::TouchPointPressed, points);
3662
175
    QCoreApplication::sendEvent(m_view, &touchEvent);
3663
176
3664
177
    QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(m_view);
3665
178
    windowPrivate->flushDelayedTouchEvent();
3666
164
}
179
}
3667
165
180
3668
166
void tst_DirectionalDragArea::passTime(qint64 timeSpanMs)
181
void tst_DirectionalDragArea::passTime(qint64 timeSpanMs)
3669
167
{
182
{
3683
168
    qint64 finalTime = fakeTimeSource->m_msecsSinceReference + timeSpanMs;
183
    qint64 finalTime = m_fakeTimerFactory->timeSource()->msecsSinceReference() + timeSpanMs;
3684
169
184
    m_fakeTimerFactory->updateTime(finalTime);
3672
170
    if (fakeTimer->isRunning() && finalTime >= fakeTimer->nextTimeoutTime()) {
3673
171
        fakeTimeSource->m_msecsSinceReference = fakeTimer->nextTimeoutTime();
3674
172
        fakeTimer->emitTimeout();
3675
173
3676
174
        qint64 timeSpanRemainder = finalTime - fakeTimeSource->m_msecsSinceReference;
3677
175
        if (timeSpanRemainder > 0) {
3678
176
            passTime(timeSpanRemainder);
3679
177
        }
3680
178
    } else {
3681
179
        fakeTimeSource->m_msecsSinceReference = finalTime;
3682
180
    }
3685
181
}
185
}
3686
182
186
3687
183
namespace {
187
namespace {
3688
@@ -186,147 +190,6 @@
3689
186
    QPointF localCenter(edgeDragArea->width() / 2., edgeDragArea->height() / 2.);
190
    QPointF localCenter(edgeDragArea->width() / 2., edgeDragArea->height() / 2.);
3690
187
    return edgeDragArea->mapToScene(localCenter);
191
    return edgeDragArea->mapToScene(localCenter);
3691
188
}
192
}
3692
189
3693
190
QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea,
3694
191
                                 qreal wideningAngleMultiplier)
3695
192
{
3696
193
    qreal angleRadians = edgeDragArea->wideningAngle() * wideningAngleMultiplier
3697
194
        * M_PI / 180.0;
3698
195
3699
196
    qreal angleCos = qCos(angleRadians);
3700
197
    qreal angleSin = qSin(angleRadians);
3701
198
3702
199
    switch (edgeDragArea->direction()) {
3703
200
        case Direction::Upwards:
3704
201
            return QPointF(angleSin, -angleCos);
3705
202
        case Direction::Downwards:
3706
203
            return QPointF(angleSin, angleCos);
3707
204
        case Direction::Leftwards:
3708
205
            return QPointF(-angleCos, angleSin);
3709
206
        default: // Direction::Rightwards:
3710
207
            return QPointF(angleCos, angleSin);
3711
208
    }
3712
209
}
3713
210
3714
211
QPointF createTouchDeviation(DirectionalDragArea *edgeDragArea)
3715
212
{
3716
213
    qreal deviation = edgeDragArea->maxDeviation() * 0.8;
3717
214
3718
215
    if (Direction::isHorizontal(edgeDragArea->direction())) {
3719
216
        return QPointF(0, deviation);
3720
217
    } else {
3721
218
        return QPointF(deviation, 0);
3722
219
    }
3723
220
}
3724
221
}
3725
222
3726
223
void tst_DirectionalDragArea::edgeDrag()
3727
224
{
3728
225
    QFETCH(QString, dragAreaObjectName);
3729
226
    QFETCH(qreal, wideningAngleMultiplier);
3730
227
    QFETCH(qreal, dragDistanceFactor);
3731
228
    QFETCH(bool, expectGestureRecognition);
3732
229
3733
230
    DirectionalDragArea *edgeDragArea =
3734
231
        m_view->rootObject()->findChild<DirectionalDragArea*>(dragAreaObjectName);
3735
232
    QVERIFY(edgeDragArea != 0);
3736
233
    edgeDragArea->setRecognitionTimer(fakeTimer);
3737
234
    edgeDragArea->setTimeSource(fakeTimeSource);
3738
235
3739
236
    QSignalSpy draggingSpy(edgeDragArea, SIGNAL(draggingChanged(bool)));
3740
237
3741
238
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
3742
239
    QPointF touchPoint = initialTouchPos;
3743
240
3744
241
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*dragDistanceFactor;
3745
242
    QPointF dragDirectionVector = calculateDirectionVector(edgeDragArea,
3746
243
                                                           wideningAngleMultiplier);
3747
244
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
3748
245
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
3749
246
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
3750
247
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
3751
248
3752
249
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
3753
250
3754
251
    QCOMPARE(draggingSpy.count(), 1);
3755
252
    QCOMPARE(edgeDragArea->dragging(), true);
3756
253
3757
254
    if (wideningAngleMultiplier > 0) {
3758
255
        // go close to the border of the valid area for this touch point
3759
256
        // in order to make it easier to leave it by dragging at an angle
3760
257
        // slightly bigger than the widening angle
3761
258
        touchPoint += createTouchDeviation(edgeDragArea);
3762
259
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
3763
260
    }
3764
261
3765
262
    for (int i = 0; i < totalMovementSteps; ++i) {
3766
263
        touchPoint += touchMovement;
3767
264
        passTime(movementTimeStepMs);
3768
265
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
3769
266
    }
3770
267
3771
268
    if (expectGestureRecognition)
3772
269
        QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
3773
270
3774
271
    if (edgeDragArea->status() == DirectionalDragArea::WaitingForTouch) {
3775
272
        QCOMPARE(edgeDragArea->dragging(), false);
3776
273
        QCOMPARE(draggingSpy.count(), 2);
3777
274
    }
3778
275
3779
276
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
3780
277
3781
278
    QCOMPARE(draggingSpy.count(), 2);
3782
279
    QCOMPARE(edgeDragArea->dragging(), false);
3783
280
}
3784
281
3785
282
void tst_DirectionalDragArea::edgeDrag_data()
3786
283
{
3787
284
    QTest::addColumn<QString>("dragAreaObjectName");
3788
285
    QTest::addColumn<qreal>("wideningAngleMultiplier");
3789
286
    QTest::addColumn<qreal>("dragDistanceFactor");
3790
287
    QTest::addColumn<bool>("expectGestureRecognition");
3791
288
3792
289
    QTest::newRow("rightwards, tiny drag")
3793
290
        << "hpDragArea" << 0.0 << 0.2 << false;
3794
291
3795
292
    QTest::newRow("rightwards, straight drag")
3796
293
        << "hpDragArea" << 0.0 << 3.0 << true;
3797
294
3798
295
    QTest::newRow("rightwards, diagonal drag")
3799
296
        << "hpDragArea" << 0.9 << 3.0 << true;
3800
297
3801
298
    QTest::newRow("rightwards, overly diagonal drag")
3802
299
        << "hpDragArea" << 2.0 << 3.0 << false;
3803
300
3804
301
    QTest::newRow("leftwards, tiny drag")
3805
302
        << "hnDragArea" << 0.0 << 0.2 << false;
3806
303
3807
304
    QTest::newRow("leftwards, straight drag")
3808
305
        << "hnDragArea" << 0.0 << 3.0 << true;
3809
306
3810
307
    QTest::newRow("leftwards, diagonal drag")
3811
308
        << "hnDragArea" << 0.9 << 3.0 << true;
3812
309
3813
310
    QTest::newRow("downwards, tiny drag")
3814
311
        << "vpDragArea" << 0.0 << 0.2 << false;
3815
312
3816
313
    QTest::newRow("downwards, straight drag")
3817
314
        << "vpDragArea" << 0.0 << 3.0 << true;
3818
315
3819
316
    QTest::newRow("downwards, diagonal drag")
3820
317
        << "vpDragArea" << 0.9 << 3.0 << true;
3821
318
3822
319
    QTest::newRow("upwards, tiny drag")
3823
320
        << "vnDragArea" << 0.0 << 0.2 << false;
3824
321
3825
322
    QTest::newRow("upwards, straight drag")
3826
323
        << "vnDragArea" << 0.0 << 3.0 << true;
3827
324
3828
325
    QTest::newRow("upwards, diagonal drag")
3829
326
        << "vnDragArea" << 0.9 << 3.0 << true;
3830
327
3831
328
    QTest::newRow("upwards, overly diagonal drag")
3832
329
        << "vnDragArea" << 2.0 << 3.0 << false;
3833
330
}
193
}
3834
331
194
3835
332
/*
195
/*
3836
@@ -339,17 +202,17 @@
3837
339
    DirectionalDragArea *edgeDragArea =
202
    DirectionalDragArea *edgeDragArea =
3838
340
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
203
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
3839
341
    QVERIFY(edgeDragArea != 0);
204
    QVERIFY(edgeDragArea != 0);
3842
342
    edgeDragArea->setRecognitionTimer(fakeTimer);
205
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
3843
343
    edgeDragArea->setTimeSource(fakeTimeSource);
206
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
3844
344
207
3845
345
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
208
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
3846
346
    QPointF touchPoint = initialTouchPos;
209
    QPointF touchPoint = initialTouchPos;
3847
347
210
3849
348
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0;
211
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0;
3850
349
    QPointF dragDirectionVector(1.0, 0.0);
212
    QPointF dragDirectionVector(1.0, 0.0);
3854
350
    qreal touchStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
213
    qreal touchStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
3855
351
    // make sure we are above minimum speed
214
    // make sure we are above maximum time
3856
352
    int touchStepTimeMs = (touchStepDistance / (edgeDragArea->minSpeed() * 5.0f)) * 1000.0f;
215
    int touchStepTimeMs = edgeDragArea->d->maxTime / 20. ;
3857
353
    QPointF touchMovement = dragDirectionVector * touchStepDistance;
216
    QPointF touchMovement = dragDirectionVector * touchStepDistance;
3858
354
217
3859
355
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
218
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
3860
@@ -373,66 +236,14 @@
3861
373
        passTime(touchStepTimeMs);
236
        passTime(touchStepTimeMs);
3862
374
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
237
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
3863
375
    } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance
238
    } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance
3865
376
            || fakeTimeSource->m_msecsSinceReference < (edgeDragArea->compositionTime() * 1.5f));
239
            || m_fakeTimerFactory->timeSource()->msecsSinceReference() < (edgeDragArea->d->compositionTime * 1.5f));
3866
377
240
3868
378
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
241
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
3869
379
242
3870
380
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
243
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
3871
381
}
244
}
3872
382
245
3873
383
/*
246
/*
3874
384
   Checks that a gesture will be rejected if it's slower than minSpeed while
3875
385
   status is Undecided.
3876
386
 */
3877
387
void tst_DirectionalDragArea::minSpeed()
3878
388
{
3879
389
    QFETCH(qreal, minSpeed);
3880
390
    QFETCH(qreal, speed);
3881
391
    QFETCH(int, expectedStatusAfterSpeedCheck);
3882
392
3883
393
    DirectionalDragArea *edgeDragArea =
3884
394
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
3885
395
    QVERIFY(edgeDragArea != 0);
3886
396
    edgeDragArea->setRecognitionTimer(fakeTimer);
3887
397
    edgeDragArea->setTimeSource(fakeTimeSource);
3888
398
3889
399
    // A really long, unattainable, number. We don't want it getting recognized before
3890
400
    // the speed checks we want have been performed
3891
401
    edgeDragArea->setDistanceThreshold(500000);
3892
402
3893
403
    edgeDragArea->setMinSpeed(minSpeed);
3894
404
3895
405
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
3896
406
    QPointF touchPoint = initialTouchPos;
3897
407
3898
408
    QPointF dragDirectionVector(1.0, 0.0);
3899
409
    qint64 timeStepMsecs = 10;
3900
410
    qreal distanceStep = (speed / 1000.0f) * timeStepMsecs;
3901
411
    QPointF touchMovement = dragDirectionVector * distanceStep;
3902
412
3903
413
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
3904
414
3905
415
    // Move for a while to ensure our speed check is performed a couple of times
3906
416
    for (int i=0; i < 20; ++i) {
3907
417
        touchPoint += touchMovement;
3908
418
        passTime(timeStepMsecs);
3909
419
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
3910
420
    }
3911
421
3912
422
    QCOMPARE((int)edgeDragArea->status(), expectedStatusAfterSpeedCheck);
3913
423
}
3914
424
3915
425
void tst_DirectionalDragArea::minSpeed_data()
3916
426
{
3917
427
    QTest::addColumn<qreal>("minSpeed");
3918
428
    QTest::addColumn<qreal>("speed");
3919
429
    QTest::addColumn<int>("expectedStatusAfterSpeedCheck");
3920
430
3921
431
    QTest::newRow("slower than minSpeed") << 100.0 << 50.0 << (int)DirectionalDragArea::WaitingForTouch;
3922
432
    QTest::newRow("faster than minSpeed") << 100.0 << 150.0 << (int)DirectionalDragArea::Undecided;
3923
433
}
3924
434
3925
435
/*
3926
436
    Checks that the recognition timer is started and stopped appropriately.
247
    Checks that the recognition timer is started and stopped appropriately.
3927
437
    I.e., check that it's running only while gesture recognition is taking place
248
    I.e., check that it's running only while gesture recognition is taking place
3928
438
    (status == Undecided)
249
    (status == Undecided)
3929
@@ -442,11 +253,9 @@
3930
442
    DirectionalDragArea *edgeDragArea =
253
    DirectionalDragArea *edgeDragArea =
3931
443
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
254
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
3932
444
    QVERIFY(edgeDragArea != 0);
255
    QVERIFY(edgeDragArea != 0);
3938
445
    edgeDragArea->setRecognitionTimer(fakeTimer);
256
    AbstractTimer *fakeTimer = m_fakeTimerFactory->createTimer();
3939
446
    edgeDragArea->setTimeSource(fakeTimeSource);
257
    edgeDragArea->d->setRecognitionTimer(fakeTimer);
3940
447
258
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
3936
448
    // don't let it interfere with our test
3937
449
    edgeDragArea->setMinSpeed(0.0);
3941
450
259
3942
451
    int timeStepMs = 5; // some arbitrary small value.
260
    int timeStepMs = 5; // some arbitrary small value.
3943
452
261
3944
@@ -454,63 +263,32 @@
3945
454
    QPointF touchPoint = initialTouchPos;
263
    QPointF touchPoint = initialTouchPos;
3946
455
264
3947
456
    QPointF dragDirectionVector(1.0, 0.0);
265
    QPointF dragDirectionVector(1.0, 0.0);
3949
457
    QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.2f);
266
    QPointF touchMovement = dragDirectionVector * (edgeDragArea->d->distanceThreshold * 0.2f);
3950
458
267
3952
459
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
268
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
3953
460
    QVERIFY(!fakeTimer->isRunning());
269
    QVERIFY(!fakeTimer->isRunning());
3954
461
270
3955
462
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
271
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
3956
463
272
3958
464
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
273
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
3959
465
    QVERIFY(fakeTimer->isRunning());
274
    QVERIFY(fakeTimer->isRunning());
3960
466
275
3961
467
    // Move beyond distance threshold and composition time to ensure recognition
276
    // Move beyond distance threshold and composition time to ensure recognition
3964
468
    while (fakeTimeSource->m_msecsSinceReference <= edgeDragArea->compositionTime() ||
277
    while (m_fakeTimerFactory->timeSource()->msecsSinceReference() <= edgeDragArea->d->compositionTime ||
3965
469
           (touchPoint - initialTouchPos).manhattanLength() <= edgeDragArea->distanceThreshold()) {
278
           (touchPoint - initialTouchPos).manhattanLength() <= edgeDragArea->d->distanceThreshold) {
3966
470
279
3968
471
        QCOMPARE(edgeDragArea->status() == DirectionalDragArea::Undecided, fakeTimer->isRunning());
280
        QCOMPARE(edgeDragArea->d->status == DirectionalDragAreaPrivate::Undecided, fakeTimer->isRunning());
3969
472
281
3970
473
        touchPoint += touchMovement;
282
        touchPoint += touchMovement;
3971
474
        passTime(timeStepMs);
283
        passTime(timeStepMs);
3972
475
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
284
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
3973
476
    }
285
    }
3974
477
286
3976
478
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
287
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
3977
479
    QVERIFY(!fakeTimer->isRunning());
288
    QVERIFY(!fakeTimer->isRunning());
3978
480
}
289
}
3979
481
290
3980
482
/*
291
/*
3981
483
    A gesture should be rejected if too much time has passed without any new input
3982
484
    events from it.
3983
485
 */
3984
486
void tst_DirectionalDragArea::maxSilenceTime()
3985
487
{
3986
488
    DirectionalDragArea *edgeDragArea =
3987
489
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
3988
490
    QVERIFY(edgeDragArea != 0);
3989
491
    edgeDragArea->setRecognitionTimer(fakeTimer);
3990
492
    edgeDragArea->setTimeSource(fakeTimeSource);
3991
493
3992
494
    // Make sure this property is not disabled
3993
495
    edgeDragArea->setMaxSilenceTime(100);
3994
496
3995
497
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
3996
498
    QPointF touchPoint = initialTouchPos;
3997
499
3998
500
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
3999
501
4000
502
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
4001
503
    QVERIFY(fakeTimer->isRunning());
4002
504
4003
505
    // Force timer to timeout until after maxSilenceTime has been reached
4004
506
    while (fakeTimeSource->m_msecsSinceReference < edgeDragArea->maxSilenceTime()) {
4005
507
        passTime(fakeTimer->interval());
4006
508
    }
4007
509
4008
510
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
4009
511
}
4010
512
4011
513
/*
4012
514
  Checks that it informs the X coordinate of the touch point in local and scene coordinates
292
  Checks that it informs the X coordinate of the touch point in local and scene coordinates
4013
515
  correctly.
293
  correctly.
4014
516
 */
294
 */
4015
@@ -519,18 +297,19 @@
4016
519
    DirectionalDragArea *edgeDragArea =
297
    DirectionalDragArea *edgeDragArea =
4017
520
        m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
298
        m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
4018
521
    QVERIFY(edgeDragArea != 0);
299
    QVERIFY(edgeDragArea != 0);
4021
522
    edgeDragArea->setRecognitionTimer(fakeTimer);
300
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4022
523
    edgeDragArea->setTimeSource(fakeTimeSource);
301
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4023
302
    edgeDragArea->setImmediateRecognition(true);
4024
524
303
4025
525
    QPointF touchScenePos(m_view->width() - (edgeDragArea->width()/2.0f), m_view->height()/2.0f);
304
    QPointF touchScenePos(m_view->width() - (edgeDragArea->width()/2.0f), m_view->height()/2.0f);
4026
526
305
4028
527
    QTest::touchEvent(m_view, m_device).press(0, touchScenePos.toPoint());
306
    sendTouchPress(0 /* timestamp */, 0 /* id */, touchScenePos);
4029
528
307
4030
529
    QSignalSpy touchXSpy(edgeDragArea, SIGNAL(touchXChanged(qreal)));
308
    QSignalSpy touchXSpy(edgeDragArea, SIGNAL(touchXChanged(qreal)));
4031
530
    QSignalSpy touchSceneXSpy(edgeDragArea, SIGNAL(touchSceneXChanged(qreal)));
309
    QSignalSpy touchSceneXSpy(edgeDragArea, SIGNAL(touchSceneXChanged(qreal)));
4032
531
310
4033
532
    touchScenePos.rx() = m_view->width() / 2;
311
    touchScenePos.rx() = m_view->width() / 2;
4035
533
    QTest::touchEvent(m_view, m_device).move(0, touchScenePos.toPoint());
312
    sendTouchUpdate(50 /* timestamp */, 0 /* id */, touchScenePos);
4036
534
313
4037
535
    QCOMPARE(touchXSpy.count(), 1);
314
    QCOMPARE(touchXSpy.count(), 1);
4038
536
    QCOMPARE(touchSceneXSpy.count(), 1);
315
    QCOMPARE(touchSceneXSpy.count(), 1);
4039
@@ -547,18 +326,19 @@
4040
547
    DirectionalDragArea *edgeDragArea =
326
    DirectionalDragArea *edgeDragArea =
4041
548
        m_view->rootObject()->findChild<DirectionalDragArea*>("vnDragArea");
327
        m_view->rootObject()->findChild<DirectionalDragArea*>("vnDragArea");
4042
549
    QVERIFY(edgeDragArea != 0);
328
    QVERIFY(edgeDragArea != 0);
4045
550
    edgeDragArea->setRecognitionTimer(fakeTimer);
329
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4046
551
    edgeDragArea->setTimeSource(fakeTimeSource);
330
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4047
331
    edgeDragArea->setImmediateRecognition(true);
4048
552
332
4049
553
    QPointF touchScenePos(m_view->width()/2.0f, m_view->height() - (edgeDragArea->height()/2.0f));
333
    QPointF touchScenePos(m_view->width()/2.0f, m_view->height() - (edgeDragArea->height()/2.0f));
4050
554
334
4052
555
    QTest::touchEvent(m_view, m_device).press(0, touchScenePos.toPoint());
335
    sendTouchPress(0 /* timestamp */, 0 /* id */, touchScenePos);
4053
556
336
4054
557
    QSignalSpy touchYSpy(edgeDragArea, SIGNAL(touchYChanged(qreal)));
337
    QSignalSpy touchYSpy(edgeDragArea, SIGNAL(touchYChanged(qreal)));
4055
558
    QSignalSpy touchSceneYSpy(edgeDragArea, SIGNAL(touchSceneYChanged(qreal)));
338
    QSignalSpy touchSceneYSpy(edgeDragArea, SIGNAL(touchSceneYChanged(qreal)));
4056
559
339
4057
560
    touchScenePos.ry() = m_view->height() / 2;
340
    touchScenePos.ry() = m_view->height() / 2;
4059
561
    QTest::touchEvent(m_view, m_device).move(0, touchScenePos.toPoint());
341
    sendTouchUpdate(50 /* timestamp */, 0 /* id */, touchScenePos);
4060
562
342
4061
563
    QCOMPARE(touchYSpy.count(), 1);
343
    QCOMPARE(touchYSpy.count(), 1);
4062
564
    QCOMPARE(touchSceneYSpy.count(), 1);
344
    QCOMPARE(touchSceneYSpy.count(), 1);
4063
@@ -577,8 +357,8 @@
4064
577
    DirectionalDragArea *edgeDragArea =
357
    DirectionalDragArea *edgeDragArea =
4065
578
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
358
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4066
579
    QVERIFY(edgeDragArea != 0);
359
    QVERIFY(edgeDragArea != 0);
4069
580
    edgeDragArea->setRecognitionTimer(fakeTimer);
360
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4070
581
    edgeDragArea->setTimeSource(fakeTimeSource);
361
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4071
582
362
4072
583
    // Make touches evenly spaced along the edgeDragArea
363
    // Make touches evenly spaced along the edgeDragArea
4073
584
    QPoint touchAPos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
364
    QPoint touchAPos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
4074
@@ -592,7 +372,7 @@
4075
592
    QTest::touchEvent(m_view, m_device)
372
    QTest::touchEvent(m_view, m_device)
4076
593
        .press(0, touchAPos);
373
        .press(0, touchAPos);
4077
594
374
4079
595
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
375
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4080
596
376
4081
597
    passTime(timeStepMsecs);
377
    passTime(timeStepMsecs);
4082
598
    QTest::touchEvent(m_view, m_device)
378
    QTest::touchEvent(m_view, m_device)
4083
@@ -601,20 +381,20 @@
4084
601
381
4085
602
    // A second touch point appeared during recognition, reject immediately as this
382
    // A second touch point appeared during recognition, reject immediately as this
4086
603
    // can't be a single-touch gesture anymore.
383
    // can't be a single-touch gesture anymore.
4088
604
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
384
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4089
605
385
4090
606
    passTime(timeStepMsecs);
386
    passTime(timeStepMsecs);
4091
607
    QTest::touchEvent(m_view, m_device)
387
    QTest::touchEvent(m_view, m_device)
4092
608
        .release(0, touchAPos)
388
        .release(0, touchAPos)
4093
609
        .move(1, touchBPos);
389
        .move(1, touchBPos);
4094
610
390
4096
611
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
391
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4097
612
392
4098
613
    passTime(timeStepMsecs);
393
    passTime(timeStepMsecs);
4099
614
    QTest::touchEvent(m_view, m_device)
394
    QTest::touchEvent(m_view, m_device)
4100
615
        .release(1, touchBPos);
395
        .release(1, touchBPos);
4101
616
396
4103
617
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
397
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4104
618
398
4105
619
    // Perform the second two-finger tap
399
    // Perform the second two-finger tap
4106
620
400
4107
@@ -622,27 +402,27 @@
4108
622
    QTest::touchEvent(m_view, m_device)
402
    QTest::touchEvent(m_view, m_device)
4109
623
        .press(0, touchAPos);
403
        .press(0, touchAPos);
4110
624
404
4112
625
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
405
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4113
626
406
4114
627
    passTime(timeStepMsecs);
407
    passTime(timeStepMsecs);
4115
628
    QTest::touchEvent(m_view, m_device)
408
    QTest::touchEvent(m_view, m_device)
4116
629
        .move(0, touchAPos)
409
        .move(0, touchAPos)
4117
630
        .press(1, touchBPos);
410
        .press(1, touchBPos);
4118
631
411
4120
632
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
412
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4121
633
413
4122
634
    passTime(timeStepMsecs);
414
    passTime(timeStepMsecs);
4123
635
    QTest::touchEvent(m_view, m_device)
415
    QTest::touchEvent(m_view, m_device)
4124
636
        .release(0, touchAPos)
416
        .release(0, touchAPos)
4125
637
        .move(1, touchBPos);
417
        .move(1, touchBPos);
4126
638
418
4128
639
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
419
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4129
640
420
4130
641
    passTime(timeStepMsecs);
421
    passTime(timeStepMsecs);
4131
642
    QTest::touchEvent(m_view, m_device)
422
    QTest::touchEvent(m_view, m_device)
4132
643
        .release(1, touchBPos);
423
        .release(1, touchBPos);
4133
644
424
4135
645
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
425
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4136
646
}
426
}
4137
647
427
4138
648
/*
428
/*
4139
@@ -659,25 +439,25 @@
4140
659
    DirectionalDragArea *edgeDragArea =
439
    DirectionalDragArea *edgeDragArea =
4141
660
        rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
440
        rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
4142
661
    Q_ASSERT(edgeDragArea != 0);
441
    Q_ASSERT(edgeDragArea != 0);
4145
662
    edgeDragArea->setRecognitionTimer(fakeTimer);
442
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4146
663
    edgeDragArea->setTimeSource(fakeTimeSource);
443
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4147
664
444
4148
665
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
445
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
4149
666
    QPointF touchPoint = initialTouchPos;
446
    QPointF touchPoint = initialTouchPos;
4150
667
447
4152
668
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
448
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
4153
669
    QPointF dragDirectionVector(1.0f, 0.0f);
449
    QPointF dragDirectionVector(1.0f, 0.0f);
4154
670
450
4156
671
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
451
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4157
672
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
452
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4158
673
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
453
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4160
674
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
454
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
4161
675
455
4162
676
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
456
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
4163
677
457
4164
678
    // Move it far ahead along the direction of the gesture
458
    // Move it far ahead along the direction of the gesture
4165
679
    // rightwardsLauncher is a parent of our DirectionalDragArea. So moving it will move our DDA
459
    // rightwardsLauncher is a parent of our DirectionalDragArea. So moving it will move our DDA
4167
680
    rightwardsLauncher->setX(rightwardsLauncher->x() + edgeDragArea->distanceThreshold() * 5.0f);
460
    rightwardsLauncher->setX(rightwardsLauncher->x() + edgeDragArea->d->distanceThreshold * 5.0f);
4168
681
461
4169
682
    for (int i = 0; i < totalMovementSteps; ++i) {
462
    for (int i = 0; i < totalMovementSteps; ++i) {
4170
683
        touchPoint += touchMovement;
463
        touchPoint += touchMovement;
4171
@@ -685,7 +465,7 @@
4172
685
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
465
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
4173
686
    }
466
    }
4174
687
467
4176
688
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
468
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4177
689
469
4178
690
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
470
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
4179
691
}
471
}
4180
@@ -699,8 +479,8 @@
4181
699
    DirectionalDragArea *edgeDragArea =
479
    DirectionalDragArea *edgeDragArea =
4182
700
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
480
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4183
701
    Q_ASSERT(edgeDragArea != 0);
481
    Q_ASSERT(edgeDragArea != 0);
4186
702
    edgeDragArea->setRecognitionTimer(fakeTimer);
482
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4187
703
    edgeDragArea->setTimeSource(fakeTimeSource);
483
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4188
704
484
4189
705
    // Make touches evenly spaced along the edgeDragArea
485
    // Make touches evenly spaced along the edgeDragArea
4190
706
    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
486
    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
4191
@@ -708,26 +488,26 @@
4192
708
488
4193
709
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
489
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
4194
710
490
4196
711
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
491
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4197
712
492
4198
713
    // leave it lying around for some time
493
    // leave it lying around for some time
4204
714
    passTime(qMax(edgeDragArea->maxSilenceTime(), edgeDragArea->compositionTime()) * 10);
494
    passTime(edgeDragArea->d->maxTime * 10);
4205
715
495
4206
716
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
496
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4207
717
497
4208
718
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
498
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
4209
719
    QPointF dragDirectionVector(1.0f, 0.0f);
499
    QPointF dragDirectionVector(1.0f, 0.0f);
4210
720
500
4212
721
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
501
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4213
722
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
502
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4214
723
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
503
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4216
724
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
504
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
4217
725
505
4218
726
    QTest::touchEvent(m_view, m_device)
506
    QTest::touchEvent(m_view, m_device)
4219
727
        .move(0, touch0Pos)
507
        .move(0, touch0Pos)
4220
728
        .press(1, touch1Pos);
508
        .press(1, touch1Pos);
4221
729
509
4223
730
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
510
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4224
731
511
4225
732
    for (int i = 0; i < totalMovementSteps; ++i) {
512
    for (int i = 0; i < totalMovementSteps; ++i) {
4226
733
        touch1Pos += touchMovement.toPoint();
513
        touch1Pos += touchMovement.toPoint();
4227
@@ -737,13 +517,13 @@
4228
737
            .move(1, touch1Pos);
517
            .move(1, touch1Pos);
4229
738
    }
518
    }
4230
739
519
4232
740
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
520
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4233
741
521
4234
742
    QTest::touchEvent(m_view, m_device)
522
    QTest::touchEvent(m_view, m_device)
4235
743
        .move(0, touch0Pos)
523
        .move(0, touch0Pos)
4236
744
        .release(1, touch1Pos);
524
        .release(1, touch1Pos);
4237
745
525
4239
746
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
526
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4240
747
}
527
}
4241
748
528
4242
749
/*
529
/*
4243
@@ -762,19 +542,19 @@
4244
762
    DirectionalDragArea *edgeDragArea =
542
    DirectionalDragArea *edgeDragArea =
4245
763
        rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
543
        rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
4246
764
    Q_ASSERT(edgeDragArea != 0);
544
    Q_ASSERT(edgeDragArea != 0);
4249
765
    edgeDragArea->setRecognitionTimer(fakeTimer);
545
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4250
766
    edgeDragArea->setTimeSource(fakeTimeSource);
546
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4251
767
547
4252
768
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
548
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
4253
769
    QPointF touchPoint = initialTouchPos;
549
    QPointF touchPoint = initialTouchPos;
4254
770
550
4256
771
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
551
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
4257
772
    QPointF dragDirectionVector(0.0f, 1.0f);
552
    QPointF dragDirectionVector(0.0f, 1.0f);
4258
773
553
4260
774
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
554
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4261
775
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
555
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4262
776
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
556
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4264
777
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
557
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
4265
778
558
4266
779
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
559
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
4267
780
560
4268
@@ -784,7 +564,7 @@
4269
784
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
564
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
4270
785
    }
565
    }
4271
786
566
4273
787
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
567
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4274
788
568
4275
789
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
569
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
4276
790
}
570
}
4277
@@ -802,31 +582,30 @@
4278
802
    DirectionalDragArea *edgeDragArea =
582
    DirectionalDragArea *edgeDragArea =
4279
803
        rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
583
        rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
4280
804
    Q_ASSERT(edgeDragArea != 0);
584
    Q_ASSERT(edgeDragArea != 0);
4283
805
    edgeDragArea->setRecognitionTimer(fakeTimer);
585
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4284
806
    edgeDragArea->setTimeSource(fakeTimeSource);
586
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4285
587
4286
588
    // to disable the position smoothing so that we can more easily check sceneDistance values
4287
589
    edgeDragArea->setImmediateRecognition(true);
4288
807
590
4289
808
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
591
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
4290
809
    QPointF touchPoint = initialTouchPos;
592
    QPointF touchPoint = initialTouchPos;
4291
810
593
4293
811
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
594
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
4294
812
595
4296
813
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
596
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4297
814
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
597
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4298
815
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
598
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4306
816
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
599
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
4307
817
600
4308
818
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
601
    qint64 timestamp = 0;
4309
819
602
4310
820
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
603
    sendTouchPress(timestamp, 0, touchPoint);
4311
821
    QQuickWindowPrivate *wp = QQuickWindowPrivate::get(m_view);
604
4305
822
#endif
4312
823
    for (int i = 0; i < totalMovementSteps; ++i) {
605
    for (int i = 0; i < totalMovementSteps; ++i) {
4313
824
        touchPoint += touchMovement;
606
        touchPoint += touchMovement;
4319
825
        passTime(movementTimeStepMs);
607
        timestamp += movementTimeStepMs;
4320
826
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
608
        sendTouchUpdate(timestamp, 0, touchPoint);
4316
827
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
4317
828
        wp->flushDelayedTouchEvent();
4318
829
#endif
4321
830
    }
609
    }
4322
831
610
4323
832
    qreal actualDragDistance = ((qreal)totalMovementSteps) * movementStepDistance;
611
    qreal actualDragDistance = ((qreal)totalMovementSteps) * movementStepDistance;
4324
@@ -836,7 +615,8 @@
4325
836
    // NB: qFuzzyCompare(), used internally by QCOMPARE(), is broken.
615
    // NB: qFuzzyCompare(), used internally by QCOMPARE(), is broken.
4326
837
    QVERIFY(qAbs(edgeDragArea->sceneDistance() - actualDragDistance) < 0.001);
616
    QVERIFY(qAbs(edgeDragArea->sceneDistance() - actualDragDistance) < 0.001);
4327
838
617
4329
839
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
618
    timestamp += movementTimeStepMs;
4330
619
    sendTouchRelease(timestamp, 0, touchPoint);
4331
840
}
620
}
4332
841
621
4333
842
void tst_DirectionalDragArea::sceneDistance_data()
622
void tst_DirectionalDragArea::sceneDistance_data()
4334
@@ -860,18 +640,18 @@
4335
860
    DirectionalDragArea *edgeDragArea =
640
    DirectionalDragArea *edgeDragArea =
4336
861
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
641
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4337
862
    Q_ASSERT(edgeDragArea != 0);
642
    Q_ASSERT(edgeDragArea != 0);
4340
863
    edgeDragArea->setRecognitionTimer(fakeTimer);
643
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4341
864
    edgeDragArea->setTimeSource(fakeTimeSource);
644
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4342
865
645
4343
866
    QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);
646
    QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);
4344
867
647
4346
868
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
648
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
4347
869
    QPointF dragDirectionVector(1., 0.); // horizontal positive
649
    QPointF dragDirectionVector(1., 0.); // horizontal positive
4348
870
650
4350
871
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
651
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4351
872
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
652
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4352
873
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
653
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4354
874
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
654
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
4355
875
655
4356
876
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
656
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
4357
877
657
4358
@@ -881,13 +661,13 @@
4359
881
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
661
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
4360
882
    }
662
    }
4361
883
663
4363
884
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
664
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4364
885
    QCOMPARE(edgeDragArea->dragging(), true);
665
    QCOMPARE(edgeDragArea->dragging(), true);
4365
886
666
4366
887
    // disable the dragArea while it's being dragged.
667
    // disable the dragArea while it's being dragged.
4367
888
    edgeDragArea->setEnabled(false);
668
    edgeDragArea->setEnabled(false);
4368
889
669
4370
890
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
670
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4371
891
    QCOMPARE(edgeDragArea->dragging(), false);
671
    QCOMPARE(edgeDragArea->dragging(), false);
4372
892
672
4373
893
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
673
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
4374
@@ -898,15 +678,14 @@
4375
898
    DirectionalDragArea *edgeDragArea =
678
    DirectionalDragArea *edgeDragArea =
4376
899
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
679
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4377
900
    Q_ASSERT(edgeDragArea != 0);
680
    Q_ASSERT(edgeDragArea != 0);
4380
901
    edgeDragArea->setRecognitionTimer(fakeTimer);
681
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4381
902
    edgeDragArea->setTimeSource(fakeTimeSource);
682
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4382
903
683
4383
904
    // Disable some constraints we're not interested in
684
    // Disable some constraints we're not interested in
4386
905
    edgeDragArea->setMaxSilenceTime(60 * 1000);
685
    edgeDragArea->d->setMaxTime(60 * 1000);
4385
906
    edgeDragArea->setMinSpeed(0);
4387
907
686
4388
908
    // And ensure others have the values we want
687
    // And ensure others have the values we want
4390
909
    edgeDragArea->setCompositionTime(60);
688
    edgeDragArea->d->compositionTime = 60;
4391
910
689
4392
911
    // Put an item right behind edgeDragArea to receive the touches ignored by it
690
    // Put an item right behind edgeDragArea to receive the touches ignored by it
4393
912
    DummyItem *dummyItem = new DummyItem;
691
    DummyItem *dummyItem = new DummyItem;
4394
@@ -923,10 +702,10 @@
4395
923
702
4396
924
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
703
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
4397
925
704
4399
926
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
705
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4400
927
706
4401
928
    // We are now going to be way beyond compositionTime
707
    // We are now going to be way beyond compositionTime
4403
929
    passTime(edgeDragArea->compositionTime()*3);
708
    passTime(edgeDragArea->d->compositionTime*3);
4404
930
709
4405
931
    QTest::touchEvent(m_view, m_device)
710
    QTest::touchEvent(m_view, m_device)
4406
932
        .move(0, touch0Pos)
711
        .move(0, touch0Pos)
4407
@@ -948,7 +727,7 @@
4408
948
        .move(0, touch0Pos)
727
        .move(0, touch0Pos)
4409
949
        .move(1, touch1Pos);
728
        .move(1, touch1Pos);
4410
950
729
4412
951
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
730
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4413
952
731
4414
953
    passTime(5);
732
    passTime(5);
4415
954
733
4416
@@ -956,7 +735,7 @@
4417
956
        .release(0, touch0Pos)
735
        .release(0, touch0Pos)
4418
957
        .move(1, touch1Pos);
736
        .move(1, touch1Pos);
4419
958
737
4421
959
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
738
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4422
960
739
4423
961
    passTime(5);
740
    passTime(5);
4424
962
741
4425
@@ -964,7 +743,7 @@
4426
964
        .release(1, touch1Pos);
743
        .release(1, touch1Pos);
4427
965
744
4428
966
    // Shouldn't be keepping info about touches that no longer exist or interest us
745
    // Shouldn't be keepping info about touches that no longer exist or interest us
4430
967
    QVERIFY(edgeDragArea->m_activeTouches.isEmpty());
746
    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
4431
968
747
4432
969
    delete dummyItem;
748
    delete dummyItem;
4433
970
}
749
}
4434
@@ -974,12 +753,11 @@
4435
974
    DirectionalDragArea *edgeDragArea =
753
    DirectionalDragArea *edgeDragArea =
4436
975
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
754
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4437
976
    Q_ASSERT(edgeDragArea != 0);
755
    Q_ASSERT(edgeDragArea != 0);
4440
977
    edgeDragArea->setRecognitionTimer(fakeTimer);
756
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4441
978
    edgeDragArea->setTimeSource(fakeTimeSource);
757
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4442
979
758
4443
980
    // Disable some constraints we're not interested in
759
    // Disable some constraints we're not interested in
4446
981
    edgeDragArea->setMaxSilenceTime(60 * 1000);
760
    edgeDragArea->d->setMaxTime(60 * 1000);
4445
982
    edgeDragArea->setMinSpeed(0);
4447
983
761
4448
984
    // Put an item right in front of edgeDragArea
762
    // Put an item right in front of edgeDragArea
4449
985
    DummyItem *dummyItem = new DummyItem(edgeDragArea->parentItem());
763
    DummyItem *dummyItem = new DummyItem(edgeDragArea->parentItem());
4450
@@ -998,11 +776,11 @@
4451
998
776
4452
999
    QTest::touchEvent(m_view, m_device).press(0, touchPos);
777
    QTest::touchEvent(m_view, m_device).press(0, touchPos);
4453
1000
778
4455
1001
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
779
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4456
1002
780
4457
1003
    m_touchRegistry->requestTouchOwnership(0, dummyItem);
781
    m_touchRegistry->requestTouchOwnership(0, dummyItem);
4458
1004
782
4460
1005
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
783
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4461
1006
784
4462
1007
    dummyItem->grabTouchPoints({0});
785
    dummyItem->grabTouchPoints({0});
4463
1008
    dummyItem->touchEventHandler = [&](QTouchEvent *event) { event->accept(); };
786
    dummyItem->touchEventHandler = [&](QTouchEvent *event) { event->accept(); };
4464
@@ -1010,9 +788,9 @@
4465
1010
    passTime(5);
788
    passTime(5);
4466
1011
    QTest::touchEvent(m_view, m_device).release(0, touchPos);
789
    QTest::touchEvent(m_view, m_device).release(0, touchPos);
4467
1012
790
4469
1013
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
791
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4470
1014
792
4472
1015
    QVERIFY(edgeDragArea->m_activeTouches.isEmpty());
793
    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
4473
1016
}
794
}
4474
1017
795
4475
1018
void tst_DirectionalDragArea::threeFingerDrag()
796
void tst_DirectionalDragArea::threeFingerDrag()
4476
@@ -1020,15 +798,14 @@
4477
1020
    DirectionalDragArea *edgeDragArea =
798
    DirectionalDragArea *edgeDragArea =
4478
1021
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
799
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4479
1022
    Q_ASSERT(edgeDragArea != 0);
800
    Q_ASSERT(edgeDragArea != 0);
4482
1023
    edgeDragArea->setRecognitionTimer(fakeTimer);
801
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4483
1024
    edgeDragArea->setTimeSource(fakeTimeSource);
802
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4484
1025
803
4485
1026
    // Disable some constraints we're not interested in
804
    // Disable some constraints we're not interested in
4488
1027
    edgeDragArea->setMaxSilenceTime(60 * 1000);
805
    edgeDragArea->d->setMaxTime(60 * 1000);
4487
1028
    edgeDragArea->setMinSpeed(0);
4489
1029
806
4490
1030
    // And ensure others have the values we want
807
    // And ensure others have the values we want
4492
1031
    edgeDragArea->setCompositionTime(60);
808
    edgeDragArea->d->compositionTime = 60;
4493
1032
809
4494
1033
    // Make touches evenly spaced along the edgeDragArea
810
    // Make touches evenly spaced along the edgeDragArea
4495
1034
    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.25f);
811
    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.25f);
4496
@@ -1038,14 +815,14 @@
4497
1038
    QTest::touchEvent(m_view, m_device)
815
    QTest::touchEvent(m_view, m_device)
4498
1039
        .press(0, touch0Pos);
816
        .press(0, touch0Pos);
4499
1040
817
4501
1041
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
818
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4502
1042
819
4503
1043
    passTime(5);
820
    passTime(5);
4504
1044
    QTest::touchEvent(m_view, m_device)
821
    QTest::touchEvent(m_view, m_device)
4505
1045
        .move(0, touch0Pos)
822
        .move(0, touch0Pos)
4506
1046
        .press(1, touch1Pos);
823
        .press(1, touch1Pos);
4507
1047
824
4509
1048
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
825
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4510
1049
826
4511
1050
    passTime(5);
827
    passTime(5);
4512
1051
    QTest::touchEvent(m_view, m_device)
828
    QTest::touchEvent(m_view, m_device)
4513
@@ -1053,7 +830,7 @@
4514
1053
        .move(1, touch1Pos)
830
        .move(1, touch1Pos)
4515
1054
        .press(2, touch2Pos);
831
        .press(2, touch2Pos);
4516
1055
832
4518
1056
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
833
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4519
1057
834
4520
1058
    passTime(10);
835
    passTime(10);
4521
1059
    QTest::touchEvent(m_view, m_device)
836
    QTest::touchEvent(m_view, m_device)
4522
@@ -1077,7 +854,7 @@
4523
1077
        .release(0, touch0Pos);
854
        .release(0, touch0Pos);
4524
1078
855
4525
1079
    // Shouldn't be keepping info about touches that no longer exist or interest us
856
    // Shouldn't be keepping info about touches that no longer exist or interest us
4527
1080
    QVERIFY(edgeDragArea->m_activeTouches.isEmpty());
857
    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
4528
1081
}
858
}
4529
1082
859
4530
1083
/*
860
/*
4531
@@ -1090,12 +867,12 @@
4532
1090
    DirectionalDragArea *edgeDragArea =
867
    DirectionalDragArea *edgeDragArea =
4533
1091
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
868
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4534
1092
    Q_ASSERT(edgeDragArea != 0);
869
    Q_ASSERT(edgeDragArea != 0);
4537
1093
    edgeDragArea->setRecognitionTimer(fakeTimer);
870
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4538
1094
    edgeDragArea->setTimeSource(fakeTimeSource);
871
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4539
1095
872
4540
1096
    // Disable the minimum amount of constraints to ensure immediate recognition
873
    // Disable the minimum amount of constraints to ensure immediate recognition
4543
1097
    edgeDragArea->setDistanceThreshold(0);
874
    edgeDragArea->d->setDistanceThreshold(0);
4544
1098
    edgeDragArea->setCompositionTime(0);
875
    edgeDragArea->d->compositionTime = 0;
4545
1099
876
4546
1100
    // Put an item right behind edgeDragArea to receive the touches ignored by it
877
    // Put an item right behind edgeDragArea to receive the touches ignored by it
4547
1101
    DummyItem *dummyItem = new DummyItem;
878
    DummyItem *dummyItem = new DummyItem;
4548
@@ -1111,7 +888,7 @@
4549
1111
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
888
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
4550
1112
889
4551
1113
    // check for immediate recognition
890
    // check for immediate recognition
4553
1114
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
891
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4554
1115
892
4555
1116
    // and therefore it should have immediately grabbed the touch point,
893
    // and therefore it should have immediately grabbed the touch point,
4556
1117
    // not letting it leak to items behind him.
894
    // not letting it leak to items behind him.
4557
@@ -1123,19 +900,19 @@
4558
1123
    DirectionalDragArea *edgeDragArea =
900
    DirectionalDragArea *edgeDragArea =
4559
1124
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
901
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4560
1125
    Q_ASSERT(edgeDragArea != 0);
902
    Q_ASSERT(edgeDragArea != 0);
4563
1126
    edgeDragArea->setRecognitionTimer(fakeTimer);
903
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4564
1127
    edgeDragArea->setTimeSource(fakeTimeSource);
904
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4565
1128
905
4566
1129
    QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);
906
    QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);
4567
1130
907
4568
1131
    // Move less than the minimum needed for the drag gesture recognition
908
    // Move less than the minimum needed for the drag gesture recognition
4570
1132
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*0.5f;
909
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 0.5f;
4571
1133
    QPointF dragDirectionVector(1., 0.); // horizontal positive
910
    QPointF dragDirectionVector(1., 0.); // horizontal positive
4572
1134
911
4574
1135
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
912
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4575
1136
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
913
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4576
1137
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
914
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4578
1138
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 0.8f) / totalMovementSteps;
915
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 0.8f) / totalMovementSteps;
4579
1139
916
4580
1140
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
917
    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
4581
1141
918
4582
@@ -1145,14 +922,14 @@
4583
1145
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
922
        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
4584
1146
    }
923
    }
4585
1147
924
4587
1148
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
925
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4588
1149
926
4589
1150
    // edgeDragArea should be an undecided candidate
927
    // edgeDragArea should be an undecided candidate
4590
1151
    {
928
    {
4591
1152
        auto touchInfo = m_touchRegistry->findTouchInfo(0);
929
        auto touchInfo = m_touchRegistry->findTouchInfo(0);
4592
1153
        QCOMPARE(touchInfo->candidates.size(), 1);
930
        QCOMPARE(touchInfo->candidates.size(), 1);
4593
1154
        QCOMPARE(touchInfo->candidates.at(0).item.data(), edgeDragArea);
931
        QCOMPARE(touchInfo->candidates.at(0).item.data(), edgeDragArea);
4595
1155
        QCOMPARE(touchInfo->candidates.at(0).undecided, true);
932
        QCOMPARE(touchInfo->candidates.at(0).state, TouchRegistry::CandidateInfo::Undecided);
4596
1156
    }
933
    }
4597
1157
934
4598
1158
    // disable the dragArea while it's still recognizing a possible drag gesture.
935
    // disable the dragArea while it's still recognizing a possible drag gesture.
4599
@@ -1169,7 +946,7 @@
4600
1169
        QCOMPARE(touchInfo->candidates.size(), 0);
946
        QCOMPARE(touchInfo->candidates.size(), 0);
4601
1170
    }
947
    }
4602
1171
948
4604
1172
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
949
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4605
1173
950
4606
1174
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
951
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
4607
1175
}
952
}
4608
@@ -1182,47 +959,13 @@
4609
1182
    QTest::newRow("invisible") << false;
959
    QTest::newRow("invisible") << false;
4610
1183
}
960
}
4611
1184
961
4612
1185
void tst_DirectionalDragArea::tappedSignal()
4613
1186
{
4614
1187
    DirectionalDragArea *edgeDragArea =
4615
1188
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4616
1189
    QVERIFY(edgeDragArea != 0);
4617
1190
    edgeDragArea->setRecognitionTimer(fakeTimer);
4618
1191
    edgeDragArea->setTimeSource(fakeTimeSource);
4619
1192
4620
1193
    QFETCH(bool, immediateGestureRecognition);
4621
1194
    if (immediateGestureRecognition) {
4622
1195
        // Disable the minimum amount of constraints to ensure immediate recognition
4623
1196
        edgeDragArea->setDistanceThreshold(0);
4624
1197
        edgeDragArea->setCompositionTime(0);
4625
1198
    }
4626
1199
4627
1200
    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()/2.0f);
4628
1201
4629
1202
    QSignalSpy tappedSpy(edgeDragArea, SIGNAL(tapped()));
4630
1203
4631
1204
    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
4632
1205
    passTime(edgeDragArea->maxTapDuration() / 2);
4633
1206
    QTest::touchEvent(m_view, m_device).release(0, touch0Pos);
4634
1207
4635
1208
    QCOMPARE(tappedSpy.count(), 1);
4636
1209
}
4637
1210
4638
1211
void tst_DirectionalDragArea::tappedSignal_data()
4639
1212
{
4640
1213
    QTest::addColumn<bool>("immediateGestureRecognition");
4641
1214
4642
1215
    QTest::newRow("immediate gesture recognition") << true;
4643
1216
    QTest::newRow("default gesture recognition") << false;
4644
1217
}
4645
1218
4646
1219
void tst_DirectionalDragArea::gettingTouchOwnershipMakesMouseAreaBehindGetCanceled()
962
void tst_DirectionalDragArea::gettingTouchOwnershipMakesMouseAreaBehindGetCanceled()
4647
1220
{
963
{
4648
1221
    DirectionalDragArea *edgeDragArea =
964
    DirectionalDragArea *edgeDragArea =
4649
1222
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
965
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4650
1223
    QVERIFY(edgeDragArea != nullptr);
966
    QVERIFY(edgeDragArea != nullptr);
4653
1224
    edgeDragArea->setRecognitionTimer(fakeTimer);
967
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4654
1225
    edgeDragArea->setTimeSource(fakeTimeSource);
968
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4655
1226
969
4656
1227
    QQuickMouseArea *mouseArea =
970
    QQuickMouseArea *mouseArea =
4657
1228
        m_view->rootObject()->findChild<QQuickMouseArea*>("mouseArea");
971
        m_view->rootObject()->findChild<QQuickMouseArea*>("mouseArea");
4658
@@ -1233,12 +976,12 @@
4659
1233
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
976
    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
4660
1234
    QPointF touchPoint = initialTouchPos;
977
    QPointF touchPoint = initialTouchPos;
4661
1235
978
4663
1236
    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2;
979
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2;
4664
1237
    QPointF dragDirectionVector(1.0f, 0.0f); // rightwards
980
    QPointF dragDirectionVector(1.0f, 0.0f); // rightwards
4666
1238
    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
981
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4667
1239
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
982
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4668
1240
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
983
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4670
1241
    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
984
    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
4671
1242
985
4672
1243
    QCOMPARE(mouseArea->pressed(), false);
986
    QCOMPARE(mouseArea->pressed(), false);
4673
1244
987
4674
@@ -1259,13 +1002,305 @@
4675
1259
    // As the DirectionalDragArea recognizes the gesture, it grabs the touch from the MouseArea,
1002
    // As the DirectionalDragArea recognizes the gesture, it grabs the touch from the MouseArea,
4676
1260
    // which should make the MouseArea get a cancelation event, which will then cause it to
1003
    // which should make the MouseArea get a cancelation event, which will then cause it to
4677
1261
    // reset its state (going back to "unpressed"/"released").
1004
    // reset its state (going back to "unpressed"/"released").
4679
1262
    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
1005
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4680
1263
    QCOMPARE(mouseArea->pressed(), false);
1006
    QCOMPARE(mouseArea->pressed(), false);
4681
1264
    QCOMPARE(mouseAreaSpy.canceledCount, 1);
1007
    QCOMPARE(mouseAreaSpy.canceledCount, 1);
4682
1265
1008
4683
1266
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
1009
    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
4684
1267
}
1010
}
4685
1268
1011
4686
1012
void tst_DirectionalDragArea::interleavedTouches()
4687
1013
{
4688
1014
    DirectionalDragArea *edgeDragArea =
4689
1015
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4690
1016
    QVERIFY(edgeDragArea != 0);
4691
1017
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4692
1018
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4693
1019
4694
1020
    QPointF touch0 = edgeDragArea->mapToScene(
4695
1021
            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.3));
4696
1022
4697
1023
    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2;
4698
1024
    QPointF dragDirectionVector(1.0f, 0.0f); // rightwards
4699
1025
    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
4700
1026
    QPointF touchMovement = dragDirectionVector * movementStepDistance;
4701
1027
    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
4702
1028
    int movementTimeStepMs = (edgeDragArea->d->maxTime * 0.4f) / totalMovementSteps;
4703
1029
4704
1030
    QTest::touchEvent(m_view, m_device).press(0, touch0.toPoint());
4705
1031
    for (int i = 0; i < totalMovementSteps; ++i) {
4706
1032
        touch0 += touchMovement;
4707
1033
        passTime(movementTimeStepMs);
4708
1034
        QTest::touchEvent(m_view, m_device).move(0, touch0.toPoint());
4709
1035
    }
4710
1036
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4711
1037
4712
1038
    QPointF touch1 = edgeDragArea->mapToScene(
4713
1039
            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.6));
4714
1040
4715
1041
    QTest::touchEvent(m_view, m_device)
4716
1042
        .move(0, touch0.toPoint())
4717
1043
        .press(1, touch1.toPoint());
4718
1044
4719
1045
    touch1 += touchMovement;
4720
1046
    passTime(movementTimeStepMs);
4721
1047
    QTest::touchEvent(m_view, m_device)
4722
1048
        .move(0, touch0.toPoint())
4723
1049
        .move(1, touch1.toPoint());
4724
1050
4725
1051
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
4726
1052
4727
1053
    QTest::touchEvent(m_view, m_device)
4728
1054
        .release(0, touch0.toPoint())
4729
1055
        .move(1, touch1.toPoint());
4730
1056
4731
1057
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4732
1058
4733
1059
    touch1 += touchMovement;
4734
1060
    passTime(movementTimeStepMs);
4735
1061
    QTest::touchEvent(m_view, m_device)
4736
1062
        .move(1, touch1.toPoint());
4737
1063
4738
1064
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4739
1065
4740
1066
    QPointF touch2 = edgeDragArea->mapToScene(
4741
1067
            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.9));
4742
1068
4743
1069
    passTime(edgeDragArea->d->compositionTime + movementTimeStepMs);
4744
1070
    QTest::touchEvent(m_view, m_device)
4745
1071
        .move(1, touch1.toPoint())
4746
1072
        .press(2, touch2.toPoint());
4747
1073
4748
1074
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
4749
1075
    QCOMPARE(edgeDragArea->d->touchId, 2);
4750
1076
4751
1077
    touch2 += touchMovement;
4752
1078
    passTime(movementTimeStepMs);
4753
1079
    QTest::touchEvent(m_view, m_device)
4754
1080
        .move(1, touch1.toPoint())
4755
1081
        .move(2, touch2.toPoint());
4756
1082
4757
1083
    touch1 += touchMovement;
4758
1084
    passTime(movementTimeStepMs);
4759
1085
    QTest::touchEvent(m_view, m_device)
4760
1086
        .move(1, touch1.toPoint())
4761
1087
        .move(2, touch2.toPoint());
4762
1088
4763
1089
    passTime(movementTimeStepMs);
4764
1090
    QTest::touchEvent(m_view, m_device)
4765
1091
        .release(1, touch1.toPoint())
4766
1092
        .move(2, touch2.toPoint());
4767
1093
4768
1094
    passTime(movementTimeStepMs);
4769
1095
    QTest::touchEvent(m_view, m_device)
4770
1096
        .release(2, touch2.toPoint());
4771
1097
4772
1098
    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
4773
1099
}
4774
1100
4775
1101
/*
4776
1102
  A valid right-edge drag performed on mako
4777
1103
 */
4778
1104
void tst_DirectionalDragArea::makoRightEdgeDrag()
4779
1105
{
4780
1106
    m_view->resize(768, 1280);
4781
1107
    QTest::qWait(300);
4782
1108
4783
1109
    DirectionalDragArea *edgeDragArea =
4784
1110
        m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
4785
1111
    QVERIFY(edgeDragArea != nullptr);
4786
1112
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4787
1113
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4788
1114
4789
1115
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
4790
1116
4791
1117
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
4792
1118
4793
1119
    sendTouchPress(319744, 0, QPointF(767.001, 719.719));
4794
1120
    sendTouchUpdate(319765, 0, QPointF(765.744,729.973));
4795
1121
    sendTouchUpdate(319784, 0, QPointF(740.879,752.182));
4796
1122
    sendTouchUpdate(319803, 0, QPointF(689.698,795.795));
4797
1123
    sendTouchUpdate(319826, 0, QPointF(616.978,856.212));
4798
1124
    sendTouchUpdate(319845, 0, QPointF(558.769,906.157));
4799
1125
    sendTouchUpdate(319859, 0, QPointF(513.219,945.266));
4800
1126
    sendTouchUpdate(319878, 0, QPointF(481.31,975.496));
4801
1127
    sendTouchUpdate(319902, 0, QPointF(460.016,997.439));
4802
1128
    sendTouchUpdate(319920, 0, QPointF(449.761,1008.6));
4803
1129
    sendTouchUpdate(319929, 0, QPointF(445.891,1012.42));
4804
1130
    sendTouchUpdate(319947, 0, QPointF(444.884,1013.93));
4805
1131
    sendTouchUpdate(319965, 0, QPointF(444.461,1014.35));
4806
1132
    sendTouchUpdate(320057, 0, QPointF(444.71,1013.56));
4807
1133
    sendTouchUpdate(320138, 0, QPointF(445.434,1013.6));
4808
1134
    sendTouchUpdate(320154, 0, QPointF(446.338,1012.98));
4809
1135
    sendTouchUpdate(320171, 0, QPointF(447.232,1012.08));
4810
1136
    sendTouchRelease(320171, 0, QPointF(447.232,1012.08));
4811
1137
4812
1138
    QCOMPARE(statusSpy->recognized(), true);
4813
1139
4814
1140
    delete statusSpy;
4815
1141
}
4816
1142
4817
1143
/*
4818
1144
   A vertical, downwards swipe performed on mako near its right edge.
4819
1145
4820
1146
   The DirectionalDragArea on the right edge must not recognize this
4821
1147
   gesture.
4822
1148
 */
4823
1149
void tst_DirectionalDragArea::makoRightEdgeDrag_verticalDownwards()
4824
1150
{
4825
1151
    m_view->resize(768, 1280);
4826
1152
    QTest::qWait(300);
4827
1153
4828
1154
    DirectionalDragArea *edgeDragArea =
4829
1155
        m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
4830
1156
    QVERIFY(edgeDragArea != nullptr);
4831
1157
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4832
1158
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4833
1159
4834
1160
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
4835
1161
4836
1162
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
4837
1163
4838
1164
    sendTouchPress(12012445, 26, QPointF(767.001,461.82));
4839
1165
    sendTouchUpdate(12012472, 26, QPointF(767.001,462.569));
4840
1166
    sendTouchUpdate(12012528, 26, QPointF(767.001,463.334));
4841
1167
    sendTouchUpdate(12012546, 26, QPointF(767.001,466.856));
4842
1168
    sendTouchUpdate(12012571, 26, QPointF(767.001,473.291));
4843
1169
    sendTouchUpdate(12012587, 26, QPointF(767.001,487.31));
4844
1170
    sendTouchUpdate(12012604, 26, QPointF(765.364,507.521));
4845
1171
    sendTouchUpdate(12012618, 26, QPointF(765.364,507.521));
4846
1172
    sendTouchUpdate(12012627, 26, QPointF(762.642,534.317));
4847
1173
    sendTouchUpdate(12012655, 26, QPointF(760.846,573.406));
4848
1174
    sendTouchUpdate(12012667, 26, QPointF(759.838,625.295));
4849
1175
    sendTouchUpdate(12012675, 26, QPointF(758.875,703.207));
4850
1176
    sendTouchUpdate(12012696, 26, QPointF(761.52,777.015));
4851
1177
    sendTouchUpdate(12012713, 26, QPointF(765.659,835.591));
4852
1178
    sendTouchUpdate(12012731, 26, QPointF(766.778,883.206));
4853
1179
    sendTouchUpdate(12012748, 26, QPointF(767.001,922.937));
4854
1180
    sendTouchUpdate(12012779, 26, QPointF(767.001,967.558));
4855
1181
    sendTouchUpdate(12012798, 26, QPointF(767.001,1006.12));
4856
1182
    sendTouchUpdate(12012809, 26, QPointF(767.001,1033.1));
4857
1183
    sendTouchRelease(12012810, 26, QPointF(767.001,1033.1));
4858
1184
4859
1185
    QCOMPARE(statusSpy->recognized(), false);
4860
1186
4861
1187
    delete statusSpy;
4862
1188
}
4863
1189
4864
1190
/*
4865
1191
   A valid left-edge drag performed on mako. This one starts a bit slow than speeds up
4866
1192
 */
4867
1193
void tst_DirectionalDragArea::makoLeftEdgeDrag_slowStart()
4868
1194
{
4869
1195
    m_view->resize(768, 1280);
4870
1196
    QTest::qWait(300);
4871
1197
4872
1198
    DirectionalDragArea *edgeDragArea =
4873
1199
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4874
1200
    QVERIFY(edgeDragArea != nullptr);
4875
1201
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4876
1202
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4877
1203
4878
1204
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
4879
1205
4880
1206
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
4881
1207
4882
1208
    sendTouchPress(4002267, 77, QPointF(0,885.154));
4883
1209
    sendTouchUpdate(4002275, 77, QPointF(0,886.214));
4884
1210
    sendTouchUpdate(4002311, 77, QPointF(1.09568,887.75));
4885
1211
    sendTouchUpdate(4002329, 77, QPointF(3.53647,890.191));
4886
1212
    sendTouchUpdate(4002347, 77, QPointF(7.87434,892.879));
4887
1213
    sendTouchUpdate(4002366, 77, QPointF(12.3036,895.075));
4888
1214
    sendTouchUpdate(4002384, 77, QPointF(15.8885,896.849));
4889
1215
    sendTouchUpdate(4002406, 77, QPointF(18.4504,897.88));
4890
1216
    sendTouchUpdate(4002420, 77, QPointF(20.2429,898.149));
4891
1217
    sendTouchUpdate(4002439, 77, QPointF(20.9945,898.149));
4892
1218
    sendTouchUpdate(4002457, 77, QPointF(21.8819,898.149));
4893
1219
    sendTouchUpdate(4002480, 77, QPointF(22.7454,897.389));
4894
1220
    sendTouchUpdate(4002493, 77, QPointF(23.5456,896.589));
4895
1221
    sendTouchUpdate(4002511, 77, QPointF(24.5435,895.031));
4896
1222
    sendTouchUpdate(4002529, 77, QPointF(25.4271,892.32));
4897
1223
    sendTouchUpdate(4002548, 77, QPointF(26.3145,889.658));
4898
1224
    sendTouchUpdate(4002566, 77, QPointF(27.2004,886.999));
4899
1225
    sendTouchUpdate(4002584, 77, QPointF(28.035,885.048));
4900
1226
    sendTouchUpdate(4002603, 77, QPointF(29.9684,883.167));
4901
1227
    sendTouchUpdate(4002620, 77, QPointF(33.3591,881.403));
4902
1228
    sendTouchUpdate(4002639, 77, QPointF(44.1017,879.642));
4903
1229
    sendTouchUpdate(4002657, 77, QPointF(64.828,878.502));
4904
1230
    sendTouchUpdate(4002675, 77, QPointF(87.9486,878.157));
4905
1231
    sendTouchUpdate(4002693, 77, QPointF(112.96,877.742));
4906
1232
    sendTouchUpdate(4002711, 77, QPointF(138.903,877.157));
4907
1233
    sendTouchUpdate(4002729, 77, QPointF(163.204,877.157));
4908
1234
    sendTouchUpdate(4002747, 77, QPointF(182.127,877.157));
4909
1235
    sendTouchUpdate(4002765, 77, QPointF(194.478,877.657));
4910
1236
    sendTouchUpdate(4002785, 77, QPointF(201.474,878.508));
4911
1237
    sendTouchUpdate(4002803, 77, QPointF(204.855,879.401));
4912
1238
    sendTouchUpdate(4002822, 77, QPointF(206.616,880.281));
4913
1239
    sendTouchUpdate(4002839, 77, QPointF(207.115,880.906));
4914
1240
    sendTouchUpdate(4002894, 77, QPointF(206.865,881.184));
4915
1241
    sendTouchUpdate(4002912, 77, QPointF(206.865,882.143));
4916
1242
    sendTouchUpdate(4002930, 77, QPointF(206.865,883.106));
4917
1243
    sendTouchUpdate(4002949, 77, QPointF(206.526,883.994));
4918
1244
    sendTouchUpdate(4002967, 77, QPointF(205.866,884.88));
4919
1245
    sendTouchUpdate(4002985, 77, QPointF(205.866,885.766));
4920
1246
    sendTouchUpdate(4003005, 77, QPointF(205.866,886.654));
4921
1247
    sendTouchUpdate(4003021, 77, QPointF(205.366,887.537));
4922
1248
    sendTouchUpdate(4003039, 77, QPointF(204.592,888.428));
4923
1249
    sendTouchUpdate(4003050, 77, QPointF(204.367,888.653));
4924
1250
    sendTouchRelease(4003050, 77, QPointF(204.367,888.653));
4925
1251
4926
1252
    QCOMPARE(statusSpy->recognized(), true);
4927
1253
4928
1254
    delete statusSpy;
4929
1255
}
4930
1256
4931
1257
void tst_DirectionalDragArea::makoLeftEdgeDrag_movesSlightlyBackwardsOnStart()
4932
1258
{
4933
1259
    m_view->resize(768, 1280);
4934
1260
    QTest::qWait(300);
4935
1261
4936
1262
    DirectionalDragArea *edgeDragArea =
4937
1263
        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
4938
1264
    QVERIFY(edgeDragArea != nullptr);
4939
1265
    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
4940
1266
    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
4941
1267
4942
1268
    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
4943
1269
4944
1270
    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
4945
1271
4946
1272
    sendTouchPress(41097, 24, QPointF(13.9909,827.177));
4947
1273
    sendTouchUpdate(41120, 24, QPointF(19.2375,825.677));
4948
1274
    sendTouchUpdate(41138, 24, QPointF(18.4057,826.177));
4949
1275
    sendTouchUpdate(41161, 24, QPointF(20.1067,825.867));
4950
1276
    sendTouchUpdate(41177, 24, QPointF(21.8869,824.977));
4951
1277
    sendTouchUpdate(41193, 24, QPointF(24.7603,823.494));
4952
1278
    sendTouchUpdate(41211, 24, QPointF(28.3889,821.725));
4953
1279
    sendTouchUpdate(41229, 24, QPointF(32.2909,819.955));
4954
1280
    sendTouchUpdate(41247, 24, QPointF(38.2251,817.431));
4955
1281
    sendTouchUpdate(41266, 24, QPointF(52.4182,814.223));
4956
1282
    sendTouchUpdate(41284, 24, QPointF(85.8465,809.483));
4957
1283
    sendTouchUpdate(41302, 24, QPointF(126.091,802.741));
4958
1284
    sendTouchUpdate(41320, 24, QPointF(153.171,797.977));
4959
1285
    sendTouchUpdate(41338, 24, QPointF(170.565,795.077));
4960
1286
    sendTouchUpdate(41356, 24, QPointF(178.685,794.101));
4961
1287
    sendTouchUpdate(41375, 24, QPointF(183.706,793.225));
4962
1288
    sendTouchUpdate(41393, 24, QPointF(186.112,793.19));
4963
1289
    sendTouchUpdate(41411, 24, QPointF(187.634,793.19));
4964
1290
    sendTouchUpdate(41429, 24, QPointF(188.505,793.19));
4965
1291
    sendTouchUpdate(41532, 24, QPointF(187.816,793.19));
4966
1292
    sendTouchUpdate(41538, 24, QPointF(186.902,793.19));
4967
1293
    sendTouchUpdate(41557, 24, QPointF(186.01,793.19));
4968
1294
    sendTouchUpdate(41575, 24, QPointF(185.125,793.444));
4969
1295
    sendTouchUpdate(41593, 24, QPointF(184.229,793.69));
4970
1296
    sendTouchUpdate(41605, 24, QPointF(183.88,793.69));
4971
1297
    sendTouchRelease(41607, 24, QPointF(183.88,793.69));
4972
1298
4973
1299
    QCOMPARE(statusSpy->recognized(), true);
4974
1300
4975
1301
    delete statusSpy;
4976
1302
}
4977
1303
4978
1269
QTEST_MAIN(tst_DirectionalDragArea)
1304
QTEST_MAIN(tst_DirectionalDragArea)
4979
1270
1305
4980
1271
#include "tst_DirectionalDragArea.moc"
1306
#include "tst_DirectionalDragArea.moc"
4981
1272
1307
4982
=== modified file 'tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.qml'
4983
--- tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.qml	2014-10-07 13:02:29 +0000
4984
+++ tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.qml	2015-04-10 21:17:56 +0000
4985
@@ -1,5 +1,5 @@
4986
1
/*
1
/*
4988
2
 * Copyright (C) 2013 Canonical, Ltd.
2
 * Copyright (C) 2013,2015 Canonical, Ltd.
4989
3
 *
3
 *
4990
4
 * This program is free software; you can redistribute it and/or modify
4
 * This program is free software; you can redistribute it and/or modify
4991
5
 * it under the terms of the GNU General Public License as published by
5
 * it under the terms of the GNU General Public License as published by
4992
@@ -16,12 +16,19 @@
4993
16
16
4994
17
import QtQuick 2.0
17
import QtQuick 2.0
4995
18
import Ubuntu.Components 0.1
18
import Ubuntu.Components 0.1
4996
19
import Unity.Test 0.1
4997
19
20
4998
20
Rectangle {
21
Rectangle {
4999
21
    width: units.gu(60)
22
    width: units.gu(60)
5000
22
    height: units.gu(60)
23
    height: units.gu(60)
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2015-04-09
Albert Astals Cid (community)		2015-04-02	Approve on 2015-04-09
Michał Sawicz		2015-04-01	Abstain on 2015-04-02
Review via email: mp+254964@code.launchpad.net