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

1218 lines
44 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 Digia's license headers Change-Id: I6c3bd7bebe3d62d1cfd0fa6334544c9db8398c76 Reviewed-by: Akseli Salovaara <akseli.salovaara@digia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@digia.com>
2013-01-02 11:17:46 +00:00
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: Ie7f5d49ed8235d7a7845ab68f99ad1c220e64d5c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-09-20 05:21:40 +00:00
** Contact: http://www.qt-project.org/legal
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$
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: Ie7f5d49ed8235d7a7845ab68f99ad1c220e64d5c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-09-20 05:21:40 +00:00
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
** GNU Lesser General Public License Usage
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: Ie7f5d49ed8235d7a7845ab68f99ad1c220e64d5c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-09-20 05:21:40 +00:00
** Alternatively, 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
**
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: Ie7f5d49ed8235d7a7845ab68f99ad1c220e64d5c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-09-20 05:21:40 +00:00
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia 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
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: Ie7f5d49ed8235d7a7845ab68f99ad1c220e64d5c Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-09-20 05:21:40 +00:00
** 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
**
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>
Don't use compatibility headers Cleaning up after the QWindowSystemInterface header change. Change-Id: Icc2df3cfd441bf6b113602f17d9b843fbc8c75ba Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
2012-08-03 11:48:46 +00:00
#include <qpa/qwindowsysteminterface.h>
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)
{
}
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
Q_INVOKABLE QQuickItem *contentItem()
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
{
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());
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
m_rootItem = c->contentItem;
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
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();
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
#ifndef QT_NO_CURSOR
void cursor();
#endif
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);
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
ConstantUpdateItem item(window.contentItem());
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();
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
TestTouchItem *bottomItem = new TestTouchItem(window->contentItem());
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");
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
middleItem->setPosition(QPointF(50, 50));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
middleItem->setSize(QSizeF(150, 150));
TestTouchItem *topItem = new TestTouchItem(middleItem);
topItem->setObjectName("Top Item");
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
topItem->setPosition(QPointF(50, 50));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
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());
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
// At one point this was failing with kwin (KDE window manager) because window->setPosition(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
// 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
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
TestTouchItem *bottomItem = new TestTouchItem(window->contentItem());
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");
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
middleItem->setPosition(QPointF(50, 50));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
middleItem->setSize(QSizeF(150, 150));
TestTouchItem *topItem = new TestTouchItem(middleItem);
topItem->setObjectName("Top Item");
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
topItem->setPosition(QPointF(50, 50));
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
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
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
TestTouchItem *item = new TestTouchItem(window->contentItem());
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
item->setPosition(QPointF(50, 50));
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->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
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
TestTouchItem *item = new TestTouchItem(window->contentItem());
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
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
item->setPosition(QPointF(50, 50));
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->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
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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);
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
TestTouchItem *item = new TestTouchItem(window->contentItem());
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
item->setPosition(QPointF(50, 50));
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->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
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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);
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
TestTouchItem *item = new TestTouchItem(window->contentItem());
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
item->setPosition(QPointF(50, 50));
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->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
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;
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
item->setParentItem(window->contentItem());
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
TestTouchItem *bottomItem = new TestTouchItem(window->contentItem());
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");
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
middleItem->setPosition(QPointF(50, 50));
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
middleItem->setSize(QSizeF(150, 150));
TestTouchItem *topItem = new TestTouchItem(middleItem);
topItem->setObjectName("Top Item");
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
topItem->setPosition(QPointF(50, 50));
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
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);
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();
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QObject> cleanup(created);
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(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);
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
window->resize(250, 250);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
window->setPosition(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
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));
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
QtQuick: Remove usages of qWaitForWindowShown(QWindow *). Change-Id: I722e20b2fb8d8c6c19c6f3f2cb16910d7433e9a4 Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
2012-07-24 12:56:35 +00:00
QVERIFY(QTest::qWaitForWindowExposed(&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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup[6];
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);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
c->setPosition(100 + i * 30, 100 + i * 20);
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->show();
windows << c;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
cleanup[i].reset(c);
QVERIFY(QTest::qWaitForWindowExposed(c));
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);
Renamed QWindow::pos property to position Abbreviated properties are to be avoided, and this is a new class so we have a good opportunity to avoid it before the release. Related to qtbase change I19c00b54b1d2712f9418e8bcf56e35a8008b89ef Change-Id: Ibd5cd10814c8cbd2b1f6e49b70782c7768d2366d Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 15:09:06 +00:00
c->setPosition(100 + i * 30, 100 + i * 20 + 100);
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
}
// 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);
}
}
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();
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QObject> cleanup(created);
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 = 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
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();
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QObject> cleanup(created);
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
QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
window->show();
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);
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();
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QObject> cleanup(created);
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(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
Do not force focus for non-focused windows. If a QQuickWindow comes to screen but is not the focus window, such as if it is a child window of another window, it should not have focus by default. Change-Id: If9015bbc179bb101178b3bc8de176a1c71c46023 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Andy Nichols <andy.nichols@digia.com>
2013-01-11 11:35:01 +00:00
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
window->requestActivate();
QVERIFY(QTest::qWaitForWindowActive(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
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
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;
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QQuickWindow> cleanup(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
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));
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
item->setParentItem(window->contentItem());
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());
}
}
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
{
Implement strict mode for qmldir modules Allow a module's qmldir to contain a module directive, which when present specifies 'strict mode' import processing. In strict mode, type registrations are only permitted into the namespace identified in the qmldir file's module directive. In addition, any type registrations to that namespace originating from other modules are treated as error conditions. Task-number: QTBUG-26551 Change-Id: I081bde2d3b83d3f28524440177fb2cd1ccee34ad Reviewed-by: Chris Adams <christopher.adams@nokia.com> Reviewed-by: Roberto Raggi <roberto.raggi@nokia.com>
2012-07-25 06:59:17 +00:00
qmlRegisterType<RootItemAccessor>("Test", 1, 0, "RootItemAccessor");
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
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("ownershipRootItem.qml"));
QObject* created = component.create();
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +00:00
QScopedPointer<QObject> cleanup(created);
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
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());
}
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
#ifndef QT_NO_CURSOR
void tst_qquickwindow::cursor()
{
QQuickWindow window;
window.resize(320, 240);
QQuickItem parentItem;
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
parentItem.setPosition(QPointF(0, 0));
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
parentItem.setSize(QSizeF(180, 180));
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
parentItem.setParentItem(window.contentItem());
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
QQuickItem childItem;
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
childItem.setPosition(QPointF(60, 90));
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
childItem.setSize(QSizeF(120, 120));
childItem.setParentItem(&parentItem);
QQuickItem clippingItem;
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
clippingItem.setPosition(QPointF(120, 120));
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
clippingItem.setSize(QSizeF(180, 180));
clippingItem.setClip(true);
Remove interim compatibility measures Also update some variables in qtdeclarative which failed to update rootItem->contentItem. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d3 Reviewed-by: Alan Alpert <416365416c@gmail.com>
2012-08-07 01:26:37 +00:00
clippingItem.setParentItem(window.contentItem());
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
QQuickItem clippedItem;
Renamed QQuickItem::pos property to position Abbreviated property names are less descriptive so we don't have many of them. Might as well be consistent. QWindow::pos was already renamed. Change-Id: Ib52673e68e7dc902b2f8942dba6b899074b2538b Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-10-22 14:59:25 +00:00
clippedItem.setPosition(QPointF(-30, -30));
Fix resolution of cursor when items are overlapping. If MouseArea with cursorShapes are overlapping then cursor shape of the foremost item under the mouse cursor should be shown, but because the hover events are delivered to the foremost items first the opposite is occuring. This makes QQuickWindow responsible for correctly setting its own cursor instead of relying on items to work it out amongst themselves. Change-Id: Iedf144c583dfa3d1ff441e19db9601b5e171902a Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-25 04:04:47 +00:00
clippedItem.setSize(QSizeF(120, 120));
clippedItem.setParentItem(&clippingItem);
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
// Position the cursor over the parent and child item and the clipped section of clippedItem.
QTest::mouseMove(&window, QPoint(100, 100));
// No items cursors, window cursor is the default arrow.
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
// The section of clippedItem under the cursor is clipped, and so doesn't affect the window cursor.
clippedItem.setCursor(Qt::ForbiddenCursor);
QCOMPARE(clippedItem.cursor().shape(), Qt::ForbiddenCursor);
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
// parentItem is under the cursor, so the window cursor is changed.
parentItem.setCursor(Qt::IBeamCursor);
QCOMPARE(parentItem.cursor().shape(), Qt::IBeamCursor);
QCOMPARE(window.cursor().shape(), Qt::IBeamCursor);
// childItem is under the cursor and is in front of its parent, so the window cursor is changed.
childItem.setCursor(Qt::WaitCursor);
QCOMPARE(childItem.cursor().shape(), Qt::WaitCursor);
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
childItem.setCursor(Qt::PointingHandCursor);
QCOMPARE(childItem.cursor().shape(), Qt::PointingHandCursor);
QCOMPARE(window.cursor().shape(), Qt::PointingHandCursor);
// childItem is the current cursor item, so this has no effect on the window cursor.
parentItem.unsetCursor();
QCOMPARE(parentItem.cursor().shape(), Qt::ArrowCursor);
QCOMPARE(window.cursor().shape(), Qt::PointingHandCursor);
parentItem.setCursor(Qt::IBeamCursor);
QCOMPARE(parentItem.cursor().shape(), Qt::IBeamCursor);
QCOMPARE(window.cursor().shape(), Qt::PointingHandCursor);
// With the childItem cursor cleared, parentItem is now foremost.
childItem.unsetCursor();
QCOMPARE(childItem.cursor().shape(), Qt::ArrowCursor);
QCOMPARE(window.cursor().shape(), Qt::IBeamCursor);
// Setting the childItem cursor to the default still takes precedence over parentItem.
childItem.setCursor(Qt::ArrowCursor);
QCOMPARE(childItem.cursor().shape(), Qt::ArrowCursor);
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
childItem.setCursor(Qt::WaitCursor);
QCOMPARE(childItem.cursor().shape(), Qt::WaitCursor);
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
// Move the cursor so it is over just parentItem.
QTest::mouseMove(&window, QPoint(20, 20));
QCOMPARE(window.cursor().shape(), Qt::IBeamCursor);
// Move the cursor so that is over all items, clippedItem wins because its a child of
// clippingItem which is in from of parentItem in painting order.
QTest::mouseMove(&window, QPoint(125, 125));
QCOMPARE(window.cursor().shape(), Qt::ForbiddenCursor);
// Over clippingItem only, so no cursor.
QTest::mouseMove(&window, QPoint(200, 280));
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
// Over no item, so no cursor.
QTest::mouseMove(&window, QPoint(10, 280));
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
// back to the start.
QTest::mouseMove(&window, QPoint(100, 100));
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
// Try with the mouse pressed.
QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(100, 100));
QTest::mouseMove(&window, QPoint(20, 20));
QCOMPARE(window.cursor().shape(), Qt::IBeamCursor);
QTest::mouseMove(&window, QPoint(125, 125));
QCOMPARE(window.cursor().shape(), Qt::ForbiddenCursor);
QTest::mouseMove(&window, QPoint(200, 280));
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
QTest::mouseMove(&window, QPoint(10, 280));
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
QTest::mouseMove(&window, QPoint(100, 100));
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(100, 100));
// Remove the cursor item from the scene. Theoretically this should make parentItem the
// cursorItem, but given the situation will correct itself after the next mouse move it's
// probably better left as is to avoid unnecessary work during tear down.
childItem.setParentItem(0);
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
parentItem.setCursor(Qt::SizeAllCursor);
QCOMPARE(parentItem.cursor().shape(), Qt::SizeAllCursor);
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
// Changing the cursor of an un-parented item doesn't affect the window's cursor.
childItem.setCursor(Qt::ClosedHandCursor);
QCOMPARE(childItem.cursor().shape(), Qt::ClosedHandCursor);
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
childItem.unsetCursor();
QCOMPARE(childItem.cursor().shape(), Qt::ArrowCursor);
QCOMPARE(window.cursor().shape(), Qt::WaitCursor);
QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(100, 101));
QCOMPARE(window.cursor().shape(), Qt::SizeAllCursor);
}
#endif
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"