c52616d · unity8 · git.iko.soy

plugins/Ubuntu/Gestures/CMakeLists.txt+1

compare with xenial

unifiedsplit

@@ -7,6 +7,7 @@ set(UbuntuGesturesQml_SOURCES

7 Damper.cpp

8 Direction.cpp

9 DirectionalDragArea.cpp

10+ FloatingFlickable.cpp

10 PressedOutsideNotifier.cpp

11 PressedOutsideNotifier.cpp

11 TouchDispatcher.cpp

12 TouchDispatcher.cpp

12 TouchGate.cpp

13 TouchGate.cpp

plugins/Ubuntu/Gestures/Direction.cpp+6−3

@@ -1,5 +1,5 @@

1/*

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

@@ -25,12 +25,15 @@ bool Direction::isHorizontal(Direction::Type type)

25

26bool Direction::isVertical(Direction::Type type)

27{

28− return type == Direction::Upwards || type == Direction::Downwards;

28+ return type == Direction::Upwards

29+ || type == Direction::Downwards

30+ || type == Direction::Vertical;

29}

31}

30

32

31bool Direction::isPositive(Direction::Type type)

33bool Direction::isPositive(Direction::Type type)

32{

34{

33 return type == Rightwards

35 return type == Rightwards

34 || type == Downwards

36 || type == Downwards

35− || type == Horizontal;

37+ || type == Horizontal

38+ || type == Vertical;

36}

39}

plugins/Ubuntu/Gestures/Direction.h+3−2

@@ -1,5 +1,5 @@

1/*

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

@@ -34,7 +34,8 @@ public:

34 Leftwards, // Along the negative direction of the X axis

35 Downwards, // Along the positive direction of the Y axis

36 Upwards, // Along the negative direction of the Y axis

37− Horizontal // Along the X axis, in any direction

37+ Horizontal, // Along the X axis, in any direction

38+ Vertical // Along the Y axis, in any direction

38 };

39 };

39

40

40 Q_INVOKABLE static bool isHorizontal(Direction::Type type);

41 Q_INVOKABLE static bool isHorizontal(Direction::Type type);

plugins/Ubuntu/Gestures/DirectionalDragArea.cpp+3−2

@@ -506,7 +506,7 @@ const QTouchEvent::TouchPoint *DirectionalDragAreaPrivate::fetchTargetTouchPoint

506

507bool DirectionalDragAreaPrivate::movingInRightDirection() const

508{

509− if (direction == Direction::Horizontal) {

509+ if (direction == Direction::Horizontal || direction == Direction::Vertical) {

510 return true;

511 } else {

512 QPointF movementVector(dampedScenePos.x() - previousDampedScenePos.x(),

@@ -532,7 +532,7 @@ bool DirectionalDragAreaPrivate::movedFarEnoughAlongGestureAxis() const

532 ddaDebug(" movedFarEnoughAlongGestureAxis: scalarProjection=" << scalarProjection

533 << ", distanceThreshold=" << distanceThreshold);

534

535− if (direction == Direction::Horizontal) {

535+ if (direction == Direction::Horizontal || direction == Direction::Vertical) {

536 return qAbs(scalarProjection) > distanceThreshold;

537 } else {

538 return scalarProjection > distanceThreshold;

@@ -843,6 +843,7 @@ void DirectionalDragAreaPrivate::updateSceneDirectionVector()

843 localDirection.ry() = -1.;

844 break;

845 case Direction::Downwards:

846+ case Direction::Vertical:

846 localDirection.rx() = 0.;

847 localDirection.rx() = 0.;

847 localDirection.ry() = 1;

848 localDirection.ry() = 1;

848 break;

849 break;

plugins/Ubuntu/Gestures/FloatingFlickable.cppnew file+150

@@ -0,0 +1,150 @@

1+/*

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.hnew file+86

@@ -0,0 +1,86 @@

1+/*

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/plugin.cpp+3−1

@@ -1,5 +1,5 @@

1/*

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

@@ -18,6 +18,7 @@

18#include "AxisVelocityCalculator.h"

19#include "Direction.h"

20#include "DirectionalDragArea.h"

21+#include "FloatingFlickable.h"

21#include "PressedOutsideNotifier.h"

22#include "PressedOutsideNotifier.h"

22#include "TouchGate.h"

23#include "TouchGate.h"

23

24

@@ -34,6 +35,7 @@ void UbuntuGesturesQmlPlugin::registerTypes(const char *uri)

34 qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);

35 qmlRegisterSingletonType<Direction>(uri, 0, 1, "Direction", directionSingleton);

35 qmlRegisterType<DirectionalDragArea>(uri, 0, 1, "DirectionalDragArea");

36 qmlRegisterType<DirectionalDragArea>(uri, 0, 1, "DirectionalDragArea");

36 qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");

37 qmlRegisterType<AxisVelocityCalculator>(uri, 0, 1, "AxisVelocityCalculator");

38+ qmlRegisterType<FloatingFlickable>(uri, 0, 1, "FloatingFlickable");

37 qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");

39 qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");

38 qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");

40 qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");

39}

41}

tests/plugins/Ubuntu/Gestures/CMakeLists.txt+2−1

@@ -22,7 +22,7 @@ add_definitions(-DUBUNTU_GESTURES_PLUGIN_DIR="${CMAKE_BINARY_DIR}/plugins")

22add_definitions(-DTESTS_UTILS_MODULES_DIR="${CMAKE_BINARY_DIR}/tests/utils/modules")

23

24macro(add_gesture_ui_test CLASSNAME)

25− add_executable(${CLASSNAME}TestExec tst_${CLASSNAME}.cpp GestureTest.cpp)

25+ add_executable(${CLASSNAME}TestExec tst_${CLASSNAME}.cpp GestureTest.cpp TestItem.cpp)

26 qt5_use_modules(${CLASSNAME}TestExec Test Core Qml Gui Quick)

27 target_link_libraries(${CLASSNAME}TestExec UbuntuGesturesQml UbuntuGestures)

28

@@ -46,6 +46,7 @@ macro(add_gesture_test CLASSNAME)

46endmacro(add_gesture_test)

47

48add_gesture_ui_test(DirectionalDragArea)

49+add_gesture_ui_test(FloatingFlickable)

49add_gesture_ui_test(PressedOutsideNotifier)

50add_gesture_ui_test(PressedOutsideNotifier)

50add_gesture_ui_test(TouchDispatcher)

51add_gesture_ui_test(TouchDispatcher)

51add_gesture_ui_test(TouchGate)

52add_gesture_ui_test(TouchGate)

tests/plugins/Ubuntu/Gestures/TestItem.cppnew file+30

@@ -0,0 +1,30 @@

1+/*

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 "TestItem.h"

18+

19+#include <QTouchEvent>

20+

21+void TestItem::touchEvent(QTouchEvent *event)

22+{

23+ QTouchEvent *clonedEvent = new QTouchEvent(event->type(),

24+ event->device(),

25+ event->modifiers(),

26+ event->touchPointStates(),

27+ event->touchPoints());

28+

29+ touchEventsReceived.append(QSharedPointer<QTouchEvent>(clonedEvent));

30+}

tests/plugins/Ubuntu/Gestures/TestItem.hnew file+33

@@ -0,0 +1,33 @@

1+/*

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 UBUNTUGESTURES_TEST_ITEM_H

18+#define UBUNTUGESTURES_TEST_ITEM_H

19+

20+#include <QQuickItem>

21+

22+class TestItem : public QQuickItem

23+{

24+ Q_OBJECT

25+

26+public:

27+ QList<QSharedPointer<QTouchEvent>> touchEventsReceived;

28+

29+protected:

30+ void touchEvent(QTouchEvent *event) override;

31+};

32+

33+#endif // UBUNTUGESTURES_TEST_ITEM_H

tests/plugins/Ubuntu/Gestures/tst_FloatingFlickable.cppnew file+122

@@ -0,0 +1,122 @@

1+/*

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 <QtTest>

18+#include <QQuickView>

19+

20+// Ubuntu.Gestures plugin

21+#include <DirectionalDragArea.h>

22+#include <FloatingFlickable.h>

23+

24+#include "GestureTest.h"

25+#include "TestItem.h"

26+

27+using namespace UbuntuGestures;

28+

29+class tst_FloatingFlickable: public GestureTest

30+{

31+ Q_OBJECT

32+public:

33+ tst_FloatingFlickable();

34+private Q_SLOTS:

35+ void tapGoesThrough();

36+ void flickChangesContentX();

37+ void flickChangesContentY();

38+};

39+

40+tst_FloatingFlickable::tst_FloatingFlickable()

41+ : GestureTest(QStringLiteral("tst_FloatingFlickable.qml"))

42+{

43+}

44+

45+void tst_FloatingFlickable::tapGoesThrough()

46+{

47+ FloatingFlickable *floatingFlickable =

48+ m_view->rootObject()->findChild<FloatingFlickable*>("floatingFlickable");

49+ QVERIFY(floatingFlickable != nullptr);

50+

51+ TestItem *testItem = new TestItem;

52+ testItem->setWidth(floatingFlickable->width());

53+ testItem->setHeight(floatingFlickable->height());

54+ testItem->setParentItem(m_view->rootObject());

55+ testItem->setZ(1.0);

56+

57+ floatingFlickable->setZ(2.0);

58+

59+ QTest::touchEvent(m_view, m_device)

60+ .press(0, QPoint(floatingFlickable->width()/2, floatingFlickable->height()/2));

61+

62+ QCOMPARE(testItem->touchEventsReceived.count(), 1);

63+}

64+

65+void tst_FloatingFlickable::flickChangesContentX()

66+{

67+ FloatingFlickable *floatingFlickable =

68+ m_view->rootObject()->findChild<FloatingFlickable*>("floatingFlickable");

69+ QVERIFY(floatingFlickable != nullptr);

70+

71+ floatingFlickable->m_dragArea->removeTimeConstraints();

72+

73+ qreal startContentX = floatingFlickable->contentX();

74+

75+ QPoint startPos(floatingFlickable->width() - 5, 10);

76+ int stepCount = 20;

77+ int step = (startPos.x() - 5) / stepCount;

78+

79+ QTest::touchEvent(m_view, m_device).press(0, startPos);

80+ for (int i = 0; i < stepCount; ++i) {

81+ QTest::qWait(10);

82+ QPoint touchPos = startPos - QPoint(step*i, 0);

83+ QTest::touchEvent(m_view, m_device).move(0, touchPos);

84+ }

85+

86+ QTest::qWait(10);

87+ QTest::touchEvent(m_view, m_device).release(0, QPoint(5, 10));

88+

89+ QVERIFY(floatingFlickable->contentX() > (startContentX + floatingFlickable->width()/2));

90+}

91+

92+void tst_FloatingFlickable::flickChangesContentY()

93+{

94+ FloatingFlickable *floatingFlickable =

95+ m_view->rootObject()->findChild<FloatingFlickable*>("floatingFlickable");

96+ QVERIFY(floatingFlickable != nullptr);

97+

98+ floatingFlickable->setDirection(Direction::Vertical);

99+ floatingFlickable->m_dragArea->removeTimeConstraints();

100+

101+ qreal startContentY = floatingFlickable->contentY();

102+

103+ QPoint startPos(10, floatingFlickable->height() - 5);

104+ int stepCount = 20;

105+ int step = (startPos.y() - 5) / stepCount;

106+

107+ QTest::touchEvent(m_view, m_device).press(0, startPos);

108+ for (int i = 0; i < stepCount; ++i) {

109+ QTest::qWait(10);

110+ QPoint touchPos = startPos - QPoint(0, step*i);

111+ QTest::touchEvent(m_view, m_device).move(0, touchPos);

112+ }

113+

114+ QTest::qWait(10);

115+ QTest::touchEvent(m_view, m_device).release(0, QPoint(10, 5));

116+

117+ QVERIFY(floatingFlickable->contentY() > (startContentY + floatingFlickable->height()/2));

118+}

119+

120+QTEST_MAIN(tst_FloatingFlickable)

121+

122+#include "tst_FloatingFlickable.moc"

tests/plugins/Ubuntu/Gestures/tst_FloatingFlickable.qmlnew file+80

@@ -0,0 +1,80 @@

1+/*

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.0

18+import Ubuntu.Components 0.1

19+import Ubuntu.Gestures 0.1

20+import Unity.Test 0.1

21+

22+Rectangle {

23+ id: root

24+ width: units.gu(60)

25+ height: units.gu(60)

26+ color: "white"

27+

28+ Binding {

29+ target: MouseTouchAdaptor

30+ property: "enabled"

31+ value: true

32+ }

33+

34+ Grid {

35+ id: colorGrid

36+ readonly property bool horizontal: floatingFlickable.direction === Direction.Horizontal

37+ x: horizontal ? -floatingFlickable.contentX : 0

38+ y: horizontal ? 0 : -floatingFlickable.contentY

39+ rows: horizontal ? 1 : 100

40+ columns: horizontal ? 100 : 1

41+ Repeater {

42+ model: 100

43+ Rectangle {

44+ width: colorGrid.horizontal ? units.gu(12) : root.width

45+ height: colorGrid.horizontal ? root.height : units.gu(12)

46+ color: mouseArea.pressed ? "red"

47+ : Qt.rgba(Math.random(), Math.random(), Math.random(), 1)

48+ MouseArea {

49+ id: mouseArea

50+ anchors.fill: parent

51+ }

52+ }

53+ }

54+ }

55+

56+ FloatingFlickable {

57+ id: floatingFlickable

58+ objectName: "floatingFlickable"

59+ anchors.fill: parent

60+ contentWidth: colorGrid.width

61+ contentHeight: colorGrid.height

62+ }

63+

64+ Button {

65+ anchors.bottom: parent.bottom

66+ anchors.right: parent.right

67+ anchors.margins: units.gu(1)

68+

69+ text: floatingFlickable.direction === Direction.Horizontal ? "Horizontal" : "Vertical"

70+ activeFocusOnPress: false

71+

72+ onClicked: {

73+ if (floatingFlickable.direction === Direction.Horizontal) {

74+ floatingFlickable.direction = Direction.Vertical;

75+ } else {

76+ floatingFlickable.direction = Direction.Horizontal;

77+ }

78+ }

79+ }

80+}

tests/plugins/Ubuntu/Gestures/tst_TouchGate.cpp+1−23

@@ -29,16 +29,7 @@

29#include <TouchGate.h>

30#include <TouchRegistry.h>

31

32−class TestItem : public QQuickItem

32+#include "TestItem.h"

33−{

34− Q_OBJECT

35−

36−public:

37− QList<QSharedPointer<QTouchEvent>> touchEventsReceived;

38−

39−protected:

40− void touchEvent(QTouchEvent *event) override;

41−};

42

33

43class CandidateItem : public QQuickItem

34class CandidateItem : public QQuickItem

44{

35{

@@ -381,19 +372,6 @@ void tst_TouchGate::disabledWhileHoldingTouch()

381 }

372 }

382}

373}

383

374

384−///////////// TestItem /////////////////////////////////////////////////////////////

385−

386−void TestItem::touchEvent(QTouchEvent *event)

387−{

388− QTouchEvent *clonedEvent = new QTouchEvent(event->type(),

389− event->device(),

390− event->modifiers(),

391− event->touchPointStates(),

392− event->touchPoints());

393−

394− touchEventsReceived.append(QSharedPointer<QTouchEvent>(clonedEvent));

395−}

396−

397///////////// CandidateItem /////////////////////////////////////////////////////////////

375///////////// CandidateItem /////////////////////////////////////////////////////////////

398

376

399void CandidateItem::touchEvent(QTouchEvent *event)

377void CandidateItem::touchEvent(QTouchEvent *event)