git.iko.soy/unity8
on xenial help sign in
Implement the FloatingFlickable without needeing the .h of SwipeArea
21dc999Albert Astals Cid
plugins/Ubuntu/Gestures/CMakeLists.txt+1−1
compare with xenial
unifiedsplit
@@ -5,7 +5,7 @@ set(UbuntuGesturesQml_SOURCES
5 plugin.cpp
5 plugin.cpp
6 AxisVelocityCalculator.cpp
6 AxisVelocityCalculator.cpp
7 Direction.cpp
7 Direction.cpp
8−# FloatingFlickable.cpp TODO
8+ FloatingFlickableHelper.cpp
9 PressedOutsideNotifier.cpp
9 PressedOutsideNotifier.cpp
10 TouchDispatcher.cpp
10 TouchDispatcher.cpp
11 TouchGate.cpp
11 TouchGate.cpp
plugins/Ubuntu/Gestures/Direction.h+1
@@ -29,6 +29,7 @@ class UBUNTUGESTURESQML_EXPORT Direction : public QObject {
29 Q_ENUMS(Type)
29 Q_ENUMS(Type)
30
30
31public:
31public:
32+ // Make sure it is kept synchronized with SDK UCSwipeArea::Direction
32 enum Type {
33 enum Type {
33 Rightwards, // Along the positive direction of the X axis
34 Rightwards, // Along the positive direction of the X axis
34 Leftwards, // Along the negative direction of the X axis
35 Leftwards, // Along the negative direction of the X axis
plugins/Ubuntu/Gestures/FloatingFlickable.cppdeleted−150
@@ -1,150 +0,0 @@
1−/*
2− * Copyright (C) 2015 Canonical, Ltd.
3− *
4− * This program is free software; you can redistribute it and/or modify
5− * it under the terms of the GNU General Public License as published by
6− * the Free Software Foundation; version 3.
7− *
8− * This program is distributed in the hope that it will be useful,
9− * but WITHOUT ANY WARRANTY; without even the implied warranty of
10− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11− * GNU General Public License for more details.
12− *
13− * You should have received a copy of the GNU General Public License
14− * along with this program. If not, see <http://www.gnu.org/licenses/>.
15− */
16−
17−#include "FloatingFlickable.h"
18−
19−#include <private/qquickflickable_p.h>
20−#include "DirectionalDragArea.h"
21−
22−#include <QDebug>
23−
24−FloatingFlickable::FloatingFlickable(QQuickItem *parent)
25− : QQuickItem(parent)
26− , m_mousePressed(false)
27−{
28− m_dragArea = new DirectionalDragArea(this);
29− m_dragArea->setWidth(width());
30− m_dragArea->setHeight(height());
31− m_dragArea->setDirection(Direction::Horizontal);
32− connect(m_dragArea, &DirectionalDragArea::touchXChanged,
33− this, &FloatingFlickable::onDragAreaTouchPosChanged);
34− connect(m_dragArea, &DirectionalDragArea::touchYChanged,
35− this, &FloatingFlickable::onDragAreaTouchPosChanged);
36− connect(m_dragArea, &DirectionalDragArea::draggingChanged,
37− this, &FloatingFlickable::onDragAreaDraggingChanged);
38− connect(m_dragArea, &DirectionalDragArea::directionChanged, this, &FloatingFlickable::directionChanged);
39−
40− m_flickable = new QQuickFlickable(this);
41− m_flickable->setEnabled(false);
42− m_flickable->setWidth(width());
43− m_flickable->setHeight(height());
44− connect(m_flickable, &QQuickFlickable::contentWidthChanged, this, &FloatingFlickable::contentWidthChanged);
45− connect(m_flickable, &QQuickFlickable::contentHeightChanged, this, &FloatingFlickable::contentHeightChanged);
46− connect(m_flickable, &QQuickFlickable::contentXChanged, this, &FloatingFlickable::contentXChanged);
47− connect(m_flickable, &QQuickFlickable::contentYChanged, this, &FloatingFlickable::contentYChanged);
48−
49− connect(this, &QQuickItem::widthChanged, this, &FloatingFlickable::updateChildrenWidth);
50− connect(this, &QQuickItem::heightChanged, this, &FloatingFlickable::updateChildrenHeight);
51−}
52−
53−qreal FloatingFlickable::contentWidth() const
54−{
55− return m_flickable->contentWidth();
56−}
57−
58−void FloatingFlickable::setContentWidth(qreal contentWidth)
59−{
60− m_flickable->setContentWidth(contentWidth);
61−}
62−
63−qreal FloatingFlickable::contentHeight() const
64−{
65− return m_flickable->contentHeight();
66−}
67−
68−void FloatingFlickable::setContentHeight(qreal contentHeight)
69−{
70− m_flickable->setContentHeight(contentHeight);
71−}
72−
73−qreal FloatingFlickable::contentX() const
74−{
75− return m_flickable->contentX();
76−}
77−
78−void FloatingFlickable::setContentX(qreal contentX)
79−{
80− m_flickable->setContentX(contentX);
81−}
82−
83−qreal FloatingFlickable::contentY() const
84−{
85− return m_flickable->contentY();
86−}
87−
88−void FloatingFlickable::setContentY(qreal contentY)
89−{
90− m_flickable->setContentY(contentY);
91−}
92−
93−Direction::Type FloatingFlickable::direction() const
94−{
95− return m_dragArea->direction();
96−}
97−
98−void FloatingFlickable::setDirection(Direction::Type direction)
99−{
100− m_dragArea->setDirection(direction);
101− if (Direction::isHorizontal(direction)) {
102− m_flickable->setFlickableDirection(QQuickFlickable::HorizontalFlick);
103− } else {
104− m_flickable->setFlickableDirection(QQuickFlickable::VerticalFlick);
105− }
106−}
107−
108−void FloatingFlickable::updateChildrenWidth()
109−{
110− m_dragArea->setWidth(width());
111− m_flickable->setWidth(width());
112−}
113−
114−void FloatingFlickable::updateChildrenHeight()
115−{
116− m_dragArea->setHeight(height());
117− m_flickable->setHeight(height());
118−}
119−
120−void FloatingFlickable::onDragAreaTouchPosChanged(qreal)
121−{
122− if (m_mousePressed) {
123− QMouseEvent mouseEvent(QEvent::MouseMove,
124− QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
125− Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
126−
127− QCoreApplication::sendEvent(m_flickable, &mouseEvent);
128−
129− }
130−}
131−
132−void FloatingFlickable::onDragAreaDraggingChanged(bool dragging)
133−{
134− if (dragging && !m_mousePressed) {
135− QMouseEvent mouseEvent(QEvent::MouseButtonPress,
136− QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
137− Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
138−
139− QCoreApplication::sendEvent(m_flickable, &mouseEvent);
140− m_mousePressed = true;
141−
142− } else if (!dragging && m_mousePressed) {
143− QMouseEvent mouseEvent(QEvent::MouseButtonRelease,
144− QPointF(m_dragArea->touchX(),m_dragArea->touchY()),
145− Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
146−
147− QCoreApplication::sendEvent(m_flickable, &mouseEvent);
148− m_mousePressed = false;
149− }
150−}
plugins/Ubuntu/Gestures/FloatingFlickable.hdeleted−86
@@ -1,86 +0,0 @@
1−/*
2− * Copyright (C) 2015 Canonical, Ltd.
3− *
4− * This program is free software; you can redistribute it and/or modify
5− * it under the terms of the GNU General Public License as published by
6− * the Free Software Foundation; version 3.
7− *
8− * This program is distributed in the hope that it will be useful,
9− * but WITHOUT ANY WARRANTY; without even the implied warranty of
10− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11− * GNU General Public License for more details.
12− *
13− * You should have received a copy of the GNU General Public License
14− * along with this program. If not, see <http://www.gnu.org/licenses/>.
15− */
16−
17−#ifndef FLOATING_FLICKABLE_H
18−#define FLOATING_FLICKABLE_H
19−
20−#include <QQuickItem>
21−#include "UbuntuGesturesQmlGlobal.h"
22−#include "Direction.h"
23−
24−class DirectionalDragArea;
25−class QQuickFlickable;
26−
27−/*
28− A Flickable that can be put in front of the item to be flicked and
29− still have the item-to-be-flicked receive input events that are not flicks.
30−
31− Ie, it's a Flickable that, input-wise, is transparent to non-flick gestures.
32−
33− With a regular Flickable you would have to make the item-to-be-flicked a child
34− of Flicakble to achieve the same result. FloatingFlickable has no such requirement
35− or limitation.
36− */
37−class UBUNTUGESTURESQML_EXPORT FloatingFlickable : public QQuickItem {
38− Q_OBJECT
39−
40− Q_PROPERTY(qreal contentWidth READ contentWidth WRITE setContentWidth NOTIFY contentWidthChanged)
41− Q_PROPERTY(qreal contentHeight READ contentHeight WRITE setContentHeight NOTIFY contentHeightChanged)
42− Q_PROPERTY(qreal contentX READ contentX WRITE setContentX NOTIFY contentXChanged)
43− Q_PROPERTY(qreal contentY READ contentY WRITE setContentY NOTIFY contentYChanged)
44−
45− Q_PROPERTY(Direction::Type direction READ direction WRITE setDirection NOTIFY directionChanged)
46−
47−Q_SIGNALS:
48− void contentWidthChanged();
49− void contentHeightChanged();
50− void contentXChanged();
51− void contentYChanged();
52− void directionChanged();
53−
54−public:
55− FloatingFlickable(QQuickItem *parent = nullptr);
56−
57− qreal contentWidth() const;
58− void setContentWidth(qreal contentWidth);
59−
60− qreal contentHeight() const;
61− void setContentHeight(qreal contentHeight);
62−
63− qreal contentX() const;
64− void setContentX(qreal contentX);
65−
66− qreal contentY() const;
67− void setContentY(qreal contentY);
68−
69− Direction::Type direction() const;
70− void setDirection(Direction::Type);
71−
72−private Q_SLOTS:
73− void updateChildrenWidth();
74− void updateChildrenHeight();
75− void onDragAreaTouchPosChanged(qreal);
76− void onDragAreaDraggingChanged(bool value);
77−
78−private:
79− DirectionalDragArea *m_dragArea;
80− QQuickFlickable *m_flickable;
81− bool m_mousePressed;
82−
83− friend class tst_FloatingFlickable;
84−};
85−
86−#endif // FLOATING_FLICKABLE_H
plugins/Ubuntu/Gestures/FloatingFlickableHelper.cppnew file+59
@@ -0,0 +1,59 @@
1+/*
2+ * Copyright (C) 2015 Canonical, Ltd.
3+ *
4+ * This program is free software; you can redistribute it and/or modify
5+ * it under the terms of the GNU General Public License as published by
6+ * the Free Software Foundation; version 3.
7+ *
8+ * This program is distributed in the hope that it will be useful,
9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11+ * GNU General Public License for more details.
12+ *
13+ * You should have received a copy of the GNU General Public License
14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
15+ */
16+
17+#include "FloatingFlickableHelper.h"
18+
19+#include <QCoreApplication>
20+#include <QMouseEvent>
21+#include <QQuickItem>
22+
23+FloatingFlickableHelper::FloatingFlickableHelper(QObject *parent)
24+ : QObject(parent)
25+ , m_mousePressed(false)
26+{
27+}
28+
29+void FloatingFlickableHelper::onDragAreaTouchPosChanged(QQuickItem *flickable, const QPointF touchPosition)
30+{
31+ if (m_mousePressed) {
32+ QMouseEvent mouseEvent(QEvent::MouseMove,
33+ QPointF(touchPosition.x(), touchPosition.y()),
34+ Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
35+
36+ QCoreApplication::sendEvent(flickable, &mouseEvent);
37+
38+ }
39+}
40+
41+void FloatingFlickableHelper::onDragAreaDraggingChanged(QQuickItem *flickable, bool dragging, const QPointF touchPosition)
42+{
43+ if (dragging && !m_mousePressed) {
44+ QMouseEvent mouseEvent(QEvent::MouseButtonPress,
45+ QPointF(touchPosition.x(), touchPosition.y()),
46+ Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
47+
48+ QCoreApplication::sendEvent(flickable, &mouseEvent);
49+ m_mousePressed = true;
50+
51+ } else if (!dragging && m_mousePressed) {
52+ QMouseEvent mouseEvent(QEvent::MouseButtonRelease,
53+ QPointF(touchPosition.x(), touchPosition.y()),
54+ Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
55+
56+ QCoreApplication::sendEvent(flickable, &mouseEvent);
57+ m_mousePressed = false;
58+ }
59+}
plugins/Ubuntu/Gestures/FloatingFlickableHelper.hnew file+42
@@ -0,0 +1,42 @@
1+/*
2+ * Copyright (C) 2015 Canonical, Ltd.
3+ *
4+ * This program is free software; you can redistribute it and/or modify
5+ * it under the terms of the GNU General Public License as published by
6+ * the Free Software Foundation; version 3.
7+ *
8+ * This program is distributed in the hope that it will be useful,
9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11+ * GNU General Public License for more details.
12+ *
13+ * You should have received a copy of the GNU General Public License
14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
15+ */
16+
17+#ifndef FLOATING_FLICKABLE_HELPER_H
18+#define FLOATING_FLICKABLE_HELPER_H
19+
20+#include <QObject>
21+#include <QPointF>
22+
23+#include "UbuntuGesturesQmlGlobal.h"
24+
25+class QQuickItem;
26+
27+class UBUNTUGESTURESQML_EXPORT FloatingFlickableHelper : public QObject {
28+ Q_OBJECT
29+
30+public:
31+ FloatingFlickableHelper(QObject *parent = nullptr);
32+
33+ Q_INVOKABLE void onDragAreaTouchPosChanged(QQuickItem *flickable, const QPointF touchPosition);
34+ Q_INVOKABLE void onDragAreaDraggingChanged(QQuickItem *flickable, bool dragging, const QPointF touchPosition);
35+
36+private:
37+ bool m_mousePressed;
38+
39+ friend class tst_FloatingFlickable;
40+};
41+
42+#endif
plugins/Ubuntu/Gestures/plugin.cpp+2−2
@@ -17,7 +17,7 @@
17#include "plugin.h"
17#include "plugin.h"
18#include "AxisVelocityCalculator.h"
18#include "AxisVelocityCalculator.h"
19#include "Direction.h"
19#include "Direction.h"
20−#include "FloatingFlickable.h"
20+#include "FloatingFlickableHelper.h"
21#include "PressedOutsideNotifier.h"
21#include "PressedOutsideNotifier.h"
22#include "TouchGate.h"
22#include "TouchGate.h"
23
23
@@ -33,7 +33,7 @@ void UbuntuGesturesQmlPlugin::registerTypes(const char *uri)
33{
33{
34 qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);
34 qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);
35 qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");
35 qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");
36−// qmlRegisterType<FloatingFlickable>(uri, 0, 1, "FloatingFlickable"); TODO
36+ qmlRegisterType<FloatingFlickableHelper>(uri, 0, 1, "FloatingFlickableHelper");
37 qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");
37 qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");
38 qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");
38 qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");
39}
39}
qml/Components/FloatingFlickable.qmlnew file+57
@@ -0,0 +1,57 @@
1+/*
2+ * Copyright (C) 2013 Canonical, Ltd.
3+ *
4+ * This program is free software; you can redistribute it and/or modify
5+ * it under the terms of the GNU General Public License as published by
6+ * the Free Software Foundation; version 3.
7+ *
8+ * This program is distributed in the hope that it will be useful,
9+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
10+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11+ * GNU General Public License for more details.
12+ *
13+ * You should have received a copy of the GNU General Public License
14+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
15+ */
16+
17+import QtQuick 2.4
18+import Ubuntu.Components 1.3
19+import Ubuntu.Gestures 0.1
20+
21+/*
22+ A Flickable that can be put in front of the item to be flicked and
23+ still have the item-to-be-flicked receive input events that are not flicks.
24+
25+ Ie, it's a Flickable that, input-wise, is transparent to non-flick gestures.
26+
27+ With a regular Flickable you would have to make the item-to-be-flicked a child
28+ of Flicakble to achieve the same result. FloatingFlickable has no such requirement
29+ or limitation.
30+ */
31+Item {
32+ property alias contentWidth: flickable.contentWidth
33+ property alias contentHeight: flickable.contentHeight
34+ property alias contentX: flickable.contentX
35+ property alias contentY: flickable.contentY
36+ property alias direction: swipeArea.direction
37+
38+ FloatingFlickableHelper {
39+ id: ffh
40+ }
41+
42+ Flickable {
43+ id: flickable
44+ enabled: false
45+ anchors.fill: parent
46+ flickableDirection: Direction.isHorizontal(swipeArea.direction) ? Flickable.HorizontalFlick : Flickable.VerticalFlick
47+ }
48+
49+ SwipeArea {
50+ id: swipeArea
51+ anchors.fill: parent
52+ direction: Direction.Horizontal
53+
54+ onTouchPositionChanged: ffh.onDragAreaTouchPosChanged(flickable, touchPosition);
55+ onDraggingChanged: ffh.onDragAreaDraggingChanged(flickable, dragging, touchPosition);
56+ }
57+}
qml/Stages/DesktopSpread.qml+1
@@ -19,6 +19,7 @@ import QtQuick.Layouts 1.1
19import Ubuntu.Components 1.3
19import Ubuntu.Components 1.3
20import Ubuntu.Gestures 0.1
20import Ubuntu.Gestures 0.1
21import Unity.Application 0.1
21import Unity.Application 0.1
22+import "../Components"
22
23
23FocusScope {
24FocusScope {
24 id: root
25 id: root
tests/plugins/Ubuntu/Gestures/CMakeLists.txt+1−1
@@ -41,7 +41,7 @@ macro(add_gesture_ui_test CLASSNAME)
41 add_manual_qml_test(. ${CLASSNAME} IMPORT_PATHS ${UNITY_PLUGINPATH})
41 add_manual_qml_test(. ${CLASSNAME} IMPORT_PATHS ${UNITY_PLUGINPATH})
42endmacro()
42endmacro()
43
43
44−# TODO add_gesture_ui_test(FloatingFlickable)
44+add_gesture_ui_test(FloatingFlickable)
45add_gesture_ui_test(PressedOutsideNotifier)
45add_gesture_ui_test(PressedOutsideNotifier)
46add_gesture_ui_test(TouchDispatcher)
46add_gesture_ui_test(TouchDispatcher)
47add_gesture_ui_test(TouchGate)
47add_gesture_ui_test(TouchGate)
tests/plugins/Ubuntu/Gestures/tst_FloatingFlickable.cpp+14−17
@@ -17,12 +17,9 @@
17#include <QtTest>
17#include <QtTest>
18#include <QQuickView>
18#include <QQuickView>
19
19
20−// Ubuntu.Gestures plugin
21−#include <DirectionalDragArea.h>
22−#include <FloatingFlickable.h>
23−
24#include "GestureTest.h"
20#include "GestureTest.h"
25#include "TestItem.h"
21#include "TestItem.h"
22+#include "Direction.h"
26
23
27using namespace UbuntuGestures;
24using namespace UbuntuGestures;
28
25
@@ -44,8 +41,8 @@ tst_FloatingFlickable::tst_FloatingFlickable()
44
41
45void tst_FloatingFlickable::tapGoesThrough()
42void tst_FloatingFlickable::tapGoesThrough()
46{
43{
47− FloatingFlickable *floatingFlickable =
44+ QQuickItem *floatingFlickable =
48− m_view->rootObject()->findChild<FloatingFlickable*>("floatingFlickable");
45+ m_view->rootObject()->findChild<QQuickItem*>("floatingFlickable");
49 QVERIFY(floatingFlickable != nullptr);
46 QVERIFY(floatingFlickable != nullptr);
50
47
51 TestItem *testItem = new TestItem;
48 TestItem *testItem = new TestItem;
@@ -64,13 +61,13 @@ void tst_FloatingFlickable::tapGoesThrough()
64
61
65void tst_FloatingFlickable::flickChangesContentX()
62void tst_FloatingFlickable::flickChangesContentX()
66{
63{
67− FloatingFlickable *floatingFlickable =
64+ QQuickItem *floatingFlickable =
68− m_view->rootObject()->findChild<FloatingFlickable*>("floatingFlickable");
65+ m_view->rootObject()->findChild<QQuickItem*>("floatingFlickable");
69 QVERIFY(floatingFlickable != nullptr);
66 QVERIFY(floatingFlickable != nullptr);
70
67
71− floatingFlickable->m_dragArea->removeTimeConstraints();
68+// TODO? floatingFlickable->m_dragArea->removeTimeConstraints();
72
69
73− qreal startContentX = floatingFlickable->contentX();
70+ qreal startContentX = floatingFlickable->property("contentX").toReal();
74
71
75 QPoint startPos(floatingFlickable->width() - 5, 10);
72 QPoint startPos(floatingFlickable->width() - 5, 10);
76 int stepCount = 20;
73 int stepCount = 20;
@@ -86,19 +83,19 @@ void tst_FloatingFlickable::flickChangesContentX()
86 QTest::qWait(10);
83 QTest::qWait(10);
87 QTest::touchEvent(m_view, m_device).release(0, QPoint(5, 10));
84 QTest::touchEvent(m_view, m_device).release(0, QPoint(5, 10));
88
85
89− QVERIFY(floatingFlickable->contentX() > (startContentX + floatingFlickable->width()/2));
86+ QVERIFY(floatingFlickable->property("contentX").toReal() > (startContentX + floatingFlickable->width()/2));
90}
87}
91
88
92void tst_FloatingFlickable::flickChangesContentY()
89void tst_FloatingFlickable::flickChangesContentY()
93{
90{
94− FloatingFlickable *floatingFlickable =
91+ QQuickItem *floatingFlickable =
95− m_view->rootObject()->findChild<FloatingFlickable*>("floatingFlickable");
92+ m_view->rootObject()->findChild<QQuickItem*>("floatingFlickable");
96 QVERIFY(floatingFlickable != nullptr);
93 QVERIFY(floatingFlickable != nullptr);
97
94
98− floatingFlickable->setDirection(Direction::Vertical);
95+ floatingFlickable->setProperty("direction", Direction::Vertical);
99− floatingFlickable->m_dragArea->removeTimeConstraints();
96+// TODO? floatingFlickable->m_dragArea->removeTimeConstraints();
100
97
101− qreal startContentY = floatingFlickable->contentY();
98+ qreal startContentY = floatingFlickable->property("contentY").toReal();
102
99
103 QPoint startPos(10, floatingFlickable->height() - 5);
100 QPoint startPos(10, floatingFlickable->height() - 5);
104 int stepCount = 20;
101 int stepCount = 20;
@@ -114,7 +111,7 @@ void tst_FloatingFlickable::flickChangesContentY()
114 QTest::qWait(10);
111 QTest::qWait(10);
115 QTest::touchEvent(m_view, m_device).release(0, QPoint(10, 5));
112 QTest::touchEvent(m_view, m_device).release(0, QPoint(10, 5));
116
113
117− QVERIFY(floatingFlickable->contentY() > (startContentY + floatingFlickable->height()/2));
114+ QVERIFY(floatingFlickable->property("contentY").toReal() > (startContentY + floatingFlickable->height()/2));
118}
115}
119
116
120QTEST_MAIN(tst_FloatingFlickable)
117QTEST_MAIN(tst_FloatingFlickable)
tests/plugins/Ubuntu/Gestures/tst_FloatingFlickable.qml+1
@@ -18,6 +18,7 @@ import QtQuick 2.4
18import Ubuntu.Components 1.3
18import Ubuntu.Components 1.3
19import Ubuntu.Gestures 0.1
19import Ubuntu.Gestures 0.1
20import Unity.Test 0.1
20import Unity.Test 0.1
21+import "../../../../../qml/Components"
21
22
22Rectangle {
23Rectangle {
23 id: root
24 id: root
tests/qmltests/Components/CMakeLists.txt+5−6
@@ -12,13 +12,12 @@ include_directories(
12 ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
12 ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
13 )
13 )
14
14
15−# TODO
16−# add_executable(DragHandleTestExec tst_DragHandle.cpp)
15+add_executable(DragHandleTestExec tst_DragHandle.cpp)
17−# qt5_use_modules(DragHandleTestExec Test Core Qml Gui Quick)
16+qt5_use_modules(DragHandleTestExec Test Core Qml Gui Quick)
18−# target_link_libraries(DragHandleTestExec UbuntuGesturesQml ${UBUNTUGESTURES_LIBRARIES})
17+target_link_libraries(DragHandleTestExec UbuntuGesturesQml ${UBUNTUGESTURES_LIBRARIES})
19
18
20−# add_unity8_uitest(DragHandle DragHandleTestExec ENVIRONMENT LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/plugins/Ubuntu/Gestures)
19+add_unity8_uitest(DragHandle DragHandleTestExec ENVIRONMENT LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/plugins/Ubuntu/Gestures)
21−# add_manual_qml_test(. DragHandle IMPORT_PATHS ${UNITY_PLUGINPATH})
20+add_manual_qml_test(. DragHandle IMPORT_PATHS ${UNITY_PLUGINPATH})
22
21
23########## tst_EdgeDragEvaluator
22########## tst_EdgeDragEvaluator
24add_executable(EdgeDragEvaluatorTestExec tst_EdgeDragEvaluator.cpp)
23add_executable(EdgeDragEvaluatorTestExec tst_EdgeDragEvaluator.cpp)
tests/qmltests/Components/tst_DragHandle.cpp+20−18
@@ -24,6 +24,7 @@
24
24
25#include <AxisVelocityCalculator.h>
25#include <AxisVelocityCalculator.h>
26#include <Timer>
26#include <Timer>
27+#include "Direction.h"
27
28
28using namespace UbuntuGestures;
29using namespace UbuntuGestures;
29
30
@@ -49,11 +50,11 @@ private Q_SLOTS:
49 void hintingAnimation_dontRestartAfterFinishedAndStillPressed();
50 void hintingAnimation_dontRestartAfterFinishedAndStillPressed();
50
51
51private:
52private:
52− void flickAndHold(DirectionalDragArea *dragHandle, qreal distance);
53+ void flickAndHold(QQuickItem *dragHandle, qreal distance);
53 void drag(QPointF &touchPoint, const QPointF& direction, qreal distance,
54 void drag(QPointF &touchPoint, const QPointF& direction, qreal distance,
54 int numSteps, qint64 timeMs = 500);
55 int numSteps, qint64 timeMs = 500);
55− DirectionalDragArea *fetchAndSetupDragHandle(const char *objectName);
56+ QQuickItem *fetchAndSetupDragHandle(const char *objectName);
56− qreal fetchDragThreshold(DirectionalDragArea *dragHandle);
57+ qreal fetchDragThreshold(QQuickItem *dragHandle);
57 void tryCompare(std::function<qreal ()> actualFunc, qreal expectedValue);
58 void tryCompare(std::function<qreal ()> actualFunc, qreal expectedValue);
58
59
59 QQuickView *createView();
60 QQuickView *createView();
@@ -128,11 +129,11 @@ void tst_DragHandle::tryCompare(std::function<qreal ()> actualFunc,
128}
129}
129
130
130namespace {
131namespace {
131−QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea)
132+QPointF calculateDirectionVector(QQuickItem *edgeDragArea)
132{
133{
133 QPointF localOrigin(0., 0.);
134 QPointF localOrigin(0., 0.);
134 QPointF localDirection;
135 QPointF localDirection;
135− switch (edgeDragArea->direction()) {
136+ switch (edgeDragArea->property("direction").toInt()) {
136 case Direction::Upwards:
137 case Direction::Upwards:
137 localDirection.rx() = 0.;
138 localDirection.rx() = 0.;
138 localDirection.ry() = -1.;
139 localDirection.ry() = -1.;
@@ -156,7 +157,7 @@ QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea)
156}
157}
157}
158}
158
159
159−void tst_DragHandle::flickAndHold(DirectionalDragArea *dragHandle,
160+void tst_DragHandle::flickAndHold(QQuickItem *dragHandle,
160 qreal distance)
161 qreal distance)
161{
162{
162 QPointF initialTouchPos = dragHandle->mapToScene(
163 QPointF initialTouchPos = dragHandle->mapToScene(
@@ -194,13 +195,14 @@ void tst_DragHandle::drag(QPointF &touchPoint, const QPointF& direction, qreal d
194 }
195 }
195}
196}
196
197
197−DirectionalDragArea *tst_DragHandle::fetchAndSetupDragHandle(const char *objectName)
198+QQuickItem *tst_DragHandle::fetchAndSetupDragHandle(const char *objectName)
198{
199{
199− DirectionalDragArea *dragHandle =
200+ QQuickItem *dragHandle =
200− m_view->rootObject()->findChild<DirectionalDragArea*>(objectName);
201+ m_view->rootObject()->findChild<QQuickItem*>(objectName);
201 Q_ASSERT(dragHandle != 0);
202 Q_ASSERT(dragHandle != 0);
203+ QObject *swipeAreaPrivate = dragHandle->findChild<QObject*>("UCSwipeAreaPrivate");
202− dragHandle->d->setRecognitionTimer(m_fakeTimer);
204+ QMetaObject::invokeMethod(swipeAreaPrivate, "setRecognitionTimer", Q_ARG(UbuntuGestures::AbstractTimer*, m_fakeTimer));
203− dragHandle->d->setTimeSource(m_fakeTimeSource);
205+ QMetaObject::invokeMethod(swipeAreaPrivate, "setTimeSource", Q_ARG(UbuntuGestures::SharedTimeSource, m_fakeTimeSource));
204
206
205 AxisVelocityCalculator *edgeDragEvaluator =
207 AxisVelocityCalculator *edgeDragEvaluator =
206 dragHandle->findChild<AxisVelocityCalculator*>("edgeDragEvaluator");
208 dragHandle->findChild<AxisVelocityCalculator*>("edgeDragEvaluator");
@@ -210,7 +212,7 @@ DirectionalDragArea *tst_DragHandle::fetchAndSetupDragHandle(const char *objectN
210 return dragHandle;
212 return dragHandle;
211}
213}
212
214
213−qreal tst_DragHandle::fetchDragThreshold(DirectionalDragArea *dragHandle)
215+qreal tst_DragHandle::fetchDragThreshold(QQuickItem *dragHandle)
214{
216{
215 AxisVelocityCalculator *edgeDragEvaluator =
217 AxisVelocityCalculator *edgeDragEvaluator =
216 dragHandle->findChild<AxisVelocityCalculator*>("edgeDragEvaluator");
218 dragHandle->findChild<AxisVelocityCalculator*>("edgeDragEvaluator");
@@ -231,7 +233,7 @@ void tst_DragHandle::dragThreshold_horizontal()
231 QQuickItem *baseItem = m_view->rootObject()->findChild<QQuickItem*>("baseItem");
233 QQuickItem *baseItem = m_view->rootObject()->findChild<QQuickItem*>("baseItem");
232 baseItem->setRotation(rotation);
234 baseItem->setRotation(rotation);
233
235
234− DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");
236+ QQuickItem *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");
235 QQuickItem *parentItem = dragHandle->parentItem();
237 QQuickItem *parentItem = dragHandle->parentItem();
236
238
237 qreal dragThreshold = fetchDragThreshold(dragHandle);
239 qreal dragThreshold = fetchDragThreshold(dragHandle);
@@ -284,7 +286,7 @@ void tst_DragHandle::dragThreshold_vertical()
284 QQuickItem *baseItem = m_view->rootObject()->findChild<QQuickItem*>("baseItem");
286 QQuickItem *baseItem = m_view->rootObject()->findChild<QQuickItem*>("baseItem");
285 baseItem->setRotation(rotation);
287 baseItem->setRotation(rotation);
286
288
287− DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
289+ QQuickItem *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
288
290
289 qreal dragThreshold = fetchDragThreshold(dragHandle);
291 qreal dragThreshold = fetchDragThreshold(dragHandle);
290
292
@@ -336,7 +338,7 @@ void tst_DragHandle::dragThreshold_vertical_data()
336 */
338 */
337void tst_DragHandle::stretch_horizontal()
339void tst_DragHandle::stretch_horizontal()
338{
340{
339− DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");
341+ QQuickItem *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");
340 qreal totalDragDistance = dragHandle->property("maxTotalDragDistance").toReal();
342 qreal totalDragDistance = dragHandle->property("maxTotalDragDistance").toReal();
341 QQuickItem *parentItem = dragHandle->parentItem();
343 QQuickItem *parentItem = dragHandle->parentItem();
342
344
@@ -366,7 +368,7 @@ void tst_DragHandle::stretch_horizontal()
366
368
367void tst_DragHandle::stretch_vertical()
369void tst_DragHandle::stretch_vertical()
368{
370{
369− DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
371+ QQuickItem *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
370 qreal totalDragDistance = dragHandle->property("maxTotalDragDistance").toReal();
372 qreal totalDragDistance = dragHandle->property("maxTotalDragDistance").toReal();
371 QQuickItem *parentItem = dragHandle->parentItem();
373 QQuickItem *parentItem = dragHandle->parentItem();
372
374
@@ -402,7 +404,7 @@ void tst_DragHandle::stretch_vertical()
402 */
404 */
403void tst_DragHandle::hintingAnimation()
405void tst_DragHandle::hintingAnimation()
404{
406{
405− DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
407+ QQuickItem *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
406 QQuickItem *parentItem = dragHandle->parentItem();
408 QQuickItem *parentItem = dragHandle->parentItem();
407 qreal hintDisplacement = 100.0;
409 qreal hintDisplacement = 100.0;
408
410
@@ -443,7 +445,7 @@ void tst_DragHandle::hintingAnimation()
443 */
445 */
444void tst_DragHandle::hintingAnimation_dontRestartAfterFinishedAndStillPressed()
446void tst_DragHandle::hintingAnimation_dontRestartAfterFinishedAndStillPressed()
445{
447{
446− DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
448+ QQuickItem *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
447 QQuickItem *parentItem = dragHandle->parentItem();
449 QQuickItem *parentItem = dragHandle->parentItem();
448 qreal hintDisplacement = 100.0;
450 qreal hintDisplacement = 100.0;
449
451