1
=== modified file 'debian/control'
2
--- debian/control	2016-03-24 09:14:57 +0000
3
+++ debian/control	2016-04-07 16:01:36 +0000
4
@@ -22,6 +22,9 @@
5
22
               libqt5sql5-sqlite,
22
               libqt5sql5-sqlite,
6
23
               libqt5svg5-dev,
23
               libqt5svg5-dev,
7
24
               libudev-dev,
24
               libudev-dev,
8
25
               libx11-dev[!armhf],
9
26
               libxcb1-dev[!armhf],
10
27
               libxi-dev[!armhf],
11
25
               libxkbcommon-dev,
28
               libxkbcommon-dev,
12
26
               libxrender-dev,
29
               libxrender-dev,
13
27
               locales,
30
               locales,
14
28
31
15
=== modified file 'debian/libubuntutoolkit5-dev.install'
16
--- debian/libubuntutoolkit5-dev.install	2016-03-04 11:58:12 +0000
17
+++ debian/libubuntutoolkit5-dev.install	2016-04-07 16:01:36 +0000
18
@@ -1,11 +1,13 @@
19
1
usr/include/*/qt5/UbuntuToolkit/AsyncLoader
1
usr/include/*/qt5/UbuntuToolkit/AsyncLoader
20
2
usr/include/*/qt5/UbuntuToolkit/ColorUtils
2
usr/include/*/qt5/UbuntuToolkit/ColorUtils
21
3
usr/include/*/qt5/UbuntuToolkit/MouseTouchAdaptor
22
3
usr/include/*/qt5/UbuntuToolkit/Tree
4
usr/include/*/qt5/UbuntuToolkit/Tree
23
4
usr/include/*/qt5/UbuntuToolkit/UbuntuToolkit
5
usr/include/*/qt5/UbuntuToolkit/UbuntuToolkit
24
5
usr/include/*/qt5/UbuntuToolkit/UbuntuToolkitDepends
6
usr/include/*/qt5/UbuntuToolkit/UbuntuToolkitDepends
25
6
usr/include/*/qt5/UbuntuToolkit/UbuntuToolkitVersion
7
usr/include/*/qt5/UbuntuToolkit/UbuntuToolkitVersion
26
7
usr/include/*/qt5/UbuntuToolkit/asyncloader.h
8
usr/include/*/qt5/UbuntuToolkit/asyncloader.h
27
8
usr/include/*/qt5/UbuntuToolkit/colorutils.h
9
usr/include/*/qt5/UbuntuToolkit/colorutils.h
28
10
usr/include/*/qt5/UbuntuToolkit/mousetouchadaptor.h
29
9
usr/include/*/qt5/UbuntuToolkit/tree.h
11
usr/include/*/qt5/UbuntuToolkit/tree.h
30
10
usr/include/*/qt5/UbuntuToolkit/ubuntutoolkitglobal.h
12
usr/include/*/qt5/UbuntuToolkit/ubuntutoolkitglobal.h
31
11
usr/include/*/qt5/UbuntuToolkit/ubuntutoolkitversion.h
13
usr/include/*/qt5/UbuntuToolkit/ubuntutoolkitversion.h
32
12
14
33
=== modified file 'src/Ubuntu/Test/plugin/plugin.pri'
34
--- src/Ubuntu/Test/plugin/plugin.pri	2016-02-25 02:29:05 +0000
35
+++ src/Ubuntu/Test/plugin/plugin.pri	2016-04-07 16:01:36 +0000
36
@@ -1,4 +1,4 @@
38
1
QT *= core-private qml qml-private quick quick-private gui-private testlib UbuntuGestures
1
QT *= core-private qml qml-private quick quick-private gui-private testlib UbuntuGestures UbuntuToolkit
39
2
2
40
3
equals(QT_MAJOR_VERSION, 5):lessThan(QT_MINOR_VERSION, 2) {
3
equals(QT_MAJOR_VERSION, 5):lessThan(QT_MINOR_VERSION, 2) {
41
4
    QT *= v8-private
4
    QT *= v8-private
42
@@ -15,11 +15,9 @@
43
15
HEADERS += \
15
HEADERS += \
44
16
    $$PWD/uctestcase.h \
16
    $$PWD/uctestcase.h \
45
17
    $$PWD/testplugin.h \
17
    $$PWD/testplugin.h \
48
18
    $$PWD/uctestextras.h \
18
    $$PWD/uctestextras.h
47
19
    $$PWD/ucmousetouchadaptor.h \
49
20
19
50
21
SOURCES += \
20
SOURCES += \
51
22
    $$PWD/uctestcase.cpp \
21
    $$PWD/uctestcase.cpp \
52
23
    $$PWD/testplugin.cpp \
22
    $$PWD/testplugin.cpp \
55
24
    $$PWD/uctestextras.cpp \
23
    $$PWD/uctestextras.cpp
54
25
    $$PWD/ucmousetouchadaptor.cpp \
56
26
24
57
=== modified file 'src/Ubuntu/Test/plugin/testplugin.cpp'
58
--- src/Ubuntu/Test/plugin/testplugin.cpp	2015-10-21 08:33:21 +0000
59
+++ src/Ubuntu/Test/plugin/testplugin.cpp	2016-04-07 16:01:36 +0000
60
@@ -1,5 +1,5 @@
61
1
/*
1
/*
63
2
 * Copyright 2014 Canonical Ltd.
2
 * Copyright 2016 Canonical Ltd.
64
3
 *
3
 *
65
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
66
5
 * it under the terms of the GNU Lesser General Public License as published by
5
 * it under the terms of the GNU Lesser General Public License as published by
67
@@ -17,7 +17,7 @@
68
17
#include "testplugin.h"
17
#include "testplugin.h"
69
18
#include <QtQml>
18
#include <QtQml>
70
19
#include "uctestextras.h"
19
#include "uctestextras.h"
72
20
#include "ucmousetouchadaptor.h"
20
#include <MouseTouchAdaptor>
73
21
21
74
22
static QObject *registerExtras(QQmlEngine *engine, QJSEngine *scriptEngine)
22
static QObject *registerExtras(QQmlEngine *engine, QJSEngine *scriptEngine)
75
23
{
23
{
76
@@ -27,16 +27,8 @@
77
27
    return new UCTestExtras;
27
    return new UCTestExtras;
78
28
}
28
}
79
29
29
80
30
static QObject *registerAdaptor(QQmlEngine *engine, QJSEngine *scriptEngine)
81
31
{
82
32
    Q_UNUSED(engine)
83
33
    Q_UNUSED(scriptEngine)
84
34
85
35
    return new UCMouseTouchAdaptor;
86
36
}
87
37
88
38
void TestPlugin::registerTypes(const char *uri)
30
void TestPlugin::registerTypes(const char *uri)
89
39
{
31
{
90
40
    qmlRegisterSingletonType<UCTestExtras>(uri, 1, 0, "TestExtras", registerExtras);
32
    qmlRegisterSingletonType<UCTestExtras>(uri, 1, 0, "TestExtras", registerExtras);
92
41
    qmlRegisterSingletonType<UCMouseTouchAdaptor>(uri, 1, 0, "MouseTouchAdaptor", registerAdaptor);
33
    qmlRegisterSingletonType<UbuntuToolkit::MouseTouchAdaptor>(uri, 1, 0, "MouseTouchAdaptor", UbuntuToolkit::MouseTouchAdaptor::registerQmlSingleton);
93
42
}
34
}
94
43
35
95
=== modified file 'src/Ubuntu/Test/plugin/uctestextras.cpp'
96
--- src/Ubuntu/Test/plugin/uctestextras.cpp	2015-12-17 15:23:26 +0000
97
+++ src/Ubuntu/Test/plugin/uctestextras.cpp	2016-04-07 16:01:36 +0000
98
@@ -1,5 +1,5 @@
99
1
/*
1
/*
101
2
 * Copyright 2014 Canonical Ltd.
2
 * Copyright 2016 Canonical Ltd.
102
3
 *
3
 *
103
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
104
5
 * it under the terms of the GNU Lesser General Public License as published by
5
 * it under the terms of the GNU Lesser General Public License as published by
105
@@ -23,6 +23,7 @@
106
23
#include <qpa/qwindowsysteminterface.h>
23
#include <qpa/qwindowsysteminterface.h>
107
24
#include <private/qobject_p.h>
24
#include <private/qobject_p.h>
108
25
#include <QSysInfo>
25
#include <QSysInfo>
109
26
#include <MouseTouchAdaptor>
110
26
27
111
27
const char *DEVICE_MISSING_MSG = "No touch device registered. Register one using registerTouchDevice() before using %1";
28
const char *DEVICE_MISSING_MSG = "No touch device registered. Register one using registerTouchDevice() before using %1";
112
28
29
113
@@ -40,7 +41,6 @@
114
40
        return; \
41
        return; \
115
41
    }
42
    }
116
42
43
117
43
QTouchDevice *UCTestExtras::m_touchDevice = 0;
118
44
UCTestExtras *UCTestExtras::m_testExtras = 0;
44
UCTestExtras *UCTestExtras::m_testExtras = 0;
119
45
45
120
46
/*!
46
/*!
121
@@ -118,24 +118,8 @@
122
118
 */
118
 */
123
119
void UCTestExtras::registerTouchDevice()
119
void UCTestExtras::registerTouchDevice()
124
120
{
120
{
143
121
    // check if there is any touch device registered in the system
121
    if (UbuntuToolkit::MouseTouchAdaptor::registerTouchDevice() && m_testExtras) {
144
122
    if (!m_touchDevice) {
122
        Q_EMIT m_testExtras->touchDevicePresentChanged();
127
123
        QList<const QTouchDevice*> touchDevices = QTouchDevice::devices();
128
124
        Q_FOREACH(const QTouchDevice *device, touchDevices) {
129
125
            if (device->type() == QTouchDevice::TouchScreen) {
130
126
                m_touchDevice = const_cast<QTouchDevice*>(device);
131
127
                break;
132
128
            }
133
129
        }
134
130
    }
135
131
    // if none, register one
136
132
    if (!m_touchDevice) {
137
133
        m_touchDevice = new QTouchDevice;
138
134
        m_touchDevice->setType(QTouchDevice::TouchScreen);
139
135
        QWindowSystemInterface::registerTouchDevice(m_touchDevice);
140
136
        if (m_testExtras) {
141
137
            Q_EMIT m_testExtras->touchDevicePresentChanged();
142
138
        }
145
139
    }
123
    }
146
140
}
124
}
147
141
125
148
@@ -148,7 +132,7 @@
149
148
void UCTestExtras::touchPress(int touchId, QQuickItem *item, const QPoint &point)
132
void UCTestExtras::touchPress(int touchId, QQuickItem *item, const QPoint &point)
150
149
{
133
{
151
150
    CHECK_TOUCH_DEVICE(touchId, item);
134
    CHECK_TOUCH_DEVICE(touchId, item);
153
151
    QTest::touchEvent(item->window(), m_touchDevice).press(touchId, item->mapToScene(point).toPoint(), item->window());
135
    QTest::touchEvent(item->window(), UbuntuToolkit::MouseTouchAdaptor::touchDevice()).press(touchId, item->mapToScene(point).toPoint(), item->window());
154
152
}
136
}
155
153
/*!
137
/*!
156
154
 * \qmlmethod TestExtras::touchRelease(touchId, item, point)
138
 * \qmlmethod TestExtras::touchRelease(touchId, item, point)
157
@@ -158,7 +142,7 @@
158
158
void UCTestExtras::touchRelease(int touchId, QQuickItem *item, const QPoint &point)
142
void UCTestExtras::touchRelease(int touchId, QQuickItem *item, const QPoint &point)
159
159
{
143
{
160
160
    CHECK_TOUCH_DEVICE(touchId, item);
144
    CHECK_TOUCH_DEVICE(touchId, item);
162
161
    QTest::touchEvent(item->window(), m_touchDevice).release(touchId, item->mapToScene(point).toPoint(), item->window());
145
    QTest::touchEvent(item->window(), UbuntuToolkit::MouseTouchAdaptor::touchDevice()).release(touchId, item->mapToScene(point).toPoint(), item->window());
163
162
}
146
}
164
163
/*!
147
/*!
165
164
 * \qmlmethod TestExtras::touchClick(touchId, item, point)
148
 * \qmlmethod TestExtras::touchClick(touchId, item, point)
166
@@ -207,7 +191,7 @@
167
207
void UCTestExtras::touchMove(int touchId, QQuickItem *item, const QPoint &point)
191
void UCTestExtras::touchMove(int touchId, QQuickItem *item, const QPoint &point)
168
208
{
192
{
169
209
    CHECK_TOUCH_DEVICE(touchId, item);
193
    CHECK_TOUCH_DEVICE(touchId, item);
171
210
    QTest::touchEvent(item->window(), m_touchDevice).move(touchId, item->mapToScene(point).toPoint(), item->window());
194
    QTest::touchEvent(item->window(), UbuntuToolkit::MouseTouchAdaptor::touchDevice()).move(touchId, item->mapToScene(point).toPoint(), item->window());
172
211
}
195
}
173
212
/*!
196
/*!
174
213
 * \qmlmethod TestExtras::touchDrag(touchId, item, from, delta, steps = 5)
197
 * \qmlmethod TestExtras::touchDrag(touchId, item, from, delta, steps = 5)
175
214
198
176
=== modified file 'src/Ubuntu/Test/plugin/uctestextras.h'
177
--- src/Ubuntu/Test/plugin/uctestextras.h	2015-12-17 14:42:40 +0000
178
+++ src/Ubuntu/Test/plugin/uctestextras.h	2016-04-07 16:01:36 +0000
179
@@ -53,7 +53,6 @@
180
53
    static void mouseDragWithPoints(QQuickItem *item, QList<QPoint> points, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = 0, int delay = -1);
53
    static void mouseDragWithPoints(QQuickItem *item, QList<QPoint> points, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = 0, int delay = -1);
181
54
54
182
55
private:
55
private:
183
56
    static QTouchDevice *m_touchDevice;
184
57
    static UCTestExtras *m_testExtras;
56
    static UCTestExtras *m_testExtras;
185
58
57
186
59
    friend class UCMouseTouchAdaptor;
58
    friend class UCMouseTouchAdaptor;
187
60
59
188
=== modified file 'src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro'
189
--- src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-02-25 14:35:59 +0000
190
+++ src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-04-07 16:01:36 +0000
191
@@ -1,7 +1,14 @@
192
1
TEMPLATE=lib
1
TEMPLATE=lib
193
2
TARGET=UbuntuToolkit
2
TARGET=UbuntuToolkit
194
3
3
196
4
QT *= core-private gui-private qml qml-private quick quick-private
4
QT *= core-private gui-private qml qml-private quick quick-private testlib
197
5
198
6
!contains(QT_ARCH, arm) {
199
7
    DEFINES += UBUNTUTOOLKIT_ENABLE_X11_TOUCH_EMULATION
200
8
    LIBS += -lX11 -lxcb -lXi
201
9
202
10
    SOURCES += mousetouchadaptor_x11.cpp
203
11
}
204
5
12
205
6
CONFIG += dll no_keywords c++11
13
CONFIG += dll no_keywords c++11
206
7
14
207
@@ -17,9 +24,12 @@
208
17
    ubuntutoolkitglobal.h \
24
    ubuntutoolkitglobal.h \
209
18
    tree.h \
25
    tree.h \
210
19
    asyncloader.h \
26
    asyncloader.h \
212
20
    asyncloader_p.h
27
    asyncloader_p.h \
213
28
    mousetouchadaptor.h \
214
29
    mousetouchadaptor_p.h
215
21
30
216
22
SOURCES += \ 
31
SOURCES += \ 
217
23
    colorutils.cpp \
32
    colorutils.cpp \
218
24
    tree.cpp \
33
    tree.cpp \
220
25
    asyncloader.cpp
34
    asyncloader.cpp \
221
35
    mousetouchadaptor.cpp
222
26
36
223
=== renamed file 'src/Ubuntu/Test/plugin/ucmousetouchadaptor.cpp' => 'src/Ubuntu/UbuntuToolkit/mousetouchadaptor.cpp'
224
--- src/Ubuntu/Test/plugin/ucmousetouchadaptor.cpp	2015-11-10 14:42:20 +0000
225
+++ src/Ubuntu/UbuntuToolkit/mousetouchadaptor.cpp	2016-04-07 16:01:36 +0000
226
@@ -1,5 +1,5 @@
227
1
/*
1
/*
229
2
 * Copyright (C) 2013,2015 Canonical, Ltd.
2
 * Copyright (C) 2013,2016 Canonical, Ltd.
230
3
 *
3
 *
231
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
232
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
233
@@ -14,36 +14,34 @@
234
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
235
15
 *
15
 *
236
16
 * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
16
 * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
237
17
 *              Zsombor Egri <zsomboir.egri@canonical.com>
238
17
 */
18
 */
239
18
19
242
19
#include "ucmousetouchadaptor.h"
20
#include "mousetouchadaptor_p.h"
241
20
#include "uctestextras.h"
243
21
21
244
22
#include <qpa/qplatformnativeinterface.h>
245
22
#include <qpa/qwindowsysteminterface.h>
23
#include <qpa/qwindowsysteminterface.h>
246
23
24
247
24
#include <QCoreApplication>
25
#include <QCoreApplication>
248
25
#include <QMouseEvent>
26
#include <QMouseEvent>
249
26
#include <QTest>
27
#include <QTest>
250
27
28
256
28
using QTest::QTouchEventSequence;
29
#ifdef UBUNTUTOOLKIT_ENABLE_X11_TOUCH_EMULATION
257
29
30
    #define ENABLE_TOUCH_EMULATION
258
30
namespace {
31
#endif
259
31
32
260
32
Qt::MouseButton translateMouseButton(xcb_button_t detail)
33
namespace UbuntuToolkit {
261
34
262
35
QTouchDevice *MouseTouchAdaptor::m_touchDevice = nullptr;
263
36
264
37
MouseTouchAdaptorPrivate::~MouseTouchAdaptorPrivate()
265
33
{
38
{
273
34
    switch (detail) {
39
    QCoreApplication::instance()->removeNativeEventFilter(this);
267
35
        case 1: return Qt::LeftButton;
268
36
        case 2: return Qt::MidButton;
269
37
        case 3: return Qt::RightButton;
270
38
        // Button values 4-7 are Wheel events
271
39
        default: return Qt::NoButton;
272
40
    }
274
41
}
40
}
275
42
} // end of anonymous namespace
276
43
41
277
44
/*!
42
/*!
278
45
 * \qmltype MouseTouchAdaptor
43
 * \qmltype MouseTouchAdaptor
280
46
 * \instantiates UCMouseTouchAdaptor
44
 * \instantiates MouseTouchAdaptor
281
47
 * \inqmlmodule Ubuntu.Test 1.0
45
 * \inqmlmodule Ubuntu.Test 1.0
282
48
 * \ingroup ubuntu-test
46
 * \ingroup ubuntu-test
283
49
 * \brief Singleton type turning mouse events into single finger touch events.
47
 * \brief Singleton type turning mouse events into single finger touch events.
284
@@ -60,109 +58,49 @@
285
60
 * \endqml
58
 * \endqml
286
61
 *
59
 *
287
62
 */
60
 */
391
63
UCMouseTouchAdaptor::UCMouseTouchAdaptor()
61
MouseTouchAdaptor::MouseTouchAdaptor(QObject *parent)
392
64
    : QObject(nullptr)
62
    :
393
65
    , m_leftButtonIsPressed(false)
63
#ifdef UBUNTUTOOLKIT_ENABLE_X11_TOUCH_EMULATION
394
66
    , m_enabled(true)
64
      QObject(*(new X11MouseTouchAdaptorPrivate), parent)
395
67
{
65
#else
396
68
    QCoreApplication::instance()->installNativeEventFilter(this);
66
      QObject(*(new MouseTouchAdaptorPrivate), parent)
397
69
67
#endif
398
70
    UCTestExtras::registerTouchDevice();
68
{
399
71
    m_touchDevice = UCTestExtras::m_touchDevice;
69
#ifdef ENABLE_TOUCH_EMULATION
400
72
}
70
    registerTouchDevice();
401
73
71
#else
402
74
bool UCMouseTouchAdaptor::nativeEventFilter(const QByteArray & eventType,
72
    qWarning() << "MouseTouchAdaptor not available on this architecture.";
403
75
                                          void * message, long * /*result*/)
73
#endif
404
76
{
74
    Q_D(MouseTouchAdaptor);
405
77
    if (!m_enabled) {
75
    d->init();
406
78
        return false;
76
}
407
79
    }
77
408
80
78
// registers a test touch device, returns true if a device was found/registered
409
81
    if (eventType != "xcb_generic_event_t") {
79
bool MouseTouchAdaptor::registerTouchDevice()
410
82
        // wrong backend.
80
{
411
83
        qWarning("MouseTouchAdaptor: XCB backend not in use. Adaptor inoperative!");
81
    // check if there is any touch device registered in the system
412
84
        return false;
82
    if (!m_touchDevice) {
413
85
    }
83
        QList<const QTouchDevice*> touchDevices = QTouchDevice::devices();
414
86
84
        Q_FOREACH(const QTouchDevice *device, touchDevices) {
415
87
    xcb_generic_event_t *xcbEvent = static_cast<xcb_generic_event_t *>(message);
85
            if (device->type() == QTouchDevice::TouchScreen) {
416
88
86
                m_touchDevice = const_cast<QTouchDevice*>(device);
417
89
    switch (xcbEvent->response_type & ~0x80) {
87
                return true;
418
90
        case XCB_BUTTON_PRESS:
88
            }
419
91
            return handleButtonPress(reinterpret_cast<xcb_button_press_event_t *>(xcbEvent));
89
        }
420
92
            break;
90
    }
421
93
        case XCB_BUTTON_RELEASE:
91
    // if none, register one
422
94
            return handleButtonRelease(reinterpret_cast<xcb_button_release_event_t *>(xcbEvent));
92
#ifdef ENABLE_TOUCH_EMULATION
423
95
            break;
93
    if (!m_touchDevice) {
424
96
        case XCB_MOTION_NOTIFY:
94
        m_touchDevice = new QTouchDevice;
425
97
            return handleMotionNotify(reinterpret_cast<xcb_motion_notify_event_t *>(xcbEvent));
95
        m_touchDevice->setType(QTouchDevice::TouchScreen);
426
98
            break;
96
        QWindowSystemInterface::registerTouchDevice(m_touchDevice);
427
99
        default:
97
        return true;
428
100
            return false;
98
    }
429
101
            break;
99
#endif
430
102
    };
100
    return false;
431
103
}
101
}
432
104
102
433
105
bool UCMouseTouchAdaptor::handleButtonPress(xcb_button_press_event_t *pressEvent)
103
QWindow *MouseTouchAdaptorPrivate::findQWindowWithXWindowID(WId windowId)
331
106
{
332
107
    Qt::MouseButton button = translateMouseButton(pressEvent->detail);
333
108
334
109
    // Just eat the event if it wasn't a left mouse press
335
110
    if (button != Qt::LeftButton)
336
111
        return true;
337
112
338
113
    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(pressEvent->event));
339
114
340
115
    QPoint windowPos(pressEvent->event_x / targetWindow->devicePixelRatio(), pressEvent->event_y / targetWindow->devicePixelRatio());
341
116
342
117
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice,
343
118
                                                       false /* autoCommit */);
344
119
    touchEvent.press(0 /* touchId */, windowPos);
345
120
    touchEvent.commit(false /* processEvents */);
346
121
347
122
    m_leftButtonIsPressed = true;
348
123
    return true;
349
124
}
350
125
351
126
bool UCMouseTouchAdaptor::handleButtonRelease(xcb_button_release_event_t *releaseEvent)
352
127
{
353
128
    Qt::MouseButton button = translateMouseButton(releaseEvent->detail);
354
129
355
130
    // Just eat the event if it wasn't a left mouse release
356
131
    if (button != Qt::LeftButton)
357
132
        return true;
358
133
359
134
    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(releaseEvent->event));
360
135
361
136
    QPoint windowPos(releaseEvent->event_x / targetWindow->devicePixelRatio(), releaseEvent->event_y / targetWindow->devicePixelRatio());
362
137
363
138
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice,
364
139
                                                       false /* autoCommit */);
365
140
    touchEvent.release(0 /* touchId */, windowPos);
366
141
    touchEvent.commit(false /* processEvents */);
367
142
368
143
    m_leftButtonIsPressed = false;
369
144
    return true;
370
145
}
371
146
372
147
bool UCMouseTouchAdaptor::handleMotionNotify(xcb_motion_notify_event_t *event)
373
148
{
374
149
    if (!m_leftButtonIsPressed) {
375
150
        return true;
376
151
    }
377
152
378
153
    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(event->event));
379
154
380
155
    QPoint windowPos(event->event_x / targetWindow->devicePixelRatio(), event->event_y / targetWindow->devicePixelRatio());
381
156
382
157
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice,
383
158
                                                       false /* autoCommit */);
384
159
    touchEvent.move(0 /* touchId */, windowPos);
385
160
    touchEvent.commit(false /* processEvents */);
386
161
387
162
    return true;
388
163
}
389
164
390
165
QWindow *UCMouseTouchAdaptor::findQWindowWithXWindowID(WId windowId)
434
166
{
104
{
435
167
    QWindowList windowList = QGuiApplication::topLevelWindows();
105
    QWindowList windowList = QGuiApplication::topLevelWindows();
436
168
    QWindow *foundWindow = nullptr;
106
    QWindow *foundWindow = nullptr;
437
@@ -185,14 +123,16 @@
438
185
 * \qmlproperty bool MouseTouchAdaptor::enabled
123
 * \qmlproperty bool MouseTouchAdaptor::enabled
439
186
 * Enables the mouse to touch conversion functionality. Defaults to true.
124
 * Enables the mouse to touch conversion functionality. Defaults to true.
440
187
 */
125
 */
452
188
bool UCMouseTouchAdaptor::enabled() const
126
bool MouseTouchAdaptorPrivate::isEnabled() const
453
189
{
127
{
454
190
    return m_enabled;
128
    return enabled;
455
191
}
129
}
456
192
void UCMouseTouchAdaptor::setEnabled(bool value)
130
void MouseTouchAdaptorPrivate::setEnabled(bool value)
457
193
{
131
{
458
194
    if (value != m_enabled) {
132
    Q_UNUSED(value);
459
195
        m_enabled = value;
133
    qWarning() << "MouseTouchAdaptor not available on this architecture, thus cannot be enabled.";
460
196
        Q_EMIT enabledChanged(value);
134
}
461
197
    }
135
462
198
}
136
} // namespace UbuntuToolkit
463
137
464
138
#include "moc_mousetouchadaptor.cpp"
465
199
139
466
=== renamed file 'src/Ubuntu/Test/plugin/ucmousetouchadaptor.h' => 'src/Ubuntu/UbuntuToolkit/mousetouchadaptor.h'
467
--- src/Ubuntu/Test/plugin/ucmousetouchadaptor.h	2015-10-21 08:33:21 +0000
468
+++ src/Ubuntu/UbuntuToolkit/mousetouchadaptor.h	2016-04-07 16:01:36 +0000
469
@@ -1,5 +1,5 @@
470
1
/*
1
/*
472
2
 * Copyright (C) 2013,2015 Canonical, Ltd.
2
 * Copyright (C) 2013,2016 Canonical, Ltd.
473
3
 *
3
 *
474
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
475
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
476
@@ -14,47 +14,50 @@
477
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
478
15
 *
15
 *
479
16
 * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
16
 * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
480
17
 *              Zsombor Egri <zsomboir.egri@canonical.com>
481
17
 */
18
 */
482
18
19
483
19
#ifndef MOUSE_TOUCH_ADAPTOR_H
20
#ifndef MOUSE_TOUCH_ADAPTOR_H
484
20
#define MOUSE_TOUCH_ADAPTOR_H
21
#define MOUSE_TOUCH_ADAPTOR_H
485
21
22
489
22
#include <QtCore/QAbstractNativeEventFilter>
23
#include "ubuntutoolkitglobal.h"
490
23
#include <QWindow>
24
491
24
#include <xcb/xcb.h>
25
#include <QtCore/QObject>
492
25
26
493
26
class QMouseEvent;
27
class QMouseEvent;
494
27
class QTouchDevice;
28
class QTouchDevice;
495
29
class QQmlEngine;
496
30
class QJSEngine;
497
31
498
32
namespace UbuntuToolkit {
499
28
33
500
29
// Transforms QMouseEvents into single-finger QTouchEvents.
34
// Transforms QMouseEvents into single-finger QTouchEvents.
502
30
class UCMouseTouchAdaptor : public QObject, public QAbstractNativeEventFilter
35
class MouseTouchAdaptorPrivate;
503
36
class UBUNTUTOOLKIT_EXPORT MouseTouchAdaptor : public QObject
504
31
{
37
{
505
32
    Q_OBJECT
38
    Q_OBJECT
506
39
    Q_PRIVATE_PROPERTY(MouseTouchAdaptor::d_func(), bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
507
33
public:
40
public:
517
34
    UCMouseTouchAdaptor();
41
    explicit MouseTouchAdaptor(QObject *parent = Q_NULLPTR);
518
35
42
519
36
    // Filters mouse events and posts the equivalent QTouchEvents.
43
    static bool registerTouchDevice();
520
37
    bool nativeEventFilter(const QByteArray & eventType, void *message, long *result) override;
44
    inline static QTouchDevice *touchDevice()
521
38
45
    {
522
39
    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
46
        return m_touchDevice;
523
40
47
    }
524
41
    bool enabled() const;
48
    static QObject *registerQmlSingleton(QQmlEngine*, QJSEngine*)
525
42
    void setEnabled(bool value);
49
    {
526
50
        return new MouseTouchAdaptor;
527
51
    }
528
43
52
529
44
Q_SIGNALS:
53
Q_SIGNALS:
530
45
    void enabledChanged(bool value);
54
    void enabledChanged(bool value);
531
46
55
532
47
private:
56
private:
543
48
57
    Q_DECLARE_PRIVATE(MouseTouchAdaptor)
544
49
    bool handleButtonPress(xcb_button_press_event_t *pressEvent);
58
    static QTouchDevice *m_touchDevice;
535
50
    bool handleButtonRelease(xcb_button_release_event_t *releaseEvent);
536
51
    bool handleMotionNotify(xcb_motion_notify_event_t *event);
537
52
    QWindow *findQWindowWithXWindowID(WId windowId);
538
53
539
54
    QTouchDevice *m_touchDevice;
540
55
    bool m_leftButtonIsPressed;
541
56
542
57
    bool m_enabled;
545
58
};
59
};
546
59
60
547
61
} // namespace UbuntuToolkit
548
62
549
60
#endif // MOUSE_TOUCH_ADAPTOR_H
63
#endif // MOUSE_TOUCH_ADAPTOR_H
550
61
64
551
=== added file 'src/Ubuntu/UbuntuToolkit/mousetouchadaptor_p.h'
552
--- src/Ubuntu/UbuntuToolkit/mousetouchadaptor_p.h	1970-01-01 00:00:00 +0000
553
+++ src/Ubuntu/UbuntuToolkit/mousetouchadaptor_p.h	2016-04-07 16:01:36 +0000
554
@@ -0,0 +1,77 @@
555
1
/*
556
2
 * Copyright (C) 2016 Canonical, Ltd.
557
3
 *
558
4
 * This program is free software; you can redistribute it and/or modify
559
5
 * it under the terms of the GNU General Public License as published by
560
6
 * the Free Software Foundation; version 3.
561
7
 *
562
8
 * This program is distributed in the hope that it will be useful,
563
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
564
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
565
11
 * GNU General Public License for more details.
566
12
 *
567
13
 * You should have received a copy of the GNU General Public License
568
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
569
15
 *
570
16
 * Authored by: Zsombor Egri <zsombor.egri@canonical.com>
571
17
 */
572
18
573
19
#ifndef MOUSETOUCHADAPTOR_P
574
20
#define MOUSETOUCHADAPTOR_P
575
21
576
22
#include "mousetouchadaptor.h"
577
23
#include <QtCore/private/qobject_p.h>
578
24
#include <QtCore/QAbstractNativeEventFilter>
579
25
#include <QWindow>
580
26
#include <xcb/xcb.h>
581
27
582
28
namespace UbuntuToolkit {
583
29
584
30
class MouseTouchAdaptorPrivate : public QObjectPrivate, public QAbstractNativeEventFilter
585
31
{
586
32
    Q_DECLARE_PUBLIC(MouseTouchAdaptor)
587
33
public:
588
34
    MouseTouchAdaptorPrivate() : QObjectPrivate() {}
589
35
    ~MouseTouchAdaptorPrivate();
590
36
591
37
    virtual void init() {}
592
38
    virtual bool nativeEventFilter(const QByteArray & eventType, void *message, long *result)
593
39
            { Q_UNUSED(eventType); Q_UNUSED(message); Q_UNUSED(result); return false; }
594
40
    bool isEnabled() const;
595
41
    virtual void setEnabled(bool enabled);
596
42
597
43
    QWindow *findQWindowWithXWindowID(WId windowId);
598
44
599
45
    // fields
600
46
    bool enabled{false};
601
47
};
602
48
603
49
#ifdef UBUNTUTOOLKIT_ENABLE_X11_TOUCH_EMULATION
604
50
class X11MouseTouchAdaptorPrivate : public MouseTouchAdaptorPrivate
605
51
{
606
52
    Q_DECLARE_PUBLIC(MouseTouchAdaptor)
607
53
public:
608
54
    X11MouseTouchAdaptorPrivate();
609
55
610
56
    void init() Q_DECL_OVERRIDE;
611
57
    bool nativeEventFilter(const QByteArray & eventType, void *message, long *result) Q_DECL_OVERRIDE;
612
58
    void setEnabled(bool value);
613
59
614
60
    bool xi2HandleEvent(xcb_ge_event_t *event);
615
61
    bool handleButtonPress(WId windowId, uint32_t detail, uint32_t modifiers, int x, int y);
616
62
    bool handleButtonRelease(WId windowId, uint32_t detail, uint32_t modifiers, int x, int y);
617
63
    bool handleMotionNotify(WId windowId, uint32_t modifiers, int x, int y);
618
64
619
65
    bool m_leftButtonIsPressed;
620
66
    bool m_triPressModifier;
621
67
622
68
    bool m_xi2Enabled{false};
623
69
    int m_xi2Minor{-1};
624
70
    int m_xiOpCode, m_xiEventBase, m_xiErrorBase;
625
71
};
626
72
#endif
627
73
628
74
} // namespace UbuntuToolkit
629
75
630
76
#endif // MOUSETOUCHADAPTOR_P
631
77
632
0
78
633
=== added file 'src/Ubuntu/UbuntuToolkit/mousetouchadaptor_x11.cpp'
634
--- src/Ubuntu/UbuntuToolkit/mousetouchadaptor_x11.cpp	1970-01-01 00:00:00 +0000
635
+++ src/Ubuntu/UbuntuToolkit/mousetouchadaptor_x11.cpp	2016-04-07 16:01:36 +0000
636
@@ -0,0 +1,350 @@
637
1
/*
638
2
 * Copyright (C) 2016 Canonical, Ltd.
639
3
 *
640
4
 * This program is free software; you can redistribute it and/or modify
641
5
 * it under the terms of the GNU General Public License as published by
642
6
 * the Free Software Foundation; version 3.
643
7
 *
644
8
 * This program is distributed in the hope that it will be useful,
645
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
646
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
647
11
 * GNU General Public License for more details.
648
12
 *
649
13
 * You should have received a copy of the GNU General Public License
650
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
651
15
 *
652
16
 * Authored by: Zsombor Egri <zsombor.egri@canonical.com>
653
17
 */
654
18
655
19
/* Some parts of the code were copied from the XCB platform plugin of the Qt Toolkit,
656
20
 * which is under the following license:
657
21
 */
658
22
659
23
/****************************************************************************
660
24
**
661
25
** Copyright (C) 2015 The Qt Company Ltd.
662
26
** Contact: http://www.qt.io/licensing/
663
27
**
664
28
** This file is part of the .
665
29
**
666
30
** $QT_BEGIN_LICENSE:LGPL21$
667
31
** Commercial License Usage
668
32
** Licensees holding valid commercial Qt licenses may use this file in
669
33
** accordance with the commercial license agreement provided with the
670
34
** Software or, alternatively, in accordance with the terms contained in
671
35
** a written agreement between you and The Qt Company. For licensing terms
672
36
** and conditions see http://www.qt.io/terms-conditions. For further
673
37
** information use the contact form at http://www.qt.io/contact-us.
674
38
**
675
39
** GNU Lesser General Public License Usage
676
40
** Alternatively, this file may be used under the terms of the GNU Lesser
677
41
** General Public License version 2.1 or version 3 as published by the Free
678
42
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
679
43
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
680
44
** following information to ensure the GNU Lesser General Public License
681
45
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
682
46
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
683
47
**
684
48
** As a special exception, The Qt Company gives you certain additional
685
49
** rights. These rights are described in The Qt Company LGPL Exception
686
50
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
687
51
**
688
52
** $QT_END_LICENSE$
689
53
**
690
54
****************************************************************************/
691
55
692
56
#include "mousetouchadaptor_p.h"
693
57
694
58
#include <qpa/qplatformnativeinterface.h>
695
59
696
60
#include <QCoreApplication>
697
61
#include <QMouseEvent>
698
62
#include <QTest>
699
63
700
64
#include <X11/extensions/XInput2.h>
701
65
#include <X11/extensions/XI2proto.h>
702
66
703
67
using QTest::QTouchEventSequence;
704
68
705
69
namespace {
706
70
707
71
const Qt::KeyboardModifiers TRI_PRESS_MODIFIER = Qt::ShiftModifier|Qt::ControlModifier|Qt::AltModifier;
708
72
709
73
Qt::MouseButton translateMouseButton(xcb_button_t detail)
710
74
{
711
75
    switch (detail) {
712
76
        case 1: return Qt::LeftButton;
713
77
        case 2: return Qt::MidButton;
714
78
        case 3: return Qt::RightButton;
715
79
        // Button values 4-7 are Wheel events
716
80
        default: return Qt::NoButton;
717
81
    }
718
82
}
719
83
720
84
Qt::KeyboardModifiers translateMofidier(uint32_t mod)
721
85
{
722
86
    Qt::KeyboardModifiers qtMod = Qt::NoModifier;
723
87
724
88
    if (mod & 0x01) qtMod |= Qt::ShiftModifier;
725
89
    if (mod & 0x04) qtMod |= Qt::ControlModifier;
726
90
    if (mod & 0x08) qtMod |= Qt::AltModifier;
727
91
    if (mod & 0x80) qtMod |= Qt::MetaModifier;
728
92
729
93
    return qtMod;
730
94
}
731
95
732
96
} // end of anonymous namespace
733
97
734
98
735
99
namespace UbuntuToolkit {
736
100
737
101
X11MouseTouchAdaptorPrivate::X11MouseTouchAdaptorPrivate()
738
102
    : m_leftButtonIsPressed(false)
739
103
    , m_triPressModifier(false)
740
104
{
741
105
    enabled = true;
742
106
}
743
107
744
108
void X11MouseTouchAdaptorPrivate::init()
745
109
{
746
110
    QPlatformNativeInterface *nativeInterface = qGuiApp->platformNativeInterface();
747
111
    Display *xDisplay = static_cast<Display*>(nativeInterface->nativeResourceForIntegration("Display"));
748
112
    if (xDisplay && XQueryExtension(xDisplay, "XInputExtension", &m_xiOpCode, &m_xiEventBase, &m_xiErrorBase)) {
749
113
        int xiMajor = 2;
750
114
        m_xi2Minor = 2; // try 2.2 first, needed for TouchBegin/Update/End
751
115
        if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) {
752
116
            m_xi2Minor = 1; // for smooth scrolling 2.1 is enough
753
117
            if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) {
754
118
                m_xi2Minor = 0; // for tablet support 2.0 is enough
755
119
                m_xi2Enabled = XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) != BadRequest;
756
120
            } else
757
121
                m_xi2Enabled = true;
758
122
        } else {
759
123
            m_xi2Enabled = true;
760
124
        }
761
125
    }
762
126
763
127
    QCoreApplication::instance()->installNativeEventFilter(this);
764
128
}
765
129
766
130
void X11MouseTouchAdaptorPrivate::setEnabled(bool value)
767
131
{
768
132
    if (value != enabled) {
769
133
        enabled = value;
770
134
        Q_EMIT q_func()->enabledChanged(value);
771
135
    }
772
136
}
773
137
774
138
// Starting from the xcb version 1.9.3 struct xcb_ge_event_t has changed:
775
139
// - "pad0" became "extension"
776
140
// - "pad1" and "pad" became "pad0"
777
141
// New and old version of this struct share the following fields:
778
142
// NOTE: API might change again in the next release of xcb in which case this comment will
779
143
// need to be updated to reflect the reality.
780
144
typedef struct qt_xcb_ge_event_t {
781
145
    uint8_t  response_type;
782
146
    uint8_t  extension;
783
147
    uint16_t sequence;
784
148
    uint32_t length;
785
149
    uint16_t event_type;
786
150
} qt_xcb_ge_event_t;
787
151
788
152
bool xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *ev, int opCode)
789
153
{
790
154
    qt_xcb_ge_event_t *event = (qt_xcb_ge_event_t *)ev;
791
155
    // xGenericEvent has "extension" on the second byte, the same is true for xcb_ge_event_t starting from
792
156
    // the xcb version 1.9.3, prior to that it was called "pad0".
793
157
    if (event->extension == opCode) {
794
158
        // xcb event structs contain stuff that wasn't on the wire, the full_sequence field
795
159
        // adds an extra 4 bytes and generic events cookie data is on the wire right after the standard 32 bytes.
796
160
        // Move this data back to have the same layout in memory as it was on the wire
797
161
        // and allow casting, overwriting the full_sequence field.
798
162
        memmove((char*) event + 32, (char*) event + 36, event->length * 4);
799
163
        return true;
800
164
    }
801
165
    return false;
802
166
}
803
167
804
168
static inline qreal fixed1616ToReal(FP1616 val)
805
169
{
806
170
    return qreal(val) / 0x10000;
807
171
}
808
172
809
173
bool X11MouseTouchAdaptorPrivate::xi2HandleEvent(xcb_ge_event_t *event)
810
174
{
811
175
    if (!xi2PrepareXIGenericDeviceEvent(event, m_xiOpCode)) {
812
176
        return false;
813
177
    }
814
178
815
179
    xXIGenericDeviceEvent *xiEvent = reinterpret_cast<xXIGenericDeviceEvent *>(event);
816
180
    xXIDeviceEvent *xiDeviceEvent = 0;
817
181
818
182
    switch (xiEvent->evtype) {
819
183
    case XI_ButtonPress:
820
184
    case XI_ButtonRelease:
821
185
    case XI_Motion:
822
186
        xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
823
187
        break;
824
188
    default:
825
189
        break;
826
190
    }
827
191
828
192
    if (!xiDeviceEvent) {
829
193
        return false;
830
194
    }
831
195
832
196
    switch (xiDeviceEvent->evtype) {
833
197
    case XI_ButtonPress:
834
198
        return handleButtonPress(
835
199
                static_cast<WId>(xiDeviceEvent->event),
836
200
                xiDeviceEvent->detail,
837
201
                xiDeviceEvent->mods.base_mods,
838
202
                fixed1616ToReal(xiDeviceEvent->event_x),
839
203
                fixed1616ToReal(xiDeviceEvent->event_y));
840
204
    case XI_ButtonRelease:
841
205
        return handleButtonRelease(
842
206
                static_cast<WId>(xiDeviceEvent->event),
843
207
                xiDeviceEvent->detail,
844
208
                    xiDeviceEvent->mods.base_mods,
845
209
                fixed1616ToReal(xiDeviceEvent->event_x),
846
210
                fixed1616ToReal(xiDeviceEvent->event_y));
847
211
    case XI_Motion:
848
212
        return handleMotionNotify(
849
213
                static_cast<WId>(xiDeviceEvent->event),
850
214
                xiDeviceEvent->mods.base_mods,
851
215
                fixed1616ToReal(xiDeviceEvent->event_x),
852
216
                fixed1616ToReal(xiDeviceEvent->event_y));
853
217
        return true;
854
218
    default:
855
219
        return false;
856
220
    }
857
221
}
858
222
859
223
bool X11MouseTouchAdaptorPrivate::nativeEventFilter(const QByteArray &eventType, void *message, long *result)
860
224
{
861
225
    Q_UNUSED(result);
862
226
    static int eventCount = 0;
863
227
    eventCount++;
864
228
    if (!enabled) {
865
229
        return false;
866
230
    }
867
231
868
232
    if (eventType != "xcb_generic_event_t") {
869
233
        // wrong backend.
870
234
        qWarning("MouseTouchAdaptor: XCB backend not in use. Adaptor inoperative!");
871
235
        return false;
872
236
    }
873
237
874
238
    xcb_generic_event_t *xcbEvent = static_cast<xcb_generic_event_t *>(message);
875
239
876
240
    switch (xcbEvent->response_type & ~0x80) {
877
241
        case XCB_BUTTON_PRESS: {
878
242
            auto pressEvent = reinterpret_cast<xcb_button_press_event_t *>(xcbEvent);
879
243
            return handleButtonPress(static_cast<WId>(pressEvent->event), pressEvent->detail, 0,
880
244
                    pressEvent->event_x, pressEvent->event_y);
881
245
        }
882
246
        case XCB_BUTTON_RELEASE: {
883
247
            auto releaseEvent = reinterpret_cast<xcb_button_release_event_t *>(xcbEvent);
884
248
            return handleButtonRelease(static_cast<WId>(releaseEvent->event), releaseEvent->detail, 0,
885
249
                    releaseEvent->event_x, releaseEvent->event_y);
886
250
        }
887
251
        case XCB_MOTION_NOTIFY: {
888
252
            auto motionEvent = reinterpret_cast<xcb_motion_notify_event_t *>(xcbEvent);
889
253
            return handleMotionNotify(static_cast<WId>(motionEvent->event), 0,
890
254
                                      motionEvent->event_x, motionEvent->event_y);
891
255
        }
892
256
        case XCB_GE_GENERIC:
893
257
            if (m_xi2Enabled) {
894
258
                return xi2HandleEvent(reinterpret_cast<xcb_ge_event_t *>(xcbEvent));
895
259
            } else {
896
260
                return false;
897
261
            }
898
262
        default:
899
263
            return false;
900
264
    };
901
265
}
902
266
903
267
bool X11MouseTouchAdaptorPrivate::handleButtonPress(WId windowId, uint32_t detail, uint32_t modifiers, int x, int y)
904
268
{
905
269
    Qt::MouseButton button = translateMouseButton(detail);
906
270
    Qt::KeyboardModifiers qtMod = translateMofidier(modifiers);
907
271
908
272
    // Just eat the event if it wasn't a left mouse press
909
273
    if (button != Qt::LeftButton)
910
274
        return true;
911
275
912
276
    QWindow *targetWindow = findQWindowWithXWindowID(windowId);
913
277
914
278
    QPoint windowPos(x / targetWindow->devicePixelRatio(), y / targetWindow->devicePixelRatio());
915
279
916
280
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, MouseTouchAdaptor::touchDevice(),
917
281
                                                       false /* autoCommit */);
918
282
    touchEvent.press(0 /* touchId */, windowPos);
919
283
    if (qtMod == TRI_PRESS_MODIFIER) {
920
284
        touchEvent.press(1, windowPos);
921
285
        touchEvent.press(2, windowPos);
922
286
        m_triPressModifier = true;
923
287
    }
924
288
    touchEvent.commit(false /* processEvents */);
925
289
926
290
    m_leftButtonIsPressed = true;
927
291
    return true;
928
292
}
929
293
930
294
bool X11MouseTouchAdaptorPrivate::handleButtonRelease(WId windowId, uint32_t detail, uint32_t, int x, int y)
931
295
{
932
296
    Qt::MouseButton button = translateMouseButton(detail);
933
297
934
298
    // Don't eat the event if it wasn't a left mouse press
935
299
    if (button != Qt::LeftButton)
936
300
        return false;
937
301
938
302
    QWindow *targetWindow = findQWindowWithXWindowID(windowId);
939
303
940
304
    QPoint windowPos(x / targetWindow->devicePixelRatio(), y / targetWindow->devicePixelRatio());
941
305
942
306
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, MouseTouchAdaptor::touchDevice(),
943
307
                                                       false /* autoCommit */);
944
308
    touchEvent.release(0 /* touchId */, windowPos);
945
309
    if (m_triPressModifier) {
946
310
        touchEvent.release(1, windowPos);
947
311
        touchEvent.release(2, windowPos);
948
312
    }
949
313
    touchEvent.commit(false /* processEvents */);
950
314
951
315
    m_leftButtonIsPressed = false;
952
316
    m_triPressModifier = false;
953
317
    return true;
954
318
}
955
319
956
320
bool X11MouseTouchAdaptorPrivate::handleMotionNotify(WId windowId, uint32_t modifiers, int x, int y)
957
321
{
958
322
    if (!m_leftButtonIsPressed) {
959
323
        return true;
960
324
    }
961
325
    Qt::KeyboardModifiers qtMod = translateMofidier(modifiers);
962
326
963
327
    QWindow *targetWindow = findQWindowWithXWindowID(windowId);
964
328
965
329
    QPoint windowPos(x / targetWindow->devicePixelRatio(), y / targetWindow->devicePixelRatio());
966
330
967
331
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, MouseTouchAdaptor::touchDevice(),
968
332
                                                       false /* autoCommit */);
969
333
    touchEvent.move(0 /* touchId */, windowPos);
970
334
    if (m_triPressModifier) {
971
335
        if (qtMod == TRI_PRESS_MODIFIER) {
972
336
            touchEvent.move(1, windowPos);
973
337
            touchEvent.move(2, windowPos);
974
338
        } else {
975
339
            // released modifiers
976
340
            touchEvent.release(1, windowPos);
977
341
            touchEvent.release(2, windowPos);
978
342
            m_triPressModifier = false;
979
343
        }
980
344
    }
981
345
    touchEvent.commit(false /* processEvents */);
982
346
983
347
    return true;
984
348
}
985
349
986
350
} // namespace UbuntuToolkit
987
0
351
988
=== added file 'tests/autopilot/ubuntuuitoolkit/tests/test_touchadaptor.py'
989
--- tests/autopilot/ubuntuuitoolkit/tests/test_touchadaptor.py	1970-01-01 00:00:00 +0000
990
+++ tests/autopilot/ubuntuuitoolkit/tests/test_touchadaptor.py	2016-04-07 16:01:36 +0000
991
@@ -0,0 +1,38 @@
992
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
993
2
#
994
3
# Copyright (C) 2016 Canonical Ltd.
995
4
#
996
5
# This program is free software; you can redistribute it and/or modify
997
6
# it under the terms of the GNU Lesser General Public License as published by
998
7
# the Free Software Foundation; version 3.
999
8
#
1000
9
# This program is distributed in the hope that it will be useful,
1001
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1002
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1003
12
# GNU Lesser General Public License for more details.
1004
13
#
1005
14
# You should have received a copy of the GNU Lesser General Public License
1006
15
# along with this program. If not, see <http://www.gnu.org/licenses/>.
1007
16
1008
17
import os
1009
18
from testtools.matchers import Equals
1010
19
from autopilot.matchers import Eventually
1011
20
from ubuntuuitoolkit import tests
1012
21
1013
22
1014
23
class TouchAdaptorTestCase(tests.QMLFileAppTestCase):
1015
24
    path = os.path.abspath(__file__)
1016
25
    dir_path = os.path.dirname(path)
1017
26
    test_qml_file_path = os.path.join(
1018
27
        dir_path, 'test_touchadaptor.qml')
1019
28
1020
29
    def get_command_line(self, command_line):
1021
30
        command_line.append('-touch')
1022
31
        return command_line
1023
32
1024
33
    def test_apparent_touch_screen(self):
1025
34
        touchArea = self.main_view.select_single(objectName="touchArea")
1026
35
        label = self.main_view.select_single(objectName="label")
1027
36
        # Trigger handlers as a courtesy to a watching person
1028
37
        self.pointing_device.click_object(touchArea)
1029
38
        self.assertThat(label.text, Eventually(Equals("Touched")))
1030
0
39
1031
=== added file 'tests/autopilot/ubuntuuitoolkit/tests/test_touchadaptor.qml'
1032
--- tests/autopilot/ubuntuuitoolkit/tests/test_touchadaptor.qml	1970-01-01 00:00:00 +0000
1033
+++ tests/autopilot/ubuntuuitoolkit/tests/test_touchadaptor.qml	2016-04-07 16:01:36 +0000
1034
@@ -0,0 +1,51 @@
1035
1
/*
1036
2
 * Copyright 2016 Canonical Ltd.
1037
3
 *
1038
4
 * This program is free software; you can redistribute it and/or modify
1039
5
 * it under the terms of the GNU Lesser General Public License as published by
1040
6
 * the Free Software Foundation; version 3.
1041
7
 *
1042
8
 * This program is distributed in the hope that it will be useful,
1043
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1044
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1045
11
 * GNU Lesser General Public License for more details.
1046
12
 *
1047
13
 * You should have received a copy of the GNU Lesser General Public License
1048
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1049
15
 */
1050
16
1051
17
import QtQuick 2.4
1052
18
import Ubuntu.Components 1.3
1053
19
1054
20
MainView {
1055
21
    width: units.gu(48)
1056
22
    height: units.gu(60)
1057
23
    objectName: "mainView"
1058
24
1059
25
    Page {
1060
26
        title: "TouchAdaptor"
1061
27
1062
28
        MultiPointTouchArea {
1063
29
            id: mpa
1064
30
            property bool touched: false
1065
31
            anchors.fill: parent
1066
32
            mouseEnabled: false
1067
33
            objectName: "touchArea"
1068
34
            touchPoints: TouchPoint {
1069
35
                id: point1
1070
36
                onPressedChanged: {
1071
37
                    if (pressed) {
1072
38
                        label.text = "Touched";
1073
39
                    }
1074
40
                }
1075
41
            }
1076
42
1077
43
            Label {
1078
44
                id: label
1079
45
                objectName: "label"
1080
46
                anchors.centerIn: parent
1081
47
                text: "Not touched"
1082
48
            }
1083
49
        }
1084
50
    }
1085
51
}
1086
0
52
1087
=== modified file 'tests/unit_x11/tst_components/tst_adaptivepagelayout.qml'
1088
--- tests/unit_x11/tst_components/tst_adaptivepagelayout.qml	2016-03-07 06:19:27 +0000
1089
+++ tests/unit_x11/tst_components/tst_adaptivepagelayout.qml	2016-04-07 16:01:36 +0000
1090
@@ -314,6 +314,7 @@
1091
314
            ];
314
            ];
1092
315
        }
315
        }
1093
316
        function test_forced_synchronous_loading_bug1540449(data) {
316
        function test_forced_synchronous_loading_bug1540449(data) {
1094
317
            layout.asynchronous = false;
1095
317
            layout[data.func](layout.primaryPage, data.page);
318
            layout[data.func](layout.primaryPage, data.page);
1096
318
            waitForRendering(layout, 400);
319
            waitForRendering(layout, 400);
1097
319
320
1098
320
321
1099
=== modified file 'ubuntu-sdk.pro'
1100
--- ubuntu-sdk.pro	2015-12-11 13:35:10 +0000
1101
+++ ubuntu-sdk.pro	2016-04-07 16:01:36 +0000
1102
@@ -8,7 +8,10 @@
1103
8
requires(qtHaveModule(quick))
8
requires(qtHaveModule(quick))
1104
9
load(qt_parts)
9
load(qt_parts)
1105
10
10
1107
11
SUBDIRS += po documentation app-launch-profiler ubuntu-ui-toolkit-launcher apicheck
11
src_uitk_launcher.subdir = ubuntu-ui-toolkit-launcher
1108
12
src_uitk_launcher.depends = sub-src
1109
13
1110
14
SUBDIRS += po documentation app-launch-profiler src_uitk_launcher apicheck
1111
12
15
1112
13
sub_tests.CONFIG -= no_default_target
16
sub_tests.CONFIG -= no_default_target
1113
14
sub_tests.CONFIG -= no_default_install
17
sub_tests.CONFIG -= no_default_install
1114
15
18
1115
=== removed file 'ubuntu-ui-toolkit-launcher/MouseTouchAdaptor.cpp'
1116
--- ubuntu-ui-toolkit-launcher/MouseTouchAdaptor.cpp	2014-06-16 09:50:56 +0000
1117
+++ ubuntu-ui-toolkit-launcher/MouseTouchAdaptor.cpp	1970-01-01 00:00:00 +0000
1118
@@ -1,159 +0,0 @@
1119
1
/*
1120
2
 * Copyright 2014 Canonical Ltd.
1121
3
 *
1122
4
 * This program is free software; you can redistribute it and/or modify
1123
5
 * it under the terms of the GNU Lesser General Public License as published by
1124
6
 * the Free Software Foundation; version 3.
1125
7
 *
1126
8
 * This program is distributed in the hope that it will be useful,
1127
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1128
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1129
11
 * GNU Lesser General Public License for more details.
1130
12
 *
1131
13
 * You should have received a copy of the GNU Lesser General Public License
1132
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1133
15
 *
1134
16
 * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
1135
17
 *
1136
18
 */
1137
19
1138
20
#include "MouseTouchAdaptor.h"
1139
21
1140
22
#include <qpa/qwindowsysteminterface.h>
1141
23
1142
24
#include <QtGui/QMouseEvent>
1143
25
#include <QtTest/QTest>
1144
26
1145
27
using QTest::QTouchEventSequence;
1146
28
1147
29
namespace {
1148
30
Qt::MouseButton translateMouseButton(xcb_button_t detail)
1149
31
{
1150
32
    switch (detail) {
1151
33
        case 1: return Qt::LeftButton;
1152
34
        case 2: return Qt::MidButton;
1153
35
        case 3: return Qt::RightButton;
1154
36
        // Button values 4-7 are Wheel events
1155
37
        default: return Qt::NoButton;
1156
38
    }
1157
39
}
1158
40
} // end of anonymous namespace
1159
41
1160
42
MouseTouchAdaptor::MouseTouchAdaptor()
1161
43
    : m_leftButtonIsPressed(false)
1162
44
{
1163
45
    m_touchDevice = new QTouchDevice;
1164
46
    m_touchDevice->setType(QTouchDevice::TouchScreen);
1165
47
    QWindowSystemInterface::registerTouchDevice(m_touchDevice);
1166
48
}
1167
49
1168
50
bool MouseTouchAdaptor::nativeEventFilter(const QByteArray & eventType,
1169
51
                                          void * message, long * /*result*/)
1170
52
{
1171
53
    if (eventType != "xcb_generic_event_t") {
1172
54
        // wrong backend.
1173
55
        qWarning("MouseTouchAdaptor: XCB backend not in use. Adaptor inoperative!");
1174
56
        return false;
1175
57
    }
1176
58
1177
59
    xcb_generic_event_t *xcbEvent = static_cast<xcb_generic_event_t *>(message);
1178
60
1179
61
    switch (xcbEvent->response_type & ~0x80) {
1180
62
        case XCB_BUTTON_PRESS:
1181
63
            return handleButtonPress(reinterpret_cast<xcb_button_press_event_t *>(xcbEvent));
1182
64
            break;
1183
65
        case XCB_BUTTON_RELEASE:
1184
66
            return handleButtonRelease(reinterpret_cast<xcb_button_release_event_t *>(xcbEvent));
1185
67
            break;
1186
68
        case XCB_MOTION_NOTIFY:
1187
69
            return handleMotionNotify(reinterpret_cast<xcb_motion_notify_event_t *>(xcbEvent));
1188
70
            break;
1189
71
        default:
1190
72
            return false;
1191
73
            break;
1192
74
    };
1193
75
}
1194
76
1195
77
bool MouseTouchAdaptor::handleButtonPress(xcb_button_press_event_t *pressEvent)
1196
78
{
1197
79
    Qt::MouseButton button = translateMouseButton(pressEvent->detail);
1198
80
1199
81
    // Skip the event if it wasn't a left mouse press
1200
82
    if (button != Qt::LeftButton) {
1201
83
        return false;
1202
84
    }
1203
85
1204
86
    QPoint windowPos(pressEvent->event_x, pressEvent->event_y);
1205
87
1206
88
    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(pressEvent->event));
1207
89
1208
90
    // no autoCommit
1209
91
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice, false);
1210
92
    touchEvent.press(0, windowPos);
1211
93
    // do not process events when committed, let the events be processed with next event loop
1212
94
    touchEvent.commit(false);
1213
95
1214
96
    m_leftButtonIsPressed = true;
1215
97
    return true;
1216
98
}
1217
99
1218
100
bool MouseTouchAdaptor::handleButtonRelease(xcb_button_release_event_t *releaseEvent)
1219
101
{
1220
102
    Qt::MouseButton button = translateMouseButton(releaseEvent->detail);
1221
103
1222
104
    // Skip the event if it wasn't a left mouse release
1223
105
    if (button != Qt::LeftButton) {
1224
106
        return false;
1225
107
    }
1226
108
1227
109
    QPoint windowPos(releaseEvent->event_x, releaseEvent->event_y);
1228
110
1229
111
    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(releaseEvent->event));
1230
112
1231
113
    // no autoCommit
1232
114
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice, false);
1233
115
    touchEvent.release(0, windowPos);
1234
116
    // do not process events when committed, let the events be processed with next event loop
1235
117
    touchEvent.commit(false);
1236
118
1237
119
    m_leftButtonIsPressed = false;
1238
120
    return true;
1239
121
}
1240
122
1241
123
bool MouseTouchAdaptor::handleMotionNotify(xcb_motion_notify_event_t *event)
1242
124
{
1243
125
    if (!m_leftButtonIsPressed) {
1244
126
        return false;
1245
127
    }
1246
128
1247
129
    QPoint windowPos(event->event_x, event->event_y);
1248
130
1249
131
    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(event->event));
1250
132
1251
133
    // no autoCommit
1252
134
    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice, false);
1253
135
    touchEvent.move(0, windowPos);
1254
136
    // do not process events when committed, let the events be processed with next event loop
1255
137
    touchEvent.commit(false);
1256
138
1257
139
    return true;
1258
140
}
1259
141
1260
142
QWindow *MouseTouchAdaptor::findQWindowWithXWindowID(WId windowId)
1261
143
{
1262
144
    QWindowList windowList = QGuiApplication::topLevelWindows();
1263
145
    QWindow *foundWindow = 0;
1264
146
1265
147
    int i = 0;
1266
148
    while (!foundWindow && i < windowList.count()) {
1267
149
        QWindow *window = windowList[i];
1268
150
        if (window->winId() == windowId) {
1269
151
            foundWindow = window;
1270
152
        } else {
1271
153
            ++i;
1272
154
        }
1273
155
    }
1274
156
1275
157
    Q_ASSERT(foundWindow);
1276
158
    return foundWindow;
1277
159
}
1278
160
0
1279
=== removed file 'ubuntu-ui-toolkit-launcher/MouseTouchAdaptor.h'
1280
--- ubuntu-ui-toolkit-launcher/MouseTouchAdaptor.h	2014-06-16 09:50:56 +0000
1281
+++ ubuntu-ui-toolkit-launcher/MouseTouchAdaptor.h	1970-01-01 00:00:00 +0000
1282
@@ -1,50 +0,0 @@
1283
1
/*
1284
2
 * Copyright 2014 Canonical Ltd.
1285
3
 *
1286
4
 * This program is free software; you can redistribute it and/or modify
1287
5
 * it under the terms of the GNU Lesser General Public License as published by
1288
6
 * the Free Software Foundation; version 3.
1289
7
 *
1290
8
 * This program is distributed in the hope that it will be useful,
1291
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1292
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1293
11
 * GNU Lesser General Public License for more details.
1294
12
 *
1295
13
 * You should have received a copy of the GNU Lesser General Public License
1296
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1297
15
 *
1298
16
 * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
1299
17
 *
1300
18
 */
1301
19
1302
20
#ifndef MOUSE_TOUCH_ADAPTOR_H
1303
21
#define MOUSE_TOUCH_ADAPTOR_H
1304
22
1305
23
#include <QtCore/QAbstractNativeEventFilter>
1306
24
#include <QWindow>
1307
25
#include <xcb/xcb.h>
1308
26
1309
27
class QMouseEvent;
1310
28
class QTouchDevice;
1311
29
1312
30
// Transforms QMouseEvents into single-finger QTouchEvents.
1313
31
class MouseTouchAdaptor : public QAbstractNativeEventFilter {
1314
32
1315
33
public:
1316
34
    MouseTouchAdaptor();
1317
35
1318
36
    // Filters mouse events and posts the equivalent QTouchEvents.
1319
37
    virtual bool nativeEventFilter(const QByteArray & eventType, void *message, long *result);
1320
38
1321
39
private:
1322
40
1323
41
    bool handleButtonPress(xcb_button_press_event_t *pressEvent);
1324
42
    bool handleButtonRelease(xcb_button_release_event_t *releaseEvent);
1325
43
    bool handleMotionNotify(xcb_motion_notify_event_t *event);
1326
44
    QWindow *findQWindowWithXWindowID(WId windowId);
1327
45
1328
46
    QTouchDevice *m_touchDevice;
1329
47
    bool m_leftButtonIsPressed;
1330
48
};
1331
49
1332
50
#endif // MOUSE_TOUCH_ADAPTOR_H
1333
51
0
1334
=== modified file 'ubuntu-ui-toolkit-launcher/launcher.cpp'
1335
--- ubuntu-ui-toolkit-launcher/launcher.cpp	2015-11-13 09:29:40 +0000
1336
+++ ubuntu-ui-toolkit-launcher/launcher.cpp	2016-04-07 16:01:36 +0000
1337
@@ -32,19 +32,10 @@
1338
32
#include <QtQuick/private/qsgcontext_p.h>
32
#include <QtQuick/private/qsgcontext_p.h>
1339
33
#include <QtCore/QCommandLineParser>
33
#include <QtCore/QCommandLineParser>
1340
34
#include <QtCore/QCommandLineOption>
34
#include <QtCore/QCommandLineOption>
1342
35
#include "MouseTouchAdaptor.h"
35
#include <MouseTouchAdaptor>
1343
36
#include <QtGui/QTouchDevice>
36
#include <QtGui/QTouchDevice>
1344
37
#include <QtQml/qqml.h>
37
#include <QtQml/qqml.h>
1345
38
38
1346
39
bool touchDevicePresent()
1347
40
{
1348
41
    Q_FOREACH(const QTouchDevice *device, QTouchDevice::devices()) {
1349
42
        if (device->type() == QTouchDevice::TouchScreen)
1350
43
            return true;
1351
44
    }
1352
45
    return false;
1353
46
}
1354
47
1355
48
static QObject *s_testRootObject = 0;
39
static QObject *s_testRootObject = 0;
1356
49
static QObject *testRootObject(QQmlEngine *engine, QJSEngine *jsEngine)
40
static QObject *testRootObject(QQmlEngine *engine, QJSEngine *jsEngine)
1357
50
{
41
{
1358
@@ -151,9 +142,9 @@
1359
151
        view->setFlags(Qt::FramelessWindowHint);
142
        view->setFlags(Qt::FramelessWindowHint);
1360
152
    }
143
    }
1361
153
144
1363
154
    if (args.isSet(_enableTouch) && !touchDevicePresent()) {
145
    if (args.isSet(_enableTouch)) {
1364
155
        // has no effect if we have touch screen
146
        // has no effect if we have touch screen
1366
156
        application.installNativeEventFilter(new MouseTouchAdaptor);
147
        new UbuntuToolkit::MouseTouchAdaptor(&application);
1367
157
    }
148
    }
1368
158
149
1369
159
    QUrl source(QUrl::fromLocalFile(filename));
150
    QUrl source(QUrl::fromLocalFile(filename));
1370
160
151
1371
=== modified file 'ubuntu-ui-toolkit-launcher/ubuntu-ui-toolkit-launcher.pro'
1372
--- ubuntu-ui-toolkit-launcher/ubuntu-ui-toolkit-launcher.pro	2015-11-19 08:45:15 +0000
1373
+++ ubuntu-ui-toolkit-launcher/ubuntu-ui-toolkit-launcher.pro	2016-04-07 16:01:36 +0000
1374
@@ -1,11 +1,9 @@
1375
1
TEMPLATE = app
1
TEMPLATE = app
1376
2
QT += qml quick
2
QT += qml quick
1377
3
# For setSharedOpenGLContext
3
# For setSharedOpenGLContext
1383
4
QT += core-private gui-private testlib quick-private
4
QT += core-private gui-private testlib quick-private UbuntuToolkit
1384
5
CONFIG += no_keywords
5
CONFIG += no_keywords c++11
1385
6
HEADERS += MouseTouchAdaptor.h
6
SOURCES += launcher.cpp
1381
7
SOURCES += launcher.cpp \
1382
8
    MouseTouchAdaptor.cpp
1386
9
installPath = $$[QT_INSTALL_PREFIX]/bin
7
installPath = $$[QT_INSTALL_PREFIX]/bin
1387
10
launcher.path = $$installPath
8
launcher.path = $$installPath
1388
11
launcher.files = ubuntu-ui-toolkit-launcher
9
launcher.files = ubuntu-ui-toolkit-launcher
Reviewer	Review Type	Date Requested	Status
ubuntu-sdk-build-bot	continuous-integration		Approve on 2016-04-07
Cris Dywan		2016-04-04	Approve on 2016-04-07
Review via email: mp+290858@code.launchpad.net