qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp

1067 lines
37 KiB
C++
Raw Normal View History

Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
/****************************************************************************
**
Update copyright year in license headers. Change-Id: I0a8d99909cac867dce72da70b1bbcb649989a51b Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2012-01-05 04:29:18 +00:00
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
Update obsolete contact address. Replace Nokia contact email address with Qt Project website. Change-Id: I6a730abc0c396fb545a48b2d6938abedac2e3f1c Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com> Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2012-01-20 04:04:27 +00:00
** Contact: http://www.qt-project.org/
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
Update licenseheader text in source files for qtdeclarative Qt module Replace old license header with correct one. Change-Id: I492ddaaa0227b2c8faf11bdcd6e12e7231a54a10 Reviewed-on: http://codereview.qt.nokia.com/1312 Reviewed-by: Jyri Tahtela <jyri.tahtela@nokia.com>
2011-07-07 12:52:03 +00:00
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
**
** In addition, as a special exception, Nokia gives you certain additional
Update licenseheader text in source files for qtdeclarative Qt module Replace old license header with correct one. Change-Id: I492ddaaa0227b2c8faf11bdcd6e12e7231a54a10 Reviewed-on: http://codereview.qt.nokia.com/1312 Reviewed-by: Jyri Tahtela <jyri.tahtela@nokia.com>
2011-07-07 12:52:03 +00:00
** rights. These rights are described in the Nokia Qt LGPL Exception
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
Update licenseheader text in source files for qtdeclarative Qt module Replace old license header with correct one. Change-Id: I492ddaaa0227b2c8faf11bdcd6e12e7231a54a10 Reviewed-on: http://codereview.qt.nokia.com/1312 Reviewed-by: Jyri Tahtela <jyri.tahtela@nokia.com>
2011-07-07 12:52:03 +00:00
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
**
Update licenseheader text in source files for qtdeclarative Qt module Replace old license header with correct one. Change-Id: I492ddaaa0227b2c8faf11bdcd6e12e7231a54a10 Reviewed-on: http://codereview.qt.nokia.com/1312 Reviewed-by: Jyri Tahtela <jyri.tahtela@nokia.com>
2011-07-07 12:52:03 +00:00
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
**
**
**
**
**
Remove "All rights reserved" line from license headers. As in the past, to avoid rewriting various autotests that contain line-number information, an extra blank line has been inserted at the end of the license text to ensure that this commit does not change the total number of lines in the license header. Change-Id: If39bd256b0fa85eba17ea30f8ab87ea27d758908 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2012-01-24 03:37:23 +00:00
**
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qtest.h>
#include <QDebug>
#include <QTouchEvent>
Say hello to QtQuick module This change moves the QtQuick 2 types and C++ API (including SceneGraph) to a new module (AKA library), QtQuick. 99% of this change is moving files from src/declarative to src/quick, and from tests/auto/declarative to tests/auto/qtquick2. The loading of QtQuick 2 ("import QtQuick 2.0") is now delegated to a plugin, src/imports/qtquick2, just like it's done for QtQuick 1. All tools, examples, and tests that use QtQuick C++ API have gotten "QT += quick" or "QT += quick-private" added to their .pro file. A few additional internal QtDeclarative classes had to be exported (via Q_DECLARATIVE_PRIVATE_EXPORT) since they're needed by the QtQuick 2 implementation. The old header locations (e.g. QtDeclarative/qquickitem.h) will still be supported for some time, but will produce compile-time warnings. (To avoid the QtQuick implementation using the compatibility headers (since QtDeclarative's includepath comes first), a few include statements were modified, e.g. from "#include <qsgnode.h>" to "#include <QtQuick/qsgnode.h>".) There's a change in qtbase that automatically adds QtQuick to the module list if QtDeclarative is used. Together with the compatibility headers, this should help reduce the migration pain for existing projects. In theory, simply getting an existing QtDeclarative-based project to compile and link shouldn't require any changes for now -- but porting to the new scheme is of course recommended, and will eventually become mandatory. Task-number: QTBUG-22889 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Change-Id: Ia52be9373172ba2f37e7623231ecb060316c96a7 Reviewed-by: Kent Hansen <kent.hansen@nokia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@nokia.com>
2011-11-23 14:14:07 +00:00
#include <QtQuick/QQuickItem>
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
#include <QtQuick/QQuickWindow>
Rename QDeclarative symbols to QQuick and QQml Symbols beginning with QDeclarative are already exported by the quick1 module. Users can apply the bin/rename-qtdeclarative-symbols.sh script to modify client code using the previous names of the renamed symbols. Task-number: QTBUG-23737 Change-Id: Ifaa482663767634931e8711a8e9bf6e404859e66 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-16 04:43:03 +00:00
#include <QtQml/QQmlEngine>
#include <QtQml/QQmlComponent>
Say hello to QtQuick module This change moves the QtQuick 2 types and C++ API (including SceneGraph) to a new module (AKA library), QtQuick. 99% of this change is moving files from src/declarative to src/quick, and from tests/auto/declarative to tests/auto/qtquick2. The loading of QtQuick 2 ("import QtQuick 2.0") is now delegated to a plugin, src/imports/qtquick2, just like it's done for QtQuick 1. All tools, examples, and tests that use QtQuick C++ API have gotten "QT += quick" or "QT += quick-private" added to their .pro file. A few additional internal QtDeclarative classes had to be exported (via Q_DECLARATIVE_PRIVATE_EXPORT) since they're needed by the QtQuick 2 implementation. The old header locations (e.g. QtDeclarative/qquickitem.h) will still be supported for some time, but will produce compile-time warnings. (To avoid the QtQuick implementation using the compatibility headers (since QtDeclarative's includepath comes first), a few include statements were modified, e.g. from "#include <qsgnode.h>" to "#include <QtQuick/qsgnode.h>".) There's a change in qtbase that automatically adds QtQuick to the module list if QtDeclarative is used. Together with the compatibility headers, this should help reduce the migration pain for existing projects. In theory, simply getting an existing QtDeclarative-based project to compile and link shouldn't require any changes for now -- but porting to the new scheme is of course recommended, and will eventually become mandatory. Task-number: QTBUG-22889 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Change-Id: Ia52be9373172ba2f37e7623231ecb060316c96a7 Reviewed-by: Kent Hansen <kent.hansen@nokia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@nokia.com>
2011-11-23 14:14:07 +00:00
#include <QtQuick/private/qquickrectangle_p.h>
#include "../../shared/util.h"
Use QSignalSpy to save some code Change-Id: If4a9b68c39facdca34482bbf3dc22ae607b294e8 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-01-04 13:50:52 +00:00
#include <QSignalSpy>
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
#include <private/qquickwindow_p.h>
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
#include <private/qguiapplication_p.h>
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
struct TouchEventData {
QEvent::Type type;
QWidget *widget;
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QWindow *window;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
Qt::TouchPointStates states;
QList<QTouchEvent::TouchPoint> touchPoints;
};
Rename Qt Quick-specific classes to QQuick* The QSG (SceneGraph) prefix is too generic for Qt Quick(2)-specific classes. All the classes and files in the declarative/items directory have been renamed. In particular, for classes that are currently public, the renaming is as follows: QSGView --> QQuickView QSGCanvas --> QQuickCanvas QSGItem --> QQuickItem QSGPaintedItem --> QQuickPaintedItem The header files have been renamed accordingly (e.g. qsgview.h --> qquickview.h). Change-Id: Iac937fff81db20bb639486a793c3aeb5230b038c Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
2011-10-14 08:51:42 +00:00
static QTouchEvent::TouchPoint makeTouchPoint(QQuickItem *item, const QPointF &p, const QPointF &lastPoint = QPointF())
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
QPointF last = lastPoint.isNull() ? p : lastPoint;
QTouchEvent::TouchPoint tp;
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
tp.setPos(p);
tp.setLastPos(last);
tp.setScenePos(item->mapToScene(p));
tp.setLastScenePos(item->mapToScene(last));
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
tp.setScreenPos(item->window()->mapToGlobal(tp.scenePos().toPoint()));
tp.setLastScreenPos(item->window()->mapToGlobal(tp.lastScenePos().toPoint()));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
return tp;
}
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
static TouchEventData makeTouchData(QEvent::Type type, QWindow *w, Qt::TouchPointStates states = 0,
const QList<QTouchEvent::TouchPoint>& touchPoints = QList<QTouchEvent::TouchPoint>())
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
{
TouchEventData d = { type, 0, w, states, touchPoints };
return d;
}
static TouchEventData makeTouchData(QEvent::Type type, QWindow *w, Qt::TouchPointStates states, const QTouchEvent::TouchPoint &touchPoint)
{
QList<QTouchEvent::TouchPoint> points;
points << touchPoint;
return makeTouchData(type, w, states, points);
}
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
#define COMPARE_TOUCH_POINTS(tp1, tp2) \
{ \
QCOMPARE(tp1.pos(), tp2.pos()); \
QCOMPARE(tp1.lastPos(), tp2.lastPos()); \
QCOMPARE(tp1.scenePos(), tp2.scenePos()); \
QCOMPARE(tp1.lastScenePos(), tp2.lastScenePos()); \
QCOMPARE(tp1.screenPos(), tp2.screenPos()); \
QCOMPARE(tp1.lastScreenPos(), tp2.lastScreenPos()); \
}
#define COMPARE_TOUCH_DATA(d1, d2) \
{ \
QCOMPARE((int)d1.type, (int)d2.type); \
QCOMPARE(d1.widget, d2.widget); \
QCOMPARE((int)d1.states, (int)d2.states); \
QCOMPARE(d1.touchPoints.count(), d2.touchPoints.count()); \
for (int i=0; i<d1.touchPoints.count(); i++) { \
COMPARE_TOUCH_POINTS(d1.touchPoints[i], d2.touchPoints[i]); \
} \
}
Set rootItem'ownership as CppOwnerShip rootItem should not be deleted until the QQuickCanvas itself has been deleted. Set the rootItem's object ownership to CppOwnerShip can prevent it being destroyed by javascript destroy() method or v8 garbage collection. Change-Id: I7d83fec8ffcb8062d143b1b050a38368a2af800f Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com> Reviewed-by: J-P Nurmi <j-p.nurmi@nokia.com>
2012-04-17 06:47:33 +00:00
class RootItemAccessor : public QQuickItem
{
Q_OBJECT
public:
RootItemAccessor()
: m_rootItemDestroyed(false)
, m_rootItem(0)
{
}
Q_INVOKABLE QQuickItem *rootItem()
{
if (!m_rootItem) {
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindowPrivate *c = QQuickWindowPrivate::get(window());
Set rootItem'ownership as CppOwnerShip rootItem should not be deleted until the QQuickCanvas itself has been deleted. Set the rootItem's object ownership to CppOwnerShip can prevent it being destroyed by javascript destroy() method or v8 garbage collection. Change-Id: I7d83fec8ffcb8062d143b1b050a38368a2af800f Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com> Reviewed-by: J-P Nurmi <j-p.nurmi@nokia.com>
2012-04-17 06:47:33 +00:00
m_rootItem = c->rootItem;
QObject::connect(m_rootItem, SIGNAL(destroyed()), this, SLOT(rootItemDestroyed()));
}
return m_rootItem;
}
bool isRootItemDestroyed() {return m_rootItemDestroyed;}
public slots:
void rootItemDestroyed() {
m_rootItemDestroyed = true;
}
private:
bool m_rootItemDestroyed;
QQuickItem *m_rootItem;
};
Rename Qt Quick-specific classes to QQuick* The QSG (SceneGraph) prefix is too generic for Qt Quick(2)-specific classes. All the classes and files in the declarative/items directory have been renamed. In particular, for classes that are currently public, the renaming is as follows: QSGView --> QQuickView QSGCanvas --> QQuickCanvas QSGItem --> QQuickItem QSGPaintedItem --> QQuickPaintedItem The header files have been renamed accordingly (e.g. qsgview.h --> qquickview.h). Change-Id: Iac937fff81db20bb639486a793c3aeb5230b038c Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
2011-10-14 08:51:42 +00:00
class TestTouchItem : public QQuickRectangle
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
Q_OBJECT
public:
Rename Qt Quick-specific classes to QQuick* The QSG (SceneGraph) prefix is too generic for Qt Quick(2)-specific classes. All the classes and files in the declarative/items directory have been renamed. In particular, for classes that are currently public, the renaming is as follows: QSGView --> QQuickView QSGCanvas --> QQuickCanvas QSGItem --> QQuickItem QSGPaintedItem --> QQuickPaintedItem The header files have been renamed accordingly (e.g. qsgview.h --> qquickview.h). Change-Id: Iac937fff81db20bb639486a793c3aeb5230b038c Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
2011-10-14 08:51:42 +00:00
TestTouchItem(QQuickItem *parent = 0)
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
: QQuickRectangle(parent), acceptTouchEvents(true), acceptMouseEvents(true),
mousePressId(0),
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
spinLoopWhenPressed(false), touchEventCount(0)
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
border()->setWidth(1);
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
setAcceptedMouseButtons(Qt::LeftButton);
setFiltersChildMouseEvents(true);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
}
void reset() {
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
acceptTouchEvents = acceptMouseEvents = true;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
setEnabled(true);
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
setVisible(true);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
lastEvent = makeTouchData(QEvent::None, window(), 0, QList<QTouchEvent::TouchPoint>());//CHECK_VALID
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
lastVelocity = lastVelocityFromMouseMove = QVector2D();
lastMousePos = QPointF();
lastMouseCapabilityFlags = 0;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
}
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
static void clearMousePressCounter()
{
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
mousePressNum = mouseMoveNum = mouseReleaseNum = 0;
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
}
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
void clearTouchEventCounter()
{
touchEventCount = 0;
}
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
bool acceptTouchEvents;
bool acceptMouseEvents;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
TouchEventData lastEvent;
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
int mousePressId;
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
bool spinLoopWhenPressed;
int touchEventCount;
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QVector2D lastVelocity;
QVector2D lastVelocityFromMouseMove;
QPointF lastMousePos;
int lastMouseCapabilityFlags;
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
void touchEvent(QTouchEvent *event) {
if (!acceptTouchEvents) {
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
event->ignore();
return;
}
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
++touchEventCount;
Set target and device for touch events. The QWidget dependency is being removed from QTouchEvent and therefore widget() will be removed. There will be QObject *target() instead. deviceType() has been deprecated and is replaced by QTouchDevice *device(). Change-Id: Ic07b2c620fbfc1ae2e5eff85c8fc7269c7d5e2a8 Reviewed-by: Laszlo Agocs <laszlo.p.agocs@nokia.com>
2011-12-08 10:46:47 +00:00
lastEvent = makeTouchData(event->type(), event->window(), event->touchPointStates(), event->touchPoints());
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
if (event->device()->capabilities().testFlag(QTouchDevice::Velocity) && !event->touchPoints().isEmpty()) {
lastVelocity = event->touchPoints().first().velocity();
} else {
lastVelocity = QVector2D();
}
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
if (spinLoopWhenPressed && event->touchPointStates().testFlag(Qt::TouchPointPressed)) {
QCoreApplication::processEvents();
}
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
}
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
void mousePressEvent(QMouseEvent *e) {
if (!acceptMouseEvents) {
e->ignore();
return;
}
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
mousePressId = ++mousePressNum;
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
lastMousePos = e->pos();
lastMouseCapabilityFlags = QGuiApplicationPrivate::mouseEventCaps(e);
}
void mouseMoveEvent(QMouseEvent *e) {
if (!acceptMouseEvents) {
e->ignore();
return;
}
++mouseMoveNum;
lastVelocityFromMouseMove = QGuiApplicationPrivate::mouseEventVelocity(e);
lastMouseCapabilityFlags = QGuiApplicationPrivate::mouseEventCaps(e);
lastMousePos = e->pos();
}
void mouseReleaseEvent(QMouseEvent *e) {
if (!acceptMouseEvents) {
e->ignore();
return;
}
++mouseReleaseNum;
lastMousePos = e->pos();
lastMouseCapabilityFlags = QGuiApplicationPrivate::mouseEventCaps(e);
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
}
Add MultiPointTouchArea element. Change-Id: I3a4f774cd96ab7f5d08e85c965f59e1416f02e0e Reviewed-by: Martin Jones <martin.jones@nokia.com>
2011-08-23 03:30:38 +00:00
bool childMouseEventFilter(QQuickItem *, QEvent *event) {
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
// TODO Is it a bug if a QTouchEvent comes here?
Add MultiPointTouchArea element. Change-Id: I3a4f774cd96ab7f5d08e85c965f59e1416f02e0e Reviewed-by: Martin Jones <martin.jones@nokia.com>
2011-08-23 03:30:38 +00:00
if (event->type() == QEvent::MouseButtonPress)
mousePressId = ++mousePressNum;
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
return false;
}
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
static int mousePressNum, mouseMoveNum, mouseReleaseNum;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
};
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
int TestTouchItem::mousePressNum = 0;
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
int TestTouchItem::mouseMoveNum = 0;
int TestTouchItem::mouseReleaseNum = 0;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
Rename Qt Quick-specific classes to QQuick* The QSG (SceneGraph) prefix is too generic for Qt Quick(2)-specific classes. All the classes and files in the declarative/items directory have been renamed. In particular, for classes that are currently public, the renaming is as follows: QSGView --> QQuickView QSGCanvas --> QQuickCanvas QSGItem --> QQuickItem QSGPaintedItem --> QQuickPaintedItem The header files have been renamed accordingly (e.g. qsgview.h --> qquickview.h). Change-Id: Iac937fff81db20bb639486a793c3aeb5230b038c Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
2011-10-14 08:51:42 +00:00
class ConstantUpdateItem : public QQuickItem
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
Q_OBJECT
public:
Rename Qt Quick-specific classes to QQuick* The QSG (SceneGraph) prefix is too generic for Qt Quick(2)-specific classes. All the classes and files in the declarative/items directory have been renamed. In particular, for classes that are currently public, the renaming is as follows: QSGView --> QQuickView QSGCanvas --> QQuickCanvas QSGItem --> QQuickItem QSGPaintedItem --> QQuickPaintedItem The header files have been renamed accordingly (e.g. qsgview.h --> qquickview.h). Change-Id: Iac937fff81db20bb639486a793c3aeb5230b038c Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
2011-10-14 08:51:42 +00:00
ConstantUpdateItem(QQuickItem *parent = 0) : QQuickItem(parent), iterations(0) {setFlag(ItemHasContents);}
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
int iterations;
protected:
QSGNode* updatePaintNode(QSGNode *, UpdatePaintNodeData *){
iterations++;
update();
return 0;
}
};
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
class tst_qquickwindow : public QQmlDataTest
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
Q_OBJECT
public:
private slots:
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
void initTestCase()
{
Rename QDeclarative symbols to QQuick and QQml Symbols beginning with QDeclarative are already exported by the quick1 module. Users can apply the bin/rename-qtdeclarative-symbols.sh script to modify client code using the previous names of the renamed symbols. Task-number: QTBUG-23737 Change-Id: Ifaa482663767634931e8711a8e9bf6e404859e66 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-16 04:43:03 +00:00
QQmlDataTest::initTestCase();
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
touchDevice = new QTouchDevice;
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
touchDevice->setType(QTouchDevice::TouchScreen);
QWindowSystemInterface::registerTouchDevice(touchDevice);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
touchDeviceWithVelocity = new QTouchDevice;
touchDeviceWithVelocity->setType(QTouchDevice::TouchScreen);
touchDeviceWithVelocity->setCapabilities(QTouchDevice::Position | QTouchDevice::Velocity);
QWindowSystemInterface::registerTouchDevice(touchDeviceWithVelocity);
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
}
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
void constantUpdates();
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
void mouseFiltering();
void headless();
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
void touchEvent_basic();
void touchEvent_propagation();
void touchEvent_propagation_data();
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
void touchEvent_cancel();
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
void touchEvent_reentrant();
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
void touchEvent_velocity();
void mouseFromTouch_basic();
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void clearWindow();
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
void qmlCreation();
void clearColor();
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
void grab();
void multipleWindows();
void animationsWhileHidden();
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
void focusObject();
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
void ignoreUnhandledMouseEvents();
Set rootItem'ownership as CppOwnerShip rootItem should not be deleted until the QQuickCanvas itself has been deleted. Set the rootItem's object ownership to CppOwnerShip can prevent it being destroyed by javascript destroy() method or v8 garbage collection. Change-Id: I7d83fec8ffcb8062d143b1b050a38368a2af800f Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com> Reviewed-by: J-P Nurmi <j-p.nurmi@nokia.com>
2012-04-17 06:47:33 +00:00
void ownershipRootItem();
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
private:
QTouchDevice *touchDevice;
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QTouchDevice *touchDeviceWithVelocity;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
};
//If the item calls update inside updatePaintNode, it should schedule another update
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::constantUpdates()
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow window;
window.resize(250, 250);
ConstantUpdateItem item(window.rootItem());
window.show();
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QTRY_VERIFY(item.iterations > 60);
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::touchEvent_basic()
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
TestTouchItem::clearMousePressCounter();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TestTouchItem *bottomItem = new TestTouchItem(window->rootItem());
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
bottomItem->setObjectName("Bottom Item");
bottomItem->setSize(QSizeF(150, 150));
TestTouchItem *middleItem = new TestTouchItem(bottomItem);
middleItem->setObjectName("Middle Item");
middleItem->setPos(QPointF(50, 50));
middleItem->setSize(QSizeF(150, 150));
TestTouchItem *topItem = new TestTouchItem(middleItem);
topItem->setObjectName("Top Item");
topItem->setPos(QPointF(50, 50));
topItem->setSize(QSizeF(150, 150));
QPointF pos(10, 10);
// press single point
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
// At one point this was failing with kwin (KDE window manager) because window->setPos(100, 100)
// would put the decorated window at that position rather than the window itself.
COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(topItem, pos)));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
topItem->reset();
// press multiple points
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window)
.press(1, bottomItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(topItem, pos)));
COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(bottomItem, pos)));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
topItem->reset();
bottomItem->reset();
// touch point on top item moves to bottom item, but top item should still receive the event
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchUpdate, window, Qt::TouchPointMoved,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
makeTouchPoint(topItem, topItem->mapFromItem(bottomItem, pos), pos)));
topItem->reset();
// touch point on bottom item moves to top item, but bottom item should still receive the event
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, bottomItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).move(0, topItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchUpdate, window, Qt::TouchPointMoved,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
makeTouchPoint(bottomItem, bottomItem->mapFromItem(topItem, pos), pos)));
bottomItem->reset();
// a single stationary press on an item shouldn't cause an event
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).stationary(0)
.press(1, bottomItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1); // received press only, not stationary
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(topItem, pos)));
COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(bottomItem, pos)));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
topItem->reset();
bottomItem->reset();
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
// cleanup: what is pressed must be released
// Otherwise you will get an assertion failure:
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
// ASSERT: "itemForTouchPointId.isEmpty()" in file items/qquickwindow.cpp
QTest::touchEvent(window, touchDevice).release(0, pos.toPoint(), window).release(1, pos.toPoint(), window);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
// move touch point from top item to bottom, and release
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).release(0, bottomItem->mapToScene(pos).toPoint(),window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchEnd, window, Qt::TouchPointReleased,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
makeTouchPoint(topItem, topItem->mapFromItem(bottomItem, pos), pos)));
topItem->reset();
// release while another point is pressed
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window)
.press(1, bottomItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).release(0, bottomItem->mapToScene(pos).toPoint(), window)
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
.stationary(1);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchEnd, window, Qt::TouchPointReleased,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
makeTouchPoint(topItem, topItem->mapFromItem(bottomItem, pos))));
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(bottomItem, pos)));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
topItem->reset();
bottomItem->reset();
delete topItem;
delete middleItem;
delete bottomItem;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::touchEvent_propagation()
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
TestTouchItem::clearMousePressCounter();
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QFETCH(bool, acceptTouchEvents);
QFETCH(bool, acceptMouseEvents);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QFETCH(bool, enableItem);
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
QFETCH(bool, showItem);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TestTouchItem *bottomItem = new TestTouchItem(window->rootItem());
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
bottomItem->setObjectName("Bottom Item");
bottomItem->setSize(QSizeF(150, 150));
TestTouchItem *middleItem = new TestTouchItem(bottomItem);
middleItem->setObjectName("Middle Item");
middleItem->setPos(QPointF(50, 50));
middleItem->setSize(QSizeF(150, 150));
TestTouchItem *topItem = new TestTouchItem(middleItem);
topItem->setObjectName("Top Item");
topItem->setPos(QPointF(50, 50));
topItem->setSize(QSizeF(150, 150));
QPointF pos(10, 10);
QPoint pointInBottomItem = bottomItem->mapToScene(pos).toPoint(); // (10, 10)
QPoint pointInMiddleItem = middleItem->mapToScene(pos).toPoint(); // (60, 60) overlaps with bottomItem
QPoint pointInTopItem = topItem->mapToScene(pos).toPoint(); // (110, 110) overlaps with bottom & top items
// disable topItem
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
topItem->acceptTouchEvents = acceptTouchEvents;
topItem->acceptMouseEvents = acceptMouseEvents;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
topItem->setEnabled(enableItem);
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
topItem->setVisible(showItem);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
// single touch to top item, should be received by middle item
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(middleItem->lastEvent.touchPoints.count(), 1);
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(middleItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
makeTouchPoint(middleItem, middleItem->mapFromItem(topItem, pos))));
// touch top and middle items, middle item should get both events
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window)
.press(1, pointInMiddleItem, window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(middleItem->lastEvent.touchPoints.count(), 2);
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(middleItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
(QList<QTouchEvent::TouchPoint>() << makeTouchPoint(middleItem, middleItem->mapFromItem(topItem, pos))
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
<< makeTouchPoint(middleItem, pos) )));
middleItem->reset();
// disable middleItem as well
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
middleItem->acceptTouchEvents = acceptTouchEvents;
middleItem->acceptMouseEvents = acceptMouseEvents;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
middleItem->setEnabled(enableItem);
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
middleItem->setVisible(showItem);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
// touch top and middle items, bottom item should get all events
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window)
.press(1, pointInMiddleItem, window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 2);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
(QList<QTouchEvent::TouchPoint>() << makeTouchPoint(bottomItem, bottomItem->mapFromItem(topItem, pos))
<< makeTouchPoint(bottomItem, bottomItem->mapFromItem(middleItem, pos)) )));
bottomItem->reset();
// disable bottom item as well
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
bottomItem->acceptTouchEvents = acceptTouchEvents;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
bottomItem->setEnabled(enableItem);
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
bottomItem->setVisible(showItem);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
// no events should be received
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window)
.press(1, pointInMiddleItem, window)
.press(2, pointInBottomItem, window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
topItem->reset();
middleItem->reset();
bottomItem->reset();
// disable middle item, touch on top item
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
middleItem->acceptTouchEvents = acceptTouchEvents;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
middleItem->setEnabled(enableItem);
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
middleItem->setVisible(showItem);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window);
qsgcanvas autotest made to work with refactor and added break statement to qsgcanvas.cpp in event processing amended wait times / changed include for private headers Change-Id: I4f790907268be357986e181e4624f8e54efcb2ec Reviewed-on: http://codereview.qt.nokia.com/4256 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-09-06 11:14:37 +00:00
QTest::qWait(50);
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
if (!enableItem || !showItem) {
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
// middle item is disabled or has 0 opacity, bottom item receives the event
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
makeTouchPoint(bottomItem, bottomItem->mapFromItem(topItem, pos))));
} else {
// middle item ignores event, sends it to the top item (top-most child)
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
makeTouchPoint(topItem, pos)));
}
delete topItem;
delete middleItem;
delete bottomItem;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::touchEvent_propagation_data()
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QTest::addColumn<bool>("acceptTouchEvents");
QTest::addColumn<bool>("acceptMouseEvents");
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QTest::addColumn<bool>("enableItem");
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
QTest::addColumn<bool>("showItem");
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
Allow mouse interaction with 0 opacity items. Don't filter event delivery to items with 0 opacity, and update the documentation the for opacity, visible and enabled properties and how each affects event delivery. Task-number: QTBUG-19193 Change-Id: Id48e4af763c9a7bbcc13b303342d303155dcadc9 Reviewed-by: Jan-Arve Sæther <jan-arve.saether@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-03 02:29:57 +00:00
QTest::newRow("disable events") << false << false << true << true;
QTest::newRow("disable item") << true << true << false << true;
QTest::newRow("hide item") << true << true << true << false;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::touchEvent_cancel()
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
{
TestTouchItem::clearMousePressCounter();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TestTouchItem *item = new TestTouchItem(window->rootItem());
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
item->setPos(QPointF(50, 50));
item->setSize(QSizeF(150, 150));
QPointF pos(10, 10);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::touchEvent(window, touchDevice).press(0, item->mapToScene(pos).toPoint(),window);
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
QCoreApplication::processEvents();
QTRY_COMPARE(item->lastEvent.touchPoints.count(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TouchEventData d = makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(item,pos));
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
COMPARE_TOUCH_DATA(item->lastEvent, d);
item->reset();
QWindowSystemInterface::handleTouchCancelEvent(0, touchDevice);
QCoreApplication::processEvents();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
d = makeTouchData(QEvent::TouchCancel, window);
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
COMPARE_TOUCH_DATA(item->lastEvent, d);
delete item;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Add basic TouchCancel handling to canvas. This makes sure that touchEvent() is properly called for all items in the scene that have an active touch. It does not handle the cancel event in any other special way. Change-Id: Id66527ced8cb63d0b29f25f37c139e6d6aec9ba0 Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-10 11:43:00 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::touchEvent_reentrant()
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
{
TestTouchItem::clearMousePressCounter();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TestTouchItem *item = new TestTouchItem(window->rootItem());
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
item->spinLoopWhenPressed = true; // will call processEvents() from the touch handler
item->setPos(QPointF(50, 50));
item->setSize(QSizeF(150, 150));
QPointF pos(60, 60);
// None of these should commit from the dtor.
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::QTouchEventSequence press = QTest::touchEvent(window, touchDevice, false).press(0, pos.toPoint(), window);
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
pos += QPointF(2, 2);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::QTouchEventSequence move = QTest::touchEvent(window, touchDevice, false).move(0, pos.toPoint(), window);
QTest::QTouchEventSequence release = QTest::touchEvent(window, touchDevice, false).release(0, pos.toPoint(), window);
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
// Now commit (i.e. call QWindowSystemInterface::handleTouchEvent), but do not process the events yet.
press.commit(false);
move.commit(false);
release.commit(false);
QCoreApplication::processEvents();
QTRY_COMPARE(item->touchEventCount, 3);
delete item;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Make touch event delivery in the canvas reentrant At the moment the unlikely case of spinning the event loop from a QQuickItem event handler for TouchBegin is not handled properly: It will end up not delivering the subsequent TouchUpdate and TouchEnd events to the item, leaving it in a state that should not normally happen. Change-Id: I668d065c9cf1a299bfd9268a9125d7a7e32f6786 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-04-24 07:51:59 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::touchEvent_velocity()
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
{
TestTouchItem::clearMousePressCounter();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QTest::qWait(10);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TestTouchItem *item = new TestTouchItem(window->rootItem());
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
item->setPos(QPointF(50, 50));
item->setSize(QSizeF(150, 150));
QList<QWindowSystemInterface::TouchPoint> points;
QWindowSystemInterface::TouchPoint tp;
tp.id = 1;
tp.state = Qt::TouchPointPressed;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QPoint pos = window->mapToGlobal(item->mapToScene(QPointF(10, 10)).toPoint());
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
tp.area = QRectF(pos, QSizeF(4, 4));
points << tp;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
points[0].state = Qt::TouchPointMoved;
points[0].area.adjust(5, 5, 5, 5);
QVector2D velocity(1.5, 2.5);
points[0].velocity = velocity;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCoreApplication::processEvents();
QCOMPARE(item->touchEventCount, 2);
QCOMPARE(item->lastEvent.touchPoints.count(), 1);
QCOMPARE(item->lastVelocity, velocity);
// Now have a transformation on the item and check if velocity and position are transformed accordingly.
item->setRotation(90); // clockwise
QMatrix4x4 transformMatrix;
transformMatrix.rotate(-90, 0, 0, 1); // counterclockwise
QVector2D transformedVelocity = transformMatrix.mapVector(velocity).toVector2D();
points[0].area.adjust(5, 5, 5, 5);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCoreApplication::processEvents();
QCOMPARE(item->lastVelocity, transformedVelocity);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QPoint itemLocalPos = item->mapFromScene(window->mapFromGlobal(points[0].area.center().toPoint())).toPoint();
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QPoint itemLocalPosFromEvent = item->lastEvent.touchPoints[0].pos().toPoint();
QCOMPARE(itemLocalPos, itemLocalPosFromEvent);
points[0].state = Qt::TouchPointReleased;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCoreApplication::processEvents();
delete item;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::mouseFromTouch_basic()
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
{
// Turn off accepting touch events with acceptTouchEvents. This
// should result in sending mouse events generated from the touch
// with the new event propagation system.
TestTouchItem::clearMousePressCounter();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QTest::qWait(10);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TestTouchItem *item = new TestTouchItem(window->rootItem());
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
item->setPos(QPointF(50, 50));
item->setSize(QSizeF(150, 150));
item->acceptTouchEvents = false;
QList<QWindowSystemInterface::TouchPoint> points;
QWindowSystemInterface::TouchPoint tp;
tp.id = 1;
tp.state = Qt::TouchPointPressed;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QPoint pos = window->mapToGlobal(item->mapToScene(QPointF(10, 10)).toPoint());
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
tp.area = QRectF(pos, QSizeF(4, 4));
points << tp;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
points[0].state = Qt::TouchPointMoved;
points[0].area.adjust(5, 5, 5, 5);
QVector2D velocity(1.5, 2.5);
points[0].velocity = velocity;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
points[0].state = Qt::TouchPointReleased;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCoreApplication::processEvents();
// The item should have received a mouse press, move, and release.
QCOMPARE(item->mousePressNum, 1);
QCOMPARE(item->mouseMoveNum, 1);
QCOMPARE(item->mouseReleaseNum, 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QCOMPARE(item->lastMousePos.toPoint(), item->mapFromScene(window->mapFromGlobal(points[0].area.center().toPoint())).toPoint());
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCOMPARE(item->lastVelocityFromMouseMove, velocity);
QVERIFY((item->lastMouseCapabilityFlags & QTouchDevice::Velocity) != 0);
// Now the same with a transformation.
item->setRotation(90); // clockwise
QMatrix4x4 transformMatrix;
transformMatrix.rotate(-90, 0, 0, 1); // counterclockwise
QVector2D transformedVelocity = transformMatrix.mapVector(velocity).toVector2D();
points[0].state = Qt::TouchPointPressed;
points[0].velocity = velocity;
points[0].area = QRectF(pos, QSizeF(4, 4));
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
points[0].state = Qt::TouchPointMoved;
points[0].area.adjust(5, 5, 5, 5);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCoreApplication::processEvents();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QCOMPARE(item->lastMousePos.toPoint(), item->mapFromScene(window->mapFromGlobal(points[0].area.center().toPoint())).toPoint());
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCOMPARE(item->lastVelocityFromMouseMove, transformedVelocity);
points[0].state = Qt::TouchPointReleased;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
QCoreApplication::processEvents();
delete item;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::clearWindow()
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
{
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
Rename Qt Quick-specific classes to QQuick* The QSG (SceneGraph) prefix is too generic for Qt Quick(2)-specific classes. All the classes and files in the declarative/items directory have been renamed. In particular, for classes that are currently public, the renaming is as follows: QSGView --> QQuickView QSGCanvas --> QQuickCanvas QSGItem --> QQuickItem QSGPaintedItem --> QQuickPaintedItem The header files have been renamed accordingly (e.g. qsgview.h --> qquickview.h). Change-Id: Iac937fff81db20bb639486a793c3aeb5230b038c Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
2011-10-14 08:51:42 +00:00
QQuickItem *item = new QQuickItem;
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
item->setParentItem(window->rootItem());
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(item->window() == window);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(item->window() == 0);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
delete item;
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::mouseFiltering()
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
{
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
TestTouchItem::clearMousePressCounter();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
TestTouchItem *bottomItem = new TestTouchItem(window->rootItem());
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
bottomItem->setObjectName("Bottom Item");
bottomItem->setSize(QSizeF(150, 150));
TestTouchItem *middleItem = new TestTouchItem(bottomItem);
middleItem->setObjectName("Middle Item");
middleItem->setPos(QPointF(50, 50));
middleItem->setSize(QSizeF(150, 150));
TestTouchItem *topItem = new TestTouchItem(middleItem);
topItem->setObjectName("Top Item");
topItem->setPos(QPointF(50, 50));
topItem->setSize(QSizeF(150, 150));
QPoint pos(100, 100);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::mousePress(window, Qt::LeftButton, 0, pos);
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
// Mouse filtering propagates down the stack, so the
// correct order is
// 1. middleItem filters event
// 2. bottomItem filters event
// 3. topItem receives event
Stabilized tst_qquickcanvas For some reason the mouseFiltering() and headless() cases fail if the touch test cases run first. Change-Id: I30839b09e9f7b287c88e6983424add5cf40a6d1a Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-01-13 15:58:47 +00:00
QTRY_COMPARE(middleItem->mousePressId, 1);
QTRY_COMPARE(bottomItem->mousePressId, 2);
QTRY_COMPARE(topItem->mousePressId, 3);
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Fix order of QSGItem mouse filtering. QGraphicsView filtered child items beginning with the item's parent, grandparent, greatgrandparent... QSGCanvas did the opposite, which breaks the QML mouse handling element filtering logic. Task-number: QTBUG-21446 Change-Id: I18e125305eef536237195895a7f41f88b532d4aa Reviewed-on: http://codereview.qt-project.org/5819 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Bea Lam <bea.lam@nokia.com>
2011-10-03 00:59:16 +00:00
}
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::qmlCreation()
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
{
Rename QDeclarative symbols to QQuick and QQml Symbols beginning with QDeclarative are already exported by the quick1 module. Users can apply the bin/rename-qtdeclarative-symbols.sh script to modify client code using the previous names of the renamed symbols. Task-number: QTBUG-23737 Change-Id: Ifaa482663767634931e8711a8e9bf6e404859e66 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-16 04:43:03 +00:00
QQmlEngine engine;
QQmlComponent component(&engine);
QDeclarative tests: Introduce base class for data tests. In tests/auto/shared/util.* replace macros/find functions by a base class QDeclarativeDataTest with accessors for the data directory helper functions to create URLs from it. The class relies on QFINDTESTDATA, which is the standard way of locating test data. Using the class should reduce the number of calls to QFileInfo.exists(), etc significantly. In addition, provide utility functions for messages. Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Change-Id: Id2beacb157922ee9412f9e45cf9695cec1f8379a Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2011-12-21 08:06:26 +00:00
component.loadUrl(testFileUrl("window.qml"));
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
QObject* created = component.create();
QVERIFY(created);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
QCOMPARE(window->color(), QColor(Qt::green));
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickItem* item = window->findChild<QQuickItem*>("item");
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
QVERIFY(item);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QCOMPARE(item->window(), window);
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::clearColor()
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
{
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
//::grab examines rendering to make sure it works visually
QQuickWindow *window = new QQuickWindow;
window->resize(250, 250);
window->setPos(100, 100);
window->setColor(Qt::blue);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QCOMPARE(window->color(), QColor(Qt::blue));
delete window;
Initial window implementation Includes adding a color property on QQuickCanvas. Note that most Window related properties come from the QWindow inheritance. Task-number: QTBUG-19799 Change-Id: I00f6c90a1e2a5c85d787793d6edac2cd7d5309ab Reviewed-by: Alan Alpert <alan.alpert@nokia.com>
2011-11-18 09:32:56 +00:00
}
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::grab()
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
{
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow window;
window.setColor(Qt::red);
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
window.resize(250, 250);
window.show();
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTest::qWaitForWindowShown(&window);
Stabilize tests Change-Id: Iafaf645787dfecfbe044dd87dbfdbb884a75040b Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-01-30 09:34:55 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QImage content = window.grabWindow();
QCOMPARE(content.width(), window.width());
QCOMPARE(content.height(), window.height());
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
QCOMPARE((uint) content.convertToFormat(QImage::Format_RGB32).pixel(0, 0), (uint) 0xffff0000);
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::multipleWindows()
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
{
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QList<QQuickWindow *> windows;
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
for (int i=0; i<6; ++i) {
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *c = new QQuickWindow();
c->setColor(Qt::GlobalColor(Qt::red + i));
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
c->resize(300, 200);
c->setPos(100 + i * 30, 100 + i * 20);
c->show();
windows << c;
Don't use QWindow::visible The deprecated method (in favor of QWindow::isVisible) is going away. Change-Id: I1ead05f8d74800a29c315ca4ca74577e89314882 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-04-16 14:14:00 +00:00
QVERIFY(c->isVisible());
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
}
// move them
for (int i=0; i<windows.size(); ++i) {
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *c = windows.at(i);
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
c->setPos(c->x() - 10, c->y() - 10);
}
// resize them
for (int i=0; i<windows.size(); ++i) {
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *c = windows.at(i);
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
c->resize(200, 150);
}
qDeleteAll(windows);
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::animationsWhileHidden()
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
{
Rename QDeclarative symbols to QQuick and QQml Symbols beginning with QDeclarative are already exported by the quick1 module. Users can apply the bin/rename-qtdeclarative-symbols.sh script to modify client code using the previous names of the renamed symbols. Task-number: QTBUG-23737 Change-Id: Ifaa482663767634931e8711a8e9bf6e404859e66 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-16 04:43:03 +00:00
QQmlEngine engine;
QQmlComponent component(&engine);
QDeclarative tests: Introduce base class for data tests. In tests/auto/shared/util.* replace macros/find functions by a base class QDeclarativeDataTest with accessors for the data directory helper functions to create URLs from it. The class relies on QFINDTESTDATA, which is the standard way of locating test data. Using the class should reduce the number of calls to QFileInfo.exists(), etc significantly. In addition, provide utility functions for messages. Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Change-Id: Id2beacb157922ee9412f9e45cf9695cec1f8379a Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2011-12-21 08:06:26 +00:00
component.loadUrl(testFileUrl("AnimationsWhileHidden.qml"));
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
QObject* created = component.create();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
QVERIFY(window->isVisible());
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
// Now hide the window and verify that it went off screen
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
window->hide();
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
QTest::qWait(10);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(!window->isVisible());
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
// Running animaiton should cause it to become visible again shortly.
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTRY_VERIFY(window->isVisible());
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::headless()
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
{
Rename QDeclarative symbols to QQuick and QQml Symbols beginning with QDeclarative are already exported by the quick1 module. Users can apply the bin/rename-qtdeclarative-symbols.sh script to modify client code using the previous names of the renamed symbols. Task-number: QTBUG-23737 Change-Id: Ifaa482663767634931e8711a8e9bf6e404859e66 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-16 04:43:03 +00:00
QQmlEngine engine;
QQmlComponent component(&engine);
QDeclarative tests: Introduce base class for data tests. In tests/auto/shared/util.* replace macros/find functions by a base class QDeclarativeDataTest with accessors for the data directory helper functions to create URLs from it. The class relies on QFINDTESTDATA, which is the standard way of locating test data. Using the class should reduce the number of calls to QFileInfo.exists(), etc significantly. In addition, provide utility functions for messages. Reviewed-by: Michael Brasser <michael.brasser@nokia.com> Change-Id: Id2beacb157922ee9412f9e45cf9695cec1f8379a Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
2011-12-21 08:06:26 +00:00
component.loadUrl(testFileUrl("Headless.qml"));
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QObject* created = component.create();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(window->isVisible());
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QSignalSpy initialized(window, SIGNAL(sceneGraphInitialized()));
QSignalSpy invalidated(window, SIGNAL(sceneGraphInvalidated()));
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
// Verify that the window is alive and kicking
QVERIFY(window->openglContext() != 0);
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
// Store the visual result
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QImage originalContent = window->grabWindow();
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
// Hide the window and verify signal emittion and GL context deletion
window->hide();
window->releaseResources();
Introduced QQuickCanvas::releaseResources(). This function can be used in certain situations to purge the texture cache and triggers more lazily to take down the scene graph and GL context Change-Id: Icd9360ff50fda0e721ba0f1b520cda678e457a35 Reviewed-by: Aaron Kennedy <aaron.kennedy@nokia.com>
2012-02-15 10:32:02 +00:00
QTRY_COMPARE(invalidated.size(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(window->openglContext() == 0);
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
// Destroy the native windowing system buffers
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
window->destroy();
QVERIFY(window->handle() == 0);
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
// Show and verify that we are back and running
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
Fix QQuickCanvas test failure. Switch to a QTRY_COMPARE to allow a little more time processing the event loop. Change-Id: I4f14feb5cbc7d11654f6c9089baff4ae67d894db Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-03-19 07:27:38 +00:00
QTRY_COMPARE(initialized.size(), 1);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(window->openglContext() != 0);
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
// Verify that the visual output is the same
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QImage newContent = window->grabWindow();
Implement "headless mode" for hidden QQuickCanvases When all views are hidden, we stop the rendering thread, kill the OpenGL context and all scene graph content. The entire scenegraph is recreated based on the QML scene when a view is shown again. Change-Id: I734619d9f29263a5cdecbcc9b88c3808d1d64a7f Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2011-12-08 12:24:17 +00:00
QCOMPARE(originalContent, newContent);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Implemented multiple windows and GL context sharing What was traditionally the QQuickRenderLoop which was used to support one QQuickCanvas instance has now grown to support multiple QQuickCanvas instances and is now called QQuickWindowManager, of which there are two implementations. QQuickRenderThreadSingleContextWindowManager: One QSGContext and one OpenGL context is being used to draw all the windows and we alternate between which surface the gl context is bound to. This implementation relies on that swap does not block, but that the graphics pipeline is vsynced and will eventually block as the buffer queue is filled up. This is the behavior we get on Mac OS X and Wayland. The benefit of this implementation is that we have vsync'ed animations, and the synchronizaiton between GUI and render thread is simple. (well, simple relative to the alternative, that is). QQuickTrivialWindowManager: One QSGContext and one OpenGL context is being used on the GUI thread. Animations are ticked from a timer. Performance of this implementation will deteriorate if the driver is using blocking swap. Task-number: QTBUG-19455 Change-Id: Ib961ac7d71eb49c70a057872b7cac020c4d19f3d Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2011-12-07 09:16:20 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::focusObject()
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
{
Rename QDeclarative symbols to QQuick and QQml Symbols beginning with QDeclarative are already exported by the quick1 module. Users can apply the bin/rename-qtdeclarative-symbols.sh script to modify client code using the previous names of the renamed symbols. Task-number: QTBUG-23737 Change-Id: Ifaa482663767634931e8711a8e9bf6e404859e66 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-02-16 04:43:03 +00:00
QQmlEngine engine;
QQmlComponent component(&engine);
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
component.loadUrl(testFileUrl("focus.qml"));
QObject *created = component.create();
QVERIFY(created);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow *window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickItem *item1 = window->findChild<QQuickItem*>("item1");
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
QVERIFY(item1);
item1->setFocus(true);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QCOMPARE(item1, window->focusObject());
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickItem *item2 = window->findChild<QQuickItem*>("item2");
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
QVERIFY(item2);
item2->setFocus(true);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QCOMPARE(item2, window->focusObject());
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
reimplement QWindow::focusObject() on QQuickCanvas Change-Id: I935a303d0baa9500ab47f749eb3b3f9a11a70946 Reviewed-by: Lars Knoll <lars.knoll@nokia.com> Reviewed-by: Joona Petrell <joona.t.petrell@nokia.com>
2012-01-20 13:38:51 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::ignoreUnhandledMouseEvents()
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
{
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow* window = new QQuickWindow;
window->resize(100, 100);
window->show();
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
QQuickItem* item = new QQuickItem;
item->setSize(QSizeF(100, 100));
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
item->setParentItem(window->rootItem());
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
{
QMouseEvent me(QEvent::MouseButtonPress, QPointF(50, 50), Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier);
me.setAccepted(true);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(QCoreApplication::sendEvent(window, &me));
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
QVERIFY(!me.isAccepted());
}
{
QMouseEvent me(QEvent::MouseMove, QPointF(51, 51), Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier);
me.setAccepted(true);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(QCoreApplication::sendEvent(window, &me));
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
QVERIFY(!me.isAccepted());
}
{
QMouseEvent me(QEvent::MouseButtonRelease, QPointF(51, 51), Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier);
me.setAccepted(true);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QVERIFY(QCoreApplication::sendEvent(window, &me));
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
QVERIFY(!me.isAccepted());
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
delete window;
Fix acceptance of unhandled mouse events. Mouse events not handled by the canvas need to be ignored, in order for features like touch synthetization to work. In case of the initially delivered mouse press event, the canvas did not ignore the event if it was not handled. This patch corrects that and adds an auto-test to verify the new behaviour. Change-Id: I8499701f5a161ce1e90a70303aa7ca4ccf2f0b6f Reviewed-by: Andras Becsi <andras.becsi@nokia.com> Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-02-03 13:41:17 +00:00
}
Set rootItem'ownership as CppOwnerShip rootItem should not be deleted until the QQuickCanvas itself has been deleted. Set the rootItem's object ownership to CppOwnerShip can prevent it being destroyed by javascript destroy() method or v8 garbage collection. Change-Id: I7d83fec8ffcb8062d143b1b050a38368a2af800f Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com> Reviewed-by: J-P Nurmi <j-p.nurmi@nokia.com>
2012-04-17 06:47:33 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
void tst_qquickwindow::ownershipRootItem()
Set rootItem'ownership as CppOwnerShip rootItem should not be deleted until the QQuickCanvas itself has been deleted. Set the rootItem's object ownership to CppOwnerShip can prevent it being destroyed by javascript destroy() method or v8 garbage collection. Change-Id: I7d83fec8ffcb8062d143b1b050a38368a2af800f Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com> Reviewed-by: J-P Nurmi <j-p.nurmi@nokia.com>
2012-04-17 06:47:33 +00:00
{
qmlRegisterType<RootItemAccessor>("QtQuick", 2, 0, "RootItemAccessor");
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("ownershipRootItem.qml"));
QObject* created = component.create();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
QtDeclarative: Remove usage of deprecated qWaitForWindowShown(). - Replace by qWaitForWindowExposed() or qWaitForWindowActive() where applicable. - Use QVERIFY to verify success. - Stabilize some tests by checking for 'active', add missing call to show(). Change-Id: I6cae063e44a3839760ed9f61dacb26cd1717118d Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-19 12:13:14 +00:00
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
Set rootItem'ownership as CppOwnerShip rootItem should not be deleted until the QQuickCanvas itself has been deleted. Set the rootItem's object ownership to CppOwnerShip can prevent it being destroyed by javascript destroy() method or v8 garbage collection. Change-Id: I7d83fec8ffcb8062d143b1b050a38368a2af800f Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com> Reviewed-by: J-P Nurmi <j-p.nurmi@nokia.com>
2012-04-17 06:47:33 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
RootItemAccessor* accessor = window->findChild<RootItemAccessor*>("accessor");
Set rootItem'ownership as CppOwnerShip rootItem should not be deleted until the QQuickCanvas itself has been deleted. Set the rootItem's object ownership to CppOwnerShip can prevent it being destroyed by javascript destroy() method or v8 garbage collection. Change-Id: I7d83fec8ffcb8062d143b1b050a38368a2af800f Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com> Reviewed-by: Martin Jones <martin.jones@nokia.com> Reviewed-by: J-P Nurmi <j-p.nurmi@nokia.com>
2012-04-17 06:47:33 +00:00
QVERIFY(accessor);
engine.collectGarbage();
QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
QCoreApplication::processEvents();
QVERIFY(!accessor->isRootItemDestroyed());
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTEST_MAIN(tst_qquickwindow)
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
#include "tst_qquickwindow.moc"