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

2448 lines
87 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
/****************************************************************************
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I04760a0801837cfc516d1c7c02d4f503f6bb70b6 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 11:23:05 +00:00
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
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.
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I04760a0801837cfc516d1c7c02d4f503f6bb70b6 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 11:23:05 +00:00
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
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
Update copyright headers Qt copyrights are now in The Qt Company, so we could update the source code headers accordingly. In the same go we should also fix the links to point to qt.io. Change-Id: I61120571787870c0ed17066afb31779b1e6e30e9 Reviewed-by: Iikka Eklund <iikka.eklund@theqtcompany.com>
2015-01-28 11:55:39 +00:00
** a written agreement between you and The Qt Company. For licensing terms
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I04760a0801837cfc516d1c7c02d4f503f6bb70b6 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 11:23:05 +00:00
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
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
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I04760a0801837cfc516d1c7c02d4f503f6bb70b6 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-19 11:23:05 +00:00
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
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>
Add Window attached property on Item An Item sometimes needs to know a few things about the window in which it is being displayed; this attached property can expose them without needing to go up the heirarchy to find the window. Instead of adding the QQuickWindow pointer as a property on Item as in 8f49f50a169db85401eb37daf4fe3a0fc3280603, having an attached property means that it will not be found by introspection; and it solves the problem that Window is in the QtQuick.Window module: you must import the module to use the attached property, instead of having access to a pointer whose type might not be defined if you didn't import it. The Window attached property is created on-demand (so the memory cost adds up if you use it in too many places); the tradeoff is that it can exist even when the item is not yet being shown in a window, so bindings at startup work. The API is purposely incomplete compared to that in QQuickWindow so that we can introduce what is needed in a controlled fasion over time. For now we know of use cases for visibility, active and activeFocusItem. [ChangeLog][QtQuick][Window] Added Item.Window attached property Change-Id: I649404cbd1383326678aa2144f790b2f2542dbbc Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
2014-08-07 11:57:50 +00:00
#include <QtQuick/QQuickView>
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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>
Avoid double deletion of QQuickWindow It's uncertain why 4fc0df58b8458052a818e3e970a97457882808e6 added the call to sendPostedEvents(0, QEvent::DeferredDelete) but now we can see that it easily results in the destructor calling itself, and therefore double-deleting its own d_ptr. removePostedEvents seems safer to ensure that the window cannot be doubly deleted, in spite of the qdoc warning that "You should never need to call this function." Task-number: QTBUG-33436 Change-Id: I4873ebe179dde551407eba1f6baac5f03ca7f177 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-09-17 13:05:04 +00:00
#include <QtQuick/private/qquickloader_p.h>
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 "../../shared/util.h"
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
#include "../shared/visualtestutil.h"
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
#include "../shared/viewtestutil.h"
Use QSignalSpy to save some code Change-Id: If4a9b68c39facdca34482bbf3dc22ae607b294e8 Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
2012-01-04 13:50:52 +00:00
#include <QSignalSpy>
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
#include <private/qquickwindow_p.h>
Propagate synthesized mouse events in parallel with touch. The old way of event propagation inside QQuickCanvas was to send the touch event through all elements, and if it was accepted along the way, stop. Otherwise generate a mouse event and propagate it through the items in the same way. With this patch the behavior is changed instead to do the propagation in parallel. The idea is to first send a touch, then a mouse event to each QML item (in paint order) that can potentially handle the events. When items filter their child elements, the same logic applies. Other changes/clarifications: - mouse events no longer get synthesized for more than one touch point - TouchPoints can be distributed to multiple Items - if an item accepts a touch point, it always gets updates, even if the point is stationary - events containing only stationary TouchPoints are discarded - PinchArea must accept any initial single TouchPoint in order to receive subsequent updates, even though it's not pinching yet. This means if PA is on top, items underneath don't get touches. New unit tests showing this behavior were added. This patch was written by Frederik Gladhorn, Laszlo Agocs and Shawn Rutledge. Due to the complexity of the logic some refactoring was done. QQuickMouseEventEx has been removed because it inherently relied on using the QEvent d pointer. Change-Id: If19ef687d7602e83cc11b18d2fecfbbdb4e44f5c Reviewed-by: Frederik Gladhorn <frederik.gladhorn@nokia.com>
2012-06-26 16:00:59 +00:00
#include <private/qguiapplication_p.h>
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
#include <QRunnable>
Prefix GL-specific shader effect code Rename the C++ sources and classes. The QML type name remains the same. No changes in functionality. The shader effect, node, material (and uniform animator and particles and bits and pieces here and there...) are highly interconnected and do not follow the usual design practices for Quick and the scenegraph and the adaptation layer. Therefore while we aim for keeping full compatibility for GL apps, other backends will likely get a different ShaderEffect item implementation. The C++ class QQuickShaderEffect itself is currently a dummy with an unchanged API. It is not in use for now but forms the basis for the implementation for other backends. This will be covered in future commits. Change-Id: Ia39ce4b303f8f33e2f241d11e35fa62423e43127 Reviewed-by: Andy Nichols <andy.nichols@theqtcompany.com>
2016-04-11 12:49:12 +00:00
#include <QOpenGLFunctions>
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
#include <QSGRendererInterface>
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;
Let TestTouchItem::reset reset the event count Change-Id: I37ddf4d45fd3457decb35a597876008ea9d09d11 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-31 21:31:56 +00:00
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
}
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
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
class EventFilter : public QObject
{
public:
bool eventFilter(QObject *watched, QEvent *event) {
Q_UNUSED(watched);
events.append(event->type());
return false;
}
QList<int> events;
};
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:
Support alpha in QQuickWindow::grabWindow(). Change-Id: I2dd69745427d8f5e882303d2a4de3935ddca02e9 Task-number: QTBUG-48787 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-10-15 13:21:17 +00:00
tst_qquickwindow()
tst_qquickwindow: make use of new QTest::createTouchDevice function So gui-private API isn't necessary anymore. Same as change 94324bd93fe9f4f61346b8f9e934c01279cb700e Task-number: QTBUG-44030 Change-Id: I780cc1eedf9285336b96219a1fb1cd4016512701 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-13 12:42:47 +00:00
: touchDevice(QTest::createTouchDevice())
, touchDeviceWithVelocity(QTest::createTouchDevice())
Support alpha in QQuickWindow::grabWindow(). Change-Id: I2dd69745427d8f5e882303d2a4de3935ddca02e9 Task-number: QTBUG-48787 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-10-15 13:21:17 +00:00
{
QQuickWindow::setDefaultAlphaBuffer(true);
tst_qquickwindow: make use of new QTest::createTouchDevice function So gui-private API isn't necessary anymore. Same as change 94324bd93fe9f4f61346b8f9e934c01279cb700e Task-number: QTBUG-44030 Change-Id: I780cc1eedf9285336b96219a1fb1cd4016512701 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-13 12:42:47 +00:00
touchDeviceWithVelocity->setCapabilities(QTouchDevice::Position | QTouchDevice::Velocity);
Support alpha in QQuickWindow::grabWindow(). Change-Id: I2dd69745427d8f5e882303d2a4de3935ddca02e9 Task-number: QTBUG-48787 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-10-15 13:21:17 +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
private slots:
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
void cleanup();
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
void openglContextCreatedSignal();
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#endif
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
void aboutToStopSignal();
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();
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
void constantUpdatesOnWindow_data();
void constantUpdatesOnWindow();
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();
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
void noUpdateWhenNothingChanges();
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();
Add mergePointerTargets to create pointer delivery list This code joins lists of "target item" which are joins of where several touch points should be delivered. Change-Id: I15ab4b7f70b8930d15368bf4cba0893ab339fa2a Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-12 14:16:28 +00:00
void mergeTouchPointLists_data();
void mergeTouchPointLists();
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 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();
Ensure that QML Windows respect the default platform window state The 'visible' property of a Window would be set on the baseclass QWindow like any other property during QML component creation, which would cause create() to be called and the platform window would be created. This left the 'visibility' of the QML window as Windowed, not respecting the platform defaults for how windows should be shown. The user would have to explicitly set "visibility: Window.AutomaticVisibility" for this default to apply, which doesn't make sense -- it should be the default. We solve this by deferring setVisible and setVisibility on the window until the component is complete and we have a full picture of its state. We then ask the platform for the default state based on the window flags (ensuring that eg "flags: Qt.Popup" will not result in maximized windows on iOS and Android), and apply the deferred visibility. The deferred visibility may still be 'false', but setting the window state makes sense anyways, so that a later "visible = true" will apply the default window state. Deferring platform window creation until the geometry has been potentially set from user code also has the benefit that the platform window can check the geometry and apply a default geometry if it's null. This was not possible when the 'visible' property was a regular property, as you could not know if the user's geometry changes would come after platform window creation. Task-number: QTBUG-35174 Change-Id: Icf3236187992048a85b2196c059f9b54699041a4 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Robin Burchell <robin+qt@viroteck.net> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-11-27 16:57:25 +00:00
void defaultState();
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
Implement QQuickWindow::grabWindow() for isVisible=false Webkit uses this for testing. Change-Id: I4539e169a02592fb6c0062903917d4dd23a4303c Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>
2013-04-18 15:02:24 +00:00
void grab_data();
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();
Store information about focus reason in QQuickWindowPrivate QtQuickControl's Desktop style needs to know whether the last focus change was requested by keyboard or not. With this information the Desktop style is able to set the QStyleOption accordingly. Without the flag, some of the QStyles (QFusionStyle, QGtkStyle) don't render a focus rectangle. This patch is needed by #change,84389 in QtQuickControls Change-Id: Ia06f56b018cd35eea933892a4c50e0aa7328042d Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2014-04-30 18:33:07 +00:00
void focusReason();
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
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
Complete rewrite of threaded render loop. This change starts using the superior implementation of the scene graph render loop which has been worked on in the scenegraph-playground project for a while. It uses a far more straightforward locking/sync paradigm compared to the existing one and is less deadlock and error prone. It also enables the scene graph thread to run on its own when the GUI thread is blocked, enabling threaded animations. This changes also introduces a naming change inside Qt Quick from "Window Manager" -> "Render Loop" as that fits better to what the code does. Change-Id: I1c2170ee04fcbef79660bd7dae6cace647cdb276 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-12-05 14:27:47 +00:00
void hideThenDelete_data();
void hideThenDelete();
void showHideAnimate();
Make sure exposeEvents trigger a render pass We needs this on non-compositing window managers to trigger repaints on partial updates. Change-Id: Ied5f3e854173c5e00ad7e1222aeb66eb9c96158c Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-20 18:39:11 +00:00
void testExpose();
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
void requestActivate();
Behavior fix when creating QML windows When a QML window is created it is set visible after the QQuickWindowQmlImpl component is complete. This works fine for a single window, but because componentCompleted is called first for the last created windows, the behavior is not as the user might expect (and different compared to version 2.0 of the QML Window API). One of the results is e.g. that a window which is created as a child object in QML will have a lower z-Order than the parent. On some platforms (e.g. BlackBerry) an even bigger problem arises because the first created window acts as a container for the whole application and is always shown fullscreen. On other platforms (Linux) the initial window position and the window focus ares not set correctly. This patch postpones showing windows until the "transientParent" is visible. [Changelog][QtQuick] Making a QtQuick Window visible is postponed till its transient parent is visible Task-number: QTBUG-37440 Change-Id: I09a94ff038c066a5d3298c6c103dafde50bef1fa Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-01-18 15:45:33 +00:00
void testWindowVisibilityOrder();
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
void blockClosing();
QQuickWindow autotest: verify that onClosing can block close() Task-number: QTBUG-40093 Change-Id: I800259f45d95736172d500494e68042180178e93 Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2014-11-07 11:54:16 +00:00
void blockCloseMethod();
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
Fix hover event crash It was possible for a hover event to be sent to a QQuickItem that has already been scheduled to be deleted (through deleteLater()). This lead to an access on an already-freed object when the leave event is generated. This change ensures that the item is part of a scene before generating the hover enter event. Task-number: QTBUG-32771 Change-Id: I69adb6bbd0ae52c70a6bda4e6c918b7671549a4c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-01 22:51:03 +00:00
void crashWhenHoverItemDeleted();
Avoid double deletion of QQuickWindow It's uncertain why 4fc0df58b8458052a818e3e970a97457882808e6 added the call to sendPostedEvents(0, QEvent::DeferredDelete) but now we can see that it easily results in the destructor calling itself, and therefore double-deleting its own d_ptr. removePostedEvents seems safer to ensure that the window cannot be doubly deleted, in spite of the qdoc warning that "You should never need to call this function." Task-number: QTBUG-33436 Change-Id: I4873ebe179dde551407eba1f6baac5f03ca7f177 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-09-17 13:05:04 +00:00
void unloadSubWindow();
Fix changing QML Window visibility in Component.onCompleted Creating a transient QML Window with visible set to false and then trying to show() it in Component.onCompleted led to a race condition where the window would be shown for a brief moment and then hidden again to enforce the delayed initialization of the visible property. Fixed by tracking the value of the visible property regardless of the 'completed' state. The same problem was fixed for the visibility property. Task-number: QTBUG-52573 Change-Id: I2a2ed7f359b951cb9189a7a6628d1d0cc1445d73 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2016-04-14 15:49:11 +00:00
void changeVisibilityInCompleted();
Avoid double deletion of QQuickWindow It's uncertain why 4fc0df58b8458052a818e3e970a97457882808e6 added the call to sendPostedEvents(0, QEvent::DeferredDelete) but now we can see that it easily results in the destructor calling itself, and therefore double-deleting its own d_ptr. removePostedEvents seems safer to ensure that the window cannot be doubly deleted, in spite of the qdoc warning that "You should never need to call this function." Task-number: QTBUG-33436 Change-Id: I4873ebe179dde551407eba1f6baac5f03ca7f177 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-09-17 13:05:04 +00:00
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
void qobjectEventFilter_touch();
void qobjectEventFilter_key();
void qobjectEventFilter_mouse();
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
Add a signal for syncing external animation systems [ChangeLog] QQuickWindow will now emit the afterAnimating() signal from the gui thread before each scenegraph sync request. Change-Id: I4897c82f75066238e781455d4fce4fb6bbe2558e Reviewed-by: Pasi Keränen <pasi.keranen@digia.com> Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2014-02-19 11:20:20 +00:00
void animatingSignal();
QQuickWindow: fix content item size Resize content item in QQuickWindow::resizeEvent() instead of using signals and slots. The signal-slot connections were only established when child items were added in QML. It should work in C++ too, since QQuickWindow and QQuickItem are part of the public C++ API and using them in C++ is a perfectly valid use case. Resizing the content item in resizeEvent() is not only faster than using signals and slots, but also in theory a bit more flexible as one would be able to override the event handler and implement their own layouting. Task-number: QTBUG-36938 Change-Id: Id05d4cf6d547021803050633e6f0a3359129a9f3 Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Mitch Curtis <mitch.curtis@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com> Reviewed-by: Jan Arve Sæther <jan-arve.saether@digia.com>
2014-02-21 14:04:21 +00:00
void contentItemSize();
Add defaultSurfaceFormat to QQuickWindow This static function can be used to set a surface format that is then picked up by all QQuickWindows, including the ones instantiated from QML. This introduces the ability to request higher OpenGL versions, core profile and other options also for windows that are created from QML via the ApplicationWindow element in Quick Controls applications. [ChangeLog] Added QQuickWindow::setDefaultSurfaceFormat() to set a surface format that applies to all Quick windows, including the ones created from QML. The OpenGL shading language version is now exposed to QML too in order to allow components to provide the correct shader source so shader effect items. Task-number: QTBUG-36392 Change-Id: I75a4718243d835894461f7ee0b4a383988840f9b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-19 14:43:49 +00:00
void defaultSurfaceFormat();
Add Window attached property on Item An Item sometimes needs to know a few things about the window in which it is being displayed; this attached property can expose them without needing to go up the heirarchy to find the window. Instead of adding the QQuickWindow pointer as a property on Item as in 8f49f50a169db85401eb37daf4fe3a0fc3280603, having an attached property means that it will not be found by introspection; and it solves the problem that Window is in the QtQuick.Window module: you must import the module to use the attached property, instead of having access to a pointer whose type might not be defined if you didn't import it. The Window attached property is created on-demand (so the memory cost adds up if you use it in too many places); the tradeoff is that it can exist even when the item is not yet being shown in a window, so bindings at startup work. The API is purposely incomplete compared to that in QQuickWindow so that we can introduce what is needed in a controlled fasion over time. For now we know of use cases for visibility, active and activeFocusItem. [ChangeLog][QtQuick][Window] Added Item.Window attached property Change-Id: I649404cbd1383326678aa2144f790b2f2542dbbc Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
2014-08-07 11:57:50 +00:00
void attachedProperty();
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
void testRenderJob();
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
void testHoverChildMouseEventFilter();
add tst_qquickwindow::eventPointCount Change-Id: I552cf69fa179d8b1260a5502e37553fa57bf32cf Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-13 12:55:50 +00:00
void pointerEventTypeAndPointCount();
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
};
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
Q_DECLARE_METATYPE(QOpenGLContext *);
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#endif
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
void tst_qquickwindow::cleanup()
{
QVERIFY(QGuiApplication::topLevelWindows().isEmpty());
}
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
void tst_qquickwindow::openglContextCreatedSignal()
{
qRegisterMetaType<QOpenGLContext *>();
QQuickWindow window;
Prefer to use normalised signal/slot signatures Change-Id: I9856c110399c4b6b1ea6aba2d92392cecff04656 Reviewed-by: Marc Mutz <marc.mutz@kdab.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2014-03-02 10:32:29 +00:00
QSignalSpy spy(&window, SIGNAL(openglContextCreated(QOpenGLContext*)));
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
window.show();
QTest::qWaitForWindowExposed(&window);
Change graphicsAPI to graphicsApi Change-Id: I065f17abd1cb71cd8d6ead76abf7a544eb7a99c0 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-06-01 07:58:27 +00:00
if (window.rendererInterface()->graphicsApi() != QSGRendererInterface::OpenGL)
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
QSKIP("Skipping OpenGL context test due to not running with OpenGL");
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
QVERIFY(spy.size() > 0);
QVariant ctx = spy.at(0).at(0);
Tests: Remove QT_DISABLE_DEPRECATED_BEFORE=0 for simple cases. Fix usage of API that is marked deprecated. Change-Id: Ia887437f99b9ce207891ca19bc49294acb7d629d Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-08-24 12:11:03 +00:00
QCOMPARE(qvariant_cast<QOpenGLContext *>(ctx), window.openglContext());
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
}
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#endif
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
void tst_qquickwindow::aboutToStopSignal()
{
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
window.show();
QTest::qWaitForWindowExposed(&window);
QSignalSpy spy(&window, SIGNAL(sceneGraphAboutToStop()));
window.hide();
Try to simplify the threaded render loop. This beast has grown and grown for some time so it was time to take step back and look at a few of the problems again. 1. show/hide vs exposed/obscured. There is really no reason why we should even bother with show. It only adds the window to a list, we can do that in handleExposure and simplify things a bit. 2. Expose, polish, repaint, sync stuff was growing increasingly complex with multiple waits and several events and states interacting. So I merged the expose into the sync and passed that information along to the render thread. The render thread now knows if the sync is for a normal state-sync or an expose. For a normal sync it will wake GUI right away. For an expose, it waits until after the renderpass has completed and the frame is swapped. Change-Id: I0b9e5135215662a43fb4ff2a51438e33c845c4a7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-17 12:45:59 +00:00
QTRY_VERIFY(spy.count() > 0);
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
}
//If the item calls update inside updatePaintNode, it should schedule another sync pass
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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());
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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();
Fix and re-enable constantUpdateOnWindow test. Change-Id: I0015ea58bfd673352405642153a038b72d44aa37 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-10 07:41:43 +00:00
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
QSignalSpy beforeSpy(&window, SIGNAL(beforeSynchronizing()));
QSignalSpy afterSpy(&window, SIGNAL(afterSynchronizing()));
Fix and re-enable constantUpdateOnWindow test. Change-Id: I0015ea58bfd673352405642153a038b72d44aa37 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-10 07:41:43 +00:00
QTRY_VERIFY(item.iterations > 10);
Introduced a few more signals to QQuickWindow. Also marked the new afterAnimation() signal as \since 5.3 and introduced proper revisioning on the new signals. [Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(), openglContextCreated(), sceneGraphAboutToStop(). Useful for deeper integration with the rendering. Change-Id: I5532b310506c2432325595e55ef9307b8934abee Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-02-10 14:51:16 +00:00
QTRY_VERIFY(beforeSpy.count() > 10);
QTRY_VERIFY(afterSpy.count() > 10);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
}
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
void tst_qquickwindow::constantUpdatesOnWindow_data()
{
QTest::addColumn<bool>("blockedGui");
QTest::addColumn<QByteArray>("signal");
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
window.setGeometry(100, 100, 300, 200);
window.show();
QTest::qWaitForWindowExposed(&window);
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
const bool threaded = QQuickWindowPrivate::get(&window)->context->thread() != QGuiApplication::instance()->thread();
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
if (threaded) {
QTest::newRow("blocked, beforeRender") << true << QByteArray(SIGNAL(beforeRendering()));
QTest::newRow("blocked, afterRender") << true << QByteArray(SIGNAL(afterRendering()));
QTest::newRow("blocked, swapped") << true << QByteArray(SIGNAL(frameSwapped()));
}
QTest::newRow("unblocked, beforeRender") << false << QByteArray(SIGNAL(beforeRendering()));
QTest::newRow("unblocked, afterRender") << false << QByteArray(SIGNAL(afterRendering()));
QTest::newRow("unblocked, swapped") << false << QByteArray(SIGNAL(frameSwapped()));
}
Fix and re-enable constantUpdateOnWindow test. Change-Id: I0015ea58bfd673352405642153a038b72d44aa37 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-10 07:41:43 +00:00
class FrameCounter : public QObject
{
Q_OBJECT
public slots:
void incr() { QMutexLocker locker(&m_mutex); ++m_counter; }
public:
FrameCounter() : m_counter(0) {}
int count() { QMutexLocker locker(&m_mutex); int x = m_counter; return x; }
private:
int m_counter;
QMutex m_mutex;
};
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
void tst_qquickwindow::constantUpdatesOnWindow()
{
QFETCH(bool, blockedGui);
QFETCH(QByteArray, signal);
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
window.setGeometry(100, 100, 300, 200);
Fix and re-enable constantUpdateOnWindow test. Change-Id: I0015ea58bfd673352405642153a038b72d44aa37 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-10 07:41:43 +00:00
bool ok = connect(&window, signal.constData(), &window, SLOT(update()), Qt::DirectConnection);
Q_ASSERT(ok);
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
window.show();
Fix and re-enable constantUpdateOnWindow test. Change-Id: I0015ea58bfd673352405642153a038b72d44aa37 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-10 07:41:43 +00:00
QTest::qWaitForWindowExposed(&window);
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
Fix and re-enable constantUpdateOnWindow test. Change-Id: I0015ea58bfd673352405642153a038b72d44aa37 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-10 07:41:43 +00:00
FrameCounter counter;
connect(&window, SIGNAL(frameSwapped()), &counter, SLOT(incr()), Qt::DirectConnection);
int frameCount = 10;
QElapsedTimer timer;
timer.start();
if (blockedGui) {
while (counter.count() < frameCount)
QTest::qSleep(100);
QVERIFY(counter.count() >= frameCount);
} else {
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
window.update();
Fix and re-enable constantUpdateOnWindow test. Change-Id: I0015ea58bfd673352405642153a038b72d44aa37 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-10 07:41:43 +00:00
QTRY_VERIFY(counter.count() > frameCount);
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
}
window.hide();
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
Stabilize QQuickWindow tests a bit Change-Id: I11a28e203c978e5675b088a5bb999c34b46f80da Reviewed-by: aavit <qt_aavit@ovi.com>
2012-08-17 08:00:06 +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);
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();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(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);
Micro optimize tst_qquickwindow::touchEvent_basic Change-Id: Ifd35eebaa8ba0aadcb15218a494c3e04167182ca Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-31 21:20:27 +00:00
QQuickTouchUtils::flush(window);
QTRY_COMPARE(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();
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).release(0, topItem->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
// press multiple points
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(), 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
.press(1, bottomItem->mapToScene(pos).toPoint(), window);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(window);
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();
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).release(0, topItem->mapToScene(pos).toPoint(), window).release(1, 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
// 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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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
QTest::touchEvent(window, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), window);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(window);
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();
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +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
// 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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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
QTest::touchEvent(window, touchDevice).move(0, topItem->mapToScene(pos).toPoint(), window);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(window);
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();
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +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
// 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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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
QTest::touchEvent(window, touchDevice).stationary(0)
.press(1, bottomItem->mapToScene(pos).toPoint(), window);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(window);
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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
QTest::touchEvent(window, touchDevice).release(0, bottomItem->mapToScene(pos).toPoint(),window);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(window);
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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
QTest::touchEvent(window, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), window);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(window);
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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(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))));
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).release(0, pointInTopItem, window);
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, 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) )));
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).release(0, pointInTopItem, window)
.release(1, pointInMiddleItem, window);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
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);
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).release(0, pointInTopItem, window)
.release(1, pointInMiddleItem, window);
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());
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).release(0, pointInTopItem, window)
.release(1, pointInMiddleItem, window)
.release(2, pointInBottomItem, window);
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();
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)));
}
tst_qquickwindow: Fix touch tests: add release There is already a comment in the test that points that are pressed must be released again. Change-Id: I3190b9f98769f7a3838ff703e5557ee321c71604 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-26 21:30:21 +00:00
QTest::touchEvent(window, touchDevice).release(0, pointInTopItem, window);
Initial import from qtquick2. Branched from the monolithic repo, Qt qtquick2 branch, at commit a4a585d2ee907746682846ae6e8a48e19deef469
2011-04-27 12:13:26 +00:00
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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(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));
Potentially stabilize tst_qquickwindow::touchEvent_cancel By moving them well into the item, (50 instead of 10 pixels) there is less risk of them not being delivered due to bad timing with window activated. Since we know that even qWaitForWindowActive sometimes returns before the final positioning of the window, this is a sensible work-around until testlib is fixed. In this test we care about the process of cancelling a touch event, not where. Change-Id: I74ad29535038995b38c913ddd09f462aa96a034c Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
2015-05-13 15:28:44 +00:00
QPointF pos(50, 50);
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);
Potentially stabilize tst_qquickwindow::touchEvent_cancel By moving them well into the item, (50 instead of 10 pixels) there is less risk of them not being delivered due to bad timing with window activated. Since we know that even qWaitForWindowActive sometimes returns before the final positioning of the window, this is a sensible work-around until testlib is fixed. In this test we care about the process of cancelling a touch event, not where. Change-Id: I74ad29535038995b38c913ddd09f462aa96a034c Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
2015-05-13 15:28:44 +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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(window);
Add minor extra check in tst_qquickwindow Change-Id: If0343c36c747b419f949cff47a0f6a93bf73250d Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-31 21:16:46 +00:00
QCOMPARE(item->touchEventCount, 1);
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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
delete item;
}
Add mergePointerTargets to create pointer delivery list This code joins lists of "target item" which are joins of where several touch points should be delivered. Change-Id: I15ab4b7f70b8930d15368bf4cba0893ab339fa2a Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-12 14:16:28 +00:00
void tst_qquickwindow::mergeTouchPointLists_data()
{
QTest::addColumn<QVector<QQuickItem*>>("list1");
QTest::addColumn<QVector<QQuickItem*>>("list2");
QTest::addColumn<QVector<QQuickItem*>>("expected");
QTest::addColumn<bool>("showItem");
// FIXME: do not leak all these items
auto item1 = new QQuickItem();
auto item2 = new QQuickItem();
auto item3 = new QQuickItem();
auto item4 = new QQuickItem();
auto item5 = new QQuickItem();
QTest::newRow("empty") << QVector<QQuickItem*>() << QVector<QQuickItem*>() << QVector<QQuickItem*>();
QTest::newRow("single list left")
<< (QVector<QQuickItem*>() << item1 << item2 << item3)
<< QVector<QQuickItem*>()
<< (QVector<QQuickItem*>() << item1 << item2 << item3);
QTest::newRow("single list right")
<< QVector<QQuickItem*>()
<< (QVector<QQuickItem*>() << item1 << item2 << item3)
<< (QVector<QQuickItem*>() << item1 << item2 << item3);
QTest::newRow("two lists identical")
<< (QVector<QQuickItem*>() << item1 << item2 << item3)
<< (QVector<QQuickItem*>() << item1 << item2 << item3)
<< (QVector<QQuickItem*>() << item1 << item2 << item3);
QTest::newRow("two lists 1")
<< (QVector<QQuickItem*>() << item1 << item2 << item5)
<< (QVector<QQuickItem*>() << item3 << item4 << item5)
<< (QVector<QQuickItem*>() << item1 << item2 << item3 << item4 << item5);
QTest::newRow("two lists 2")
<< (QVector<QQuickItem*>() << item1 << item2 << item5)
<< (QVector<QQuickItem*>() << item3 << item4 << item5)
<< (QVector<QQuickItem*>() << item1 << item2 << item3 << item4 << item5);
QTest::newRow("two lists 3")
<< (QVector<QQuickItem*>() << item1 << item2 << item3)
<< (QVector<QQuickItem*>() << item1 << item4 << item5)
<< (QVector<QQuickItem*>() << item1 << item2 << item3 << item4 << item5);
Extend tst_qquickwindow::mergeTouchPointLists Change-Id: I199c57197fafed84ba0065765411d5239804d17f Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-08-01 13:55:02 +00:00
QTest::newRow("two lists 4")
Add mergePointerTargets to create pointer delivery list This code joins lists of "target item" which are joins of where several touch points should be delivered. Change-Id: I15ab4b7f70b8930d15368bf4cba0893ab339fa2a Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-12 14:16:28 +00:00
<< (QVector<QQuickItem*>() << item1 << item3 << item4)
<< (QVector<QQuickItem*>() << item2 << item3 << item5)
<< (QVector<QQuickItem*>() << item1 << item2 << item3 << item4 << item5);
Extend tst_qquickwindow::mergeTouchPointLists Change-Id: I199c57197fafed84ba0065765411d5239804d17f Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-08-01 13:55:02 +00:00
QTest::newRow("two lists 5")
<< (QVector<QQuickItem*>() << item1 << item2 << item4)
<< (QVector<QQuickItem*>() << item1 << item3 << item4)
<< (QVector<QQuickItem*>() << item1 << item2 << item3 << item4);
Add mergePointerTargets to create pointer delivery list This code joins lists of "target item" which are joins of where several touch points should be delivered. Change-Id: I15ab4b7f70b8930d15368bf4cba0893ab339fa2a Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-12 14:16:28 +00:00
}
void tst_qquickwindow::mergeTouchPointLists()
{
QFETCH(QVector<QQuickItem*>, list1);
QFETCH(QVector<QQuickItem*>, list2);
QFETCH(QVector<QQuickItem*>, expected);
QQuickWindow win;
auto windowPrivate = QQuickWindowPrivate::get(&win);
auto targetList = windowPrivate->mergePointerTargets(list1, list2);
QCOMPARE(targetList, expected);
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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
// 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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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
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);
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QGuiApplication::processEvents();
QQuickTouchUtils::flush(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(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();
Compress touch events in QQuickWindow. Instead of sending multiple touch updates per frame, we store the last one and flush the pending events just before we enter into the scene graph sync phase. [ChangeLog][QtQuick] QQuickWindow will compresses touch events and delivers at most one touch event per frame. Done-with: Robin Burchell <robin.burchell@jollamobile.com> Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-04-03 11:16:42 +00:00
QQuickTouchUtils::flush(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
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;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
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
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(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
tests/quick: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b). - Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer). - Replace Q[TRY]_VERIFY(smartPointer == 0) by Q[TRY]_VERIFY(smartPointer.isNull()). - Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) and add casts where necessary. The values will then be logged should a test fail. Change-Id: Ib9f4c2486af23c47990be4b9e004b965de226dcc Reviewed-by: Mitch Curtis <mitch.curtis@theqtcompany.com>
2015-07-24 13:32:22 +00:00
QVERIFY(!item->window());
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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(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 delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
// clean up mouse press state for the next tests
QTest::mouseRelease(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
}
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"));
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +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);
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +00:00
QQuickWindow *window = qobject_cast<QQuickWindow*>(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
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
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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));
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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
Ensure that QML Windows respect the default platform window state The 'visible' property of a Window would be set on the baseclass QWindow like any other property during QML component creation, which would cause create() to be called and the platform window would be created. This left the 'visibility' of the QML window as Windowed, not respecting the platform defaults for how windows should be shown. The user would have to explicitly set "visibility: Window.AutomaticVisibility" for this default to apply, which doesn't make sense -- it should be the default. We solve this by deferring setVisible and setVisibility on the window until the component is complete and we have a full picture of its state. We then ask the platform for the default state based on the window flags (ensuring that eg "flags: Qt.Popup" will not result in maximized windows on iOS and Android), and apply the deferred visibility. The deferred visibility may still be 'false', but setting the window state makes sense anyways, so that a later "visible = true" will apply the default window state. Deferring platform window creation until the geometry has been potentially set from user code also has the benefit that the platform window can check the geometry and apply a default geometry if it's null. This was not possible when the 'visible' property was a regular property, as you could not know if the user's geometry changes would come after platform window creation. Task-number: QTBUG-35174 Change-Id: Icf3236187992048a85b2196c059f9b54699041a4 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Robin Burchell <robin+qt@viroteck.net> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-11-27 16:57:25 +00:00
void tst_qquickwindow::defaultState()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.setData("import QtQuick 2.0; import QtQuick.Window 2.1; Window { }", QUrl());
QObject *created = component.create();
QScopedPointer<QObject> cleanup(created);
QVERIFY(created);
QQuickWindow *qmlWindow = qobject_cast<QQuickWindow*>(created);
QVERIFY(qmlWindow);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
qmlWindow->setTitle(QTest::currentTestFunction());
Ensure that QML Windows respect the default platform window state The 'visible' property of a Window would be set on the baseclass QWindow like any other property during QML component creation, which would cause create() to be called and the platform window would be created. This left the 'visibility' of the QML window as Windowed, not respecting the platform defaults for how windows should be shown. The user would have to explicitly set "visibility: Window.AutomaticVisibility" for this default to apply, which doesn't make sense -- it should be the default. We solve this by deferring setVisible and setVisibility on the window until the component is complete and we have a full picture of its state. We then ask the platform for the default state based on the window flags (ensuring that eg "flags: Qt.Popup" will not result in maximized windows on iOS and Android), and apply the deferred visibility. The deferred visibility may still be 'false', but setting the window state makes sense anyways, so that a later "visible = true" will apply the default window state. Deferring platform window creation until the geometry has been potentially set from user code also has the benefit that the platform window can check the geometry and apply a default geometry if it's null. This was not possible when the 'visible' property was a regular property, as you could not know if the user's geometry changes would come after platform window creation. Task-number: QTBUG-35174 Change-Id: Icf3236187992048a85b2196c059f9b54699041a4 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Robin Burchell <robin+qt@viroteck.net> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-11-27 16:57:25 +00:00
QQuickWindow cppWindow;
cppWindow.show();
QTest::qWaitForWindowExposed(&cppWindow);
QCOMPARE(qmlWindow->windowState(), cppWindow.windowState());
}
Implement QQuickWindow::grabWindow() for isVisible=false Webkit uses this for testing. Change-Id: I4539e169a02592fb6c0062903917d4dd23a4303c Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>
2013-04-18 15:02:24 +00:00
void tst_qquickwindow::grab_data()
{
QTest::addColumn<bool>("visible");
Support alpha in QQuickWindow::grabWindow(). Change-Id: I2dd69745427d8f5e882303d2a4de3935ddca02e9 Task-number: QTBUG-48787 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-10-15 13:21:17 +00:00
QTest::addColumn<bool>("alpha");
QTest::newRow("visible,opaque") << true << false;
QTest::newRow("invisible,opaque") << false << false;
QTest::newRow("visible,transparent") << true << true;
QTest::newRow("invisible,transparent") << false << true;
Implement QQuickWindow::grabWindow() for isVisible=false Webkit uses this for testing. Change-Id: I4539e169a02592fb6c0062903917d4dd23a4303c Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>
2013-04-18 15:02:24 +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
{
Implement QQuickWindow::grabWindow() for isVisible=false Webkit uses this for testing. Change-Id: I4539e169a02592fb6c0062903917d4dd23a4303c Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>
2013-04-18 15:02:24 +00:00
QFETCH(bool, visible);
Support alpha in QQuickWindow::grabWindow(). Change-Id: I2dd69745427d8f5e882303d2a4de3935ddca02e9 Task-number: QTBUG-48787 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-10-15 13:21:17 +00:00
QFETCH(bool, alpha);
Implement QQuickWindow::grabWindow() for isVisible=false Webkit uses this for testing. Change-Id: I4539e169a02592fb6c0062903917d4dd23a4303c Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>
2013-04-18 15:02:24 +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;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QLatin1String(QTest::currentTestFunction()) + QLatin1Char(' ') + QLatin1String(QTest::currentDataTag()));
Support alpha in QQuickWindow::grabWindow(). Change-Id: I2dd69745427d8f5e882303d2a4de3935ddca02e9 Task-number: QTBUG-48787 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-10-15 13:21:17 +00:00
if (alpha) {
window.setColor(QColor(0, 0, 0, 0));
} else {
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);
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
Implement QQuickWindow::grabWindow() for isVisible=false Webkit uses this for testing. Change-Id: I4539e169a02592fb6c0062903917d4dd23a4303c Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>
2013-04-18 15:02:24 +00:00
if (visible) {
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
} else {
window.create();
}
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();
Support alpha in QQuickWindow::grabWindow(). Change-Id: I2dd69745427d8f5e882303d2a4de3935ddca02e9 Task-number: QTBUG-48787 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-10-15 13:21:17 +00:00
QCOMPARE(content.width(), int(window.width() * window.devicePixelRatio()));
QCOMPARE(content.height(), int(window.height() * window.devicePixelRatio()));
if (alpha) {
QCOMPARE((uint) content.convertToFormat(QImage::Format_ARGB32_Premultiplied).pixel(0, 0), (uint) 0x00000000);
} else {
QCOMPARE((uint) content.convertToFormat(QImage::Format_RGB32).pixel(0, 0), (uint) 0xffff0000);
}
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::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();
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
c->setTitle(QLatin1String(QTest::currentTestFunction()) + QString::number(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
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"));
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +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
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +00:00
QQuickWindow *window = qobject_cast<QQuickWindow*>(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
QVERIFY(window);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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
// 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
}
Stabilize tst_qquickwindow and tst_scenegraph. Change-Id: I6f1b6c0ed86869149658e3ce07545217ce9797a7 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2014-03-17 14:54:44 +00:00
// When running on native Nvidia graphics cards on linux, the
// distance field glyph pixels have a measurable, but not visible
// pixel error. Use a custom compare function to avoid
//
// This was GT-216 with the ubuntu "nvidia-319" driver package.
// llvmpipe does not show the same issue.
//
bool compareImages(const QImage &ia, const QImage &ib)
{
if (ia.size() != ib.size())
qDebug() << "images are of different size" << ia.size() << ib.size();
Q_ASSERT(ia.size() == ib.size());
Q_ASSERT(ia.format() == ib.format());
int w = ia.width();
int h = ia.height();
const int tolerance = 5;
for (int y=0; y<h; ++y) {
const uint *as= (const uint *) ia.constScanLine(y);
const uint *bs= (const uint *) ib.constScanLine(y);
for (int x=0; x<w; ++x) {
uint a = as[x];
uint b = bs[x];
// No tolerance for error in the alpha.
if ((a & 0xff000000) != (b & 0xff000000))
return false;
if (qAbs(qRed(a) - qRed(b)) > tolerance)
return false;
if (qAbs(qRed(a) - qRed(b)) > tolerance)
return false;
if (qAbs(qRed(a) - qRed(b)) > tolerance)
return false;
}
}
return true;
}
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"));
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +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
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +00:00
QQuickWindow *window = qobject_cast<QQuickWindow*>(created);
Complete rewrite of threaded render loop. This change starts using the superior implementation of the scene graph render loop which has been worked on in the scenegraph-playground project for a while. It uses a far more straightforward locking/sync paradigm compared to the existing one and is less deadlock and error prone. It also enables the scene graph thread to run on its own when the GUI thread is blocked, enabling threaded animations. This changes also introduces a naming change inside Qt Quick from "Window Manager" -> "Render Loop" as that fits better to what the code does. Change-Id: I1c2170ee04fcbef79660bd7dae6cace647cdb276 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-12-05 14:27:47 +00:00
window->setPersistentOpenGLContext(false);
window->setPersistentSceneGraph(false);
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
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());
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
const bool threaded = QQuickWindowPrivate::get(window)->context->thread() != QThread::currentThread();
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
QVERIFY(window->isSceneGraphInitialized());
Change graphicsAPI to graphicsApi Change-Id: I065f17abd1cb71cd8d6ead76abf7a544eb7a99c0 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-06-01 07:58:27 +00:00
const bool isGL = window->rendererInterface()->graphicsApi() == QSGRendererInterface::OpenGL;
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
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
Fix cleanup of non-threaded render loops. They would unconditionally call cleanupNodesOnShutdown on hide(), but QQuickWindow::sceneGraphInvalidated would only be emitted if this was the last window being hidden, leading to an inconsistent state in the application. Since the non-threaded render loops do not support releasing resources (there is one OpenGL context and one QSGRenderContext shared between all windows) we delay cleanup until the window is destroyed. This change also make the render loops track the windows until they are destroyed, similar to what the threaded one does. The purpose of this is to, in the case of dangling windows, only trigger invalidation of the scene graph when the last QQuickWindow is destroyed through QSGRenderLoop::cleanup(). Task-number: QTBUG-41210 Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a Reviewed-by: Ulf Hermann <ulf.hermann@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-09-19 07:52:25 +00:00
if (threaded) {
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
QTRY_VERIFY(invalidated.size() >= 1);
if (isGL)
QVERIFY(!window->isSceneGraphInitialized());
Fix cleanup of non-threaded render loops. They would unconditionally call cleanupNodesOnShutdown on hide(), but QQuickWindow::sceneGraphInvalidated would only be emitted if this was the last window being hidden, leading to an inconsistent state in the application. Since the non-threaded render loops do not support releasing resources (there is one OpenGL context and one QSGRenderContext shared between all windows) we delay cleanup until the window is destroyed. This change also make the render loops track the windows until they are destroyed, similar to what the threaded one does. The purpose of this is to, in the case of dangling windows, only trigger invalidation of the scene graph when the last QQuickWindow is destroyed through QSGRenderLoop::cleanup(). Task-number: QTBUG-41210 Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a Reviewed-by: Ulf Hermann <ulf.hermann@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-09-19 07:52:25 +00:00
}
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
Skip tst_qquickwindow::headless() when using ANGLE/Windows. The test crashes frequently. Task-number: QTBUG-42967 Change-Id: Ic17c6187bfa657154a9b04eb9c5b9a3de291cb1e Reviewed-by: Andrew Knight <andrew.knight@theqtcompany.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2014-12-01 09:45:00 +00:00
if (QGuiApplication::platformName() == QLatin1String("windows")
&& QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGLES) {
QSKIP("Crashes on Windows/ANGLE, QTBUG-42967");
}
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#endif
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();
tests/quick: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b). - Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer). - Replace Q[TRY]_VERIFY(smartPointer == 0) by Q[TRY]_VERIFY(smartPointer.isNull()). - Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) and add casts where necessary. The values will then be logged should a test fail. Change-Id: Ib9f4c2486af23c47990be4b9e004b965de226dcc Reviewed-by: Mitch Curtis <mitch.curtis@theqtcompany.com>
2015-07-24 13:32:22 +00:00
QVERIFY(!window->handle());
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 cleanup of non-threaded render loops. They would unconditionally call cleanupNodesOnShutdown on hide(), but QQuickWindow::sceneGraphInvalidated would only be emitted if this was the last window being hidden, leading to an inconsistent state in the application. Since the non-threaded render loops do not support releasing resources (there is one OpenGL context and one QSGRenderContext shared between all windows) we delay cleanup until the window is destroyed. This change also make the render loops track the windows until they are destroyed, similar to what the threaded one does. The purpose of this is to, in the case of dangling windows, only trigger invalidation of the scene graph when the last QQuickWindow is destroyed through QSGRenderLoop::cleanup(). Task-number: QTBUG-41210 Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a Reviewed-by: Ulf Hermann <ulf.hermann@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-09-19 07:52:25 +00:00
if (threaded)
QTRY_COMPARE(initialized.size(), 1);
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
QVERIFY(window->isSceneGraphInitialized());
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();
Stabilize tst_qquickwindow and tst_scenegraph. Change-Id: I6f1b6c0ed86869149658e3ce07545217ce9797a7 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2014-03-17 14:54:44 +00:00
QVERIFY(compareImages(newContent, originalContent));
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
}
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
void tst_qquickwindow::noUpdateWhenNothingChanges()
{
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
window.setGeometry(100, 100, 300, 200);
QQuickRectangle rect(window.contentItem());
Fix tst_qquickwindow for fullscreen platforms Change-Id: I040282f1bf1a2a8f212b9c7192a5ffaa2dbfdfb8 Reviewed-by: Wolfgang Bremer <wbremer@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-07-24 22:17:11 +00:00
window.showNormal();
Use one render loop per QQuickWindow See the task for the full reasoning behind this patch. The threaded renderloop has been refactored to have one window per thread. This is mostly a simplification of the current code path where for loops over multiple windows are turned into if (window). The QSGContext has been split into two classes, QSGRenderContext for which there is one per OpenGLContext. The rest of the patch is name changes and a couple of cleanups in the hopes of simplifying this change. Task-number: QTBUG-33993 Change-Id: I31c81f9694d7da7474a72333169be38de62613c4 Reviewed-by: Sean Harmer <sean.harmer@kdab.com>
2013-10-17 12:53:33 +00:00
QTest::qWaitForWindowExposed(&window);
// Many platforms are broken in the sense that that they follow up
// the initial expose with a second expose or more. Let these go
// through before we let the test continue.
QTest::qWait(100);
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
if (QQuickWindowPrivate::get(&window)->context->thread() == QGuiApplication::instance()->thread()) {
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
QSKIP("Only threaded renderloop implements this feature");
return;
}
QSignalSpy spy(&window, SIGNAL(frameSwapped()));
rect.update();
Use one render loop per QQuickWindow See the task for the full reasoning behind this patch. The threaded renderloop has been refactored to have one window per thread. This is mostly a simplification of the current code path where for loops over multiple windows are turned into if (window). The QSGContext has been split into two classes, QSGRenderContext for which there is one per OpenGLContext. The rest of the patch is name changes and a couple of cleanups in the hopes of simplifying this change. Task-number: QTBUG-33993 Change-Id: I31c81f9694d7da7474a72333169be38de62613c4 Reviewed-by: Sean Harmer <sean.harmer@kdab.com>
2013-10-17 12:53:33 +00:00
// Wait a while and verify that no more frameSwapped come our way.
QTest::qWait(100);
Improved animations in the new render loop To advance animations in line with vsync, we used a dedicated event from the rendering thread which we fired immediately after sync. This is a bit elaborate as we know in Gui when sync is complete and we can just animate there and then. This means we can remove all animation logic from the rendering thread, making it simpler. I also updated the syncAndRender pass so that it does not render anything if the scene graph reported no changes during the sync pass. This will prevent non-visual animations and property updates from triggering render passes which will save quite a few cycles. Change-Id: I62bb5484f0673f99abe726fca5a9b424f6b0a317 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-15 14:35:04 +00:00
QCOMPARE(spy.size(), 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
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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
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
Only emit focusObjectChanged when an actual change occurs. Change-Id: If18b460a8773e5cac597c02c51836b79711c20f4 Done-with: Matthew Vogt <matthew.vogt@jollamobile.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-12-05 17:35:44 +00:00
QSignalSpy focusObjectSpy(window, SIGNAL(focusObjectChanged(QObject*)));
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));
Only emit focusObjectChanged when an actual change occurs. Change-Id: If18b460a8773e5cac597c02c51836b79711c20f4 Done-with: Matthew Vogt <matthew.vogt@jollamobile.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-12-05 17:35:44 +00:00
QCOMPARE(window->contentItem(), window->focusObject());
QCOMPARE(focusObjectSpy.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
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());
Only emit focusObjectChanged when an actual change occurs. Change-Id: If18b460a8773e5cac597c02c51836b79711c20f4 Done-with: Matthew Vogt <matthew.vogt@jollamobile.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-12-05 17:35:44 +00:00
QCOMPARE(focusObjectSpy.count(), 2);
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());
Only emit focusObjectChanged when an actual change occurs. Change-Id: If18b460a8773e5cac597c02c51836b79711c20f4 Done-with: Matthew Vogt <matthew.vogt@jollamobile.com> Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-12-05 17:35:44 +00:00
QCOMPARE(focusObjectSpy.count(), 3);
// set focus for item in non-focused focus scope and
// ensure focusObject does not change and signal is not emitted
QQuickItem *item3 = window->findChild<QQuickItem*>("item3");
QVERIFY(item3);
item3->setFocus(true);
QCOMPARE(item2, window->focusObject());
QCOMPARE(focusObjectSpy.count(), 3);
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
}
Store information about focus reason in QQuickWindowPrivate QtQuickControl's Desktop style needs to know whether the last focus change was requested by keyboard or not. With this information the Desktop style is able to set the QStyleOption accordingly. Without the flag, some of the QStyles (QFusionStyle, QGtkStyle) don't render a focus rectangle. This patch is needed by #change,84389 in QtQuickControls Change-Id: Ia06f56b018cd35eea933892a4c50e0aa7328042d Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2014-04-30 18:33:07 +00:00
void tst_qquickwindow::focusReason()
{
QQuickWindow *window = new QQuickWindow;
QScopedPointer<QQuickWindow> cleanup(window);
window->resize(200, 200);
window->show();
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
Store information about focus reason in QQuickWindowPrivate QtQuickControl's Desktop style needs to know whether the last focus change was requested by keyboard or not. With this information the Desktop style is able to set the QStyleOption accordingly. Without the flag, some of the QStyles (QFusionStyle, QGtkStyle) don't render a focus rectangle. This patch is needed by #change,84389 in QtQuickControls Change-Id: Ia06f56b018cd35eea933892a4c50e0aa7328042d Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2014-04-30 18:33:07 +00:00
QVERIFY(QTest::qWaitForWindowExposed(window));
QQuickItem *firstItem = new QQuickItem;
firstItem->setSize(QSizeF(100, 100));
firstItem->setParentItem(window->contentItem());
QQuickItem *secondItem = new QQuickItem;
secondItem->setSize(QSizeF(100, 100));
secondItem->setParentItem(window->contentItem());
firstItem->forceActiveFocus(Qt::OtherFocusReason);
QCOMPARE(QQuickWindowPrivate::get(window)->lastFocusReason, Qt::OtherFocusReason);
secondItem->forceActiveFocus(Qt::TabFocusReason);
QCOMPARE(QQuickWindowPrivate::get(window)->lastFocusReason, Qt::TabFocusReason);
firstItem->forceActiveFocus(Qt::BacktabFocusReason);
QCOMPARE(QQuickWindowPrivate::get(window)->lastFocusReason, Qt::BacktabFocusReason);
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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
{
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +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);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in 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
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +00:00
QQuickItem *item = new QQuickItem;
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
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"));
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +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);
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
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +00:00
QQuickWindow *window = qobject_cast<QQuickWindow*>(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
QVERIFY(window);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window->setTitle(QTest::currentTestFunction());
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;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
window.setFramePosition(QGuiApplication::primaryScreen()->availableGeometry().topLeft() + QPoint(50, 50));
window.resize(320, 290);
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 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();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(&window));
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
// 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
Unset the cursor when an Item is unparented It's possible for a cursor to get stuck if an item gets deleted. QQuickItemPrivate::derefWindow sets the cursorItem in QQuickWindowPrivate to 0, but doesn't unset the cursor. This causes the cursor to get stuck until the user hovers their mouse over an item that has a cursor set. Change-Id: I1d5d3ff13d69c76e4f8fe86b1f5b669bb714ecca Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-09 19:04:41 +00:00
// cursorItem, but given the situation will correct itself after the next mouse move it
// simply unsets the window cursor for now.
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.setParentItem(0);
Unset the cursor when an Item is unparented It's possible for a cursor to get stuck if an item gets deleted. QQuickItemPrivate::derefWindow sets the cursorItem in QQuickWindowPrivate to 0, but doesn't unset the cursor. This causes the cursor to get stuck until the user hovers their mouse over an item that has a cursor set. Change-Id: I1d5d3ff13d69c76e4f8fe86b1f5b669bb714ecca Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-09 19:04:41 +00:00
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
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.setCursor(Qt::SizeAllCursor);
QCOMPARE(parentItem.cursor().shape(), Qt::SizeAllCursor);
Unset the cursor when an Item is unparented It's possible for a cursor to get stuck if an item gets deleted. QQuickItemPrivate::derefWindow sets the cursorItem in QQuickWindowPrivate to 0, but doesn't unset the cursor. This causes the cursor to get stuck until the user hovers their mouse over an item that has a cursor set. Change-Id: I1d5d3ff13d69c76e4f8fe86b1f5b669bb714ecca Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-09 19:04:41 +00:00
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
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
// 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);
Unset the cursor when an Item is unparented It's possible for a cursor to get stuck if an item gets deleted. QQuickItemPrivate::derefWindow sets the cursorItem in QQuickWindowPrivate to 0, but doesn't unset the cursor. This causes the cursor to get stuck until the user hovers their mouse over an item that has a cursor set. Change-Id: I1d5d3ff13d69c76e4f8fe86b1f5b669bb714ecca Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-09 19:04:41 +00:00
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
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.unsetCursor();
QCOMPARE(childItem.cursor().shape(), Qt::ArrowCursor);
Unset the cursor when an Item is unparented It's possible for a cursor to get stuck if an item gets deleted. QQuickItemPrivate::derefWindow sets the cursorItem in QQuickWindowPrivate to 0, but doesn't unset the cursor. This causes the cursor to get stuck until the user hovers their mouse over an item that has a cursor set. Change-Id: I1d5d3ff13d69c76e4f8fe86b1f5b669bb714ecca Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-09 19:04:41 +00:00
QCOMPARE(window.cursor().shape(), Qt::ArrowCursor);
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
QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(100, 101));
QCOMPARE(window.cursor().shape(), Qt::SizeAllCursor);
}
#endif
Complete rewrite of threaded render loop. This change starts using the superior implementation of the scene graph render loop which has been worked on in the scenegraph-playground project for a while. It uses a far more straightforward locking/sync paradigm compared to the existing one and is less deadlock and error prone. It also enables the scene graph thread to run on its own when the GUI thread is blocked, enabling threaded animations. This changes also introduces a naming change inside Qt Quick from "Window Manager" -> "Render Loop" as that fits better to what the code does. Change-Id: I1c2170ee04fcbef79660bd7dae6cace647cdb276 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-12-05 14:27:47 +00:00
void tst_qquickwindow::hideThenDelete_data()
{
QTest::addColumn<bool>("persistentSG");
QTest::addColumn<bool>("persistentGL");
QTest::newRow("persistent:SG=false,GL=false") << false << false;
QTest::newRow("persistent:SG=true,GL=false") << true << false;
QTest::newRow("persistent:SG=false,GL=true") << false << true;
QTest::newRow("persistent:SG=true,GL=true") << true << true;
}
void tst_qquickwindow::hideThenDelete()
{
QFETCH(bool, persistentSG);
QFETCH(bool, persistentGL);
QSignalSpy *openglDestroyed = 0;
QSignalSpy *sgInvalidated = 0;
{
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QLatin1String(QTest::currentTestFunction()) + QLatin1Char(' ')
+ QLatin1String(QTest::currentDataTag()));
Complete rewrite of threaded render loop. This change starts using the superior implementation of the scene graph render loop which has been worked on in the scenegraph-playground project for a while. It uses a far more straightforward locking/sync paradigm compared to the existing one and is less deadlock and error prone. It also enables the scene graph thread to run on its own when the GUI thread is blocked, enabling threaded animations. This changes also introduces a naming change inside Qt Quick from "Window Manager" -> "Render Loop" as that fits better to what the code does. Change-Id: I1c2170ee04fcbef79660bd7dae6cace647cdb276 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-12-05 14:27:47 +00:00
window.setColor(Qt::red);
window.setPersistentSceneGraph(persistentSG);
window.setPersistentOpenGLContext(persistentGL);
window.resize(400, 300);
window.show();
QTest::qWaitForWindowExposed(&window);
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
const bool threaded = QQuickWindowPrivate::get(&window)->context->thread() != QGuiApplication::instance()->thread();
Change graphicsAPI to graphicsApi Change-Id: I065f17abd1cb71cd8d6ead76abf7a544eb7a99c0 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-06-01 07:58:27 +00:00
const bool isGL = window.rendererInterface()->graphicsApi() == QSGRendererInterface::OpenGL;
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
if (isGL)
openglDestroyed = new QSignalSpy(window.openglContext(), SIGNAL(aboutToBeDestroyed()));
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#endif
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
Complete rewrite of threaded render loop. This change starts using the superior implementation of the scene graph render loop which has been worked on in the scenegraph-playground project for a while. It uses a far more straightforward locking/sync paradigm compared to the existing one and is less deadlock and error prone. It also enables the scene graph thread to run on its own when the GUI thread is blocked, enabling threaded animations. This changes also introduces a naming change inside Qt Quick from "Window Manager" -> "Render Loop" as that fits better to what the code does. Change-Id: I1c2170ee04fcbef79660bd7dae6cace647cdb276 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-12-05 14:27:47 +00:00
sgInvalidated = new QSignalSpy(&window, SIGNAL(sceneGraphInvalidated()));
window.hide();
QTRY_VERIFY(!window.isExposed());
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
Fix cleanup of non-threaded render loops. They would unconditionally call cleanupNodesOnShutdown on hide(), but QQuickWindow::sceneGraphInvalidated would only be emitted if this was the last window being hidden, leading to an inconsistent state in the application. Since the non-threaded render loops do not support releasing resources (there is one OpenGL context and one QSGRenderContext shared between all windows) we delay cleanup until the window is destroyed. This change also make the render loops track the windows until they are destroyed, similar to what the threaded one does. The purpose of this is to, in the case of dangling windows, only trigger invalidation of the scene graph when the last QQuickWindow is destroyed through QSGRenderLoop::cleanup(). Task-number: QTBUG-41210 Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a Reviewed-by: Ulf Hermann <ulf.hermann@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-09-19 07:52:25 +00:00
if (threaded) {
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
if (!isGL)
QSKIP("Skipping persistency verification due to not running with OpenGL");
Fix cleanup of non-threaded render loops. They would unconditionally call cleanupNodesOnShutdown on hide(), but QQuickWindow::sceneGraphInvalidated would only be emitted if this was the last window being hidden, leading to an inconsistent state in the application. Since the non-threaded render loops do not support releasing resources (there is one OpenGL context and one QSGRenderContext shared between all windows) we delay cleanup until the window is destroyed. This change also make the render loops track the windows until they are destroyed, similar to what the threaded one does. The purpose of this is to, in the case of dangling windows, only trigger invalidation of the scene graph when the last QQuickWindow is destroyed through QSGRenderLoop::cleanup(). Task-number: QTBUG-41210 Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a Reviewed-by: Ulf Hermann <ulf.hermann@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-09-19 07:52:25 +00:00
if (!persistentSG) {
QVERIFY(sgInvalidated->size() > 0);
if (!persistentGL)
QVERIFY(openglDestroyed->size() > 0);
else
tests/quick: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b). - Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer). - Replace Q[TRY]_VERIFY(smartPointer == 0) by Q[TRY]_VERIFY(smartPointer.isNull()). - Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) and add casts where necessary. The values will then be logged should a test fail. Change-Id: Ib9f4c2486af23c47990be4b9e004b965de226dcc Reviewed-by: Mitch Curtis <mitch.curtis@theqtcompany.com>
2015-07-24 13:32:22 +00:00
QCOMPARE(openglDestroyed->size(), 0);
Fix cleanup of non-threaded render loops. They would unconditionally call cleanupNodesOnShutdown on hide(), but QQuickWindow::sceneGraphInvalidated would only be emitted if this was the last window being hidden, leading to an inconsistent state in the application. Since the non-threaded render loops do not support releasing resources (there is one OpenGL context and one QSGRenderContext shared between all windows) we delay cleanup until the window is destroyed. This change also make the render loops track the windows until they are destroyed, similar to what the threaded one does. The purpose of this is to, in the case of dangling windows, only trigger invalidation of the scene graph when the last QQuickWindow is destroyed through QSGRenderLoop::cleanup(). Task-number: QTBUG-41210 Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a Reviewed-by: Ulf Hermann <ulf.hermann@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-09-19 07:52:25 +00:00
} else {
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(sgInvalidated->size(), 0);
QCOMPARE(openglDestroyed->size(), 0);
Fix cleanup of non-threaded render loops. They would unconditionally call cleanupNodesOnShutdown on hide(), but QQuickWindow::sceneGraphInvalidated would only be emitted if this was the last window being hidden, leading to an inconsistent state in the application. Since the non-threaded render loops do not support releasing resources (there is one OpenGL context and one QSGRenderContext shared between all windows) we delay cleanup until the window is destroyed. This change also make the render loops track the windows until they are destroyed, similar to what the threaded one does. The purpose of this is to, in the case of dangling windows, only trigger invalidation of the scene graph when the last QQuickWindow is destroyed through QSGRenderLoop::cleanup(). Task-number: QTBUG-41210 Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a Reviewed-by: Ulf Hermann <ulf.hermann@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-09-19 07:52:25 +00:00
}
Complete rewrite of threaded render loop. This change starts using the superior implementation of the scene graph render loop which has been worked on in the scenegraph-playground project for a while. It uses a far more straightforward locking/sync paradigm compared to the existing one and is less deadlock and error prone. It also enables the scene graph thread to run on its own when the GUI thread is blocked, enabling threaded animations. This changes also introduces a naming change inside Qt Quick from "Window Manager" -> "Render Loop" as that fits better to what the code does. Change-Id: I1c2170ee04fcbef79660bd7dae6cace647cdb276 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-12-05 14:27:47 +00:00
}
}
QVERIFY(sgInvalidated->size() > 0);
Fix some test failures with QT_NO_OPENGL builds Change-Id: I4154084b4a0e0709ee8cb39a856a37a611e2d537 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-26 09:49:52 +00:00
#ifndef QT_NO_OPENGL
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
if (openglDestroyed)
QVERIFY(openglDestroyed->size() > 0);
Fix some test failures with QT_NO_OPENGL builds Change-Id: I4154084b4a0e0709ee8cb39a856a37a611e2d537 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-26 09:49:52 +00:00
#endif
Complete rewrite of threaded render loop. This change starts using the superior implementation of the scene graph render loop which has been worked on in the scenegraph-playground project for a while. It uses a far more straightforward locking/sync paradigm compared to the existing one and is less deadlock and error prone. It also enables the scene graph thread to run on its own when the GUI thread is blocked, enabling threaded animations. This changes also introduces a naming change inside Qt Quick from "Window Manager" -> "Render Loop" as that fits better to what the code does. Change-Id: I1c2170ee04fcbef79660bd7dae6cace647cdb276 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-12-05 14:27:47 +00:00
}
void tst_qquickwindow::showHideAnimate()
{
// This test tries to mimick a bug triggered in the qquickanimatedimage test
// A window is shown, then removed again before it is exposed. This left
// traces in the render loop which prevent other animations from running
// later on.
{
QQuickWindow window;
window.resize(400, 300);
window.show();
}
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("showHideAnimate.qml"));
QQuickItem* created = qobject_cast<QQuickItem *>(component.create());
QVERIFY(created);
QTRY_VERIFY(created->opacity() > 0.5);
QTRY_VERIFY(created->opacity() < 0.5);
}
Make sure exposeEvents trigger a render pass We needs this on non-compositing window managers to trigger repaints on partial updates. Change-Id: Ied5f3e854173c5e00ad7e1222aeb66eb9c96158c Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-20 18:39:11 +00:00
void tst_qquickwindow::testExpose()
{
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Make sure exposeEvents trigger a render pass We needs this on non-compositing window managers to trigger repaints on partial updates. Change-Id: Ied5f3e854173c5e00ad7e1222aeb66eb9c96158c Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2013-02-20 18:39:11 +00:00
window.setGeometry(100, 100, 300, 200);
window.show();
QTRY_VERIFY(window.isExposed());
QSignalSpy swapSpy(&window, SIGNAL(frameSwapped()));
// exhaust pending exposes, as some platforms send us plenty
// while showing the first time
QTest::qWait(1000);
while (swapSpy.size() != 0) {
swapSpy.clear();
QTest::qWait(100);
}
QWindowSystemInterface::handleExposeEvent(&window, QRegion(10, 10, 20, 20));
QTRY_COMPARE(swapSpy.size(), 1);
}
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
void tst_qquickwindow::requestActivate()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("active.qml"));
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QScopedPointer<QQuickWindow> window1(qobject_cast<QQuickWindow *>(component.create()));
QVERIFY(!window1.isNull());
window1->setTitle(QTest::currentTestFunction());
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
QWindowList windows = QGuiApplication::topLevelWindows();
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(windows.size(), 2);
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
for (int i = 0; i < windows.size(); ++i) {
if (windows.at(i)->objectName() == window1->objectName()) {
windows.removeAt(i);
break;
}
}
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(windows.size(), 1);
QCOMPARE(windows.at(0)->objectName(), QLatin1String("window2"));
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
window1->show();
Behavior fix when creating QML windows When a QML window is created it is set visible after the QQuickWindowQmlImpl component is complete. This works fine for a single window, but because componentCompleted is called first for the last created windows, the behavior is not as the user might expect (and different compared to version 2.0 of the QML Window API). One of the results is e.g. that a window which is created as a child object in QML will have a lower z-Order than the parent. On some platforms (e.g. BlackBerry) an even bigger problem arises because the first created window acts as a container for the whole application and is always shown fullscreen. On other platforms (Linux) the initial window position and the window focus ares not set correctly. This patch postpones showing windows until the "transientParent" is visible. [Changelog][QtQuick] Making a QtQuick Window visible is postponed till its transient parent is visible Task-number: QTBUG-37440 Change-Id: I09a94ff038c066a5d3298c6c103dafde50bef1fa Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-01-18 15:45:33 +00:00
QVERIFY(QTest::qWaitForWindowExposed(windows.at(0))); //We wait till window 2 comes up
window1->requestActivate(); // and then transfer the focus to window1
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QTRY_COMPARE(QGuiApplication::focusWindow(), window1.data());
Tests: Replace Q[TRY]_VERIFY(v == true|false) by QVERIFY(v)|QVERIFY(!v). Preparing the replacement of Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) for non-boolean types. Change-Id: I8a4e44a2b4e20a9c8b811799e3932c8ce1a2cbbb Reviewed-by: Mitch Curtis <mitch.curtis@theqtcompany.com>
2015-07-24 11:39:05 +00:00
QVERIFY(window1->isActive());
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
QQuickItem *item = QQuickVisualTestUtil::findItem<QQuickItem>(window1->contentItem(), "item1");
QVERIFY(item);
//copied from src/qmltest/quicktestevent.cpp
QPoint pos = item->mapToScene(QPointF(item->width()/2, item->height()/2)).toPoint();
QMouseEvent me(QEvent::MouseButtonPress, pos, window1->mapToGlobal(pos), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QSpontaneKeyEvent::setSpontaneous(&me);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
if (!qApp->notify(window1.data(), &me)) {
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
QString warning = QString::fromLatin1("Mouse event MousePress not accepted by receiving window");
QWARN(warning.toLatin1().data());
}
me = QMouseEvent(QEvent::MouseButtonPress, pos, window1->mapToGlobal(pos), Qt::LeftButton, 0, Qt::NoModifier);
QSpontaneKeyEvent::setSpontaneous(&me);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
if (!qApp->notify(window1.data(), &me)) {
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
QString warning = QString::fromLatin1("Mouse event MouseRelease not accepted by receiving window");
QWARN(warning.toLatin1().data());
}
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QTRY_COMPARE(QGuiApplication::focusWindow(), windows.at(0));
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
QVERIFY(windows.at(0)->isActive());
Behavior fix when creating QML windows When a QML window is created it is set visible after the QQuickWindowQmlImpl component is complete. This works fine for a single window, but because componentCompleted is called first for the last created windows, the behavior is not as the user might expect (and different compared to version 2.0 of the QML Window API). One of the results is e.g. that a window which is created as a child object in QML will have a lower z-Order than the parent. On some platforms (e.g. BlackBerry) an even bigger problem arises because the first created window acts as a container for the whole application and is always shown fullscreen. On other platforms (Linux) the initial window position and the window focus ares not set correctly. This patch postpones showing windows until the "transientParent" is visible. [Changelog][QtQuick] Making a QtQuick Window visible is postponed till its transient parent is visible Task-number: QTBUG-37440 Change-Id: I09a94ff038c066a5d3298c6c103dafde50bef1fa Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-01-18 15:45:33 +00:00
}
void tst_qquickwindow::testWindowVisibilityOrder()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("windoworder.qml"));
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QScopedPointer<QQuickWindow> window1(qobject_cast<QQuickWindow *>(component.create()));
QVERIFY(!window1.isNull());
window1->setTitle(QTest::currentTestFunction());
Behavior fix when creating QML windows When a QML window is created it is set visible after the QQuickWindowQmlImpl component is complete. This works fine for a single window, but because componentCompleted is called first for the last created windows, the behavior is not as the user might expect (and different compared to version 2.0 of the QML Window API). One of the results is e.g. that a window which is created as a child object in QML will have a lower z-Order than the parent. On some platforms (e.g. BlackBerry) an even bigger problem arises because the first created window acts as a container for the whole application and is always shown fullscreen. On other platforms (Linux) the initial window position and the window focus ares not set correctly. This patch postpones showing windows until the "transientParent" is visible. [Changelog][QtQuick] Making a QtQuick Window visible is postponed till its transient parent is visible Task-number: QTBUG-37440 Change-Id: I09a94ff038c066a5d3298c6c103dafde50bef1fa Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-01-18 15:45:33 +00:00
QQuickWindow *window2 = window1->property("win2").value<QQuickWindow*>();
QQuickWindow *window3 = window1->property("win3").value<QQuickWindow*>();
QQuickWindow *window4 = window1->property("win4").value<QQuickWindow*>();
QQuickWindow *window5 = window1->property("win5").value<QQuickWindow*>();
QVERIFY(window2);
QVERIFY(window3);
QTest::qWaitForWindowExposed(window3);
QWindowList windows = QGuiApplication::topLevelWindows();
QTRY_COMPARE(windows.size(), 5);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(window3, QGuiApplication::focusWindow());
Behavior fix when creating QML windows When a QML window is created it is set visible after the QQuickWindowQmlImpl component is complete. This works fine for a single window, but because componentCompleted is called first for the last created windows, the behavior is not as the user might expect (and different compared to version 2.0 of the QML Window API). One of the results is e.g. that a window which is created as a child object in QML will have a lower z-Order than the parent. On some platforms (e.g. BlackBerry) an even bigger problem arises because the first created window acts as a container for the whole application and is always shown fullscreen. On other platforms (Linux) the initial window position and the window focus ares not set correctly. This patch postpones showing windows until the "transientParent" is visible. [Changelog][QtQuick] Making a QtQuick Window visible is postponed till its transient parent is visible Task-number: QTBUG-37440 Change-Id: I09a94ff038c066a5d3298c6c103dafde50bef1fa Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-01-18 15:45:33 +00:00
QVERIFY(window1->isActive());
QVERIFY(window2->isActive());
QVERIFY(window3->isActive());
//Test if window4 is shown 2 seconds after the application startup
//with window4 visible window5 (transient child) should also become visible
QVERIFY(!window4->isVisible());
QVERIFY(!window5->isVisible());
window4->setVisible(true);
QTest::qWaitForWindowExposed(window5);
QVERIFY(window4->isVisible());
QVERIFY(window5->isVisible());
Added doc and test for active and requestActivate in QQuickWindow Autotest is included. Change-Id: I0f8614b502f1e51cab5612fee283c929e078108b Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Liang Qi <liang.qi@digia.com>
2013-04-18 07:36:28 +00:00
}
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
void tst_qquickwindow::blockClosing()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("ucantclosethis.qml"));
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QScopedPointer<QQuickWindow> window(qobject_cast<QQuickWindow *>(component.create()));
QVERIFY(!window.isNull());
window->setTitle(QTest::currentTestFunction());
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
window->show();
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QTest::qWaitForWindowExposed(window.data());
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
QVERIFY(window->isVisible());
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QWindowSystemInterface::handleCloseEvent(window.data());
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
QVERIFY(window->isVisible());
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QWindowSystemInterface::handleCloseEvent(window.data());
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
QVERIFY(window->isVisible());
window->setProperty("canCloseThis", true);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QWindowSystemInterface::handleCloseEvent(window.data());
Add QQuickWindow::closing signal, and ability to ignore the event An application can implement onClosing() and set closeEvent.accepted = false to delay the closing (for example to prompt the user to save changes). Depends on change I9abed47fca02a002b78727f98d678a824854adfc in qtbase. Task-number: QTBUG-31019 Change-Id: Icfd4a03ecef3621bdbbee2e2c3157b897a9b6524 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2013-05-06 12:40:28 +00:00
QTRY_VERIFY(!window->isVisible());
}
QQuickWindow autotest: verify that onClosing can block close() Task-number: QTBUG-40093 Change-Id: I800259f45d95736172d500494e68042180178e93 Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2014-11-07 11:54:16 +00:00
void tst_qquickwindow::blockCloseMethod()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("ucantclosethis.qml"));
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QScopedPointer<QQuickWindow> window(qobject_cast<QQuickWindow *>(component.create()));
QVERIFY(!window.isNull());
window->setTitle(QTest::currentTestFunction());
QQuickWindow autotest: verify that onClosing can block close() Task-number: QTBUG-40093 Change-Id: I800259f45d95736172d500494e68042180178e93 Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2014-11-07 11:54:16 +00:00
window->show();
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QTest::qWaitForWindowExposed(window.data());
QQuickWindow autotest: verify that onClosing can block close() Task-number: QTBUG-40093 Change-Id: I800259f45d95736172d500494e68042180178e93 Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2014-11-07 11:54:16 +00:00
QVERIFY(window->isVisible());
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QVERIFY(QMetaObject::invokeMethod(window.data(), "close", Qt::DirectConnection));
QQuickWindow autotest: verify that onClosing can block close() Task-number: QTBUG-40093 Change-Id: I800259f45d95736172d500494e68042180178e93 Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2014-11-07 11:54:16 +00:00
QVERIFY(window->isVisible());
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QVERIFY(QMetaObject::invokeMethod(window.data(), "close", Qt::DirectConnection));
QQuickWindow autotest: verify that onClosing can block close() Task-number: QTBUG-40093 Change-Id: I800259f45d95736172d500494e68042180178e93 Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2014-11-07 11:54:16 +00:00
QVERIFY(window->isVisible());
window->setProperty("canCloseThis", true);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QVERIFY(QMetaObject::invokeMethod(window.data(), "close", Qt::DirectConnection));
QQuickWindow autotest: verify that onClosing can block close() Task-number: QTBUG-40093 Change-Id: I800259f45d95736172d500494e68042180178e93 Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2014-11-07 11:54:16 +00:00
QTRY_VERIFY(!window->isVisible());
}
Fix hover event crash It was possible for a hover event to be sent to a QQuickItem that has already been scheduled to be deleted (through deleteLater()). This lead to an access on an already-freed object when the leave event is generated. This change ensures that the item is part of a scene before generating the hover enter event. Task-number: QTBUG-32771 Change-Id: I69adb6bbd0ae52c70a6bda4e6c918b7671549a4c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-01 22:51:03 +00:00
void tst_qquickwindow::crashWhenHoverItemDeleted()
{
// QTBUG-32771
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("hoverCrash.qml"));
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QScopedPointer<QQuickWindow> window(qobject_cast<QQuickWindow *>(component.create()));
QVERIFY(!window.isNull());
window->setTitle(QTest::currentTestFunction());
Fix hover event crash It was possible for a hover event to be sent to a QQuickItem that has already been scheduled to be deleted (through deleteLater()). This lead to an access on an already-freed object when the leave event is generated. This change ensures that the item is part of a scene before generating the hover enter event. Task-number: QTBUG-32771 Change-Id: I69adb6bbd0ae52c70a6bda4e6c918b7671549a4c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-01 22:51:03 +00:00
window->show();
Merge remote-tracking branch 'origin/5.5' into dev Conflicts: src/qml/jsruntime/qv4engine_p.h src/quick/items/qquickitemsmodule.cpp src/quick/items/qquicktext.cpp src/quick/util/qquickpixmapcache.cpp tests/auto/quick/qquickwindow/tst_qquickwindow.cpp Change-Id: I90ecaad6a4bfaa4f36149a7463f4d7141f4a516a
2015-06-04 08:24:46 +00:00
QTest::qWaitForWindowActive(window.data());
Fix hover event crash It was possible for a hover event to be sent to a QQuickItem that has already been scheduled to be deleted (through deleteLater()). This lead to an access on an already-freed object when the leave event is generated. This change ensures that the item is part of a scene before generating the hover enter event. Task-number: QTBUG-32771 Change-Id: I69adb6bbd0ae52c70a6bda4e6c918b7671549a4c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-01 22:51:03 +00:00
// Simulate a move from the first rectangle to the second. Crash will happen in here
// Moving instantaneously from (0, 99) to (0, 102) does not cause the crash
Fix some style issues in tst_qquickwindow Change-Id: I5802f10f9aaff3e443696644d07203160fbc3b91 Reviewed-by: hjk <hjk121@nokiamail.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-14 05:23:39 +00:00
for (int i = 99; i < 102; ++i) {
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QTest::mouseMove(window.data(), QPoint(0, i));
Fix hover event crash It was possible for a hover event to be sent to a QQuickItem that has already been scheduled to be deleted (through deleteLater()). This lead to an access on an already-freed object when the leave event is generated. This change ensures that the item is part of a scene before generating the hover enter event. Task-number: QTBUG-32771 Change-Id: I69adb6bbd0ae52c70a6bda4e6c918b7671549a4c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-08-01 22:51:03 +00:00
}
}
Avoid double deletion of QQuickWindow It's uncertain why 4fc0df58b8458052a818e3e970a97457882808e6 added the call to sendPostedEvents(0, QEvent::DeferredDelete) but now we can see that it easily results in the destructor calling itself, and therefore double-deleting its own d_ptr. removePostedEvents seems safer to ensure that the window cannot be doubly deleted, in spite of the qdoc warning that "You should never need to call this function." Task-number: QTBUG-33436 Change-Id: I4873ebe179dde551407eba1f6baac5f03ca7f177 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-09-17 13:05:04 +00:00
// QTBUG-33436
void tst_qquickwindow::unloadSubWindow()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("unloadSubWindow.qml"));
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QScopedPointer<QQuickWindow> window(qobject_cast<QQuickWindow *>(component.create()));
QVERIFY(!window.isNull());
window->setTitle(QTest::currentTestFunction());
Avoid double deletion of QQuickWindow It's uncertain why 4fc0df58b8458052a818e3e970a97457882808e6 added the call to sendPostedEvents(0, QEvent::DeferredDelete) but now we can see that it easily results in the destructor calling itself, and therefore double-deleting its own d_ptr. removePostedEvents seems safer to ensure that the window cannot be doubly deleted, in spite of the qdoc warning that "You should never need to call this function." Task-number: QTBUG-33436 Change-Id: I4873ebe179dde551407eba1f6baac5f03ca7f177 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-09-17 13:05:04 +00:00
window->show();
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QTest::qWaitForWindowExposed(window.data());
Fix use-after-free in testcase. The call to setActive does a deleteLater on the window. Then the QTRY_* macros run the event loop, thereby deleting the window. So, after wrapping the window in a QPointer, that pointer must either be null, or the window shouldn't be visible. Change-Id: Ib3fc5c5284bd5dae378a0f6a17117b262b9a3687 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
2014-08-06 13:18:08 +00:00
QPointer<QQuickWindow> transient;
Avoid double deletion of QQuickWindow It's uncertain why 4fc0df58b8458052a818e3e970a97457882808e6 added the call to sendPostedEvents(0, QEvent::DeferredDelete) but now we can see that it easily results in the destructor calling itself, and therefore double-deleting its own d_ptr. removePostedEvents seems safer to ensure that the window cannot be doubly deleted, in spite of the qdoc warning that "You should never need to call this function." Task-number: QTBUG-33436 Change-Id: I4873ebe179dde551407eba1f6baac5f03ca7f177 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-09-17 13:05:04 +00:00
QTRY_VERIFY(transient = window->property("transientWindow").value<QQuickWindow*>());
QTest::qWaitForWindowExposed(transient);
// Unload the inner window (in nested Loaders) and make sure it doesn't crash
QQuickLoader *loader = window->property("loader1").value<QQuickLoader*>();
loader->setActive(false);
Fix use-after-free in testcase. The call to setActive does a deleteLater on the window. Then the QTRY_* macros run the event loop, thereby deleting the window. So, after wrapping the window in a QPointer, that pointer must either be null, or the window shouldn't be visible. Change-Id: Ib3fc5c5284bd5dae378a0f6a17117b262b9a3687 Reviewed-by: Simon Hausmann <simon.hausmann@digia.com> Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
2014-08-06 13:18:08 +00:00
QTRY_VERIFY(transient.isNull() || !transient->isVisible());
Avoid double deletion of QQuickWindow It's uncertain why 4fc0df58b8458052a818e3e970a97457882808e6 added the call to sendPostedEvents(0, QEvent::DeferredDelete) but now we can see that it easily results in the destructor calling itself, and therefore double-deleting its own d_ptr. removePostedEvents seems safer to ensure that the window cannot be doubly deleted, in spite of the qdoc warning that "You should never need to call this function." Task-number: QTBUG-33436 Change-Id: I4873ebe179dde551407eba1f6baac5f03ca7f177 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-09-17 13:05:04 +00:00
}
Fix changing QML Window visibility in Component.onCompleted Creating a transient QML Window with visible set to false and then trying to show() it in Component.onCompleted led to a race condition where the window would be shown for a brief moment and then hidden again to enforce the delayed initialization of the visible property. Fixed by tracking the value of the visible property regardless of the 'completed' state. The same problem was fixed for the visibility property. Task-number: QTBUG-52573 Change-Id: I2a2ed7f359b951cb9189a7a6628d1d0cc1445d73 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2016-04-14 15:49:11 +00:00
// QTBUG-52573
void tst_qquickwindow::changeVisibilityInCompleted()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("changeVisibilityInCompleted.qml"));
QScopedPointer<QQuickWindow> window(qobject_cast<QQuickWindow *>(component.create()));
QVERIFY(!window.isNull());
window->setTitle(QTest::currentTestFunction());
window->show();
QTest::qWaitForWindowExposed(window.data());
QPointer<QQuickWindow> winVisible;
QTRY_VERIFY(winVisible = window->property("winVisible").value<QQuickWindow*>());
QPointer<QQuickWindow> winVisibility;
QTRY_VERIFY(winVisibility = window->property("winVisibility").value<QQuickWindow*>());
QTest::qWaitForWindowExposed(winVisible);
QTest::qWaitForWindowExposed(winVisibility);
QVERIFY(winVisible->isVisible());
QCOMPARE(winVisibility->visibility(), QWindow::Windowed);
}
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
// QTBUG-32004
void tst_qquickwindow::qobjectEventFilter_touch()
{
QQuickWindow window;
window.resize(250, 250);
window.setPosition(100, 100);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
window.show();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(&window));
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
TestTouchItem *item = new TestTouchItem(window.contentItem());
item->setSize(QSizeF(150, 150));
EventFilter eventFilter;
item->installEventFilter(&eventFilter);
QPointF pos(10, 10);
// press single point
QTest::touchEvent(&window, touchDevice).press(0, item->mapToScene(pos).toPoint(), &window);
QCOMPARE(eventFilter.events.count(), 1);
QCOMPARE(eventFilter.events.first(), (int)QEvent::TouchBegin);
}
// QTBUG-32004
void tst_qquickwindow::qobjectEventFilter_key()
{
QQuickWindow window;
window.resize(250, 250);
window.setPosition(100, 100);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
window.show();
Wait for window activation, not for exposal in key press test The previous version only worked when simulated input events were queued and thus incidentally delivered after the window activation that follows the exposal. 66050f2ac875d451bec31e0d8ff507795b5b18d6 in qtbase made event delivery synchronous for simulated input events. Change-Id: Ieea3d1360b32f3466059a2ffe570d6dc633f81dc Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
2015-05-27 13:04:48 +00:00
QVERIFY(QTest::qWaitForWindowActive(&window));
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
TestTouchItem *item = new TestTouchItem(window.contentItem());
item->setSize(QSizeF(150, 150));
item->setFocus(true);
EventFilter eventFilter;
item->installEventFilter(&eventFilter);
QTest::keyPress(&window, Qt::Key_A);
// NB: It may also receive some QKeyEvent(ShortcutOverride) which we're not interested in
QVERIFY(eventFilter.events.contains((int)QEvent::KeyPress));
eventFilter.events.clear();
QTest::keyRelease(&window, Qt::Key_A);
QVERIFY(eventFilter.events.contains((int)QEvent::KeyRelease));
}
// QTBUG-32004
void tst_qquickwindow::qobjectEventFilter_mouse()
{
QQuickWindow window;
window.resize(250, 250);
window.setPosition(100, 100);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
window.show();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(&window));
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
TestTouchItem *item = new TestTouchItem(window.contentItem());
item->setSize(QSizeF(150, 150));
EventFilter eventFilter;
item->installEventFilter(&eventFilter);
QPoint point = item->mapToScene(QPointF(10, 10)).toPoint();
Move the mouse to the right place before simulating a click Otherwise the mouse event can be split in two and only a mouse move will be immediately delivered. This problem was exposed by commit 66050f2ac875d451bec31e0d8ff507795b5b18d6 in qtbase. Change-Id: I9d458bd446c754f566d1de412eb90a43f0686ab9 Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
2015-05-27 14:43:04 +00:00
QTest::mouseMove(&window, point);
Fix delivery of QEvents to QQuickItems Make them go through QObject::event() and comply to filtering from objects passsed to QObject::installEventFilter() Task-number: QTBUG-32004 Change-Id: Ib6972e7f5e588bee986ae5f2d69aa6fccb58af95 Reviewed-by: J-P Nurmi <jpnurmi@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-11-12 13:47:32 +00:00
QTest::mousePress(&window, Qt::LeftButton, Qt::NoModifier, point);
QVERIFY(eventFilter.events.contains((int)QEvent::MouseButtonPress));
// clean up mouse press state for the next tests
QTest::mouseRelease(&window, Qt::LeftButton, Qt::NoModifier, point);
}
Add a signal for syncing external animation systems [ChangeLog] QQuickWindow will now emit the afterAnimating() signal from the gui thread before each scenegraph sync request. Change-Id: I4897c82f75066238e781455d4fce4fb6bbe2558e Reviewed-by: Pasi Keränen <pasi.keranen@digia.com> Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2014-02-19 11:20:20 +00:00
void tst_qquickwindow::animatingSignal()
{
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Add a signal for syncing external animation systems [ChangeLog] QQuickWindow will now emit the afterAnimating() signal from the gui thread before each scenegraph sync request. Change-Id: I4897c82f75066238e781455d4fce4fb6bbe2558e Reviewed-by: Pasi Keränen <pasi.keranen@digia.com> Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2014-02-19 11:20:20 +00:00
window.setGeometry(100, 100, 300, 200);
QSignalSpy spy(&window, SIGNAL(afterAnimating()));
window.show();
QTRY_VERIFY(window.isExposed());
QTRY_VERIFY(spy.count() > 1);
}
QQuickWindow: fix content item size Resize content item in QQuickWindow::resizeEvent() instead of using signals and slots. The signal-slot connections were only established when child items were added in QML. It should work in C++ too, since QQuickWindow and QQuickItem are part of the public C++ API and using them in C++ is a perfectly valid use case. Resizing the content item in resizeEvent() is not only faster than using signals and slots, but also in theory a bit more flexible as one would be able to override the event handler and implement their own layouting. Task-number: QTBUG-36938 Change-Id: Id05d4cf6d547021803050633e6f0a3359129a9f3 Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Mitch Curtis <mitch.curtis@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com> Reviewed-by: Jan Arve Sæther <jan-arve.saether@digia.com>
2014-02-21 14:04:21 +00:00
// QTBUG-36938
void tst_qquickwindow::contentItemSize()
{
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
QQuickWindow: fix content item size Resize content item in QQuickWindow::resizeEvent() instead of using signals and slots. The signal-slot connections were only established when child items were added in QML. It should work in C++ too, since QQuickWindow and QQuickItem are part of the public C++ API and using them in C++ is a perfectly valid use case. Resizing the content item in resizeEvent() is not only faster than using signals and slots, but also in theory a bit more flexible as one would be able to override the event handler and implement their own layouting. Task-number: QTBUG-36938 Change-Id: Id05d4cf6d547021803050633e6f0a3359129a9f3 Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Mitch Curtis <mitch.curtis@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com> Reviewed-by: Jan Arve Sæther <jan-arve.saether@digia.com>
2014-02-21 14:04:21 +00:00
QQuickItem *contentItem = window.contentItem();
QVERIFY(contentItem);
QCOMPARE(QSize(contentItem->width(), contentItem->height()), window.size());
QSizeF size(300, 200);
window.resize(size.toSize());
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
QCOMPARE(window.size(), size.toSize());
QCOMPARE(QSizeF(contentItem->width(), contentItem->height()), size);
QQmlEngine engine;
QQmlComponent component(&engine);
component.setData(QByteArray("import QtQuick 2.1\n Rectangle { anchors.fill: parent }"), QUrl());
QQuickItem *rect = qobject_cast<QQuickItem *>(component.create());
QVERIFY(rect);
rect->setParentItem(window.contentItem());
QCOMPARE(QSizeF(rect->width(), rect->height()), size);
size.transpose();
window.resize(size.toSize());
QCOMPARE(window.size(), size.toSize());
// wait for resize event
QTRY_COMPARE(QSizeF(contentItem->width(), contentItem->height()), size);
QCOMPARE(QSizeF(rect->width(), rect->height()), size);
}
Add defaultSurfaceFormat to QQuickWindow This static function can be used to set a surface format that is then picked up by all QQuickWindows, including the ones instantiated from QML. This introduces the ability to request higher OpenGL versions, core profile and other options also for windows that are created from QML via the ApplicationWindow element in Quick Controls applications. [ChangeLog] Added QQuickWindow::setDefaultSurfaceFormat() to set a surface format that applies to all Quick windows, including the ones created from QML. The OpenGL shading language version is now exposed to QML too in order to allow components to provide the correct shader source so shader effect items. Task-number: QTBUG-36392 Change-Id: I75a4718243d835894461f7ee0b4a383988840f9b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-19 14:43:49 +00:00
void tst_qquickwindow::defaultSurfaceFormat()
{
// It is quite difficult to verify anything for real since the resulting format after
// surface/context creation can be anything, depending on the platform and drivers,
// and many options and settings may fail in various configurations, but test at
// least using some harmless settings to check that the global, static format is
// taken into account in the requested format.
Remove setDefaultFormat() from QQuickWindow Replaced by QSurfaceFormat::setDefaultFormat(). Change-Id: If4e37b75ccb55d556d80b0079be89e5a521f6dbb Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-08-07 15:19:50 +00:00
QSurfaceFormat savedDefaultFormat = QSurfaceFormat::defaultFormat();
Add defaultSurfaceFormat to QQuickWindow This static function can be used to set a surface format that is then picked up by all QQuickWindows, including the ones instantiated from QML. This introduces the ability to request higher OpenGL versions, core profile and other options also for windows that are created from QML via the ApplicationWindow element in Quick Controls applications. [ChangeLog] Added QQuickWindow::setDefaultSurfaceFormat() to set a surface format that applies to all Quick windows, including the ones created from QML. The OpenGL shading language version is now exposed to QML too in order to allow components to provide the correct shader source so shader effect items. Task-number: QTBUG-36392 Change-Id: I75a4718243d835894461f7ee0b4a383988840f9b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-19 14:43:49 +00:00
// Verify that depth and stencil are set, as they should be, unless they are disabled
// via environment variables.
QSurfaceFormat format = savedDefaultFormat;
format.setSwapInterval(0);
format.setRedBufferSize(8);
format.setGreenBufferSize(8);
format.setBlueBufferSize(8);
format.setProfile(QSurfaceFormat::CompatibilityProfile);
format.setOption(QSurfaceFormat::DebugContext);
Remove setDefaultFormat() from QQuickWindow Replaced by QSurfaceFormat::setDefaultFormat(). Change-Id: If4e37b75ccb55d556d80b0079be89e5a521f6dbb Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-08-07 15:19:50 +00:00
// Will not set depth and stencil. That should be added automatically,
// unless the are disabled (but they aren't).
QSurfaceFormat::setDefaultFormat(format);
Add defaultSurfaceFormat to QQuickWindow This static function can be used to set a surface format that is then picked up by all QQuickWindows, including the ones instantiated from QML. This introduces the ability to request higher OpenGL versions, core profile and other options also for windows that are created from QML via the ApplicationWindow element in Quick Controls applications. [ChangeLog] Added QQuickWindow::setDefaultSurfaceFormat() to set a surface format that applies to all Quick windows, including the ones created from QML. The OpenGL shading language version is now exposed to QML too in order to allow components to provide the correct shader source so shader effect items. Task-number: QTBUG-36392 Change-Id: I75a4718243d835894461f7ee0b4a383988840f9b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-19 14:43:49 +00:00
QQuickWindow window;
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Add defaultSurfaceFormat to QQuickWindow This static function can be used to set a surface format that is then picked up by all QQuickWindows, including the ones instantiated from QML. This introduces the ability to request higher OpenGL versions, core profile and other options also for windows that are created from QML via the ApplicationWindow element in Quick Controls applications. [ChangeLog] Added QQuickWindow::setDefaultSurfaceFormat() to set a surface format that applies to all Quick windows, including the ones created from QML. The OpenGL shading language version is now exposed to QML too in order to allow components to provide the correct shader source so shader effect items. Task-number: QTBUG-36392 Change-Id: I75a4718243d835894461f7ee0b4a383988840f9b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-19 14:43:49 +00:00
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
Change graphicsAPI to graphicsApi Change-Id: I065f17abd1cb71cd8d6ead76abf7a544eb7a99c0 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-06-01 07:58:27 +00:00
if (window.rendererInterface()->graphicsApi() != QSGRendererInterface::OpenGL)
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
QSKIP("Skipping OpenGL context test due to not running with OpenGL");
Add defaultSurfaceFormat to QQuickWindow This static function can be used to set a surface format that is then picked up by all QQuickWindows, including the ones instantiated from QML. This introduces the ability to request higher OpenGL versions, core profile and other options also for windows that are created from QML via the ApplicationWindow element in Quick Controls applications. [ChangeLog] Added QQuickWindow::setDefaultSurfaceFormat() to set a surface format that applies to all Quick windows, including the ones created from QML. The OpenGL shading language version is now exposed to QML too in order to allow components to provide the correct shader source so shader effect items. Task-number: QTBUG-36392 Change-Id: I75a4718243d835894461f7ee0b4a383988840f9b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-19 14:43:49 +00:00
const QSurfaceFormat reqFmt = window.requestedFormat();
QCOMPARE(format.swapInterval(), reqFmt.swapInterval());
QCOMPARE(format.redBufferSize(), reqFmt.redBufferSize());
QCOMPARE(format.greenBufferSize(), reqFmt.greenBufferSize());
QCOMPARE(format.blueBufferSize(), reqFmt.blueBufferSize());
QCOMPARE(format.profile(), reqFmt.profile());
QCOMPARE(int(format.options()), int(reqFmt.options()));
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
Remove setDefaultFormat() from QQuickWindow Replaced by QSurfaceFormat::setDefaultFormat(). Change-Id: If4e37b75ccb55d556d80b0079be89e5a521f6dbb Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-08-07 15:19:50 +00:00
// Depth and stencil should be >= what has been requested. For real. But use
// the context since the window's surface format is only partially updated
// on most platforms.
QVERIFY(window.openglContext()->format().depthBufferSize() >= 16);
QVERIFY(window.openglContext()->format().stencilBufferSize() >= 8);
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#endif
Remove setDefaultFormat() from QQuickWindow Replaced by QSurfaceFormat::setDefaultFormat(). Change-Id: If4e37b75ccb55d556d80b0079be89e5a521f6dbb Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-08-07 15:19:50 +00:00
QSurfaceFormat::setDefaultFormat(savedDefaultFormat);
Add defaultSurfaceFormat to QQuickWindow This static function can be used to set a surface format that is then picked up by all QQuickWindows, including the ones instantiated from QML. This introduces the ability to request higher OpenGL versions, core profile and other options also for windows that are created from QML via the ApplicationWindow element in Quick Controls applications. [ChangeLog] Added QQuickWindow::setDefaultSurfaceFormat() to set a surface format that applies to all Quick windows, including the ones created from QML. The OpenGL shading language version is now exposed to QML too in order to allow components to provide the correct shader source so shader effect items. Task-number: QTBUG-36392 Change-Id: I75a4718243d835894461f7ee0b4a383988840f9b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-19 14:43:49 +00:00
}
Add Window attached property on Item An Item sometimes needs to know a few things about the window in which it is being displayed; this attached property can expose them without needing to go up the heirarchy to find the window. Instead of adding the QQuickWindow pointer as a property on Item as in 8f49f50a169db85401eb37daf4fe3a0fc3280603, having an attached property means that it will not be found by introspection; and it solves the problem that Window is in the QtQuick.Window module: you must import the module to use the attached property, instead of having access to a pointer whose type might not be defined if you didn't import it. The Window attached property is created on-demand (so the memory cost adds up if you use it in too many places); the tradeoff is that it can exist even when the item is not yet being shown in a window, so bindings at startup work. The API is purposely incomplete compared to that in QQuickWindow so that we can introduce what is needed in a controlled fasion over time. For now we know of use cases for visibility, active and activeFocusItem. [ChangeLog][QtQuick][Window] Added Item.Window attached property Change-Id: I649404cbd1383326678aa2144f790b2f2542dbbc Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
2014-08-07 11:57:50 +00:00
void tst_qquickwindow::attachedProperty()
{
QQuickView view(testFileUrl("windowattached.qml"));
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
view.setTitle(QTest::currentTestFunction());
Add Window attached property on Item An Item sometimes needs to know a few things about the window in which it is being displayed; this attached property can expose them without needing to go up the heirarchy to find the window. Instead of adding the QQuickWindow pointer as a property on Item as in 8f49f50a169db85401eb37daf4fe3a0fc3280603, having an attached property means that it will not be found by introspection; and it solves the problem that Window is in the QtQuick.Window module: you must import the module to use the attached property, instead of having access to a pointer whose type might not be defined if you didn't import it. The Window attached property is created on-demand (so the memory cost adds up if you use it in too many places); the tradeoff is that it can exist even when the item is not yet being shown in a window, so bindings at startup work. The API is purposely incomplete compared to that in QQuickWindow so that we can introduce what is needed in a controlled fasion over time. For now we know of use cases for visibility, active and activeFocusItem. [ChangeLog][QtQuick][Window] Added Item.Window attached property Change-Id: I649404cbd1383326678aa2144f790b2f2542dbbc Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
2014-08-07 11:57:50 +00:00
view.show();
view.requestActivate();
QVERIFY(QTest::qWaitForWindowActive(&view));
QVERIFY(view.rootObject()->property("windowActive").toBool());
Add attached Window::contentItem property This is essential to the Qt Quick Controls for implementing floating text selection handle popups. Change-Id: Ibae65110a5db6d65dacd197fef3ad567d11342dc Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-11-03 16:23:11 +00:00
QCOMPARE(view.rootObject()->property("contentItem").value<QQuickItem*>(), view.contentItem());
Add Window.width and Window.height attached properties [ChangeLog][QtQuick] Added Window.width and Window.height attached properties Change-Id: I3ef590a0d3e6fa660ed88992d5ae843deb09c7bc Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-01-05 20:00:40 +00:00
QCOMPARE(view.rootObject()->property("windowWidth").toInt(), view.width());
QCOMPARE(view.rootObject()->property("windowHeight").toInt(), view.height());
Add Window.window attached property The Window attached property exposes all kinds of window attributes, but not the window itself. Being able to access the window is often useful for various purposes. For example, in QML TestCase, to be able to access the window of the TestCase so that one can call various slots such as requestActivate(). Change-Id: Id03c9f277bb17810b41a60957011ccf07399e149 Reviewed-by: Mitch Curtis <mitch.curtis@theqtcompany.com>
2016-01-31 08:39:34 +00:00
QCOMPARE(view.rootObject()->property("window").value<QQuickView*>(), &view);
Add Window attached property on Item An Item sometimes needs to know a few things about the window in which it is being displayed; this attached property can expose them without needing to go up the heirarchy to find the window. Instead of adding the QQuickWindow pointer as a property on Item as in 8f49f50a169db85401eb37daf4fe3a0fc3280603, having an attached property means that it will not be found by introspection; and it solves the problem that Window is in the QtQuick.Window module: you must import the module to use the attached property, instead of having access to a pointer whose type might not be defined if you didn't import it. The Window attached property is created on-demand (so the memory cost adds up if you use it in too many places); the tradeoff is that it can exist even when the item is not yet being shown in a window, so bindings at startup work. The API is purposely incomplete compared to that in QQuickWindow so that we can introduce what is needed in a controlled fasion over time. For now we know of use cases for visibility, active and activeFocusItem. [ChangeLog][QtQuick][Window] Added Item.Window attached property Change-Id: I649404cbd1383326678aa2144f790b2f2542dbbc Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
2014-08-07 11:57:50 +00:00
QQuickWindow *innerWindow = view.rootObject()->findChild<QQuickWindow*>("extraWindow");
QVERIFY(innerWindow);
innerWindow->requestActivate();
QVERIFY(QTest::qWaitForWindowActive(innerWindow));
QQuickText *text = view.rootObject()->findChild<QQuickText*>("extraWindowText");
QVERIFY(text);
QCOMPARE(text->text(), QLatin1String("active\nvisibility: 2"));
Add attached Window::contentItem property This is essential to the Qt Quick Controls for implementing floating text selection handle popups. Change-Id: Ibae65110a5db6d65dacd197fef3ad567d11342dc Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2014-11-03 16:23:11 +00:00
QCOMPARE(text->property("contentItem").value<QQuickItem*>(), innerWindow->contentItem());
Add Window.width and Window.height attached properties [ChangeLog][QtQuick] Added Window.width and Window.height attached properties Change-Id: I3ef590a0d3e6fa660ed88992d5ae843deb09c7bc Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-01-05 20:00:40 +00:00
QCOMPARE(text->property("windowWidth").toInt(), innerWindow->width());
QCOMPARE(text->property("windowHeight").toInt(), innerWindow->height());
Add Window.window attached property The Window attached property exposes all kinds of window attributes, but not the window itself. Being able to access the window is often useful for various purposes. For example, in QML TestCase, to be able to access the window of the TestCase so that one can call various slots such as requestActivate(). Change-Id: Id03c9f277bb17810b41a60957011ccf07399e149 Reviewed-by: Mitch Curtis <mitch.curtis@theqtcompany.com>
2016-01-31 08:39:34 +00:00
QCOMPARE(text->property("window").value<QQuickWindow*>(), innerWindow);
Window attached property: fix notifier signals The change notifiers must be emitted when an item's window is reset. Otherwise any existing bindings don't get re-evaluated, and in worst scenario one ends up with dangling pointers. Change-Id: I6075957f1447bb8628d25bd822345e45837c027a Reviewed-by: Shawn Rutledge <shawn.rutledge@theqtcompany.com>
2016-01-31 09:42:11 +00:00
text->setParentItem(0);
QVERIFY(!text->property("contentItem").value<QQuickItem*>());
QCOMPARE(text->property("windowWidth").toInt(), 0);
QCOMPARE(text->property("windowHeight").toInt(), 0);
Add Window.window attached property The Window attached property exposes all kinds of window attributes, but not the window itself. Being able to access the window is often useful for various purposes. For example, in QML TestCase, to be able to access the window of the TestCase so that one can call various slots such as requestActivate(). Change-Id: Id03c9f277bb17810b41a60957011ccf07399e149 Reviewed-by: Mitch Curtis <mitch.curtis@theqtcompany.com>
2016-01-31 08:39:34 +00:00
QVERIFY(!text->property("window").value<QQuickWindow*>());
Add Window attached property on Item An Item sometimes needs to know a few things about the window in which it is being displayed; this attached property can expose them without needing to go up the heirarchy to find the window. Instead of adding the QQuickWindow pointer as a property on Item as in 8f49f50a169db85401eb37daf4fe3a0fc3280603, having an attached property means that it will not be found by introspection; and it solves the problem that Window is in the QtQuick.Window module: you must import the module to use the attached property, instead of having access to a pointer whose type might not be defined if you didn't import it. The Window attached property is created on-demand (so the memory cost adds up if you use it in too many places); the tradeoff is that it can exist even when the item is not yet being shown in a window, so bindings at startup work. The API is purposely incomplete compared to that in QQuickWindow so that we can introduce what is needed in a controlled fasion over time. For now we know of use cases for visibility, active and activeFocusItem. [ChangeLog][QtQuick][Window] Added Item.Window attached property Change-Id: I649404cbd1383326678aa2144f790b2f2542dbbc Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
2014-08-07 11:57:50 +00:00
}
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
class RenderJob : public QRunnable
{
public:
RenderJob(QQuickWindow::RenderStage s, QList<QQuickWindow::RenderStage> *l) : stage(s), list(l) { }
~RenderJob() { ++deleted; }
QQuickWindow::RenderStage stage;
QList<QQuickWindow::RenderStage> *list;
void run() {
list->append(stage);
}
static int deleted;
};
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
class GlRenderJob : public QRunnable
{
public:
GlRenderJob(GLubyte *buf) : readPixel(buf), mutex(0), condition(0) {}
~GlRenderJob() {}
void run() {
QOpenGLContext::currentContext()->functions()->glClearColor(1.0f, 0, 0, 1.0f);
QOpenGLContext::currentContext()->functions()->glClear(GL_COLOR_BUFFER_BIT);
QOpenGLContext::currentContext()->functions()->glReadPixels(0, 0, 1, 1, GL_RGBA,
GL_UNSIGNED_BYTE,
(void *)readPixel);
if (mutex) {
mutex->lock();
condition->wakeOne();
mutex->unlock();
}
}
GLubyte *readPixel;
QMutex *mutex;
QWaitCondition *condition;
};
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#endif
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
int RenderJob::deleted = 0;
void tst_qquickwindow::testRenderJob()
{
QList<QQuickWindow::RenderStage> completedJobs;
QQuickWindow::RenderStage stages[] = {
QQuickWindow::BeforeSynchronizingStage,
QQuickWindow::AfterSynchronizingStage,
QQuickWindow::BeforeRenderingStage,
QQuickWindow::AfterRenderingStage,
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
QQuickWindow::AfterSwapStage,
QQuickWindow::NoStage
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
};
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
const int numJobs = 6;
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
{
QQuickWindow window;
Merge remote-tracking branch 'origin/5.5' into dev Conflicts: src/qml/jsruntime/qv4engine_p.h src/quick/items/qquickitemsmodule.cpp src/quick/items/qquicktext.cpp src/quick/util/qquickpixmapcache.cpp tests/auto/quick/qquickwindow/tst_qquickwindow.cpp Change-Id: I90ecaad6a4bfaa4f36149a7463f4d7141f4a516a
2015-06-04 08:24:46 +00:00
window.setTitle(QTest::currentTestFunction());
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
RenderJob::deleted = 0;
// Schedule the jobs
for (int i = 0; i < numJobs; ++i)
window.scheduleRenderJob(new RenderJob(stages[i], &completedJobs), stages[i]);
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
// All jobs should be deleted
QTRY_COMPARE(RenderJob::deleted, numJobs);
// The NoStage job is not completed, if it is issued when there is no context,
// but the rest will be queued and completed once relevant render stage is hit.
QCOMPARE(completedJobs.size(), numJobs - 1);
// Verify jobs were completed in correct order
for (int i = 0; i < numJobs - 1; ++i)
QCOMPARE(completedJobs.at(i), stages[i]);
// Check that NoStage job gets executed if it is scheduled when window is exposed
completedJobs.clear();
RenderJob::deleted = 0;
window.scheduleRenderJob(new RenderJob(QQuickWindow::NoStage, &completedJobs),
QQuickWindow::NoStage);
QTRY_COMPARE(RenderJob::deleted, 1);
QCOMPARE(completedJobs.size(), 1);
Get tests building when QT_NO_OPENGL is defined Change-Id: I36f9e5e916b59657990d7613850ba76d2489a21e Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-04-25 10:09:44 +00:00
#ifndef QT_NO_OPENGL
Change graphicsAPI to graphicsApi Change-Id: I065f17abd1cb71cd8d6ead76abf7a544eb7a99c0 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-06-01 07:58:27 +00:00
if (window.rendererInterface()->graphicsApi() == QSGRendererInterface::OpenGL) {
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
// Do a synchronized GL job.
GLubyte readPixel[4] = {0, 0, 0, 0};
GlRenderJob *glJob = new GlRenderJob(readPixel);
if (window.openglContext()->thread() != QThread::currentThread()) {
QMutex mutex;
QWaitCondition condition;
glJob->mutex = &mutex;
glJob->condition = &condition;
mutex.lock();
window.scheduleRenderJob(glJob, QQuickWindow::NoStage);
condition.wait(&mutex);
mutex.unlock();
} else {
window.scheduleRenderJob(glJob, QQuickWindow::NoStage);
}
QCOMPARE(int(readPixel[0]), 255);
QCOMPARE(int(readPixel[1]), 0);
QCOMPARE(int(readPixel[2]), 0);
QCOMPARE(int(readPixel[3]), 255);
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
}
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
#endif
Fix build with QT_NO_OPENGL after rebase Change-Id: Ia4243de07ec75030bb98f4f6d95f70d88e29fdba Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-05-08 18:17:35 +00:00
}
D3D12: Massage tst_qquickwindow and some sg semantics Change-Id: Ic4cc9ae5c1df2ab7e1da50ac414dc3d7f264e691 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-07 13:33:47 +00:00
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
// Verify that jobs are deleted when window is not rendered at all
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
completedJobs.clear();
RenderJob::deleted = 0;
{
QQuickWindow window2;
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
for (int i = 0; i < numJobs; ++i) {
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
window2.scheduleRenderJob(new RenderJob(stages[i], &completedJobs), stages[i]);
}
}
Added a new render job stage: NoStage NoStage allows scheduling jobs for immediate execution on the renderer thread. [ChangeLog][QtQuick][QQuickWindow] Added a render job stage: NoStage Task-number: QTBUG-44953 Change-Id: I918c79f1d095bc27d911a88d81376d146a04313c Reviewed-by: Gunnar Sletta <gunnar@sletta.org> Reviewed-by: Venugopal Shivashankar <venugopal.shivashankar@digia.com> Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
2015-03-18 12:13:10 +00:00
QTRY_COMPARE(RenderJob::deleted, numJobs);
Introducing QQuickWindow::scheduleRenderJob() [ChangeLog][QtQuick][QQuickWindow] Added QQuickWindow::scheduleRenderJob(), a convenience alternative to the equivalent signals for one-shot tasks. Change-Id: I5e4f0d67d5223f7fd77bca394e2a85810fadd335 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-07-04 21:50:50 +00:00
QCOMPARE(completedJobs.size(), 0);
}
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
class EventCounter : public QQuickRectangle
{
public:
EventCounter(QQuickItem *parent = 0)
: QQuickRectangle(parent)
{ }
void addFilterEvent(QEvent::Type type)
{
m_returnTrueForType.append(type);
}
int childMouseEventFilterEventCount(QEvent::Type type)
{
return m_childMouseEventFilterEventCount.value(type, 0);
}
int eventCount(QEvent::Type type)
{
return m_eventCount.value(type, 0);
}
void reset()
{
m_eventCount.clear();
m_childMouseEventFilterEventCount.clear();
}
protected:
bool childMouseEventFilter(QQuickItem *, QEvent *event) Q_DECL_OVERRIDE
{
m_childMouseEventFilterEventCount[event->type()]++;
return m_returnTrueForType.contains(event->type());
}
bool event(QEvent *event) Q_DECL_OVERRIDE
{
m_eventCount[event->type()]++;
return QQuickRectangle::event(event);
}
private:
QList<QEvent::Type> m_returnTrueForType;
QMap<QEvent::Type, int> m_childMouseEventFilterEventCount;
QMap<QEvent::Type, int> m_eventCount;
};
void tst_qquickwindow::testHoverChildMouseEventFilter()
{
QQuickWindow window;
window.resize(250, 250);
window.setPosition(100, 100);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
window.setTitle(QTest::currentTestFunction());
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
window.show();
Stabilize QQuickWindow test Various test functions use QTest::touch* and QTest::mouse* to synthesize touch/mouse events. The synthetization relies on the QWindow to be globally positioned (with regards to the window manager), as it performs a translation of the supplied window coordinates to global coordinates. If this happens too early in the window mapping process, we end up with wrong global coordinates, that in turn mean that when the event is mapped back to the window coordinates later, it has the wrong coordinates and not what the test expects. qWaitForWindowActive tries to accommodate this case by waiting until the positioning of the window is "complete", as opposed to qWaitForWindowExposed, which returns as soon as we have a rendering surface. The symptom in the CI system was that when this race condition hit, the y coordinate of events was off by 28 pixels on Ubuntu machines, which appears to be the height of the title or menu bar. Therefore this patch changes test functions that synthesize events to use qWaitForWindowActive. Change-Id: Ia8ecff517f4eefb15068ca1c342ef6666681c362 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-04-21 08:48:29 +00:00
QVERIFY(QTest::qWaitForWindowActive(&window));
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
EventCounter *bottomItem = new EventCounter(window.contentItem());
bottomItem->setObjectName("Bottom Item");
bottomItem->setSize(QSizeF(150, 150));
bottomItem->setAcceptHoverEvents(true);
EventCounter *middleItem = new EventCounter(bottomItem);
middleItem->setObjectName("Middle Item");
middleItem->setPosition(QPointF(50, 50));
middleItem->setSize(QSizeF(150, 150));
middleItem->setAcceptHoverEvents(true);
EventCounter *topItem = new EventCounter(middleItem);
topItem->setObjectName("Top Item");
topItem->setPosition(QPointF(50, 50));
topItem->setSize(QSizeF(150, 150));
topItem->setAcceptHoverEvents(true);
QPoint pos(10, 10);
QTest::mouseMove(&window, pos);
QTRY_VERIFY(bottomItem->eventCount(QEvent::HoverEnter) > 0);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(bottomItem->childMouseEventFilterEventCount(QEvent::HoverEnter), 0);
QCOMPARE(middleItem->eventCount(QEvent::HoverEnter), 0);
QCOMPARE(topItem->eventCount(QEvent::HoverEnter), 0);
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
bottomItem->reset();
pos = QPoint(60, 60);
QTest::mouseMove(&window, pos);
QTRY_VERIFY(middleItem->eventCount(QEvent::HoverEnter) > 0);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(bottomItem->childMouseEventFilterEventCount(QEvent::HoverEnter), 0);
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
middleItem->reset();
pos = QPoint(70,70);
bottomItem->setFiltersChildMouseEvents(true);
QTest::mouseMove(&window, pos);
QTRY_VERIFY(middleItem->eventCount(QEvent::HoverMove) > 0);
QVERIFY(bottomItem->childMouseEventFilterEventCount(QEvent::HoverMove) > 0);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(topItem->eventCount(QEvent::HoverEnter), 0);
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
bottomItem->reset();
middleItem->reset();
pos = QPoint(110,110);
bottomItem->addFilterEvent(QEvent::HoverEnter);
QTest::mouseMove(&window, pos);
QTRY_VERIFY(bottomItem->childMouseEventFilterEventCount(QEvent::HoverEnter) > 0);
tst_qquickwindow: Prospective fix for instability of cursor test. FAIL! : tst_qquickwindow::cursor() Compared values are not the same Loc: [tst_qquickwindow.cpp(1444)] Check that no windows are leaked in slot cleanup and fix all leaking tests. Position the window and enlarge it to fix the warning: WARNING: tst_qquickwindow::cursor() Mouse event occurs outside of target window. Add window titles to tests. Replace QVERIFY(a == b) by QCOMPARE(a, b). Change-Id: Ida892e8a8d7d5f40d4f50787608940dbffc7a29d Reviewed-by: Caroline Chao <caroline.chao@theqtcompany.com>
2015-06-03 12:27:27 +00:00
QCOMPARE(topItem->eventCount(QEvent::HoverEnter), 0);
QCOMPARE(middleItem->eventCount(QEvent::HoverEnter), 0);
Send hover events also to QQuickItem::childMouseEventFilter childMouseEventFilter already gets touch events, and it is logical to send the hover events which are essentially mouse events. By also sending hover events to the filter it allows an item to track the mouse. Existing implementations of childMouseEventFilter should not be effected by more events being sent to it as checking for the event type should be practiced in all overloads. Change-Id: Ie00aceef05e41e4e8f6d80007343c5a5b9f566cf Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
2015-01-14 08:41:23 +00:00
}
add tst_qquickwindow::eventPointCount Change-Id: I552cf69fa179d8b1260a5502e37553fa57bf32cf Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-13 12:55:50 +00:00
void tst_qquickwindow::pointerEventTypeAndPointCount()
{
QMouseEvent me(QEvent::MouseButtonPress, QPointF(), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QTouchEvent te(QEvent::TouchBegin, touchDevice, Qt::NoModifier, Qt::TouchPointPressed,
QList<QTouchEvent::TouchPoint>() << QTouchEvent::TouchPoint(1));
Hierarchy for touch and mouse pointer events Change-Id: Ie84e39918d9657b29df697be7b0e5198298c48ba Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-15 14:24:34 +00:00
QQuickPointerMouseEvent pme;
pme.reset(&me);
QVERIFY(pme.isValid());
Improve encapsuation of touch/mouse event specific things This makes it easy to avoid casts when using the classes. Change-Id: I27bd1244bffb3a7d2cdb4572c229333e4c499d9b Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-21 09:35:42 +00:00
QCOMPARE(pme.asMouseEvent(), &me);
QVERIFY(pme.asPointerMouseEvent());
QVERIFY(!pme.asPointerTouchEvent());
QVERIFY(!pme.asPointerTabletEvent());
Hierarchy for touch and mouse pointer events Change-Id: Ie84e39918d9657b29df697be7b0e5198298c48ba Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-15 14:24:34 +00:00
// QVERIFY(!pe->asTabletEvent()); // TODO
QCOMPARE(pme.pointCount(), 1);
QQuickPointerTouchEvent pte;
pte.reset(&te);
QVERIFY(pte.isValid());
Improve encapsuation of touch/mouse event specific things This makes it easy to avoid casts when using the classes. Change-Id: I27bd1244bffb3a7d2cdb4572c229333e4c499d9b Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-21 09:35:42 +00:00
QCOMPARE(pte.asTouchEvent(), &te);
QVERIFY(!pte.asPointerMouseEvent());
QVERIFY(pte.asPointerTouchEvent());
QVERIFY(!pte.asPointerTabletEvent());
Hierarchy for touch and mouse pointer events Change-Id: Ie84e39918d9657b29df697be7b0e5198298c48ba Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-15 14:24:34 +00:00
QVERIFY(pte.asTouchEvent());
// QVERIFY(!pte.asTabletEvent()); // TODO
QCOMPARE(pte.pointCount(), 1);
QCOMPARE(pte.touchPointById(1)->id(), 1);
QVERIFY(!pte.touchPointById(0));
add tst_qquickwindow::eventPointCount Change-Id: I552cf69fa179d8b1260a5502e37553fa57bf32cf Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-13 12:55:50 +00:00
te.setTouchPoints(QList<QTouchEvent::TouchPoint>() << QTouchEvent::TouchPoint(1) << QTouchEvent::TouchPoint(2));
Hierarchy for touch and mouse pointer events Change-Id: Ie84e39918d9657b29df697be7b0e5198298c48ba Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-15 14:24:34 +00:00
pte.reset(&te);
QCOMPARE(pte.pointCount(), 2);
QCOMPARE(pte.touchPointById(1)->id(), 1);
QCOMPARE(pte.touchPointById(2)->id(), 2);
QVERIFY(!pte.touchPointById(0));
add tst_qquickwindow::eventPointCount Change-Id: I552cf69fa179d8b1260a5502e37553fa57bf32cf Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-13 12:55:50 +00:00
te.setTouchPoints(QList<QTouchEvent::TouchPoint>() << QTouchEvent::TouchPoint(2));
Hierarchy for touch and mouse pointer events Change-Id: Ie84e39918d9657b29df697be7b0e5198298c48ba Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-07-15 14:24:34 +00:00
pte.reset(&te);
QCOMPARE(pte.pointCount(), 1);
QCOMPARE(pte.touchPointById(2)->id(), 2);
QVERIFY(!pte.touchPointById(1));
QVERIFY(!pte.touchPointById(0));
add tst_qquickwindow::eventPointCount Change-Id: I552cf69fa179d8b1260a5502e37553fa57bf32cf Reviewed-by: Frederik Gladhorn <frederik.gladhorn@qt.io>
2016-07-13 12:55:50 +00:00
}
QQuickCanvas renames QQuickCanvas is now called QQuickWindow QQuickCanvas::rootItem is now QQuickWindow::contentItem QQuickItem::canvas is now QQuickItem::window QQuickItem::ItemChangeData::canvas is also renamed window QQuickCanvas::grabFrameBuffer is now QQuickWindow::grabWindow The functions related to the color property have dropped the clear from their names. The first three changes have interim compatibility measures in place to ease the transition. Change-Id: Id34e29546a22a74a7ae2ad90ee3a8def6fc541d2 Reviewed-by: Martin Jones <martin.jones@nokia.com>
2012-07-11 07:32:16 +00:00
QTEST_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"