id: label
color: "black"
wrapMode: Text.WordWrap
- text: "The background here is a squircle rendered with raw OpenGL using the 'beforeRender()' signal in QQuickCanvas. This text label and its border is rendered using QML"
+ text: "The background here is a squircle rendered with raw OpenGL using the 'beforeRender()' signal in QQuickWindow. This text label and its border is rendered using QML"
anchors.right: parent.right
anchors.left: parent.left
anchors.bottom: parent.bottom
#include "squircle.h"
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
#include <QOpenGLShaderProgram>
Squircle::Squircle()
void Squircle::itemChange(ItemChange change, const ItemChangeData &)
{
- // The ItemSceneChange event is sent when we are first attached to a canvas.
+ // The ItemSceneChange event is sent when we are first attached to a window.
if (change == ItemSceneChange) {
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
// Connect our the beforeRendering signal to our paint function.
// Since this call is executed on the rendering thread it must be
m_program->setAttributeArray(0, GL_FLOAT, values, 2);
m_program->setUniformValue("t", (float) m_t);
- glViewport(0, 0, canvas()->width(), canvas()->height());
+ glViewport(0, 0, window()->width(), window()->height());
glDisable(GL_DEPTH_TEST);
void QQuickCustomParticle::itemChange(ItemChange change, const ItemChangeData &value)
{
if (change == QQuickItem::ItemSceneChange)
- m_common.updateCanvas(value.canvas);
+ m_common.updateWindow(value.window);
QQuickParticlePainter::itemChange(change, value);
}
****************************************************************************/
#include "qquickparticlepainter_p.h"
-#include <QQuickCanvas>
+#include <QQuickWindow>
#include <QDebug>
QT_BEGIN_NAMESPACE
/*!
*/
QQuickParticlePainter::QQuickParticlePainter(QQuickItem *parent) :
QQuickItem(parent),
- m_system(0), m_count(0), m_pleaseReset(true), m_canvas(0)
+ m_system(0), m_count(0), m_pleaseReset(true), m_window(0)
{
}
void QQuickParticlePainter::itemChange(ItemChange change, const ItemChangeData &data)
{
if (change == QQuickItem::ItemSceneChange) {
- if (m_canvas)
- disconnect(m_canvas, SIGNAL(sceneGraphInvalidated()), this, SLOT(sceneGraphInvalidated()));
- m_canvas = data.canvas;
- if (m_canvas)
- connect(m_canvas, SIGNAL(sceneGraphInvalidated()), this, SLOT(sceneGraphInvalidated()), Qt::DirectConnection);
+ if (m_window)
+ disconnect(m_window, SIGNAL(sceneGraphInvalidated()), this, SLOT(sceneGraphInvalidated()));
+ m_window = data.window;
+ if (m_window)
+ connect(m_window, SIGNAL(sceneGraphInvalidated()), this, SLOT(sceneGraphInvalidated()), Qt::DirectConnection);
}
}
QStringList m_groups;
QPointF m_systemOffset;
- QQuickCanvas *m_canvas;
+ QQuickWindow *m_window;
private:
QSet<QPair<int,int> > m_pendingCommits;
QRect QAccessibleQuickItem::viewRect() const
{
- // ### no canvas in some cases.
- if (!item()->canvas()) {
+ // ### no window in some cases.
+ if (!item()->window()) {
return QRect();
}
- QQuickCanvas *canvas = item()->canvas();
- QPoint screenPos = canvas->mapToGlobal(QPoint(0,0));
- return QRect(screenPos, canvas->size());
+ QQuickWindow *window = item()->window();
+ QPoint screenPos = window->mapToGlobal(QPoint(0,0));
+ return QRect(screenPos, window->size());
}
{
QQuickItem *parent = item()->parentItem();
if (parent) {
- QQuickCanvas *canvas = item()->canvas();
+ QQuickWindow *window = item()->window();
// Jump out to the scene widget if the parent is the root item.
- // There are two root items, QQuickCanvas::rootItem and
+ // There are two root items, QQuickWindow::rootItem and
// QQuickView::declarativeRoot. The former is the true root item,
// but is not a part of the accessibility tree. Check if we hit
// it here and return an interface for the scene instead.
- if (canvas && (parent == canvas->rootItem())) {
- return QAccessible::queryAccessibleInterface(canvas);
+ if (window && (parent == window->contentItem())) {
+ return QAccessible::queryAccessibleInterface(window);
} else {
return QAccessible::queryAccessibleInterface(parent);
}
if (item()->hasActiveFocus())
state.focused = true;
- if (!item()->canvas() ||!item()->isVisible() || qFuzzyIsNull(item()->opacity()))
+ if (!item()->window() ||!item()->isVisible() || qFuzzyIsNull(item()->opacity()))
state.invisible = true;
QAccessible::Role r = role();
*/
QRect itemScreenRect(QQuickItem *item)
{
- // ### no canvas in some cases.
+ // ### no window in some cases.
// ### Should we really check for 0 opacity?
- if (!item->canvas() ||!item->isVisible() || qFuzzyIsNull(item->opacity())) {
+ if (!item->window() ||!item->isVisible() || qFuzzyIsNull(item->opacity())) {
return QRect();
}
}
QPointF scenePoint = item->mapToScene(QPointF(0, 0));
- QPoint screenPos = item->canvas()->mapToGlobal(scenePoint.toPoint());
+ QPoint screenPos = item->window()->mapToGlobal(scenePoint.toPoint());
return QRect(screenPos, itemSize);
}
#include <QtCore/QTimer>
#include <QtGui/QPainter>
#include <QtGui/QStaticText>
-#include <QtQuick/QQuickCanvas>
+#include <QtQuick/QQuickWindow>
namespace QmlJSDebugger {
namespace QtQuick2 {
connect(item, SIGNAL(transformOriginChanged(TransformOrigin)),
SLOT(adjust()));
}
- QQuickCanvas *view = item->canvas();
+ QQuickWindow *view = item->window();
QQuickItem * rootItem = view->rootItem();
if (rootItem) {
connect(rootItem, SIGNAL(xChanged()), SLOT(adjust()));
setSize(QSizeF(m_item->width(), m_item->height()));
qreal scaleFactor = 1;
QPointF originOffset = QPointF(0,0);
- QQuickCanvas *view = m_item->canvas();
+ QQuickWindow *view = m_item->window();
if (view->rootItem()) {
scaleFactor = view->rootItem()->scale();
originOffset -= view->rootItem()->pos();
A QML document can be loaded with QQmlComponent or QQuickView.
QQmlComponent loads a QML component as a C++ QObject;
QQuickView also does this, but additionally loads the QML component
- directly into a QQuickCanvas which displays visual QML object types
+ directly into a QQuickWindow which displays visual QML object types
provided by Qt Quick, or object types derived from those.
It is convenient for loading a displayable
QML component as a root QWindow.
that is compiled into the executable:
\code
- QQuickView *canvas = new QQuickView;
- canvas->setUrl(QUrl("qrc:/dial.qml"));
+ QQuickView *view = new QQuickView;
+ view->setUrl(QUrl("qrc:/dial.qml"));
\endcode
The content itself can then use relative URLs, and so be transparently unaware that the content is
#include <QtTest/qtestkeyboard.h>
#include <QtQml/qqml.h>
#include <QtQuick/qquickitem.h>
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
QT_BEGIN_NAMESPACE
{
QQuickItem *sgitem = qobject_cast<QQuickItem *>(parent());
if (sgitem)
- return sgitem->canvas();
+ return sgitem->window();
return 0;
}
#include <QtCore/qdebug.h>
#include <QtCore/QUrl>
#include <QtCore/QDir>
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
QT_BEGIN_NAMESPACE
QObject *QuickTestResult::grabImage(QQuickItem *item)
{
if (item) {
- QQuickCanvas *canvas = item->canvas();
- QImage grabbed = canvas->grabFrameBuffer();
+ QQuickWindow *window = item->window();
+ QImage grabbed = window->grabWindow();
QRectF rf(item->x(), item->y(), item->width(), item->height());
rf = rf.intersected(QRectF(0, 0, grabbed.width(), grabbed.height()));
return new QuickTestImageObject(grabbed.copy(rf.toAlignedRect()));
return;
QQuickItemPrivate::get(referencedItem)->refFromEffectItem(hide);
- QQuickCanvasPrivate::get(referencedItem->canvas())->updateDirtyNode(referencedItem);
+ QQuickWindowPrivate::get(referencedItem->window())->updateDirtyNode(referencedItem);
Q_ASSERT(QQuickItemPrivate::get(referencedItem)->rootNode());
QQuickItemPrivate::get(referencedItem)->removeFromDirtyList();
}
-QTransform DesignerSupport::canvasTransform(QQuickItem *referencedItem)
+QTransform DesignerSupport::windowTransform(QQuickItem *referencedItem)
{
if (referencedItem == 0)
return QTransform();
- return QQuickItemPrivate::get(referencedItem)->itemToCanvasTransform();
+ return QQuickItemPrivate::get(referencedItem)->itemToWindowTransform();
}
QTransform DesignerSupport::parentTransform(QQuickItem *referencedItem)
void DesignerSupport::updateDirtyNode(QQuickItem *item)
{
- QQuickCanvasPrivate::get(item->canvas())->updateDirtyNode(item);
+ QQuickWindowPrivate::get(item->window())->updateDirtyNode(item);
}
QT_END_NAMESPACE
ParentChanged = 0x00000800,
Clip = 0x00001000,
- Canvas = 0x00002000,
+ Window = 0x00002000,
EffectReference = 0x00008000,
Visible = 0x00010000,
HideReference = 0x00020000,
- TransformUpdateMask = TransformOrigin | Transform | BasicTransform | Position | Size | Canvas,
- ComplexTransformUpdateMask = Transform | Canvas,
- ContentUpdateMask = Size | Content | Smooth | Canvas,
- ChildrenUpdateMask = ChildrenChanged | ChildrenStackingChanged | EffectReference | Canvas
+ TransformUpdateMask = TransformOrigin | Transform | BasicTransform | Position | Size | Window,
+ ComplexTransformUpdateMask = Transform | Window,
+ ContentUpdateMask = Size | Content | Smooth | Window,
+ ChildrenUpdateMask = ChildrenChanged | ChildrenStackingChanged | EffectReference | Window
};
static bool isDirty(QQuickItem *referencedItem, DirtyType dirtyType);
static void resetDirty(QQuickItem *referencedItem);
- static QTransform canvasTransform(QQuickItem *referencedItem);
+ static QTransform windowTransform(QQuickItem *referencedItem);
static QTransform parentTransform(QQuickItem *referencedItem);
static bool isAnchoredTo(QQuickItem *fromItem, QQuickItem *toItem);
is less performant than using the \c QSG* classes.
When porting from QDeclarativeView to QQuickView, note that QDeclarativeItem inherited from
-QGraphicsView. In contrast, QQuickView inherits from QQuickCanvas and uses the QWindow
+QGraphicsView. In contrast, QQuickView inherits from QQuickWindow and uses the QWindow
infrastructure introduced in Qt 5; any QGraphicsView-specific functionality is no longer available.
The scene graph is closely tied to QML and can not be used as
stand-alone. The scene graph is managed and rendered by the
-QQuickCanvas class and custom QML elements will add their graphical
+QQuickWindow class and custom QML elements will add their graphical
primitives into the scene graph through a call to
QQuickItem::updatePaintNode().
\section1 Rendering
The rendering of the scene graph happens internally in the
-QQuickCanvas class and is described under the \l{Scene Graph and
+QQuickWindow class and is described under the \l{Scene Graph and
Rendering} section.
How to integrate QPainter based graphics is explained in \l{Custom
\list
\li Custom textures; specifically the implementation of
-QQuickCanvas::createTextureFromImage and the internal representation
+QQuickWindow::createTextureFromImage and the internal representation
of the texture used by \l Image and \l BorderImage elements.
\li Custom renderer; the adaptation layer lets the plugin decide how
\list
\li QQuickItem - the base visual QML type (replaces \c QDeclarativeItem)
-\li QQuickView - a window for rendering a QML scene from a QML file (replaces \c QDeclarativeView)
-\li QQuickCanvas - a base canvas for displaying a QML scene
+\li QQuickView - a convenience window for rendering a QML scene from a QML file (replaces \c QDeclarativeView)
+\li QQuickWindow - a base window for displaying a QML scene
\li QQuickPaintedItem - convenience for using the QPainter API with the scenegraph
\li QQuickImageProvider - fetches custom images for use in QML applications (replaces \c
QDeclarativeImageProvider)
QT_BEGIN_NAMESPACE
-QQuickCanvasPixmap::QQuickCanvasPixmap(const QImage& image, QQuickCanvas *canvas)
+QQuickCanvasPixmap::QQuickCanvasPixmap(const QImage& image, QQuickWindow *window)
: m_pixmap(0)
, m_image(image)
, m_texture(0)
- , m_canvas(canvas)
+ , m_window(window)
{
}
-QQuickCanvasPixmap::QQuickCanvasPixmap(QQuickPixmap *pixmap, QQuickCanvas *canvas)
+QQuickCanvasPixmap::QQuickCanvasPixmap(QQuickPixmap *pixmap, QQuickWindow *window)
: m_pixmap(pixmap)
, m_texture(0)
- , m_canvas(canvas)
+ , m_window(window)
{
}
if (!m_texture) {
if (m_pixmap) {
Q_ASSERT(m_pixmap->textureFactory());
- m_texture = m_pixmap->textureFactory()->createTexture(m_canvas);
+ m_texture = m_pixmap->textureFactory()->createTexture(m_window);
} else {
- m_texture = QQuickCanvasPrivate::get(m_canvas)->context->createTexture(m_image);
+ m_texture = QQuickWindowPrivate::get(m_window)->context->createTexture(m_image);
}
}
return m_texture;
if (d->available)
return;
- if (value.canvas == 0)
+ if (value.window== 0)
return;
- d->canvas = value.canvas;
- if (d->canvas->openglContext() != 0) // available context == initialized
+ d->window = value.window;
+ if (d->window->openglContext() != 0) // available context == initialized
sceneGraphInitialized();
else
- connect(d->canvas, SIGNAL(sceneGraphInitialized()), SLOT(sceneGraphInitialized()));
+ connect(d->window, SIGNAL(sceneGraphInitialized()), SLOT(sceneGraphInitialized()));
}
void QQuickCanvasItem::updatePolish()
if (!d->pixmaps.contains(fullPathUrl)) {
QQuickPixmap* pix = new QQuickPixmap();
QQmlRefPointer<QQuickCanvasPixmap> canvasPix;
- canvasPix.take(new QQuickCanvasPixmap(pix, d->canvas));
+ canvasPix.take(new QQuickCanvasPixmap(pix, d->window));
d->pixmaps.insert(fullPathUrl, canvasPix);
pix->load(qmlEngine(this)
class QQuickCanvasPixmap : public QQmlRefCount
{
public:
- QQuickCanvasPixmap(const QImage& image, QQuickCanvas *canvas);
- QQuickCanvasPixmap(QQuickPixmap *pixmap, QQuickCanvas *canvas);
+ QQuickCanvasPixmap(const QImage& image, QQuickWindow *window);
+ QQuickCanvasPixmap(QQuickPixmap *pixmap, QQuickWindow *window);
~QQuickCanvasPixmap();
QSGTexture *texture();
QQuickPixmap *m_pixmap;
QImage m_image;
QSGTexture *m_texture;
- QQuickCanvas *m_canvas;
+ QQuickWindow *m_window;
};
class QQuickCanvasItem : public QQuickItem
QT_END_HEADER
-#endif //QQUICKCANVASITEM_P_H
\ No newline at end of file
+#endif //QQUICKCANVASITEM_P_H
#include <qqmlengine.h>
#include <private/qv8domerrors_p.h>
#include <QtCore/qnumeric.h>
-#include <private/qquickcanvas_p.h>
+#include <private/qquickwindow_p.h>
#include <private/qquickwindowmanager_p.h>
#include <QtGui/private/qguiapplication_p.h>
#include <qpa/qplatformintegration.h>
QV8Context2DPixelArrayResource *pix = v8_resource_cast<QV8Context2DPixelArrayResource>(args[0]->ToObject()->GetInternalField(0)->ToObject());
if (pix && !pix->image.isNull()) {
- pixmap.take(new QQuickCanvasPixmap(pix->image, r->context->canvas()->canvas()));
+ pixmap.take(new QQuickCanvasPixmap(pix->image, r->context->canvas()->window()));
} else if (imageItem) {
pixmap.take(r->context->createPixmap(imageItem->source()));
} else if (canvas) {
QImage img = canvas->toImage();
if (!img.isNull())
- pixmap.take(new QQuickCanvasPixmap(img, canvas->canvas()));
+ pixmap.take(new QQuickCanvasPixmap(img, canvas->window()));
} else {
V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
}
m_canvas = canvasItem;
m_renderTarget = canvasItem->renderTarget();
- QQuickCanvas *canvas = canvasItem->canvas();
- m_windowManager = QQuickCanvasPrivate::get(canvas)->windowManager;
+ QQuickWindow *window = canvasItem->window();
+ m_windowManager = QQuickWindowPrivate::get(window)->windowManager;
m_renderStrategy = canvasItem->renderStrategy();
switch (m_renderTarget) {
m_texture->setSmooth(canvasItem->smooth());
QThread *renderThread = QThread::currentThread();
- QThread *sceneGraphThread = canvas->openglContext() ? canvas->openglContext()->thread() : 0;
+ QThread *sceneGraphThread = window->openglContext() ? window->openglContext()->thread() : 0;
if (m_renderStrategy == QQuickCanvasItem::Threaded)
renderThread = QQuickContext2DRenderThread::instance(qmlEngine(canvasItem));
renderThread = sceneGraphThread;
if (m_renderTarget == QQuickCanvasItem::FramebufferObject && renderThread != sceneGraphThread) {
- QOpenGLContext *cc = QQuickCanvasPrivate::get(canvas)->context->glContext();
- m_surface = canvas;
+ QOpenGLContext *cc = QQuickWindowPrivate::get(window)->context->glContext();
+ m_surface = window;
m_glContext = new QOpenGLContext;
m_glContext->setFormat(cc->format());
m_glContext->setShareContext(cc);
$$PWD/qquickitemchangelistener_p.h \
$$PWD/qquickrectangle_p.h \
$$PWD/qquickrectangle_p_p.h \
+ $$PWD/qquickwindow.h \
+ $$PWD/qquickwindow_p.h \
$$PWD/qquickcanvas.h \
- $$PWD/qquickcanvas_p.h \
$$PWD/qquickfocusscope_p.h \
$$PWD/qquickitemsmodule_p.h \
$$PWD/qquickpainteditem.h \
$$PWD/qquickanchors.cpp \
$$PWD/qquickitem.cpp \
$$PWD/qquickrectangle.cpp \
- $$PWD/qquickcanvas.cpp \
+ $$PWD/qquickwindow.cpp \
$$PWD/qquickfocusscope.cpp \
$$PWD/qquickitemsmodule.cpp \
$$PWD/qquickpainteditem.cpp \
#include <QtQuick/qsgnode.h>
#include <QtQuick/qsgtexturematerial.h>
#include <QtQuick/qsgtexture.h>
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
#include <QtQml/qqmlinfo.h>
#include <QFile>
#include <cmath>
if (image.isNull())
return 0;
m_sheetSize = QSizeF(image.size());
- m_material->texture = canvas()->createTextureFromImage(image);
+ m_material->texture = window()->createTextureFromImage(image);
m_material->texture->setFiltering(QSGTexture::Linear);
m_spriteEngine->start(0);
m_material->animT = 0;
{
Q_D(QQuickBorderImage);
- QSGTexture *texture = d->sceneGraphContext()->textureForFactory(d->pix.textureFactory(), canvas());
+ QSGTexture *texture = d->sceneGraphContext()->textureForFactory(d->pix.textureFactory(), window());
if (!texture || width() <= 0 || height() <= 0) {
delete oldNode;
#ifndef QQUICKCANVAS_H
#define QQUICKCANVAS_H
-#include <QtQuick/qtquickglobal.h>
-#include <QtCore/qmetatype.h>
-#include <QtGui/qopengl.h>
-#include <QtGui/qwindow.h>
-#include <QtGui/qevent.h>
+#include "qquickwindow.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-class QQuickItem;
-class QSGTexture;
-class QInputMethodEvent;
-class QQuickCanvasPrivate;
-class QOpenGLFramebufferObject;
-class QQmlIncubationController;
-class QInputMethodEvent;
-
-class Q_QUICK_EXPORT QQuickCanvas : public QWindow
-{
- Q_OBJECT
- Q_PRIVATE_PROPERTY(QQuickCanvas::d_func(), QQmlListProperty<QObject> data READ data DESIGNABLE false)
- Q_PROPERTY(QColor color READ clearColor WRITE setClearColor NOTIFY clearColorChanged)
- Q_CLASSINFO("DefaultProperty", "data")
- Q_DECLARE_PRIVATE(QQuickCanvas)
-public:
- enum CreateTextureOption {
- TextureHasAlphaChannel = 0x0001,
- TextureHasMipmaps = 0x0002,
- TextureOwnsGLTexture = 0x0004
- };
-
- Q_DECLARE_FLAGS(CreateTextureOptions, CreateTextureOption)
-
- QQuickCanvas(QWindow *parent = 0);
-
- virtual ~QQuickCanvas();
-
- QQuickItem *rootItem() const;
- QQuickItem *activeFocusItem() const;
- QObject *focusObject() const;
-
- QQuickItem *mouseGrabberItem() const;
-
- bool sendEvent(QQuickItem *, QEvent *);
-
- QImage grabFrameBuffer();
-
- void setRenderTarget(QOpenGLFramebufferObject *fbo);
- QOpenGLFramebufferObject *renderTarget() const;
-
- void setRenderTarget(uint fboId, const QSize &size);
- uint renderTargetId() const;
- QSize renderTargetSize() const;
-
- QQmlIncubationController *incubationController() const;
-
-#ifndef QT_NO_ACCESSIBILITY
- virtual QAccessibleInterface *accessibleRoot() const;
-#endif
-
- // Scene graph specific functions
- QSGTexture *createTextureFromImage(const QImage &image) const;
- QSGTexture *createTextureFromId(uint id, const QSize &size, CreateTextureOptions options = CreateTextureOption(0)) const;
-
- void setClearBeforeRendering(bool enabled);
- bool clearBeforeRendering() const;
-
- void setClearColor(const QColor &color);
- QColor clearColor() const;
-
- void setPersistentOpenGLContext(bool persistent);
- bool isPersistentOpenGLContext() const;
-
- void setPersistentSceneGraph(bool persistent);
- bool isPersistentSceneGraph() const;
-
- QOpenGLContext *openglContext() const;
-
-Q_SIGNALS:
- void frameSwapped();
- void sceneGraphInitialized();
- void sceneGraphInvalidated();
- void beforeSynchronizing();
- void beforeRendering();
- void afterRendering();
- void clearColorChanged(const QColor &);
-
-public Q_SLOTS:
- void update();
- void releaseResources();
-
-protected:
- QQuickCanvas(QQuickCanvasPrivate &dd, QWindow *parent = 0);
-
- virtual void exposeEvent(QExposeEvent *);
- virtual void resizeEvent(QResizeEvent *);
-
- virtual void showEvent(QShowEvent *);
- virtual void hideEvent(QHideEvent *);
-
- virtual void focusInEvent(QFocusEvent *);
- virtual void focusOutEvent(QFocusEvent *);
-
- virtual bool event(QEvent *);
- virtual void keyPressEvent(QKeyEvent *);
- virtual void keyReleaseEvent(QKeyEvent *);
- virtual void mousePressEvent(QMouseEvent *);
- virtual void mouseReleaseEvent(QMouseEvent *);
- virtual void mouseDoubleClickEvent(QMouseEvent *);
- virtual void mouseMoveEvent(QMouseEvent *);
-#ifndef QT_NO_WHEELEVENT
- virtual void wheelEvent(QWheelEvent *);
-#endif
-
-private Q_SLOTS:
- void maybeUpdate();
- void cleanupSceneGraph();
-
-private:
- friend class QQuickItem;
- friend class QQuickCanvasRenderLoop;
- Q_DISABLE_COPY(QQuickCanvas)
-};
+typedef QQuickWindow QQuickCanvas;
QT_END_NAMESPACE
-Q_DECLARE_METATYPE(QQuickCanvas *)
-
QT_END_HEADER
#endif // QQUICKCANVAS_H
void deliverEnterEvent();
void deliverMoveEvent();
void deliverLeaveEvent();
- void deliverEvent(QQuickCanvas *canvas, QEvent *event);
+ void deliverEvent(QQuickWindow *window, QEvent *event);
void start() { start(supportedActions); }
void start(Qt::DropActions supportedActions);
void setTarget(QQuickItem *item);
QQmlGuard<QObject> source;
QQmlGuard<QObject> target;
- QQmlGuard<QQuickCanvas> canvas;
+ QQmlGuard<QQuickWindow> window;
QQuickItem *attachedItem;
QQuickDragMimeData *mimeData;
Qt::DropAction proposedAction;
if (!active || dragRestarted)
return;
- QQuickCanvas *newCanvas = attachedItem->canvas();
+ QQuickWindow *newWindow = attachedItem->window();
- if (canvas != newCanvas)
+ if (window != newWindow)
restartDrag();
- else if (canvas)
+ else if (window)
updatePosition();
}
dragRestarted = false;
itemMoved = false;
- canvas = attachedItem->canvas();
+ window = attachedItem->window();
mimeData->m_source = source;
if (!overrideActions)
mimeData->m_supportedActions = supportedActions;
mimeData->m_keys = keys;
- if (canvas) {
+ if (window) {
QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint();
QDragEnterEvent event(scenePos, mimeData->m_supportedActions, mimeData, Qt::NoButton, Qt::NoModifier);
QQuickDropEventEx::setProposedAction(&event, proposedAction);
- deliverEvent(canvas, &event);
+ deliverEvent(window, &event);
}
}
Q_Q(QQuickDragAttached);
itemMoved = false;
- if (canvas) {
+ if (window) {
QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint();
QDragMoveEvent event(scenePos, mimeData->m_supportedActions, mimeData, Qt::NoButton, Qt::NoModifier);
QQuickDropEventEx::setProposedAction(&event, proposedAction);
- deliverEvent(canvas, &event);
+ deliverEvent(window, &event);
if (target != dragGrabber.target()) {
target = dragGrabber.target();
emit q->targetChanged();
void QQuickDragAttachedPrivate::deliverLeaveEvent()
{
- if (canvas) {
+ if (window) {
QDragLeaveEvent event;
- deliverEvent(canvas, &event);
- canvas = 0;
+ deliverEvent(window, &event);
+ window = 0;
}
}
-void QQuickDragAttachedPrivate::deliverEvent(QQuickCanvas *canvas, QEvent *event)
+void QQuickDragAttachedPrivate::deliverEvent(QQuickWindow *window, QEvent *event)
{
Q_ASSERT(!inEvent);
inEvent = true;
- QQuickCanvasPrivate::get(canvas)->deliverDragEvent(&dragGrabber, event);
+ QQuickWindowPrivate::get(window)->deliverDragEvent(&dragGrabber, event);
inEvent = false;
}
QObject *target = 0;
- if (d->canvas) {
+ if (d->window) {
QPoint scenePos = d->attachedItem->mapToScene(d->hotSpot).toPoint();
QDropEvent event(
scenePos, d->mimeData->m_supportedActions, d->mimeData, Qt::NoButton, Qt::NoModifier);
QQuickDropEventEx::setProposedAction(&event, d->proposedAction);
- d->deliverEvent(d->canvas, &event);
+ d->deliverEvent(d->window, &event);
if (event.isAccepted()) {
acceptedAction = event.dropAction();
#include "qquickdroparea_p.h"
#include "qquickdrag_p.h"
#include "qquickitem_p.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include <private/qqmlengine_p.h>
#include "qquickflickable_p.h"
#include "qquickflickable_p_p.h"
-#include "qquickcanvas.h"
-#include "qquickcanvas_p.h"
+#include "qquickwindow.h"
+#include "qquickwindow_p.h"
#include "qquickevents_p_p.h"
#include <QtQuick/private/qquicktransition_p.h>
qint64 elapsedSincePress = computeCurrentTime(event) - lastPressTime;
if (q->yflick()) {
qreal dy = event->localPos().y() - pressPos.y();
- bool overThreshold = QQuickCanvasPrivate::dragOverThreshold(dy, Qt::YAxis, event);
+ bool overThreshold = QQuickWindowPrivate::dragOverThreshold(dy, Qt::YAxis, event);
if (overThreshold || elapsedSincePress > 200) {
if (!vMoved)
vData.dragStartOffset = dy;
if (q->xflick()) {
qreal dx = event->localPos().x() - pressPos.x();
- bool overThreshold = QQuickCanvasPrivate::dragOverThreshold(dx, Qt::XAxis, event);
+ bool overThreshold = QQuickWindowPrivate::dragOverThreshold(dx, Qt::XAxis, event);
if (overThreshold || elapsedSincePress > 200) {
if (!hMoved)
hData.dragStartOffset = dx;
d->clearDelayedPress();
d->handleMouseReleaseEvent(event);
event->accept();
- if (canvas() && canvas()->mouseGrabberItem() == this)
+ if (window() && window()->mouseGrabberItem() == this)
ungrabMouse();
} else {
QQuickItem::mouseReleaseEvent(event);
void QQuickFlickablePrivate::captureDelayedPress(QMouseEvent *event)
{
Q_Q(QQuickFlickable);
- if (!q->canvas() || pressDelay <= 0)
+ if (!q->window() || pressDelay <= 0)
return;
if (!isOutermostPressDelay())
return;
- delayedPressTarget = q->canvas()->mouseGrabberItem();
- delayedPressEvent = QQuickCanvasPrivate::cloneMouseEvent(event);
+ delayedPressTarget = q->window()->mouseGrabberItem();
+ delayedPressEvent = QQuickWindowPrivate::cloneMouseEvent(event);
delayedPressEvent->setAccepted(false);
delayedPressTimer.start(pressDelay, q);
}
if (event->timerId() == d->delayedPressTimer.timerId()) {
d->delayedPressTimer.stop();
if (d->delayedPressEvent) {
- QQuickItem *grabber = canvas() ? canvas()->mouseGrabberItem() : 0;
+ QQuickItem *grabber = window() ? window()->mouseGrabberItem() : 0;
if (!grabber || grabber != this) {
// We replay the mouse press but the grabber we had might not be interessted by the event (e.g. overlay)
// so we reset the grabber
- if (canvas()->mouseGrabberItem() == d->delayedPressTarget)
+ if (window()->mouseGrabberItem() == d->delayedPressTarget)
d->delayedPressTarget->ungrabMouse();
// Use the event handler that will take care of finding the proper item to propagate the event
- QQuickCanvasPrivate::get(canvas())->deliverMouseEvent(d->delayedPressEvent);
+ QQuickWindowPrivate::get(window())->deliverMouseEvent(d->delayedPressEvent);
}
delete d->delayedPressEvent;
d->delayedPressEvent = 0;
Q_D(QQuickFlickable);
QPointF localPos = mapFromScene(event->windowPos());
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool grabberDisabled = grabber && !grabber->isEnabled();
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || contains(localPos)) && (!grabber || !grabber->keepMouseGrab() || grabberDisabled)) {
- QScopedPointer<QMouseEvent> mouseEvent(QQuickCanvasPrivate::cloneMouseEvent(event, &localPos));
+ QScopedPointer<QMouseEvent> mouseEvent(QQuickWindowPrivate::cloneMouseEvent(event, &localPos));
mouseEvent->setAccepted(false);
switch (mouseEvent->type()) {
if (c->mouseGrabberItem() == d->delayedPressTarget)
d->delayedPressTarget->ungrabMouse();
// Use the event handler that will take care of finding the proper item to propagate the event
- QQuickCanvasPrivate::get(canvas())->deliverMouseEvent(d->delayedPressEvent);
+ QQuickWindowPrivate::get(window())->deliverMouseEvent(d->delayedPressEvent);
d->clearDelayedPress();
// We send the release
- canvas()->sendEvent(c->mouseGrabberItem(), event);
+ window()->sendEvent(c->mouseGrabberItem(), event);
// And the event has been consumed
d->stealMouse = false;
d->pressed = false;
case QEvent::MouseButtonRelease:
return sendMouseEvent(static_cast<QMouseEvent *>(e));
case QEvent::UngrabMouse:
- if (d->canvas && d->canvas->mouseGrabberItem() && d->canvas->mouseGrabberItem() != this) {
+ if (d->window && d->window->mouseGrabberItem() && d->window->mouseGrabberItem() != this) {
// The grab has been taken away from a child and given to some other item.
mouseUngrabEvent();
}
Q_D(const QQuickImage);
if (!d->provider) {
// Make sure it gets thread affinity on the rendering thread so deletion works properly..
- Q_ASSERT_X(d->canvas
+ Q_ASSERT_X(d->window
&& d->sceneGraphContext()
&& QThread::currentThread() == d->sceneGraphContext()->thread(),
"QQuickImage::textureProvider",
QQuickImagePrivate *dd = const_cast<QQuickImagePrivate *>(d);
dd->provider = new QQuickImageTextureProvider;
dd->provider->m_smooth = d->smooth;
- dd->provider->m_texture = d->sceneGraphContext()->textureForFactory(d->pix.textureFactory(), canvas());
+ dd->provider->m_texture = d->sceneGraphContext()->textureForFactory(d->pix.textureFactory(), window());
}
return d->provider;
{
Q_D(QQuickImage);
- QSGTexture *texture = d->sceneGraphContext()->textureForFactory(d->pix.textureFactory(), canvas());
+ QSGTexture *texture = d->sceneGraphContext()->textureForFactory(d->pix.textureFactory(), window());
// Copy over the current texture state into the texture provider...
if (d->provider) {
#include "qquickitem.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include <QtQml/qjsengine.h>
-#include "qquickcanvas_p.h"
+#include "qquickwindow_p.h"
#include "qquickevents_p_p.h"
#include "qquickscreen_p.h"
}
// first process forwards
- if (d->item && d->item->canvas()) {
+ if (d->item && d->item->window()) {
d->inPress = true;
for (int ii = 0; ii < d->targets.count(); ++ii) {
QQuickItem *i = d->targets.at(ii);
if (i && i->isVisible()) {
- d->item->canvas()->sendEvent(i, event);
+ d->item->window()->sendEvent(i, event);
if (event->isAccepted()) {
d->inPress = false;
return;
return;
}
- if (d->item && d->item->canvas()) {
+ if (d->item && d->item->window()) {
d->inRelease = true;
for (int ii = 0; ii < d->targets.count(); ++ii) {
QQuickItem *i = d->targets.at(ii);
if (i && i->isVisible()) {
- d->item->canvas()->sendEvent(i, event);
+ d->item->window()->sendEvent(i, event);
if (event->isAccepted()) {
d->inRelease = false;
return;
void QQuickKeysAttached::inputMethodEvent(QInputMethodEvent *event, bool post)
{
Q_D(QQuickKeysAttached);
- if (post == m_processPost && d->item && !d->inIM && d->item->canvas()) {
+ if (post == m_processPost && d->item && !d->inIM && d->item->window()) {
d->inIM = true;
for (int ii = 0; ii < d->targets.count(); ++ii) {
QQuickItem *i = d->targets.at(ii);
if (i && i->isVisible() && (i->flags() & QQuickItem::ItemAcceptsInputMethod)) {
- d->item->canvas()->sendEvent(i, event);
+ d->item->window()->sendEvent(i, event);
if (event->isAccepted()) {
d->imeItem = i;
d->inIM = false;
surface. Using scene graph API directly is always significantly
faster.
- \sa QQuickCanvas, QQuickPaintedItem
+ \sa QQuickWindow, QQuickPaintedItem
*/
/*!
Q_D(QQuickItem);
- if (d->canvasRefCount > 1)
- d->canvasRefCount = 1; // Make sure canvas is set to null in next call to derefCanvas().
+ if (d->windowRefCount > 1)
+ d->windowRefCount = 1; // Make sure window is set to null in next call to derefWindow().
if (d->parentItem)
setParentItem(0);
- else if (d->canvas)
- d->derefCanvas();
+ else if (d->window)
+ d->derefWindow();
// XXX todo - optimize
while (!d->childItems.isEmpty())
scopeItem = oldParentItem;
while (!scopeItem->isFocusScope() && scopeItem->parentItem())
scopeItem = scopeItem->parentItem();
- if (d->canvas) {
- QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scopeItem, scopeFocusedItem,
- QQuickCanvasPrivate::DontChangeFocusProperty);
+ if (d->window) {
+ QQuickWindowPrivate::get(d->window)->clearFocusInScope(scopeItem, scopeFocusedItem,
+ QQuickWindowPrivate::DontChangeFocusProperty);
if (scopeFocusedItem != this)
QQuickItemPrivate::get(scopeFocusedItem)->updateSubFocusItem(this, true);
} else {
if (wasVisible) {
emit oldParentItem->visibleChildrenChanged();
}
- } else if (d->canvas) {
- QQuickCanvasPrivate::get(d->canvas)->parentlessItems.remove(this);
+ } else if (d->window) {
+ QQuickWindowPrivate::get(d->window)->parentlessItems.remove(this);
}
- QQuickCanvas *oldParentCanvas = oldParentItem ? QQuickItemPrivate::get(oldParentItem)->canvas : 0;
- QQuickCanvas *parentCanvas = parentItem ? QQuickItemPrivate::get(parentItem)->canvas : 0;
- if (oldParentCanvas == parentCanvas) {
- // Avoid freeing and reallocating resources if the canvas stays the same.
+ QQuickWindow *oldParentWindow = oldParentItem ? QQuickItemPrivate::get(oldParentItem)->window : 0;
+ QQuickWindow *parentWindow = parentItem ? QQuickItemPrivate::get(parentItem)->window : 0;
+ if (oldParentWindow == parentWindow) {
+ // Avoid freeing and reallocating resources if the window stays the same.
d->parentItem = parentItem;
} else {
- if (oldParentCanvas)
- d->derefCanvas();
+ if (oldParentWindow)
+ d->derefWindow();
d->parentItem = parentItem;
- if (parentCanvas)
- d->refCanvas(parentCanvas);
+ if (parentWindow)
+ d->refWindow(parentWindow);
}
d->dirty(QQuickItemPrivate::ParentChanged);
if (d->parentItem)
QQuickItemPrivate::get(d->parentItem)->addChild(this);
- else if (d->canvas)
- QQuickCanvasPrivate::get(d->canvas)->parentlessItems.insert(this);
+ else if (d->window)
+ QQuickWindowPrivate::get(d->window)->parentlessItems.insert(this);
d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
d->setEffectiveEnableRecur(0, d->calcEffectiveEnable());
QQuickItemPrivate::get(scopeFocusedItem)->focus = false;
emit scopeFocusedItem->focusChanged(false);
} else {
- if (d->canvas) {
- QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scopeItem, scopeFocusedItem,
- QQuickCanvasPrivate::DontChangeFocusProperty);
+ if (d->window) {
+ QQuickWindowPrivate::get(d->window)->setFocusInScope(scopeItem, scopeFocusedItem,
+ QQuickWindowPrivate::DontChangeFocusProperty);
} else {
QQuickItemPrivate::get(scopeFocusedItem)->updateSubFocusItem(scopeItem, true);
}
return d->parentItem;
}
-QQuickCanvas *QQuickItem::canvas() const
+QQuickWindow *QQuickItem::window() const
{
Q_D(const QQuickItem);
- return d->canvas;
+ return d->window;
}
static bool itemZOrder_sort(QQuickItem *lhs, QQuickItem *rhs)
emit q->childrenChanged();
}
-void QQuickItemPrivate::refCanvas(QQuickCanvas *c)
+void QQuickItemPrivate::refWindow(QQuickWindow *c)
{
- // An item needs a canvas if it is referenced by another item which has a canvas.
+ // An item needs a window if it is referenced by another item which has a window.
// Typically the item is referenced by a parent, but can also be referenced by a
- // ShaderEffect or ShaderEffectSource. 'canvasRefCount' counts how many items with
- // a canvas is referencing this item. When the reference count goes from zero to one,
- // or one to zero, the canvas of this item is updated and propagated to the children.
- // As long as the reference count stays above zero, the canvas is unchanged.
- // refCanvas() increments the reference count.
- // derefCanvas() decrements the reference count.
+ // ShaderEffect or ShaderEffectSource. 'windowRefCount' counts how many items with
+ // a window is referencing this item. When the reference count goes from zero to one,
+ // or one to zero, the window of this item is updated and propagated to the children.
+ // As long as the reference count stays above zero, the window is unchanged.
+ // refWindow() increments the reference count.
+ // derefWindow() decrements the reference count.
Q_Q(QQuickItem);
- Q_ASSERT((canvas != 0) == (canvasRefCount > 0));
+ Q_ASSERT((window != 0) == (windowRefCount > 0));
Q_ASSERT(c);
- if (++canvasRefCount > 1) {
- if (c != canvas)
- qWarning("QQuickItem: Cannot use same item on different canvases at the same time.");
- return; // Canvas already set.
+ if (++windowRefCount > 1) {
+ if (c != window)
+ qWarning("QQuickItem: Cannot use same item on different windows at the same time.");
+ return; // Window already set.
}
- Q_ASSERT(canvas == 0);
- canvas = c;
+ Q_ASSERT(window == 0);
+ window = c;
if (polishScheduled)
- QQuickCanvasPrivate::get(canvas)->itemsToPolish.insert(q);
+ QQuickWindowPrivate::get(window)->itemsToPolish.insert(q);
if (!parentItem)
- QQuickCanvasPrivate::get(canvas)->parentlessItems.insert(q);
+ QQuickWindowPrivate::get(window)->parentlessItems.insert(q);
for (int ii = 0; ii < childItems.count(); ++ii) {
QQuickItem *child = childItems.at(ii);
- QQuickItemPrivate::get(child)->refCanvas(c);
+ QQuickItemPrivate::get(child)->refWindow(c);
}
- dirty(Canvas);
+ dirty(Window);
if (extra.isAllocated() && extra->screenAttached)
- extra->screenAttached->canvasChanged(c);
+ extra->screenAttached->windowChanged(c);
itemChange(QQuickItem::ItemSceneChange, c);
}
-void QQuickItemPrivate::derefCanvas()
+void QQuickItemPrivate::derefWindow()
{
Q_Q(QQuickItem);
- Q_ASSERT((canvas != 0) == (canvasRefCount > 0));
+ Q_ASSERT((window != 0) == (windowRefCount > 0));
- if (!canvas)
+ if (!window)
return; // This can happen when destroying recursive shader effect sources.
- if (--canvasRefCount > 0)
- return; // There are still other references, so don't set canvas to null yet.
+ if (--windowRefCount > 0)
+ return; // There are still other references, so don't set window to null yet.
q->releaseResources();
removeFromDirtyList();
- QQuickCanvasPrivate *c = QQuickCanvasPrivate::get(canvas);
+ QQuickWindowPrivate *c = QQuickWindowPrivate::get(window);
if (polishScheduled)
c->itemsToPolish.remove(q);
QMutableHashIterator<int, QQuickItem *> itemTouchMapIt(c->itemForTouchPointId);
if (!parentItem)
c->parentlessItems.remove(q);
- canvas = 0;
+ window = 0;
itemNodeInstance = 0;
for (int ii = 0; ii < childItems.count(); ++ii) {
QQuickItem *child = childItems.at(ii);
- QQuickItemPrivate::get(child)->derefCanvas();
+ QQuickItemPrivate::get(child)->derefWindow();
}
- dirty(Canvas);
+ dirty(Window);
if (extra.isAllocated() && extra->screenAttached)
- extra->screenAttached->canvasChanged(0);
- itemChange(QQuickItem::ItemSceneChange, (QQuickCanvas *)0);
+ extra->screenAttached->windowChanged(0);
+ itemChange(QQuickItem::ItemSceneChange, (QQuickWindow *)0);
}
/*!
-Returns a transform that maps points from canvas space into item space.
+Returns a transform that maps points from window space into item space.
*/
-QTransform QQuickItemPrivate::canvasToItemTransform() const
+QTransform QQuickItemPrivate::windowToItemTransform() const
{
// XXX todo - optimize
- return itemToCanvasTransform().inverted();
+ return itemToWindowTransform().inverted();
}
/*!
-Returns a transform that maps points from item space into canvas space.
+Returns a transform that maps points from item space into window space.
*/
-QTransform QQuickItemPrivate::itemToCanvasTransform() const
+QTransform QQuickItemPrivate::itemToWindowTransform() const
{
// XXX todo
- QTransform rv = parentItem?QQuickItemPrivate::get(parentItem)->itemToCanvasTransform():QTransform();
+ QTransform rv = parentItem?QQuickItemPrivate::get(parentItem)->itemToWindowTransform():QTransform();
itemToParentTransform(rv);
return rv;
}
, dirtyAttributes(0)
, nextDirtyItem(0)
, prevDirtyItem(0)
- , canvas(0)
- , canvasRefCount(0)
+ , window(0)
+ , windowRefCount(0)
, parentItem(0)
, sortedChildItems(&childItems)
, subFocusItem(0)
/*!
This function is called when the item's scene graph resources are no longer needed.
It allows items to free its resources, for instance textures, that are not owned by scene graph
- nodes. Note that scene graph nodes are managed by QQuickCanvas and should not be deleted by
+ nodes. Note that scene graph nodes are managed by QQuickWindow and should not be deleted by
this function. Scene graph resources are no longer needed when the parent is set to null and
the item is not used by any \l ShaderEffect or \l ShaderEffectSource.
* Schedules a call to updatePaintNode() for this item.
*
* The call to QQuickItem::updatePaintNode() will always happen if the
- * item is showing in a QQuickCanvas.
+ * item is showing in a QQuickWindow.
*
* Only items which specifies QQuickItem::ItemHasContents are allowed
* to call QQuickItem::update().
Q_D(QQuickItem);
if (!d->polishScheduled) {
d->polishScheduled = true;
- if (d->canvas) {
- QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(d->canvas);
+ if (d->window) {
+ QQuickWindowPrivate *p = QQuickWindowPrivate::get(d->window);
bool maybeupdate = p->itemsToPolish.isEmpty();
p->itemsToPolish.insert(this);
- if (maybeupdate) d->canvas->maybeUpdate();
+ if (maybeupdate) d->window->maybeUpdate();
}
}
}
// invalid cases
if (ok) *ok = true;
- QTransform t = d->itemToCanvasTransform();
- if (other) t *= QQuickItemPrivate::get(other)->canvasToItemTransform();
+ QTransform t = d->itemToWindowTransform();
+ if (other) t *= QQuickItemPrivate::get(other)->windowToItemTransform();
return t;
}
if (d->extra.isAllocated() && d->extra->contents)
d->extra->contents->complete();
- if (d->canvas && d->dirtyAttributes) {
+ if (d->window && d->dirtyAttributes) {
d->addToDirtyList();
- QQuickCanvasPrivate::get(d->canvas)->dirtyItem(this);
+ QQuickWindowPrivate::get(d->window)->dirtyItem(this);
}
}
dirty(Visible);
if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
- if (canvas) {
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
- if (canvasPriv->mouseGrabberItem == q)
+ if (window) {
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(window);
+ if (windowPriv->mouseGrabberItem == q)
q->ungrabMouse();
}
effectiveEnable = newEffectiveEnable;
- if (canvas) {
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
- if (canvasPriv->mouseGrabberItem == q)
+ if (window) {
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(window);
+ if (windowPriv->mouseGrabberItem == q)
q->ungrabMouse();
if (scope && !effectiveEnable && activeFocus) {
- canvasPriv->clearFocusInScope(
- scope, q, QQuickCanvasPrivate::DontChangeFocusProperty | QQuickCanvasPrivate::DontChangeSubFocusItem);
+ windowPriv->clearFocusInScope(
+ scope, q, QQuickWindowPrivate::DontChangeFocusProperty | QQuickWindowPrivate::DontChangeSubFocusItem);
}
}
(flags & QQuickItem::ItemIsFocusScope) && scope ? q : scope, newEffectiveEnable);
}
- if (canvas && scope && effectiveEnable && focus) {
- QQuickCanvasPrivate::get(canvas)->setFocusInScope(
- scope, q, QQuickCanvasPrivate::DontChangeFocusProperty | QQuickCanvasPrivate::DontChangeSubFocusItem);
+ if (window && scope && effectiveEnable && focus) {
+ QQuickWindowPrivate::get(window)->setFocusInScope(
+ scope, q, QQuickWindowPrivate::DontChangeFocusProperty | QQuickWindowPrivate::DontChangeSubFocusItem);
}
emit q->enabledChanged();
DIRTY_TO_STRING(ChildrenStackingChanged);
DIRTY_TO_STRING(ParentChanged);
DIRTY_TO_STRING(Clip);
- DIRTY_TO_STRING(Canvas);
+ DIRTY_TO_STRING(Window);
DIRTY_TO_STRING(EffectReference);
DIRTY_TO_STRING(Visible);
DIRTY_TO_STRING(HideReference);
if (type & (TransformOrigin | Transform | BasicTransform | Position | Size))
transformChanged();
- if (!(dirtyAttributes & type) || (canvas && !prevDirtyItem)) {
+ if (!(dirtyAttributes & type) || (window && !prevDirtyItem)) {
dirtyAttributes |= type;
- if (canvas && componentComplete) {
+ if (window && componentComplete) {
addToDirtyList();
- QQuickCanvasPrivate::get(canvas)->dirtyItem(q);
+ QQuickWindowPrivate::get(window)->dirtyItem(q);
}
}
}
{
Q_Q(QQuickItem);
- Q_ASSERT(canvas);
+ Q_ASSERT(window);
if (!prevDirtyItem) {
Q_ASSERT(!nextDirtyItem);
- QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(canvas);
+ QQuickWindowPrivate *p = QQuickWindowPrivate::get(window);
nextDirtyItem = p->dirtyItemList;
if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = &nextDirtyItem;
prevDirtyItem = &p->dirtyItemList;
Q_D(QQuickItem);
if ((flags & ItemIsFocusScope) != (d->flags & ItemIsFocusScope)) {
- if (flags & ItemIsFocusScope && !d->childItems.isEmpty() && d->canvas) {
- qWarning("QQuickItem: Cannot set FocusScope once item has children and is in a canvas.");
+ if (flags & ItemIsFocusScope && !d->childItems.isEmpty() && d->window) {
+ qWarning("QQuickItem: Cannot set FocusScope once item has children and is in a window.");
flags &= ~ItemIsFocusScope;
} else if (d->flags & ItemIsFocusScope) {
qWarning("QQuickItem: Cannot unset FocusScope flag.");
if (d->focus == focus)
return;
- if (d->canvas || d->parentItem) {
+ if (d->window || d->parentItem) {
// Need to find our nearest focus scope
QQuickItem *scope = parentItem();
while (scope && !scope->isFocusScope() && scope->parentItem())
scope = scope->parentItem();
- if (d->canvas) {
+ if (d->window) {
if (focus)
- QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scope, this);
+ QQuickWindowPrivate::get(d->window)->setFocusInScope(scope, this);
else
- QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scope, this);
+ QQuickWindowPrivate::get(d->window)->clearFocusInScope(scope, this);
} else {
// do the focus changes from setFocusInScope/clearFocusInScope that are
- // unrelated to a canvas
+ // unrelated to a window
QVarLengthArray<QQuickItem *, 20> changed;
QQuickItem *oldSubFocusItem = QQuickItemPrivate::get(scope)->subFocusItem;
if (oldSubFocusItem) {
changed << this;
emit focusChanged(focus);
- QQuickCanvasPrivate::notifyFocusChangesRecur(changed.data(), changed.count() - 1);
+ QQuickWindowPrivate::notifyFocusChangesRecur(changed.data(), changed.count() - 1);
}
} else {
QVarLengthArray<QQuickItem *, 20> changed;
changed << this;
emit focusChanged(focus);
- QQuickCanvasPrivate::notifyFocusChangesRecur(changed.data(), changed.count() - 1);
+ QQuickWindowPrivate::notifyFocusChangesRecur(changed.data(), changed.count() - 1);
}
}
bool QQuickItem::isUnderMouse() const
{
Q_D(const QQuickItem);
- if (!d->canvas)
+ if (!d->window)
return false;
QPointF cursorPos = QGuiApplicationPrivate::lastCursorPosition;
- return contains(mapFromScene(d->canvas->mapFromGlobal(cursorPos.toPoint())));
+ return contains(mapFromScene(d->window->mapFromGlobal(cursorPos.toPoint())));
}
bool QQuickItem::acceptHoverEvents() const
void QQuickItem::grabMouse()
{
Q_D(QQuickItem);
- if (!d->canvas)
+ if (!d->window)
return;
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
- if (canvasPriv->mouseGrabberItem == this)
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(d->window);
+ if (windowPriv->mouseGrabberItem == this)
return;
- QQuickItem *oldGrabber = canvasPriv->mouseGrabberItem;
- canvasPriv->mouseGrabberItem = this;
+ QQuickItem *oldGrabber = windowPriv->mouseGrabberItem;
+ windowPriv->mouseGrabberItem = this;
if (oldGrabber) {
QEvent ev(QEvent::UngrabMouse);
- d->canvas->sendEvent(oldGrabber, &ev);
+ d->window->sendEvent(oldGrabber, &ev);
}
}
void QQuickItem::ungrabMouse()
{
Q_D(QQuickItem);
- if (!d->canvas)
+ if (!d->window)
return;
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
- if (canvasPriv->mouseGrabberItem != this) {
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(d->window);
+ if (windowPriv->mouseGrabberItem != this) {
qWarning("QQuickItem::ungrabMouse(): Item is not the mouse grabber.");
return;
}
- canvasPriv->mouseGrabberItem = 0;
+ windowPriv->mouseGrabberItem = 0;
QEvent ev(QEvent::UngrabMouse);
- d->canvas->sendEvent(this, &ev);
+ d->window->sendEvent(this, &ev);
}
bool QQuickItem::keepMouseGrab() const
void QQuickItem::grabTouchPoints(const QVector<int> &ids)
{
Q_D(QQuickItem);
- if (!d->canvas)
+ if (!d->window)
return;
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(d->window);
QSet<QQuickItem*> ungrab;
for (int i = 0; i < ids.count(); ++i) {
- QQuickItem *oldGrabber = canvasPriv->itemForTouchPointId.value(ids.at(i));
+ QQuickItem *oldGrabber = windowPriv->itemForTouchPointId.value(ids.at(i));
if (oldGrabber == this)
return;
- canvasPriv->itemForTouchPointId[ids.at(i)] = this;
+ windowPriv->itemForTouchPointId[ids.at(i)] = this;
if (oldGrabber)
ungrab.insert(oldGrabber);
}
void QQuickItem::ungrabTouchPoints()
{
Q_D(QQuickItem);
- if (!d->canvas)
+ if (!d->window)
return;
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(d->window);
- QMutableHashIterator<int, QQuickItem*> i(canvasPriv->itemForTouchPointId);
+ QMutableHashIterator<int, QQuickItem*> i(windowPriv->itemForTouchPointId);
while (i.hasNext()) {
i.next();
if (i.value() == this)
QPointF QQuickItem::mapToScene(const QPointF &point) const
{
Q_D(const QQuickItem);
- return d->itemToCanvasTransform().map(point);
+ return d->itemToWindowTransform().map(point);
}
QRectF QQuickItem::mapRectToItem(const QQuickItem *item, const QRectF &rect) const
{
Q_D(const QQuickItem);
- QTransform t = d->itemToCanvasTransform();
+ QTransform t = d->itemToWindowTransform();
if (item)
- t *= QQuickItemPrivate::get(item)->canvasToItemTransform();
+ t *= QQuickItemPrivate::get(item)->windowToItemTransform();
return t.mapRect(rect);
}
QRectF QQuickItem::mapRectToScene(const QRectF &rect) const
{
Q_D(const QQuickItem);
- return d->itemToCanvasTransform().mapRect(rect);
+ return d->itemToWindowTransform().mapRect(rect);
}
QPointF QQuickItem::mapFromItem(const QQuickItem *item, const QPointF &point) const
QPointF QQuickItem::mapFromScene(const QPointF &point) const
{
Q_D(const QQuickItem);
- return d->canvasToItemTransform().map(point);
+ return d->windowToItemTransform().map(point);
}
QRectF QQuickItem::mapRectFromItem(const QQuickItem *item, const QRectF &rect) const
{
Q_D(const QQuickItem);
- QTransform t = item?QQuickItemPrivate::get(item)->itemToCanvasTransform():QTransform();
- t *= d->canvasToItemTransform();
+ QTransform t = item?QQuickItemPrivate::get(item)->itemToWindowTransform():QTransform();
+ t *= d->windowToItemTransform();
return t.mapRect(rect);
}
QRectF QQuickItem::mapRectFromScene(const QRectF &rect) const
{
Q_D(const QQuickItem);
- return d->canvasToItemTransform().mapRect(rect);
+ return d->windowToItemTransform().mapRect(rect);
}
\l {Filter}{Filters} include things like \l {Blur}{blurring}
the item, or giving it a \l Reflection. Some
- filters may not be available on all canvases; if a filter is not
- available on a certain canvas, it will simply not be applied for
- that canvas (but the QML will still be considered valid).
+ filters may not be available on all windows; if a filter is not
+ available on a certain window, it will simply not be applied for
+ that window (but the QML will still be considered valid).
\qml
Item {
class QQuickKeyEvent;
class QQuickAnchors;
class QQuickItemPrivate;
-class QQuickCanvas;
+class QQuickWindow;
class QTouchEvent;
class QSGNode;
class QSGTransformNode;
enum ItemChange {
ItemChildAddedChange, // value.item
ItemChildRemovedChange, // value.item
- ItemSceneChange, // value.canvas
+ ItemSceneChange, // value.window
ItemVisibleHasChanged, // value.boolValue
ItemParentHasChanged, // value.item
ItemOpacityHasChanged, // value.realValue
union ItemChangeData {
ItemChangeData(QQuickItem *v) : item(v) {}
- ItemChangeData(QQuickCanvas *v) : canvas(v) {}
+ ItemChangeData(QQuickWindow *v) : window(v) {}
ItemChangeData(qreal v) : realValue(v) {}
ItemChangeData(bool v) : boolValue(v) {}
QQuickItem *item;
- QQuickCanvas *canvas;
+ QQuickWindow *window;
qreal realValue;
bool boolValue;
};
QQuickItem(QQuickItem *parent = 0);
virtual ~QQuickItem();
- QQuickCanvas *canvas() const;
+ //canvas() is being removed in favor of window() really soon now
+ QQuickWindow *canvas() const { return window(); }
+ QQuickWindow *window() const;
QQuickItem *parentItem() const;
void setParentItem(QQuickItem *parent);
void stackBefore(const QQuickItem *);
struct UpdatePaintNodeData {
QSGTransformNode *transformNode;
private:
- friend class QQuickCanvasPrivate;
+ friend class QQuickWindowPrivate;
UpdatePaintNodeData();
};
QQuickItem(QQuickItemPrivate &dd, QQuickItem *parent = 0);
private:
- friend class QQuickCanvas;
- friend class QQuickCanvasPrivate;
+ friend class QQuickWindow;
+ friend class QQuickWindowPrivate;
friend class QSGRenderer;
friend class QAccessibleQuickItem;
friend class QQuickAccessibleAttached;
#include "qquickanchors_p_p.h"
#include "qquickitemchangelistener_p.h"
-#include "qquickcanvas_p.h"
+#include "qquickwindow_p.h"
#include <QtQuick/qsgnode.h>
#include "qquickclipnode_p.h"
ParentChanged = 0x00000800,
Clip = 0x00001000,
- Canvas = 0x00002000,
+ Window = 0x00002000,
EffectReference = 0x00008000,
Visible = 0x00010000,
// dirtyToString()
TransformUpdateMask = TransformOrigin | Transform | BasicTransform | Position |
- Size | Canvas,
- ComplexTransformUpdateMask = Transform | Canvas,
- ContentUpdateMask = Size | Content | Smooth | Canvas | Antialiasing,
- ChildrenUpdateMask = ChildrenChanged | ChildrenStackingChanged | EffectReference | Canvas
+ Size | Window,
+ ComplexTransformUpdateMask = Transform | Window,
+ ContentUpdateMask = Size | Content | Smooth | Window | Antialiasing,
+ ChildrenUpdateMask = ChildrenChanged | ChildrenStackingChanged | EffectReference | Window
};
quint32 dirtyAttributes;
void setCulled(bool);
- QQuickCanvas *canvas;
- int canvasRefCount;
+ QQuickWindow *window;
+ int windowRefCount;
inline QSGContext *sceneGraphContext() const;
QQuickItem *parentItem;
inline void markSortedChildrenDirty(QQuickItem *child);
- void refCanvas(QQuickCanvas *);
- void derefCanvas();
+ void refWindow(QQuickWindow *);
+ void derefWindow();
QQuickItem *subFocusItem;
void updateSubFocusItem(QQuickItem *scope, bool focus);
- QTransform canvasToItemTransform() const;
- QTransform itemToCanvasTransform() const;
+ QTransform windowToItemTransform() const;
+ QTransform itemToWindowTransform() const;
void itemToParentTransform(QTransform &) const;
qreal x;
QSGContext *QQuickItemPrivate::sceneGraphContext() const
{
- Q_ASSERT(canvas);
- return static_cast<QQuickCanvasPrivate *>(QObjectPrivate::get(canvas))->context;
+ Q_ASSERT(window);
+ return static_cast<QQuickWindowPrivate *>(QObjectPrivate::get(window))->context;
}
void QQuickItemPrivate::markSortedChildrenDirty(QQuickItem *child)
#include "qquickmousearea_p.h"
#include "qquickmousearea_p_p.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include "qquickevents_p_p.h"
#include "qquickdrag_p.h"
if (!propagateComposedEvents)
return;
QPointF scenePos = q->mapToScene(QPointF(event->x(), event->y()));
- propagateHelper(event, canvas->rootItem(), scenePos, t);
+ propagateHelper(event, window->rootItem(), scenePos, t);
}
bool QQuickMouseAreaPrivate::propagateHelper(QQuickMouseEvent *ev, QQuickItem *item,const QPointF &sp, PropagateType sig)
{
- //Based off of QQuickCanvas::deliverInitialMousePressEvent
- //But specific to MouseArea, so doesn't belong in canvas
+ //Based off of QQuickWindow::deliverInitialMousePressEvent
+ //But specific to MouseArea, so doesn't belong in window
Q_Q(const QQuickMouseArea);
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
d->drag->target()->setPos(dragPos);
if (!keepMouseGrab()) {
- bool xDragged = QQuickCanvasPrivate::dragOverThreshold(dx, Qt::XAxis, event);
- bool yDragged = QQuickCanvasPrivate::dragOverThreshold(dy, Qt::YAxis, event);
+ bool xDragged = QQuickWindowPrivate::dragOverThreshold(dx, Qt::XAxis, event);
+ bool yDragged = QQuickWindowPrivate::dragOverThreshold(dy, Qt::YAxis, event);
if ((!dragY && !yDragged && dragX && xDragged)
|| (!dragX && !xDragged && dragY && yDragged)
|| (dragX && dragY && (xDragged || yDragged))) {
// If we don't accept hover, we need to reset containsMouse.
if (!acceptHoverEvents())
setHovered(false);
- QQuickCanvas *c = canvas();
- if (c && c->mouseGrabberItem() == this)
+ QQuickWindow *w = window();
+ if (w && w->mouseGrabberItem() == this)
ungrabMouse();
setKeepMouseGrab(false);
}
Q_D(QQuickMouseArea);
QPointF localPos = mapFromScene(event->windowPos());
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || contains(localPos)) && (!grabber || !grabber->keepMouseGrab())) {
if (acceptHoverEvents() && d->hovered != (isVisible() && isUnderMouse())) {
if (!d->hovered) {
QPointF cursorPos = QGuiApplicationPrivate::lastCursorPosition;
- d->lastScenePos = d->canvas->mapFromGlobal(cursorPos.toPoint());
+ d->lastScenePos = d->window->mapFromGlobal(cursorPos.toPoint());
d->lastPos = mapFromScene(d->lastScenePos);
}
setHovered(!d->hovered);
#ifndef QT_NO_CURSOR
if (d->cursor) {
if (d->hovered) {
- canvas()->setCursor(QCursor(*d->cursor));
+ window()->setCursor(QCursor(*d->cursor));
} else {
- canvas()->unsetCursor();
+ window()->unsetCursor();
}
}
#endif
****************************************************************************/
#include "qquickmultipointtoucharea_p.h"
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
#include <private/qsgadaptationlayer_p.h>
#include <private/qquickitem_p.h>
#include <QEvent>
case QEvent::TouchUpdate:
case QEvent::TouchEnd: {
//if e.g. a parent Flickable has the mouse grab, don't process the touch events
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
if (grabber && grabber != this && grabber->keepMouseGrab() && grabber->isEnabled()) {
QQuickItem *item = this;
}
updateTouchData(event);
if (event->type() == QEvent::TouchEnd) {
- //TODO: move to canvas
+ //TODO: move to window
_stealMouse = false;
setKeepMouseGrab(false);
setKeepTouchGrab(false);
QQuickItem::mouseReleaseEvent(event);
return;
}
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
if (c && c->mouseGrabberItem() == this)
ungrabMouse();
setKeepMouseGrab(false);
void QQuickMultiPointTouchArea::ungrab()
{
if (_touchPoints.count()) {
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
if (c && c->mouseGrabberItem() == this) {
_stealMouse = false;
setKeepMouseGrab(false);
{
QPointF localPos = mapFromScene(event->windowPos());
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool stealThisEvent = _stealMouse;
if ((stealThisEvent || contains(localPos)) && (!grabber || !grabber->keepMouseGrab())) {
bool QQuickMultiPointTouchArea::shouldFilter(QEvent *event)
{
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool disabledItem = grabber && !grabber->isEnabled();
bool stealThisEvent = _stealMouse;
#include "qquickpathview_p.h"
#include "qquickpathview_p_p.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include <QtQuick/private/qquickstate_p.h>
#include <private/qqmlglobal_p.h>
Q_D(QQuickPathView);
QPointF localPos = mapFromScene(event->windowPos());
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
QQuickItem *grabber = c ? c->mouseGrabberItem() : 0;
bool stealThisEvent = d->stealMouse;
if ((stealThisEvent || contains(localPos)) && (!grabber || !grabber->keepMouseGrab())) {
****************************************************************************/
#include "qquickpincharea_p_p.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include <QtGui/qevent.h>
#include <QtGui/qguiapplication.h>
// A common non-trivial starting scenario is the user puts down one finger,
// then that finger remains stationary while putting down a second one.
- // However QQuickCanvas will not send TouchUpdates for TouchPoints which
+ // However QQuickWindow will not send TouchUpdates for TouchPoints which
// were not initially accepted; that would be inefficient and noisy.
// So even if there is only one touchpoint so far, it's important to accept it
// in order to get updates later on (and it's accepted by default anyway).
if (pe.accepted()) {
d->inPinch = true;
d->stealMouse = true;
- QQuickCanvas *c = canvas();
+ QQuickWindow *c = window();
if (c && c->mouseGrabberItem() != this)
grabMouse();
setKeepMouseGrab(true);
#include "qquickitem.h"
#include "qquickitem_p.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include <QScreen>
if (m_attachee) {
QQuickItemPrivate::get(m_attachee)->extra.value().screenAttached = this;
- if (m_attachee->canvas()) //It might not be assigned to a canvas yet
- canvasChanged(m_attachee->canvas());
+ if (m_attachee->window()) //It might not be assigned to a window yet
+ windowChanged(m_attachee->window());
}
}
return m_screen->angleBetween((Qt::ScreenOrientation)a,(Qt::ScreenOrientation)b);
}
-void QQuickScreenAttached::canvasChanged(QQuickCanvas* c)//Called by QQuickItemPrivate::initCanvas
+void QQuickScreenAttached::windowChanged(QQuickWindow* c)//Called by QQuickItemPrivate::initWindow
{
QScreen* screen = c ? c->screen() : 0;
if (screen != m_screen) {
class QQuickItem;
-class QQuickCanvas;
+class QQuickWindow;
class QScreen;
class Q_AUTOTEST_EXPORT QQuickScreenAttached : public QObject
//Treats int as Qt::ScreenOrientation, due to QTBUG-20639
Q_INVOKABLE int angleBetween(int a, int b);
- void canvasChanged(QQuickCanvas*);
+ void windowChanged(QQuickWindow*);
Q_SIGNALS:
void widthChanged();
#include <QtQuick/private/qsgcontext_p.h>
#include <QtQuick/qsgtextureprovider.h>
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include "qquickimage_p.h"
#include "qquickshadereffectsource_p.h"
if (d.specialType == UniformData::Sampler) {
QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
if (source) {
- if (item->canvas())
- QQuickItemPrivate::get(source)->derefCanvas();
+ if (item->window())
+ QQuickItemPrivate::get(source)->derefWindow();
QObject::disconnect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
}
}
if (d.specialType == UniformData::Sampler) {
QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
if (source) {
- if (item->canvas())
- QQuickItemPrivate::get(source)->refCanvas(item->canvas());
+ if (item->window())
+ QQuickItemPrivate::get(source)->refWindow(item->window());
QObject::connect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
}
}
}
}
-void QQuickShaderEffectCommon::updateCanvas(QQuickCanvas *canvas)
+void QQuickShaderEffectCommon::updateWindow(QQuickWindow *window)
{
// See comment in QQuickShaderEffectCommon::propertyChanged().
- if (canvas) {
+ if (window) {
for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
for (int i = 0; i < uniformData[shaderType].size(); ++i) {
const UniformData &d = uniformData[shaderType].at(i);
if (d.specialType == UniformData::Sampler) {
QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
if (source)
- QQuickItemPrivate::get(source)->refCanvas(canvas);
+ QQuickItemPrivate::get(source)->refWindow(window);
}
}
}
if (d.specialType == UniformData::Sampler) {
QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
if (source)
- QQuickItemPrivate::get(source)->derefCanvas();
+ QQuickItemPrivate::get(source)->derefWindow();
}
}
}
if (d.specialType == UniformData::Sampler) {
QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
if (source) {
- if (item->canvas())
- QQuickItemPrivate::get(source)->derefCanvas();
+ if (item->window())
+ QQuickItemPrivate::get(source)->derefWindow();
QObject::disconnect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
}
source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
if (source) {
- // 'source' needs a canvas to get a scene graph node. It usually gets one through its
+ // 'source' needs a window to get a scene graph node. It usually gets one through its
// parent, but if the source item is "inline" rather than a reference -- i.e.
// "property variant source: Image { }" instead of "property variant source: foo" -- it
- // will not get a parent. In those cases, 'source' should get the canvas from 'item'.
- if (item->canvas())
- QQuickItemPrivate::get(source)->refCanvas(item->canvas());
+ // will not get a parent. In those cases, 'source' should get the window from 'item'.
+ if (item->window())
+ QQuickItemPrivate::get(source)->refWindow(item->window());
QObject::connect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
}
if (textureProviderChanged)
void QQuickShaderEffect::itemChange(ItemChange change, const ItemChangeData &value)
{
if (change == QQuickItem::ItemSceneChange)
- m_common.updateCanvas(value.canvas);
+ m_common.updateWindow(value.window);
QQuickItem::itemChange(change, value);
}
void updateShader(QQuickItem *item, Key::ShaderType shaderType);
void updateMaterial(QQuickShaderEffectNode *node, QQuickShaderEffectMaterial *material,
bool updateUniforms, bool updateUniformValues, bool updateTextureProviders);
- void updateCanvas(QQuickCanvas *canvas);
+ void updateWindow(QQuickWindow *window);
// Called by slots in QQuickShaderEffect:
void sourceDestroyed(QObject *object);
#include "qquickshadereffectsource_p.h"
#include "qquickitem_p.h"
-#include "qquickcanvas_p.h"
+#include "qquickwindow_p.h"
#include <private/qsgadaptationlayer_p.h>
#include <QtQuick/private/qsgrenderer_p.h>
QQuickItemPrivate *sd = QQuickItemPrivate::get(m_sourceItem);
sd->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
sd->derefFromEffectItem(m_hideSource);
- if (canvas())
- sd->derefCanvas();
+ if (window())
+ sd->derefWindow();
}
}
if (m_texture)
return;
- Q_ASSERT_X(QQuickItemPrivate::get(this)->canvas
+ Q_ASSERT_X(QQuickItemPrivate::get(this)->window
&& QQuickItemPrivate::get(this)->sceneGraphContext()
&& QThread::currentThread() == QQuickItemPrivate::get(this)->sceneGraphContext()->thread(),
"QQuickShaderEffectSource::ensureTexture",
{
if (!m_provider) {
// Make sure it gets thread affinity on the rendering thread so deletion works properly..
- Q_ASSERT_X(QQuickItemPrivate::get(this)->canvas
+ Q_ASSERT_X(QQuickItemPrivate::get(this)->window
&& QQuickItemPrivate::get(this)->sceneGraphContext()
&& QThread::currentThread() == QQuickItemPrivate::get(this)->sceneGraphContext()->thread(),
"QQuickShaderEffectSource::textureProvider",
d->derefFromEffectItem(m_hideSource);
d->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
disconnect(m_sourceItem, SIGNAL(destroyed(QObject*)), this, SLOT(sourceItemDestroyed(QObject*)));
- if (canvas())
- d->derefCanvas();
+ if (window())
+ d->derefWindow();
}
m_sourceItem = item;
if (item) {
QQuickItemPrivate *d = QQuickItemPrivate::get(item);
- // 'item' needs a canvas to get a scene graph node. It usually gets one through its
+ // 'item' needs a window to get a scene graph node. It usually gets one through its
// parent, but if the source item is "inline" rather than a reference -- i.e.
// "sourceItem: Item { }" instead of "sourceItem: foo" -- it will not get a parent.
- // In those cases, 'item' should get the canvas from 'this'.
- if (canvas())
- d->refCanvas(canvas());
+ // In those cases, 'item' should get the window from 'this'.
+ if (window())
+ d->refWindow(window());
d->refFromEffectItem(m_hideSource);
d->addItemChangeListener(this, QQuickItemPrivate::Geometry);
connect(m_sourceItem, SIGNAL(destroyed(QObject*)), this, SLOT(sourceItemDestroyed(QObject*)));
{
if (change == QQuickItem::ItemSceneChange && m_sourceItem) {
// See comment in QQuickShaderEffectSource::setSourceItem().
- if (value.canvas)
- QQuickItemPrivate::get(m_sourceItem)->refCanvas(value.canvas);
+ if (value.window)
+ QQuickItemPrivate::get(m_sourceItem)->refWindow(value.window);
else
- QQuickItemPrivate::get(m_sourceItem)->derefCanvas();
+ QQuickItemPrivate::get(m_sourceItem)->derefWindow();
}
QQuickItem::itemChange(change, value);
}
#include <QtQuick/qsgnode.h>
#include <QtQuick/qsgtexturematerial.h>
#include <QtQuick/qsgtexture.h>
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
#include <QtQml/qqmlinfo.h>
#include <QFile>
#include <cmath>
if (image.isNull())
return 0;
m_sheetSize = QSizeF(image.size());
- m_material->texture = canvas()->createTextureFromImage(image);
+ m_material->texture = window()->createTextureFromImage(image);
m_material->texture->setFiltering(QSGTexture::Linear);
m_spriteEngine->start(0);
m_material->animT = 0;
#include "qquicktextcontrol_p.h"
#include "qquicktext_p_p.h"
#include "qquickevents_p_p.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include "qquicktextnode_p.h"
#include "qquicktextutil_p.h"
#include <QtQuick/qsgsimplerectnode.h>
#include "qquicktextinput_p.h"
#include "qquicktextinput_p_p.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include "qquicktextutil_p.h"
#include <private/qqmlglobal_p.h>
#include "qquickview.h"
#include "qquickview_p.h"
-#include "qquickcanvas_p.h"
+#include "qquickwindow_p.h"
#include "qquickitem_p.h"
#include "qquickitemchangelistener_p.h"
\inmodule QtQuick
- This is a convenience subclass of QQuickCanvas which
+ This is a convenience subclass of QQuickWindow which
will automatically load and display a QML scene when given the URL of the main source file. Alternatively,
- you can instantiate your own objects using QQmlComponent and place them in a manually setup QQuickCanvas.
+ you can instantiate your own objects using QQmlComponent and place them in a manually setup QQuickWindow.
Typical usage:
*/
QQuickView::QQuickView(QWindow *parent)
-: QQuickCanvas(*(new QQuickViewPrivate), parent)
+: QQuickWindow(*(new QQuickViewPrivate), parent)
{
d_func()->init();
}
*/
QQuickView::QQuickView(const QUrl &source, QWindow *parent)
-: QQuickCanvas(*(new QQuickViewPrivate), parent)
+: QQuickWindow(*(new QQuickViewPrivate), parent)
{
d_func()->init();
setSource(source);
\sa Status, status(), errors()
*/
QQuickView::QQuickView(QQmlEngine* engine, QWindow *parent)
- : QQuickCanvas(*(new QQuickViewPrivate), parent)
+ : QQuickWindow(*(new QQuickViewPrivate), parent)
{
Q_ASSERT(engine);
d_func()->init(engine);
/*!
\property QQuickView::resizeMode
- \brief whether the view should resize the canvas contents
+ \brief whether the view should resize the window contents
If this property is set to SizeViewToRootObject (the default), the view
resizes to the size of the root item in the QML.
return;
if (QQuickItem *sgItem = qobject_cast<QQuickItem *>(obj)) {
root = sgItem;
- sgItem->setParentItem(q->QQuickCanvas::rootItem());
+ sgItem->setParentItem(q->QQuickWindow::rootItem());
} else {
qWarning() << "QQuickView only supports loading of root objects that derive from QQuickItem." << endl
<< endl
if (d->resizeMode == SizeRootObjectToView)
d->updateSize();
- QQuickCanvas::resizeEvent(e);
+ QQuickWindow::resizeEvent(e);
}
/*! \reimp */
{
QQmlProfilerService::addEvent(QQmlProfilerService::Key);
- QQuickCanvas::keyPressEvent(e);
+ QQuickWindow::keyPressEvent(e);
}
/*! \reimp */
{
QQmlProfilerService::addEvent(QQmlProfilerService::Key);
- QQuickCanvas::keyReleaseEvent(e);
+ QQuickWindow::keyReleaseEvent(e);
}
/*! \reimp */
{
QQmlProfilerService::addEvent(QQmlProfilerService::Mouse);
- QQuickCanvas::mouseMoveEvent(e);
+ QQuickWindow::mouseMoveEvent(e);
}
/*! \reimp */
{
QQmlProfilerService::addEvent(QQmlProfilerService::Mouse);
- QQuickCanvas::mousePressEvent(e);
+ QQuickWindow::mousePressEvent(e);
}
/*! \reimp */
{
QQmlProfilerService::addEvent(QQmlProfilerService::Mouse);
- QQuickCanvas::mouseReleaseEvent(e);
+ QQuickWindow::mouseReleaseEvent(e);
}
#ifndef QQUICKVIEW_H
#define QQUICKVIEW_H
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
#include <QtCore/qurl.h>
#include <QtQml/qqmldebug.h>
class QQuickItem;
class QQuickViewPrivate;
-class Q_QUICK_EXPORT QQuickView : public QQuickCanvas
+class Q_QUICK_EXPORT QQuickView : public QQuickWindow
{
Q_OBJECT
Q_PROPERTY(ResizeMode resizeMode READ resizeMode WRITE setResizeMode)
#include <QtCore/QWeakPointer>
#include <QtQml/qqmlengine.h>
-#include "qquickcanvas_p.h"
+#include "qquickwindow_p.h"
#include "qquickitemchangelistener_p.h"
class QQuickItem;
class QQmlComponent;
-class QQuickViewPrivate : public QQuickCanvasPrivate,
+class QQuickViewPrivate : public QQuickWindowPrivate,
public QQuickItemChangeListener
{
Q_DECLARE_PUBLIC(QQuickView)
**
****************************************************************************/
-#include "qquickcanvas.h"
-#include "qquickcanvas_p.h"
+#include "qquickwindow.h"
+#include "qquickwindow_p.h"
#include "qquickitem.h"
#include "qquickitem_p.h"
QT_BEGIN_NAMESPACE
-void QQuickCanvasPrivate::updateFocusItemTransform()
+void QQuickWindowPrivate::updateFocusItemTransform()
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
QQuickItem *focus = q->activeFocusItem();
if (focus && qApp->focusObject() == focus)
- qApp->inputMethod()->setInputItemTransform(QQuickItemPrivate::get(focus)->itemToCanvasTransform());
+ qApp->inputMethod()->setInputItemTransform(QQuickItemPrivate::get(focus)->itemToWindowTransform());
}
-class QQuickCanvasIncubationController : public QObject, public QQmlIncubationController
+class QQuickWindowIncubationController : public QObject, public QQmlIncubationController
{
public:
- QQuickCanvasIncubationController(QQuickCanvasPrivate *canvas)
- : m_canvas(canvas), m_eventSent(false) {}
+ QQuickWindowIncubationController(QQuickWindowPrivate *window)
+ : m_window(window), m_eventSent(false) {}
protected:
virtual bool event(QEvent *e)
{
if (e->type() == QEvent::User) {
Q_ASSERT(m_eventSent);
- volatile bool *amtp = m_canvas->windowManager->allowMainThreadProcessing();
+ volatile bool *amtp = m_window->windowManager->allowMainThreadProcessing();
while (incubatingObjectCount()) {
if (amtp)
incubateWhile(amtp, 2);
QCoreApplication::postEvent(this, new QEvent(QEvent::User));
}
// If no animations are running, the renderer may be waiting
- m_canvas->windowManager->wakeup();
+ m_window->windowManager->wakeup();
}
private:
- QQuickCanvasPrivate *m_canvas;
+ QQuickWindowPrivate *m_window;
bool m_eventSent;
};
#ifndef QT_NO_ACCESSIBILITY
-QAccessibleInterface *QQuickCanvas::accessibleRoot() const
+QAccessibleInterface *QQuickWindow::accessibleRoot() const
{
- return QAccessible::queryAccessibleInterface(const_cast<QQuickCanvas*>(this));
+ return QAccessible::queryAccessibleInterface(const_cast<QQuickWindow*>(this));
}
#endif
Focus behavior
==============
-Prior to being added to a valid canvas items can set and clear focus with no
-effect. Only once items are added to a canvas (by way of having a parent set that
-already belongs to a canvas) do the focus rules apply. Focus goes back to
-having no effect if an item is removed from a canvas.
+Prior to being added to a valid window items can set and clear focus with no
+effect. Only once items are added to a window (by way of having a parent set that
+already belongs to a window) do the focus rules apply. Focus goes back to
+having no effect if an item is removed from a window.
-When an item is moved into a new focus scope (either being added to a canvas
+When an item is moved into a new focus scope (either being added to a window
for the first time, or having its parent changed), if the focus scope already has
a scope focused item that takes precedence over the item being added. Otherwise,
the focus of the added tree is used. In the case of of a tree of items being
-added to a canvas for the first time, which may have a conflicted focus state (two
+added to a window for the first time, which may have a conflicted focus state (two
or more items in one scope having focus set), the same rule is applied item by item -
thus the first item that has focus will get it (assuming the scope doesn't already
have a scope focused item), and the other items will have their focus cleared.
}
/*! \reimp */
-void QQuickCanvas::exposeEvent(QExposeEvent *)
+void QQuickWindow::exposeEvent(QExposeEvent *)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->windowManager->exposureChanged(this);
}
/*! \reimp */
-void QQuickCanvas::resizeEvent(QResizeEvent *)
+void QQuickWindow::resizeEvent(QResizeEvent *)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->windowManager->resize(this, size());
}
/*! \reimp */
-void QQuickCanvas::showEvent(QShowEvent *)
+void QQuickWindow::showEvent(QShowEvent *)
{
d_func()->windowManager->show(this);
}
/*! \reimp */
-void QQuickCanvas::hideEvent(QHideEvent *)
+void QQuickWindow::hideEvent(QHideEvent *)
{
d_func()->windowManager->hide(this);
}
/*! \reimp */
-void QQuickCanvas::focusOutEvent(QFocusEvent *)
+void QQuickWindow::focusOutEvent(QFocusEvent *)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->rootItem->setFocus(false);
}
/*! \reimp */
-void QQuickCanvas::focusInEvent(QFocusEvent *)
+void QQuickWindow::focusInEvent(QFocusEvent *)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->rootItem->setFocus(true);
d->updateFocusItemTransform();
}
-void QQuickCanvasPrivate::polishItems()
+void QQuickWindowPrivate::polishItems()
{
int maxPolishCycles = 100000;
}
if (maxPolishCycles == 0)
- qWarning("QQuickCanvas: possible QQuickItem::polish() loop");
+ qWarning("QQuickWindow: possible QQuickItem::polish() loop");
updateFocusItemTransform();
}
/**
- * This parameter enables that this canvas can be rendered without
+ * This parameter enables that this window can be rendered without
* being shown on screen. This feature is very limited in what it supports.
*
* There needs to be another window actually showing that we can make current
* one needs to hook into beforeRender() and set the render tareget.
*
*/
-void QQuickCanvasPrivate::setRenderWithoutShowing(bool render)
+void QQuickWindowPrivate::setRenderWithoutShowing(bool render)
{
if (render == renderWithoutShowing)
return;
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
renderWithoutShowing = render;
if (render)
/*!
- * Schedules the canvas to render another frame.
+ * Schedules the window to render another frame.
*
- * Calling QQuickCanvas::update() differs from QQuickItem::update() in that
+ * Calling QQuickWindow::update() differs from QQuickItem::update() in that
* it always triggers a repaint, regardless of changes in the underlying
* scene graph or not.
*/
-void QQuickCanvas::update()
+void QQuickWindow::update()
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->windowManager->update(this);
}
forceUpdate(items.at(i));
}
-void QQuickCanvasPrivate::syncSceneGraph()
+void QQuickWindowPrivate::syncSceneGraph()
{
QML_MEMORY_SCOPE_STRING("SceneGraph");
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
emit q->beforeSynchronizing();
if (!renderer) {
updateDirtyNodes();
- // Copy the current state of clearing from canvas into renderer.
+ // Copy the current state of clearing from window into renderer.
renderer->setClearColor(clearColor);
QSGRenderer::ClearMode mode = QSGRenderer::ClearStencilBuffer | QSGRenderer::ClearDepthBuffer;
if (clearBeforeRendering)
}
-void QQuickCanvasPrivate::renderSceneGraph(const QSize &size)
+void QQuickWindowPrivate::renderSceneGraph(const QSize &size)
{
QML_MEMORY_SCOPE_STRING("SceneGraph");
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
emit q->beforeRendering();
int fboId = 0;
renderer->setDeviceRect(QRect(QPoint(0, 0), size));
emit q->afterRendering();
}
-QQuickCanvasPrivate::QQuickCanvasPrivate()
+QQuickWindowPrivate::QQuickWindowPrivate()
: rootItem(0)
, activeFocusItem(0)
, mouseGrabberItem(0)
{
}
-QQuickCanvasPrivate::~QQuickCanvasPrivate()
+QQuickWindowPrivate::~QQuickWindowPrivate()
{
}
-void QQuickCanvasPrivate::init(QQuickCanvas *c)
+void QQuickWindowPrivate::init(QQuickWindow *c)
{
q_ptr = c;
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
rootItem = new QQuickRootItem;
QQmlEngine::setObjectOwnership(rootItem, QQmlEngine::CppOwnership);
QQuickItemPrivate *rootItemPrivate = QQuickItemPrivate::get(rootItem);
- rootItemPrivate->canvas = q;
- rootItemPrivate->canvasRefCount = 1;
+ rootItemPrivate->window = q;
+ rootItemPrivate->windowRefCount = 1;
rootItemPrivate->flags |= QQuickItem::ItemIsFocusScope;
// In the absence of a focus in event on some platforms assume the window will
// be activated immediately and set focus on the rootItem
// ### Remove when QTBUG-22415 is resolved.
- //It is important that this call happens after the rootItem has a canvas..
+ //It is important that this call happens after the rootItem has a window..
rootItem->setFocus(true);
windowManager = QQuickWindowManager::instance();
QObject::connect(context, SIGNAL(invalidated()), q, SLOT(cleanupSceneGraph()), Qt::DirectConnection);
}
-QQmlListProperty<QObject> QQuickCanvasPrivate::data()
+QQmlListProperty<QObject> QQuickWindowPrivate::data()
{
initRootItem();
return QQuickItemPrivate::get(rootItem)->data();
}
-void QQuickCanvasPrivate::initRootItem()
+void QQuickWindowPrivate::initRootItem()
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
q->connect(q, SIGNAL(widthChanged(int)),
rootItem, SLOT(setWidth(int)));
q->connect(q, SIGNAL(heightChanged(int)),
QVector2D transformedVelocity = p.velocity();
if (transformNeeded) {
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- QMatrix4x4 transformMatrix(itemPrivate->canvasToItemTransform());
+ QMatrix4x4 transformMatrix(itemPrivate->windowToItemTransform());
transformedVelocity = transformMatrix.mapVector(p.velocity()).toVector2D();
}
QGuiApplicationPrivate::setMouseEventCapsAndVelocity(me, event->device()->capabilities(), transformedVelocity);
return me;
}
-bool QQuickCanvasPrivate::translateTouchToMouse(QQuickItem *item, QTouchEvent *event)
+bool QQuickWindowPrivate::translateTouchToMouse(QQuickItem *item, QTouchEvent *event)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
// For each point, check if it is accepted, if not, try the next point.
// Any of the fingers can become the mouse one.
// This can happen because a mouse area might not accept an event at some point but another.
return false;
}
-void QQuickCanvasPrivate::transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform)
+void QQuickWindowPrivate::transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform)
{
QMatrix4x4 transformMatrix(transform);
for (int i=0; i<touchPoints.count(); i++) {
/*!
-Translates the data in \a touchEvent to this canvas. This method leaves the item local positions in
+Translates the data in \a touchEvent to this window. This method leaves the item local positions in
\a touchEvent untouched (these are filled in later).
*/
-void QQuickCanvasPrivate::translateTouchEvent(QTouchEvent *touchEvent)
+void QQuickWindowPrivate::translateTouchEvent(QTouchEvent *touchEvent)
{
QList<QTouchEvent::TouchPoint> touchPoints = touchEvent->touchPoints();
for (int i = 0; i < touchPoints.count(); ++i) {
touchEvent->setTouchPoints(touchPoints);
}
-void QQuickCanvasPrivate::setFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions options)
+void QQuickWindowPrivate::setFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions options)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
Q_ASSERT(item);
Q_ASSERT(scope || item == rootItem);
#ifdef FOCUS_DEBUG
- qWarning() << "QQuickCanvasPrivate::setFocusInScope():";
+ qWarning() << "QQuickWindowPrivate::setFocusInScope():";
qWarning() << " scope:" << (QObject *)scope;
if (scope)
qWarning() << " scopeSubFocusItem:" << (QObject *)QQuickItemPrivate::get(scope)->subFocusItem;
notifyFocusChangesRecur(changed.data(), changed.count() - 1);
}
-void QQuickCanvasPrivate::clearFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions options)
+void QQuickWindowPrivate::clearFocusInScope(QQuickItem *scope, QQuickItem *item, FocusOptions options)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
Q_ASSERT(item);
Q_ASSERT(scope || item == rootItem);
#ifdef FOCUS_DEBUG
- qWarning() << "QQuickCanvasPrivate::clearFocusInScope():";
+ qWarning() << "QQuickWindowPrivate::clearFocusInScope():";
qWarning() << " scope:" << (QObject *)scope;
qWarning() << " item:" << (QObject *)item;
qWarning() << " activeFocusItem:" << (QObject *)activeFocusItem;
notifyFocusChangesRecur(changed.data(), changed.count() - 1);
}
-void QQuickCanvasPrivate::notifyFocusChangesRecur(QQuickItem **items, int remaining)
+void QQuickWindowPrivate::notifyFocusChangesRecur(QQuickItem **items, int remaining)
{
QQmlGuard<QQuickItem> item(*items);
}
}
-void QQuickCanvasPrivate::dirtyItem(QQuickItem *)
+void QQuickWindowPrivate::dirtyItem(QQuickItem *)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
q->maybeUpdate();
}
-void QQuickCanvasPrivate::cleanup(QSGNode *n)
+void QQuickWindowPrivate::cleanup(QSGNode *n)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
Q_ASSERT(!cleanupNodeList.contains(n));
cleanupNodeList.append(n);
*/
/*!
- \qmlclass Window QQuickCanvas
+ \qmlclass Window QQuickWindow
\inqmlmodule QtQuick.Window 2
\ingroup qtquick-visual
\brief Creates a new top-level window
Restricting this import will allow you to have a QML environment without access to window system features.
*/
/*!
- \class QQuickCanvas
+ \class QQuickWindow
\since QtQuick 2.0
\inmodule QtQuick
- \brief The QQuickCanvas class provides the canvas for displaying a graphical QML scene
+ \brief The QQuickWindow class provides the window for displaying a graphical QML scene
- QQuickCanvas provides the graphical scene management needed to interact with and display
+ QQuickWindow provides the graphical scene management needed to interact with and display
a scene of QQuickItems.
- A QQuickCanvas always has a single invisible root item. To add items to this canvas,
+ A QQuickWindow always has a single invisible root item. To add items to this window,
reparent the items to the root item or to an existing item in the scene.
For easily displaying a scene from a QML file, see \l{QQuickView}.
\section1 Scene Graph and Rendering
- The QQuickCanvas uses a scene graph on top of OpenGL to render. This scene graph is disconnected
+ The QQuickWindow uses a scene graph on top of OpenGL to render. This scene graph is disconnected
from the QML scene and potentially lives in another thread, depending on the platform
implementation. Since the rendering scene graph lives independently from the QML scene, it can
also be completely released without affecting the state of the QML scene.
\list 1
- \li The QQuickCanvas::beforeSynchronizing() signal is emitted.
+ \li The QQuickWindow::beforeSynchronizing() signal is emitted.
Applications can make direct connections (Qt::DirectConnection)
to this signal to do any preparation required before calls to
QQuickItem::updatePaintNode().
synchroniation. This is the only time the QML items and the nodes
in the scene graph interact.
- \li The canvas to be rendered is made current using
+ \li The window to be rendered is made current using
QOpenGLContext::makeCurrent().
- \li The QQuickCanvas::beforeRendering() signal is
+ \li The QQuickWindow::beforeRendering() signal is
emitted. Applications can make direct connections
(Qt::DirectConnection) to this signal to use custom OpenGL calls
which will then stack visually beneath the QML scene.
\li Items that have specified QSGNode::UsesPreprocess, will have their
QSGNode::preprocess() function invoked.
- \li The QQuickCanvas is cleared according to what is specified
- using QQuickCanvas::setClearBeforeRendering() and
- QQuickCanvas::setClearColor().
+ \li The QQuickWindow is cleared according to what is specified
+ using QQuickWindow::setClearBeforeRendering() and
+ QQuickWindow::setClearColor().
\li The scene graph is rendered.
- \li The QQuickCanvas::afterRendering() signal is
+ \li The QQuickWindow::afterRendering() signal is
emitted. Applications can make direct connections
(Qt::DirectConnection) to this signal to use custom OpenGL calls
which will then stack visually over the QML scene.
- \li The rendered frame is swapped and QQuickCanvas::frameSwapped()
+ \li The rendered frame is swapped and QQuickWindow::frameSwapped()
is emitted.
\endlist
for the next frame. This means that as long as users are not using scene graph API
directly, the added complexity of a rendering thread can be completely ignored.
- When a QQuickCanvas is programatically hidden with hide() or setVisible(false), it will
+ When a QQuickWindow is programatically hidden with hide() or setVisible(false), it will
stop rendering and its scene graph and OpenGL context might be released. The
sceneGraphInvalidated() signal will be emitted when this happens.
sceneGraphInvalidated() signal will be emitted when this happens.
*/
-QQuickCanvas::QQuickCanvas(QWindow *parent)
- : QWindow(*(new QQuickCanvasPrivate), parent)
+QQuickWindow::QQuickWindow(QWindow *parent)
+ : QWindow(*(new QQuickWindowPrivate), parent)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->init(this);
}
-QQuickCanvas::QQuickCanvas(QQuickCanvasPrivate &dd, QWindow *parent)
+QQuickWindow::QQuickWindow(QQuickWindowPrivate &dd, QWindow *parent)
: QWindow(dd, parent)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->init(this);
}
-QQuickCanvas::~QQuickCanvas()
+QQuickWindow::~QQuickWindow()
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
- d->windowManager->canvasDestroyed(this);
+ d->windowManager->windowDestroyed(this);
QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
delete d->incubationController; d->incubationController = 0;
\sa sceneGraphInvalidated(), setPersistentOpenGLContext(), setPersistentSceneGraph().
*/
-void QQuickCanvas::releaseResources()
+void QQuickWindow::releaseResources()
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->windowManager->releaseResources();
QQuickPixmap::purgeCache();
}
\sa setPersistentSceneGraph()
*/
-void QQuickCanvas::setPersistentOpenGLContext(bool persistent)
+void QQuickWindow::setPersistentOpenGLContext(bool persistent)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->persistentGLContext = persistent;
}
releaseResources().
*/
-bool QQuickCanvas::isPersistentOpenGLContext() const
+bool QQuickWindow::isPersistentOpenGLContext() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->persistentGLContext;
}
\sa setPersistentOpenGLContext()
*/
-void QQuickCanvas::setPersistentSceneGraph(bool persistent)
+void QQuickWindow::setPersistentSceneGraph(bool persistent)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->persistentSceneGraph = persistent;
}
of a call to releaseResources().
*/
-bool QQuickCanvas::isPersistentSceneGraph() const
+bool QQuickWindow::isPersistentSceneGraph() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->persistentSceneGraph;
}
/*!
Returns the invisible root item of the scene.
- A QQuickCanvas always has a single invisible root item. To add items to this canvas,
- reparent the items to the root item or to an existing item in the scene.
+ A QQuickWindow always has a single invisible root item containing all of its content.
+ To add items to this window, reparent the items to the contentItem or to an existing
+ item in the scene.
*/
-QQuickItem *QQuickCanvas::rootItem() const
+QQuickItem *QQuickWindow::contentItem() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->rootItem;
}
/*!
Returns the item which currently has active focus.
*/
-QQuickItem *QQuickCanvas::activeFocusItem() const
+QQuickItem *QQuickWindow::activeFocusItem() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->activeFocusItem;
}
-QObject *QQuickCanvas::focusObject() const
+/*!
+ \internal
+ \reimp
+*/
+QObject *QQuickWindow::focusObject() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
if (d->activeFocusItem)
return d->activeFocusItem;
- return const_cast<QQuickCanvas*>(this);
+ return const_cast<QQuickWindow*>(this);
}
/*!
Returns the item which currently has the mouse grab.
*/
-QQuickItem *QQuickCanvas::mouseGrabberItem() const
+QQuickItem *QQuickWindow::mouseGrabberItem() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->mouseGrabberItem;
}
Setting this property is more efficient than using a separate Rectangle.
*/
-bool QQuickCanvasPrivate::clearHover()
+bool QQuickWindowPrivate::clearHover()
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
if (hoverItems.isEmpty())
return false;
}
/*! \reimp */
-bool QQuickCanvas::event(QEvent *e)
+bool QQuickWindow::event(QEvent *e)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
switch (e->type()) {
}
/*! \reimp */
-void QQuickCanvas::keyPressEvent(QKeyEvent *e)
+void QQuickWindow::keyPressEvent(QKeyEvent *e)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
if (d->activeFocusItem)
sendEvent(d->activeFocusItem, e);
}
/*! \reimp */
-void QQuickCanvas::keyReleaseEvent(QKeyEvent *e)
+void QQuickWindow::keyReleaseEvent(QKeyEvent *e)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
if (d->activeFocusItem)
sendEvent(d->activeFocusItem, e);
}
-QMouseEvent *QQuickCanvasPrivate::cloneMouseEvent(QMouseEvent *event, QPointF *transformedLocalPos)
+QMouseEvent *QQuickWindowPrivate::cloneMouseEvent(QMouseEvent *event, QPointF *transformedLocalPos)
{
int caps = QGuiApplicationPrivate::mouseEventCaps(event);
QVector2D velocity = QGuiApplicationPrivate::mouseEventVelocity(event);
return me;
}
-bool QQuickCanvasPrivate::deliverInitialMousePressEvent(QQuickItem *item, QMouseEvent *event)
+bool QQuickWindowPrivate::deliverInitialMousePressEvent(QQuickItem *item, QMouseEvent *event)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
return false;
}
-bool QQuickCanvasPrivate::deliverMouseEvent(QMouseEvent *event)
+bool QQuickWindowPrivate::deliverMouseEvent(QMouseEvent *event)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
lastMousePosition = event->windowPos();
}
/*! \reimp */
-void QQuickCanvas::mousePressEvent(QMouseEvent *event)
+void QQuickWindow::mousePressEvent(QMouseEvent *event)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
#ifdef MOUSE_DEBUG
- qWarning() << "QQuickCanvas::mousePressEvent()" << event->localPos() << event->button() << event->buttons();
+ qWarning() << "QQuickWindow::mousePressEvent()" << event->localPos() << event->button() << event->buttons();
#endif
d->deliverMouseEvent(event);
}
/*! \reimp */
-void QQuickCanvas::mouseReleaseEvent(QMouseEvent *event)
+void QQuickWindow::mouseReleaseEvent(QMouseEvent *event)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
#ifdef MOUSE_DEBUG
- qWarning() << "QQuickCanvas::mouseReleaseEvent()" << event->localPos() << event->button() << event->buttons();
+ qWarning() << "QQuickWindow::mouseReleaseEvent()" << event->localPos() << event->button() << event->buttons();
#endif
if (!d->mouseGrabberItem) {
}
/*! \reimp */
-void QQuickCanvas::mouseDoubleClickEvent(QMouseEvent *event)
+void QQuickWindow::mouseDoubleClickEvent(QMouseEvent *event)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
#ifdef MOUSE_DEBUG
- qWarning() << "QQuickCanvas::mouseDoubleClickEvent()" << event->localPos() << event->button() << event->buttons();
+ qWarning() << "QQuickWindow::mouseDoubleClickEvent()" << event->localPos() << event->button() << event->buttons();
#endif
if (!d->mouseGrabberItem && (event->buttons() & event->button()) == event->buttons()) {
d->deliverMouseEvent(event);
}
-bool QQuickCanvasPrivate::sendHoverEvent(QEvent::Type type, QQuickItem *item,
+bool QQuickWindowPrivate::sendHoverEvent(QEvent::Type type, QQuickItem *item,
const QPointF &scenePos, const QPointF &lastScenePos,
Qt::KeyboardModifiers modifiers, bool accepted)
{
- Q_Q(QQuickCanvas);
- const QTransform transform = QQuickItemPrivate::get(item)->canvasToItemTransform();
+ Q_Q(QQuickWindow);
+ const QTransform transform = QQuickItemPrivate::get(item)->windowToItemTransform();
//create copy of event
QHoverEvent hoverEvent(type, transform.map(scenePos), transform.map(lastScenePos), modifiers);
}
/*! \reimp */
-void QQuickCanvas::mouseMoveEvent(QMouseEvent *event)
+void QQuickWindow::mouseMoveEvent(QMouseEvent *event)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
#ifdef MOUSE_DEBUG
- qWarning() << "QQuickCanvas::mouseMoveEvent()" << event->localPos() << event->button() << event->buttons();
+ qWarning() << "QQuickWindow::mouseMoveEvent()" << event->localPos() << event->button() << event->buttons();
#endif
if (!d->mouseGrabberItem) {
d->deliverMouseEvent(event);
}
-bool QQuickCanvasPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &scenePos, const QPointF &lastScenePos,
+bool QQuickWindowPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &scenePos, const QPointF &lastScenePos,
Qt::KeyboardModifiers modifiers, bool &accepted)
{
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
return false;
}
-bool QQuickCanvasPrivate::deliverWheelEvent(QQuickItem *item, QWheelEvent *event)
+bool QQuickWindowPrivate::deliverWheelEvent(QQuickItem *item, QWheelEvent *event)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
#ifndef QT_NO_WHEELEVENT
/*! \reimp */
-void QQuickCanvas::wheelEvent(QWheelEvent *event)
+void QQuickWindow::wheelEvent(QWheelEvent *event)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
#ifdef MOUSE_DEBUG
- qWarning() << "QQuickCanvas::wheelEvent()" << event->pixelDelta() << event->angleDelta();
+ qWarning() << "QQuickWindow::wheelEvent()" << event->pixelDelta() << event->angleDelta();
#endif
//if the actual wheel event was accepted, accept the compatability wheel event and return early
#endif // QT_NO_WHEELEVENT
-bool QQuickCanvasPrivate::deliverTouchCancelEvent(QTouchEvent *event)
+bool QQuickWindowPrivate::deliverTouchCancelEvent(QTouchEvent *event)
{
#ifdef TOUCH_DEBUG
qWarning("touchCancelEvent");
#endif
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
// A TouchCancel event will typically not contain any points.
// Deliver it to all items that have active touches.
QSet<QQuickItem *> cancelDelivered;
// check what kind of touch we have (begin/update) and
// call deliverTouchPoints to actually dispatch the points
-bool QQuickCanvasPrivate::deliverTouchEvent(QTouchEvent *event)
+bool QQuickWindowPrivate::deliverTouchEvent(QTouchEvent *event)
{
#ifdef TOUCH_DEBUG
if (event->type() == QEvent::TouchBegin)
}
// This function recurses and sends the events to the individual items
-bool QQuickCanvasPrivate::deliverTouchPoints(QQuickItem *item, QTouchEvent *event, const QList<QTouchEvent::TouchPoint> &newPoints, QSet<int> *acceptedNewPoints, QHash<QQuickItem *, QList<QTouchEvent::TouchPoint> > *updatedPoints)
+bool QQuickWindowPrivate::deliverTouchPoints(QQuickItem *item, QTouchEvent *event, const QList<QTouchEvent::TouchPoint> &newPoints, QSet<int> *acceptedNewPoints, QHash<QQuickItem *, QList<QTouchEvent::TouchPoint> > *updatedPoints)
{
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
}
// If there are no matching new points, and the existing points are all stationary,
// there's no need to send an event to this item. This is required by a test in
- // tst_qquickcanvas::touchEvent_basic:
+ // tst_qquickwindow::touchEvent_basic:
// a single stationary press on an item shouldn't cause an event
if (matchingNewPoints.isEmpty()) {
bool stationaryOnly = true;
// Now we know this item might be interested in the event. Copy and send it, but
// with only the subset of TouchPoints which are relevant to that item: that's matchingPoints.
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- transformTouchPoints(matchingPoints, itemPrivate->canvasToItemTransform());
+ transformTouchPoints(matchingPoints, itemPrivate->windowToItemTransform());
deliverMatchingPointsToItem(item, event, acceptedNewPoints, matchingNewPoints, matchingPoints);
}
// only the points that are relevant for this item. Thus the need for
// matchingPoints to already be that set of interesting points.
// They are all pre-transformed, too.
-bool QQuickCanvasPrivate::deliverMatchingPointsToItem(QQuickItem *item, QTouchEvent *event, QSet<int> *acceptedNewPoints, const QSet<int> &matchingNewPoints, const QList<QTouchEvent::TouchPoint> &matchingPoints)
+bool QQuickWindowPrivate::deliverMatchingPointsToItem(QQuickItem *item, QTouchEvent *event, QSet<int> *acceptedNewPoints, const QSet<int> &matchingNewPoints, const QList<QTouchEvent::TouchPoint> &matchingPoints)
{
QScopedPointer<QTouchEvent> touchEvent(touchEventWithPoints(*event, matchingPoints));
touchEvent.data()->setTarget(item);
return touchEventAccepted;
}
-QTouchEvent *QQuickCanvasPrivate::touchEventForItemBounds(QQuickItem *target, const QTouchEvent &originalEvent)
+QTouchEvent *QQuickWindowPrivate::touchEventForItemBounds(QQuickItem *target, const QTouchEvent &originalEvent)
{
const QList<QTouchEvent::TouchPoint> &touchPoints = originalEvent.touchPoints();
QList<QTouchEvent::TouchPoint> pointsInBounds;
pointsInBounds.append(tp);
}
}
- transformTouchPoints(pointsInBounds, QQuickItemPrivate::get(target)->canvasToItemTransform());
+ transformTouchPoints(pointsInBounds, QQuickItemPrivate::get(target)->windowToItemTransform());
}
QTouchEvent* touchEvent = touchEventWithPoints(originalEvent, pointsInBounds);
return touchEvent;
}
-QTouchEvent *QQuickCanvasPrivate::touchEventWithPoints(const QTouchEvent &event, const QList<QTouchEvent::TouchPoint> &newPoints)
+QTouchEvent *QQuickWindowPrivate::touchEventWithPoints(const QTouchEvent &event, const QList<QTouchEvent::TouchPoint> &newPoints)
{
Qt::TouchPointStates eventStates;
for (int i=0; i<newPoints.count(); i++)
}
#ifndef QT_NO_DRAGANDDROP
-void QQuickCanvasPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QEvent *event)
+void QQuickWindowPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QEvent *event)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
grabber->resetTarget();
QQuickDragGrabber::iterator grabItem = grabber->begin();
if (grabItem != grabber->end()) {
}
}
-bool QQuickCanvasPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QQuickItem *item, QDragMoveEvent *event)
+bool QQuickWindowPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QQuickItem *item, QDragMoveEvent *event)
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
bool accepted = false;
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
if (!item->isVisible() || !item->isEnabled())
}
#endif // QT_NO_DRAGANDDROP
-bool QQuickCanvasPrivate::sendFilteredTouchEvent(QQuickItem *target, QQuickItem *item, QTouchEvent *event)
+bool QQuickWindowPrivate::sendFilteredTouchEvent(QQuickItem *target, QQuickItem *item, QTouchEvent *event)
{
if (!target)
return false;
return sendFilteredTouchEvent(target->parentItem(), item, event);
}
-bool QQuickCanvasPrivate::sendFilteredMouseEvent(QQuickItem *target, QQuickItem *item, QEvent *event)
+bool QQuickWindowPrivate::sendFilteredMouseEvent(QQuickItem *target, QQuickItem *item, QEvent *event)
{
if (!target)
return false;
return false;
}
-bool QQuickCanvasPrivate::dragOverThreshold(qreal d, Qt::Axis axis, QMouseEvent *event)
+bool QQuickWindowPrivate::dragOverThreshold(qreal d, Qt::Axis axis, QMouseEvent *event)
{
QStyleHints *styleHints = qApp->styleHints();
int caps = QGuiApplicationPrivate::mouseEventCaps(event);
}
/*!
- Propagates an event to a QQuickItem on the canvas
+ Propagates an event to a QQuickItem on the window
*/
-bool QQuickCanvas::sendEvent(QQuickItem *item, QEvent *e)
+bool QQuickWindow::sendEvent(QQuickItem *item, QEvent *e)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
if (!item) {
- qWarning("QQuickCanvas::sendEvent: Cannot send event to a null item");
+ qWarning("QQuickWindow::sendEvent: Cannot send event to a null item");
return false;
}
return false;
}
-void QQuickCanvasPrivate::cleanupNodes()
+void QQuickWindowPrivate::cleanupNodes()
{
for (int ii = 0; ii < cleanupNodeList.count(); ++ii)
delete cleanupNodeList.at(ii);
cleanupNodeList.clear();
}
-void QQuickCanvasPrivate::cleanupNodesOnShutdown(QQuickItem *item)
+void QQuickWindowPrivate::cleanupNodesOnShutdown(QQuickItem *item)
{
QQuickItemPrivate *p = QQuickItemPrivate::get(item);
if (p->itemNodeInstance) {
}
// This must be called from the render thread, with the main thread frozen
-void QQuickCanvasPrivate::cleanupNodesOnShutdown()
+void QQuickWindowPrivate::cleanupNodesOnShutdown()
{
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
cleanupNodes();
cleanupNodesOnShutdown(rootItem);
QSet<QQuickItem *>::const_iterator it = parentlessItems.begin();
q->cleanupSceneGraph();
}
-void QQuickCanvasPrivate::updateDirtyNodes()
+void QQuickWindowPrivate::updateDirtyNodes()
{
#ifdef DIRTY_DEBUG
- qWarning() << "QQuickCanvasPrivate::updateDirtyNodes():";
+ qWarning() << "QQuickWindowPrivate::updateDirtyNodes():";
#endif
cleanupNodes();
}
}
-void QQuickCanvasPrivate::updateDirtyNode(QQuickItem *item)
+void QQuickWindowPrivate::updateDirtyNode(QQuickItem *item)
{
#ifdef QML_RUNTIME_TESTING
bool didFlash = false;
itemPriv->itemNode()->setMatrix(matrix);
}
- bool clipEffectivelyChanged = (dirty & (QQuickItemPrivate::Clip | QQuickItemPrivate::Canvas)) &&
+ bool clipEffectivelyChanged = (dirty & (QQuickItemPrivate::Clip | QQuickItemPrivate::Window)) &&
((item->clip() == false) != (itemPriv->clipNode() == 0));
int effectRefCount = itemPriv->extra.isAllocated()?itemPriv->extra->effectRefCount:0;
- bool effectRefEffectivelyChanged = (dirty & (QQuickItemPrivate::EffectReference | QQuickItemPrivate::Canvas)) &&
+ bool effectRefEffectivelyChanged = (dirty & (QQuickItemPrivate::EffectReference | QQuickItemPrivate::Window)) &&
((effectRefCount == 0) != (itemPriv->rootNode() == 0));
if (clipEffectivelyChanged) {
}
if (dirty & (QQuickItemPrivate::OpacityValue | QQuickItemPrivate::Visible
- | QQuickItemPrivate::HideReference | QQuickItemPrivate::Canvas))
+ | QQuickItemPrivate::HideReference | QQuickItemPrivate::Window))
{
qreal opacity = itemPriv->explicitVisible && (!itemPriv->extra.isAllocated() || itemPriv->extra->hideRefCount == 0)
? itemPriv->opacity() : qreal(0);
itemPriv->childContainerNode()->appendChildNode(flash);
didFlash = true;
}
- Q_Q(QQuickCanvas);
+ Q_Q(QQuickWindow);
if (didFlash) {
q->maybeUpdate();
}
}
-void QQuickCanvas::maybeUpdate()
+void QQuickWindow::maybeUpdate()
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->windowManager->maybeUpdate(this);
}
-void QQuickCanvas::cleanupSceneGraph()
+void QQuickWindow::cleanupSceneGraph()
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
if (!d->renderer)
return;
\sa sceneGraphInitialized(), sceneGraphInvalidated()
*/
-QOpenGLContext *QQuickCanvas::openglContext() const
+QOpenGLContext *QQuickWindow::openglContext() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
if (d->context->isReady())
return d->context->glContext();
return 0;
/*!
- Sets the render target for this canvas to be \a fbo.
+ Sets the render target for this window to be \a fbo.
- The specified fbo must be created in the context of the canvas
+ The specified fbo must be created in the context of the window
or one that shares with it.
\warning
the rendering.
*/
-void QQuickCanvas::setRenderTarget(QOpenGLFramebufferObject *fbo)
+void QQuickWindow::setRenderTarget(QOpenGLFramebufferObject *fbo)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
if (d->context && d->context && QThread::currentThread() != d->context->thread()) {
- qWarning("QQuickCanvas::setRenderThread: Cannot set render target from outside the rendering thread");
+ qWarning("QQuickWindow::setRenderThread: Cannot set render target from outside the rendering thread");
return;
}
/*!
\overload
*/
-void QQuickCanvas::setRenderTarget(uint fboId, const QSize &size)
+void QQuickWindow::setRenderTarget(uint fboId, const QSize &size)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
if (d->context && d->context && QThread::currentThread() != d->context->thread()) {
- qWarning("QQuickCanvas::setRenderThread: Cannot set render target from outside the rendering thread");
+ qWarning("QQuickWindow::setRenderThread: Cannot set render target from outside the rendering thread");
return;
}
/*!
Returns the FBO id of the render target when set; otherwise returns 0.
*/
-uint QQuickCanvas::renderTargetId() const
+uint QQuickWindow::renderTargetId() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->renderTargetId;
}
/*!
Returns the size of the currently set render target; otherwise returns an enpty size.
*/
-QSize QQuickCanvas::renderTargetSize() const
+QSize QQuickWindow::renderTargetSize() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->renderTargetSize;
}
/*!
- Returns the render target for this canvas.
+ Returns the render target for this window.
- The default is to render to the surface of the canvas, in which
+ The default is to render to the surface of the window, in which
case the render target is 0.
*/
-QOpenGLFramebufferObject *QQuickCanvas::renderTarget() const
+QOpenGLFramebufferObject *QQuickWindow::renderTarget() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->renderTarget;
}
/*!
- Grabs the contents of the framebuffer and returns it as an image.
+ Grabs the contents of the window and returns it as an image.
- This function might not work if the view is not visible.
+ This function might not work if the window is not visible.
\warning Calling this function will cause performance problems.
\warning This function can only be called from the GUI thread.
*/
-QImage QQuickCanvas::grabFrameBuffer()
+QImage QQuickWindow::grabWindow()
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
return d->windowManager->grab(this);
}
/*!
Returns an incubation controller that splices incubation between frames
- for this canvas. QQuickView automatically installs this controller for you,
+ for this window. QQuickView automatically installs this controller for you,
otherwise you will need to install it yourself using \l{QQmlEngine::setIncubationController}
- The controller is owned by the canvas and will be destroyed when the canvas
+ The controller is owned by the window and will be destroyed when the window
is deleted.
*/
-QQmlIncubationController *QQuickCanvas::incubationController() const
+QQmlIncubationController *QQuickWindow::incubationController() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
if (!d->incubationController)
- d->incubationController = new QQuickCanvasIncubationController(const_cast<QQuickCanvasPrivate *>(d));
+ d->incubationController = new QQuickWindowIncubationController(const_cast<QQuickWindowPrivate *>(d));
return d->incubationController;
}
/*!
- \enum QQuickCanvas::CreateTextureOption
+ \enum QQuickWindow::CreateTextureOption
The CreateTextureOption enums are used to customize a texture is wrapped.
*/
/*!
- \fn void QQuickCanvas::beforeRendering()
+ \fn void QQuickWindow::beforeRendering()
This signal is emitted before the scene starts rendering.
*/
/*!
- \fn void QQuickCanvas::afterRendering()
+ \fn void QQuickWindow::afterRendering()
This signal is emitted after the scene has completed rendering, before swapbuffers is called.
\sa beforeRendering()
*/
-void QQuickCanvas::setClearBeforeRendering(bool enabled)
+void QQuickWindow::setClearBeforeRendering(bool enabled)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
d->clearBeforeRendering = enabled;
}
Returns weither clearing of the color buffer is done before rendering or not.
*/
-bool QQuickCanvas::clearBeforeRendering() const
+bool QQuickWindow::clearBeforeRendering() const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
return d->clearBeforeRendering;
}
\sa sceneGraphInitialized()
*/
-QSGTexture *QQuickCanvas::createTextureFromImage(const QImage &image) const
+QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image) const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
if (d->context && d->context->isReady())
return d->context->createTexture(image);
else
\sa sceneGraphInitialized()
*/
-QSGTexture *QQuickCanvas::createTextureFromId(uint id, const QSize &size, CreateTextureOptions options) const
+QSGTexture *QQuickWindow::createTextureFromId(uint id, const QSize &size, CreateTextureOptions options) const
{
- Q_D(const QQuickCanvas);
+ Q_D(const QQuickWindow);
if (d->context && d->context->isReady()) {
QSGPlainTexture *texture = new QSGPlainTexture();
texture->setTextureId(id);
\sa setClearBeforeRendering()
*/
-void QQuickCanvas::setClearColor(const QColor &color)
+void QQuickWindow::setColor(const QColor &color)
{
- Q_D(QQuickCanvas);
+ Q_D(QQuickWindow);
if (color == d->clearColor)
return;
d->clearColor = color;
- emit clearColorChanged(color);
+ emit colorChanged(color);
}
Returns the color used to clear the opengl context.
*/
-QColor QQuickCanvas::clearColor() const
+QColor QQuickWindow::color() const
{
return d_func()->clearColor;
}
-#include "moc_qquickcanvas.cpp"
+#include "moc_qquickwindow.cpp"
QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKWINDOW_H
+#define QQUICKWINDOW_H
+
+#include <QtQuick/qtquickglobal.h>
+#include <QtCore/qmetatype.h>
+#include <QtGui/qopengl.h>
+#include <QtGui/qwindow.h>
+#include <QtGui/qevent.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QQuickItem;
+class QSGTexture;
+class QInputMethodEvent;
+class QQuickWindowPrivate;
+class QOpenGLFramebufferObject;
+class QQmlIncubationController;
+class QInputMethodEvent;
+
+class Q_QUICK_EXPORT QQuickWindow : public QWindow
+{
+ Q_OBJECT
+ Q_PRIVATE_PROPERTY(QQuickWindow::d_func(), QQmlListProperty<QObject> data READ data DESIGNABLE false)
+ Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
+ Q_PROPERTY(QQuickItem* contentItem READ contentItem CONSTANT FINAL)
+ Q_CLASSINFO("DefaultProperty", "data")
+ Q_DECLARE_PRIVATE(QQuickWindow)
+public:
+ enum CreateTextureOption {
+ TextureHasAlphaChannel = 0x0001,
+ TextureHasMipmaps = 0x0002,
+ TextureOwnsGLTexture = 0x0004
+ };
+
+ Q_DECLARE_FLAGS(CreateTextureOptions, CreateTextureOption)
+
+ QQuickWindow(QWindow *parent = 0);
+
+ virtual ~QQuickWindow();
+
+ QQuickItem *contentItem() const;
+ //XXX rootItem renamed contentItem - this function must be removed before 5.0
+ QQuickItem *rootItem() const { return contentItem(); }
+
+ QQuickItem *activeFocusItem() const;
+ QObject *focusObject() const;
+
+ QQuickItem *mouseGrabberItem() const;
+
+ bool sendEvent(QQuickItem *, QEvent *);
+
+ QImage grabWindow();
+
+ void setRenderTarget(QOpenGLFramebufferObject *fbo);
+ QOpenGLFramebufferObject *renderTarget() const;
+
+ void setRenderTarget(uint fboId, const QSize &size);
+ uint renderTargetId() const;
+ QSize renderTargetSize() const;
+
+ QQmlIncubationController *incubationController() const;
+
+#ifndef QT_NO_ACCESSIBILITY
+ virtual QAccessibleInterface *accessibleRoot() const;
+#endif
+
+ // Scene graph specific functions
+ QSGTexture *createTextureFromImage(const QImage &image) const;
+ QSGTexture *createTextureFromId(uint id, const QSize &size, CreateTextureOptions options = CreateTextureOption(0)) const;
+
+ void setClearBeforeRendering(bool enabled);
+ bool clearBeforeRendering() const;
+
+ void setColor(const QColor &color);
+ QColor color() const;
+
+ void setPersistentOpenGLContext(bool persistent);
+ bool isPersistentOpenGLContext() const;
+
+ void setPersistentSceneGraph(bool persistent);
+ bool isPersistentSceneGraph() const;
+
+ QOpenGLContext *openglContext() const;
+
+Q_SIGNALS:
+ void frameSwapped();
+ void sceneGraphInitialized();
+ void sceneGraphInvalidated();
+ void beforeSynchronizing();
+ void beforeRendering();
+ void afterRendering();
+ void colorChanged(const QColor &);
+
+public Q_SLOTS:
+ void update();
+ void releaseResources();
+
+protected:
+ QQuickWindow(QQuickWindowPrivate &dd, QWindow *parent = 0);
+
+ virtual void exposeEvent(QExposeEvent *);
+ virtual void resizeEvent(QResizeEvent *);
+
+ virtual void showEvent(QShowEvent *);
+ virtual void hideEvent(QHideEvent *);
+
+ virtual void focusInEvent(QFocusEvent *);
+ virtual void focusOutEvent(QFocusEvent *);
+
+ virtual bool event(QEvent *);
+ virtual void keyPressEvent(QKeyEvent *);
+ virtual void keyReleaseEvent(QKeyEvent *);
+ virtual void mousePressEvent(QMouseEvent *);
+ virtual void mouseReleaseEvent(QMouseEvent *);
+ virtual void mouseDoubleClickEvent(QMouseEvent *);
+ virtual void mouseMoveEvent(QMouseEvent *);
+#ifndef QT_NO_WHEELEVENT
+ virtual void wheelEvent(QWheelEvent *);
+#endif
+
+private Q_SLOTS:
+ void maybeUpdate();
+ void cleanupSceneGraph();
+
+private:
+ friend class QQuickItem;
+ friend class QQuickWindowRenderLoop;
+ Q_DISABLE_COPY(QQuickWindow)
+};
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(QQuickWindow *)
+
+QT_END_HEADER
+
+#endif // QQUICKWINDOW_H
+
**
****************************************************************************/
-#ifndef QQUICKCANVAS_P_H
-#define QQUICKCANVAS_P_H
+#ifndef QQUICKWINDOW_P_H
+#define QQUICKWINDOW_P_H
//
// W A R N I N G
//
#include "qquickitem.h"
-#include "qquickcanvas.h"
+#include "qquickwindow.h"
#include <private/qqmlguard_p.h>
#include <QtQuick/private/qsgcontext_p.h>
};
class QQuickItemPrivate;
-class QQuickCanvasPrivate;
+class QQuickWindowPrivate;
class QTouchEvent;
-class QQuickCanvasRenderLoop;
-class QQuickCanvasIncubationController;
+class QQuickWindowRenderLoop;
+class QQuickWindowIncubationController;
-class Q_QUICK_PRIVATE_EXPORT QQuickCanvasPrivate : public QWindowPrivate
+class Q_QUICK_PRIVATE_EXPORT QQuickWindowPrivate : public QWindowPrivate
{
public:
- Q_DECLARE_PUBLIC(QQuickCanvas)
+ Q_DECLARE_PUBLIC(QQuickWindow)
- static inline QQuickCanvasPrivate *get(QQuickCanvas *c) { return c->d_func(); }
+ static inline QQuickWindowPrivate *get(QQuickWindow *c) { return c->d_func(); }
- QQuickCanvasPrivate();
- virtual ~QQuickCanvasPrivate();
+ QQuickWindowPrivate();
+ virtual ~QQuickWindowPrivate();
- void init(QQuickCanvas *);
+ void init(QQuickWindow *);
void initRootItem();//Currently only used if items added in QML
QQuickRootItem *rootItem;
// Keeps track of which touch point (int) was last accepted by which item
QHash<int, QQuickItem *> itemForTouchPointId;
- mutable QQuickCanvasIncubationController *incubationController;
+ mutable QQuickWindowIncubationController *incubationController;
static bool dragOverThreshold(qreal d, Qt::Axis axis, QMouseEvent *event);
};
-Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickCanvasPrivate::FocusOptions)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickWindowPrivate::FocusOptions)
QT_END_NAMESPACE
-#endif // QQUICKCANVAS_P_H
+#endif // QQUICKWINDOW_P_H
#include <QtQml/private/qqmlglobal_p.h>
-#include <QtQuick/QQuickCanvas>
-#include <QtQuick/private/qquickcanvas_p.h>
+#include <QtQuick/QQuickWindow>
+#include <QtQuick/private/qquickwindow_p.h>
#include <QtQuick/private/qsgcontext_p.h>
QT_BEGIN_NAMESPACE
const QEvent::Type QEvent_DeferredUpdate = QEvent::Type(QEvent::User + 1);
-#define QQUICK_CANVAS_TIMING
-#ifdef QQUICK_CANVAS_TIMING
-static bool qquick_canvas_timing = !qgetenv("QML_CANVAS_TIMING").isEmpty();
+#define QQUICK_RENDER_TIMING
+#ifdef QQUICK_RENDER_TIMING
+static bool qquick_render_timing = !qgetenv("QML_RENDER_TIMING").isEmpty();
static QTime threadTimer;
static int syncTime;
static int renderTime;
, shouldExit(false)
, hasExited(false)
, isDeferredUpdatePosted(false)
- , canvasToGrab(0)
+ , windowToGrab(0)
{
sg->moveToThread(this);
void releaseResources() { }
- void show(QQuickCanvas *canvas);
- void hide(QQuickCanvas *canvas);
+ void show(QQuickWindow *window);
+ void hide(QQuickWindow *window);
- void canvasDestroyed(QQuickCanvas *canvas);
+ void windowDestroyed(QQuickWindow *window);
- void exposureChanged(QQuickCanvas *canvas);
- QImage grab(QQuickCanvas *canvas);
- void resize(QQuickCanvas *canvas, const QSize &size);
+ void exposureChanged(QQuickWindow *window);
+ QImage grab(QQuickWindow *window);
+ void resize(QQuickWindow *window, const QSize &size);
void handleDeferredUpdate();
- void maybeUpdate(QQuickCanvas *canvas);
- void update(QQuickCanvas *canvas) { maybeUpdate(canvas); } // identical for this implementation
+ void maybeUpdate(QQuickWindow *window);
+ void update(QQuickWindow *window) { maybeUpdate(window); } // identical for this implementation
void wakeup();
void startRendering();
void run();
- QQuickCanvas *masterCanvas() {
- QQuickCanvas *win = 0;
- for (QHash<QQuickCanvas *, CanvasData *>::const_iterator it = m_rendered_windows.constBegin();
+ QQuickWindow *masterWindow() {
+ QQuickWindow *win = 0;
+ for (QHash<QQuickWindow *, WindowData *>::const_iterator it = m_rendered_windows.constBegin();
it != m_rendered_windows.constEnd() && !win; ++it) {
if (it.value()->isVisible)
win = it.key();
public slots:
void animationStarted();
void animationStopped();
- void canvasVisibilityChanged();
+ void windowVisibilityChanged();
private:
void handleAddedWindows();
- void handleAddedWindow(QQuickCanvas *canvas);
+ void handleAddedWindow(QQuickWindow *window);
void handleRemovedWindows(bool clearGLContext = true);
QSGContext *sg;
uint hasExited : 1;
uint isDeferredUpdatePosted : 1;
- QQuickCanvas *canvasToGrab;
+ QQuickWindow *windowToGrab;
QImage grabContent;
- struct CanvasData {
+ struct WindowData {
QSize renderedSize;
QSize windowSize;
QSize viewportSize;
uint isVisible : 1;
};
- QHash<QQuickCanvas *, CanvasData *> m_rendered_windows;
+ QHash<QQuickWindow *, WindowData *> m_rendered_windows;
- struct CanvasTracker {
- QQuickCanvas *canvas;
+ struct WindowTracker {
+ QQuickWindow *window;
uint isVisible : 1;
uint toBeRemoved : 1;
};
- QList<CanvasTracker> m_tracked_windows;
+ QList<WindowTracker> m_tracked_windows;
- QList<QQuickCanvas *> m_removed_windows;
- QList<QQuickCanvas *> m_added_windows;
+ QList<QQuickWindow *> m_removed_windows;
+ QList<QQuickWindow *> m_added_windows;
};
public:
QQuickTrivialWindowManager();
- void show(QQuickCanvas *canvas);
- void hide(QQuickCanvas *canvas);
+ void show(QQuickWindow *window);
+ void hide(QQuickWindow *window);
- void canvasDestroyed(QQuickCanvas *canvas);
+ void windowDestroyed(QQuickWindow *window);
void initializeGL();
- void renderCanvas(QQuickCanvas *canvas);
- void exposureChanged(QQuickCanvas *canvas);
- QImage grab(QQuickCanvas *canvas);
- void resize(QQuickCanvas *canvas, const QSize &size);
+ void renderWindow(QQuickWindow *window);
+ void exposureChanged(QQuickWindow *window);
+ QImage grab(QQuickWindow *window);
+ void resize(QQuickWindow *window, const QSize &size);
void wakeup();
- void maybeUpdate(QQuickCanvas *canvas);
- void update(QQuickCanvas *canvas) { maybeUpdate(canvas); } // identical for this implementation.
+ void maybeUpdate(QQuickWindow *window);
+ void update(QQuickWindow *window) { maybeUpdate(window); } // identical for this implementation.
void releaseResources() { }
bool event(QEvent *);
- struct CanvasData {
+ struct WindowData {
bool updatePending : 1;
bool grabOnly : 1;
};
- QHash<QQuickCanvas *, CanvasData> m_windows;
+ QHash<QQuickWindow *, WindowData> m_windows;
QOpenGLContext *gl;
QSGContext *sg;
{
Q_ASSERT(m_rendered_windows.size());
- QQuickCanvas *win = masterCanvas();
+ QQuickWindow *win = masterWindow();
if (!win)
return;
gl->setFormat(win->requestedFormat());
gl->create();
if (!gl->makeCurrent(win))
- qWarning("QQuickCanvas: makeCurrent() failed...");
+ qWarning("QQuickWindow: makeCurrent() failed...");
Q_ASSERT(!sg->isReady());
sg->initialize(gl);
/*!
- This function is called when the canvas is created to register the canvas with
+ This function is called when the window is created to register the window with
the window manager.
Called on GUI Thread.
*/
-void QQuickRenderThreadSingleContextWindowManager::show(QQuickCanvas *canvas)
+void QQuickRenderThreadSingleContextWindowManager::show(QQuickWindow *window)
{
#ifdef THREAD_DEBUG
- printf("GUI: Canvas added to windowing system, %p, %dx%d\n", canvas, canvas->width(), canvas->height());
+ printf("GUI: Window added to windowing system, %p, %dx%d\n", window, window->width(), window->height());
#endif
- CanvasTracker tracker;
- tracker.canvas = canvas;
+ WindowTracker tracker;
+ tracker.window = window;
tracker.isVisible = false;
tracker.toBeRemoved = false;
m_tracked_windows << tracker;
- connect(canvas, SIGNAL(widthChanged(int)), this, SLOT(canvasVisibilityChanged()), Qt::DirectConnection);
- connect(canvas, SIGNAL(heightChanged(int)), this, SLOT(canvasVisibilityChanged()), Qt::DirectConnection);
+ connect(window, SIGNAL(widthChanged(int)), this, SLOT(windowVisibilityChanged()), Qt::DirectConnection);
+ connect(window, SIGNAL(heightChanged(int)), this, SLOT(windowVisibilityChanged()), Qt::DirectConnection);
- canvasVisibilityChanged();
+ windowVisibilityChanged();
}
-void QQuickRenderThreadSingleContextWindowManager::handleAddedWindow(QQuickCanvas *canvas)
+void QQuickRenderThreadSingleContextWindowManager::handleAddedWindow(QQuickWindow *window)
{
#ifdef THREAD_DEBUG
- printf(" RenderThread: adding canvas: %p\n", canvas);
+ printf(" RenderThread: adding window: %p\n", window);
#endif
- CanvasData *data = new CanvasData;
+ WindowData *data = new WindowData;
data->sizeWasChanged = false;
- data->windowSize = canvas->size();
- data->isVisible = canvas->isVisible();
- m_rendered_windows[canvas] = data;
+ data->windowSize = window->size();
+ data->isVisible = window->isVisible();
+ m_rendered_windows[window] = data;
isExternalUpdatePending = true;
}
#endif
while (m_added_windows.size()) {
- QQuickCanvas *canvas = m_added_windows.takeLast();
- handleAddedWindow(canvas);
+ QQuickWindow *window = m_added_windows.takeLast();
+ handleAddedWindow(window);
}
}
/*!
- Called on the GUI Thread, from the canvas' destructor
+ Called on the GUI Thread, from the window' destructor
*/
-void QQuickRenderThreadSingleContextWindowManager::canvasDestroyed(QQuickCanvas *canvas)
+void QQuickRenderThreadSingleContextWindowManager::windowDestroyed(QQuickWindow *window)
{
#ifdef THREAD_DEBUG
- printf("GUI: Canvas destroyed: %p\n", canvas);
+ printf("GUI: Window destroyed: %p\n", window);
#endif
- hide(canvas);
+ hide(window);
}
Called on GUI Thread
*/
-void QQuickRenderThreadSingleContextWindowManager::hide(QQuickCanvas *canvas)
+void QQuickRenderThreadSingleContextWindowManager::hide(QQuickWindow *window)
{
#ifdef THREAD_DEBUG
- printf("GUI: Canvas hidden: %p\n", canvas);
+ printf("GUI: Window hidden: %p\n", window);
#endif
int position = -1;
for (int i=0; i<m_tracked_windows.size(); ++i) {
- if (m_tracked_windows.at(i).canvas == canvas) {
+ if (m_tracked_windows.at(i).window == window) {
m_tracked_windows[i].toBeRemoved = true;
position = i;
break;
}
if (position >= 0) {
- disconnect(canvas, SIGNAL(widthChanged(int)), this, SLOT(canvasVisibilityChanged()));
- disconnect(canvas, SIGNAL(heightChanged(int)), this, SLOT(canvasVisibilityChanged()));
- canvasVisibilityChanged();
+ disconnect(window, SIGNAL(widthChanged(int)), this, SLOT(windowVisibilityChanged()));
+ disconnect(window, SIGNAL(heightChanged(int)), this, SLOT(windowVisibilityChanged()));
+ windowVisibilityChanged();
m_tracked_windows.removeAt(position);
}
#ifdef THREAD_DEBUG
- printf("GUI: Canvas removal completed... %p\n", canvas);
+ printf("GUI: Window removal completed... %p\n", window);
#endif
}
bool removedAnything = false;
while (m_removed_windows.size()) {
- QQuickCanvas *canvas = m_removed_windows.takeLast();
+ QQuickWindow *window = m_removed_windows.takeLast();
#ifdef THREAD_DEBUG
- printf(" RenderThread: removing %p\n", canvas);
+ printf(" RenderThread: removing %p\n", window);
#endif
- QQuickCanvasPrivate::get(canvas)->cleanupNodesOnShutdown();
- delete m_rendered_windows.take(canvas);
+ QQuickWindowPrivate::get(window)->cleanupNodesOnShutdown();
+ delete m_rendered_windows.take(window);
removedAnything = true;
}
Called on GUI Thread
*/
-void QQuickRenderThreadSingleContextWindowManager::canvasVisibilityChanged()
+void QQuickRenderThreadSingleContextWindowManager::windowVisibilityChanged()
{
bool anyoneShowing = false;
- QList<QQuickCanvas *> toAdd, toRemove;
+ QList<QQuickWindow *> toAdd, toRemove;
// Not optimal, but also not frequently used...
for (int i=0; i<m_tracked_windows.size(); ++i) {
- CanvasTracker &t = const_cast<CanvasTracker &>(m_tracked_windows.at(i));
- QQuickCanvas *win = t.canvas;
+ WindowTracker &t = const_cast<WindowTracker &>(m_tracked_windows.at(i));
+ QQuickWindow *win = t.window;
- Q_ASSERT(win->isVisible() || QQuickCanvasPrivate::get(win)->renderWithoutShowing || t.toBeRemoved);
- bool canvasVisible = win->width() > 0 && win->height() > 0;
- anyoneShowing |= (canvasVisible && !t.toBeRemoved);
+ Q_ASSERT(win->isVisible() || QQuickWindowPrivate::get(win)->renderWithoutShowing || t.toBeRemoved);
+ bool windowVisible = win->width() > 0 && win->height() > 0;
+ anyoneShowing |= (windowVisible && !t.toBeRemoved);
- if ((!canvasVisible && t.isVisible) || t.toBeRemoved) {
+ if ((!windowVisible && t.isVisible) || t.toBeRemoved) {
toRemove << win;
- } else if (canvasVisible && !t.isVisible) {
+ } else if (windowVisible && !t.isVisible) {
toAdd << win;
}
- t.isVisible = canvasVisible;
+ t.isVisible = windowVisible;
}
if (isRunning()) {
#ifdef THREAD_DEBUG
printf(" RenderThread: Doing locked sync\n");
#endif
-#ifdef QQUICK_CANVAS_TIMING
- if (qquick_canvas_timing)
+#ifdef QQUICK_RENDER_TIMING
+ if (qquick_render_timing)
threadTimer.start();
#endif
inSync = true;
- for (QHash<QQuickCanvas *, CanvasData *>::const_iterator it = m_rendered_windows.constBegin();
+ for (QHash<QQuickWindow *, WindowData *>::const_iterator it = m_rendered_windows.constBegin();
it != m_rendered_windows.constEnd(); ++it) {
- QQuickCanvas *canvas = it.key();
+ QQuickWindow *window = it.key();
#ifdef THREAD_DEBUG
- printf(" RenderThread: Syncing canvas: %p\n", canvas);
+ printf(" RenderThread: Syncing window: %p\n", window);
#endif
- CanvasData *canvasData = it.value();
- QQuickCanvasPrivate *canvasPrivate = QQuickCanvasPrivate::get(canvas);
+ WindowData *windowData = it.value();
+ QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(window);
- Q_ASSERT(canvasData->windowSize.width() > 0 && canvasData->windowSize.height() > 0);
+ Q_ASSERT(windowData->windowSize.width() > 0 && windowData->windowSize.height() > 0);
- if (!canvasData->isVisible)
- gl->makeCurrent(masterCanvas());
+ if (!windowData->isVisible)
+ gl->makeCurrent(masterWindow());
else
- gl->makeCurrent(canvas);
+ gl->makeCurrent(window);
- if (canvasData->viewportSize != canvasData->windowSize) {
+ if (windowData->viewportSize != windowData->windowSize) {
#ifdef THREAD_DEBUG
printf(" RenderThread: --- window has changed size...\n");
#endif
- canvasData->viewportSize = canvasData->windowSize;
- canvasData->sizeWasChanged = true;
- glViewport(0, 0, canvasData->viewportSize.width(), canvasData->viewportSize.height());
+ windowData->viewportSize = windowData->windowSize;
+ windowData->sizeWasChanged = true;
+ glViewport(0, 0, windowData->viewportSize.width(), windowData->viewportSize.height());
}
- canvasPrivate->syncSceneGraph();
+ windowPrivate->syncSceneGraph();
}
inSync = false;
#ifdef THREAD_DEBUG
printf(" RenderThread: sync done\n");
#endif
-#ifdef QQUICK_CANVAS_TIMING
- if (qquick_canvas_timing)
+#ifdef QQUICK_RENDER_TIMING
+ if (qquick_render_timing)
syncTime = threadTimer.elapsed();
#endif
- for (QHash<QQuickCanvas *, CanvasData *>::const_iterator it = m_rendered_windows.constBegin();
+ for (QHash<QQuickWindow *, WindowData *>::const_iterator it = m_rendered_windows.constBegin();
it != m_rendered_windows.constEnd(); ++it) {
- QQuickCanvas *canvas = it.key();
- CanvasData *canvasData = it.value();
- QQuickCanvasPrivate *canvasPrivate = QQuickCanvasPrivate::get(canvas);
+ QQuickWindow *window = it.key();
+ WindowData *windowData = it.value();
+ QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(window);
#ifdef THREAD_DEBUG
- printf(" RenderThread: Rendering canvas %p\n", canvas);
+ printf(" RenderThread: Rendering window %p\n", window);
#endif
- Q_ASSERT(canvasData->windowSize.width() > 0 && canvasData->windowSize.height() > 0);
+ Q_ASSERT(windowData->windowSize.width() > 0 && windowData->windowSize.height() > 0);
#ifdef THREAD_DEBUG
printf(" RenderThread: --- rendering at size %dx%d\n",
- canvasData->viewportSize.width(), canvasData->viewportSize.height()
+ windowData->viewportSize.width(), windowData->viewportSize.height()
);
#endif
// We only need to re-makeCurrent when we have multiple surfaces.
if (m_rendered_windows.size() > 1)
- gl->makeCurrent(canvas);
+ gl->makeCurrent(window);
- canvasPrivate->renderSceneGraph(canvasData->viewportSize);
-#ifdef QQUICK_CANVAS_TIMING
- if (qquick_canvas_timing)
+ windowPrivate->renderSceneGraph(windowData->viewportSize);
+#ifdef QQUICK_RENDER_TIMING
+ if (qquick_render_timing)
renderTime = threadTimer.elapsed() - syncTime;
#endif
// The content of the target buffer is undefined after swap() so grab needs
// to happen before swap();
- if (canvas == canvasToGrab) {
+ if (window == windowToGrab) {
#ifdef THREAD_DEBUG
printf(" RenderThread: --- grabbing...\n");
#endif
- grabContent = qt_gl_read_framebuffer(canvasData->windowSize, false, false);
- canvasToGrab = 0;
+ grabContent = qt_gl_read_framebuffer(windowData->windowSize, false, false);
+ windowToGrab = 0;
}
#ifdef THREAD_DEBUG
printf(" RenderThread: --- wait for swap...\n");
#endif
- if (canvasData->isVisible && canvas->isExposed())
- gl->swapBuffers(canvas);
+ if (windowData->isVisible && window->isExposed())
+ gl->swapBuffers(window);
- canvasPrivate->fireFrameSwapped();
+ windowPrivate->fireFrameSwapped();
#ifdef THREAD_DEBUG
printf(" RenderThread: --- swap complete...\n");
#endif
}
-#ifdef QQUICK_CANVAS_TIMING
- if (qquick_canvas_timing) {
+#ifdef QQUICK_RENDER_TIMING
+ if (qquick_render_timing) {
swapTime = threadTimer.elapsed() - renderTime;
qDebug() << "- Breakdown of frame time; sync:" << syncTime
<< "ms render:" << renderTime << "ms swap:" << swapTime
handleRemovedWindows();
// Update sizes...
- for (QHash<QQuickCanvas *, CanvasData *>::const_iterator it = m_rendered_windows.constBegin();
+ for (QHash<QQuickWindow *, WindowData *>::const_iterator it = m_rendered_windows.constBegin();
it != m_rendered_windows.constEnd(); ++it) {
- CanvasData *canvasData = it.value();
- if (canvasData->sizeWasChanged) {
- canvasData->renderedSize = canvasData->viewportSize;
- canvasData->sizeWasChanged = false;
+ WindowData *windowData = it.value();
+ if (windowData->sizeWasChanged) {
+ windowData->renderedSize = windowData->viewportSize;
+ windowData->sizeWasChanged = false;
}
}
// but we don't want to lock an extra time.
wake();
- if (!animationRunning && !isExternalUpdatePending && !shouldExit && !canvasToGrab) {
+ if (!animationRunning && !isExternalUpdatePending && !shouldExit && !windowToGrab) {
#ifdef THREAD_DEBUG
printf(" RenderThread: nothing to do, going to sleep...\n");
#endif
if (e->type() == QEvent_Sync) {
- // If all canvases have been hidden, ignore the event
+ // If all windows have been hidden, ignore the event
if (!isRunning())
return true;
if (!guiAlreadyLocked)
lockInGui();
- for (QHash<QQuickCanvas *, CanvasData *>::const_iterator it = m_rendered_windows.constBegin();
+ for (QHash<QQuickWindow *, WindowData *>::const_iterator it = m_rendered_windows.constBegin();
it != m_rendered_windows.constEnd(); ++it) {
- QQuickCanvasPrivate::get(it.key())->polishItems();
+ QQuickWindowPrivate::get(it.key())->polishItems();
}
wake();
}
-void QQuickRenderThreadSingleContextWindowManager::exposureChanged(QQuickCanvas *canvas)
+void QQuickRenderThreadSingleContextWindowManager::exposureChanged(QQuickWindow *window)
{
- Q_UNUSED(canvas);
+ Q_UNUSED(window);
#ifdef THREAD_DEBUG
- printf("GUI: exposure changed: %p\n", canvas);
+ printf("GUI: exposure changed: %p\n", window);
#endif
- if (canvas->isExposed())
- maybeUpdate(canvas);
+ if (window->isExposed())
+ maybeUpdate(window);
#ifdef THREAD_DEBUG
- printf("GUI: exposure changed done: %p\n", canvas);
+ printf("GUI: exposure changed done: %p\n", window);
#endif
}
-void QQuickRenderThreadSingleContextWindowManager::resize(QQuickCanvas *canvas, const QSize &size)
+void QQuickRenderThreadSingleContextWindowManager::resize(QQuickWindow *window, const QSize &size)
{
#ifdef THREAD_DEBUG
- printf("GUI: Resize Event: %p = %dx%d\n", canvas, size.width(), size.height());
+ printf("GUI: Resize Event: %p = %dx%d\n", window, size.width(), size.height());
#endif
// If the rendering thread is not running we do not need to do anything.
- // Also if the canvas is being resized to an invalid size, it will be removed
- // by the canvasVisibilityChanged slot as result of width/heightcChanged()
+ // Also if the window is being resized to an invalid size, it will be removed
+ // by the windowVisibilityChanged slot as result of width/heightcChanged()
if (!isRunning() || size.width() <= 0 || size.height() <= 0)
return;
lockInGui();
exhaustSyncEvent();
- CanvasData *canvasData = m_rendered_windows.value(canvas);
- if (canvasData) {
- canvasData->windowSize = size;
- while (isRunning() && canvasData->renderedSize != size && size.width() > 0 && size.height() > 0) {
+ WindowData *windowData = m_rendered_windows.value(window);
+ if (windowData) {
+ windowData->windowSize = size;
+ while (isRunning() && windowData->renderedSize != size && size.width() > 0 && size.height() > 0) {
if (isRenderBlocked)
wake();
wait();
unlockInGui();
#ifdef THREAD_DEBUG
- printf("GUI: Resize done: %p\n", canvas);
+ printf("GUI: Resize done: %p\n", window);
#endif
}
-QImage QQuickRenderThreadSingleContextWindowManager::grab(QQuickCanvas *canvas)
+QImage QQuickRenderThreadSingleContextWindowManager::grab(QQuickWindow *window)
{
if (!isRunning())
return QImage();
if (QThread::currentThread() != qApp->thread()) {
- qWarning("QQuickCanvas::grabFrameBuffer: can only be called from the GUI thread");
+ qWarning("QQuickWindow::grabFrameBuffer: can only be called from the GUI thread");
return QImage();
}
lockInGui();
exhaustSyncEvent();
- canvasToGrab = canvas;
- while (isRunning() && canvasToGrab) {
+ windowToGrab = window;
+ while (isRunning() && windowToGrab) {
if (isRenderBlocked)
wake();
wait();
unlockInGui();
}
-void QQuickRenderThreadSingleContextWindowManager::maybeUpdate(QQuickCanvas *)
+void QQuickRenderThreadSingleContextWindowManager::maybeUpdate(QQuickWindow *)
{
Q_ASSERT_X(QThread::currentThread() == QCoreApplication::instance()->thread() || inSync,
- "QQuickCanvas::update",
+ "QQuickWindow::update",
"Function can only be called from GUI thread or during QQuickItem::updatePaintNode()");
if (inSync) {
}
-void QQuickTrivialWindowManager::show(QQuickCanvas *canvas)
+void QQuickTrivialWindowManager::show(QQuickWindow *window)
{
- CanvasData data;
+ WindowData data;
data.updatePending = false;
data.grabOnly = false;
- m_windows[canvas] = data;
+ m_windows[window] = data;
- maybeUpdate(canvas);
+ maybeUpdate(window);
}
-void QQuickTrivialWindowManager::hide(QQuickCanvas *canvas)
+void QQuickTrivialWindowManager::hide(QQuickWindow *window)
{
- if (!m_windows.contains(canvas))
+ if (!m_windows.contains(window))
return;
- m_windows.remove(canvas);
- QQuickCanvasPrivate *cd = QQuickCanvasPrivate::get(canvas);
+ m_windows.remove(window);
+ QQuickWindowPrivate *cd = QQuickWindowPrivate::get(window);
cd->cleanupNodesOnShutdown();
if (m_windows.size() == 0) {
}
}
-void QQuickTrivialWindowManager::canvasDestroyed(QQuickCanvas *canvas)
+void QQuickTrivialWindowManager::windowDestroyed(QQuickWindow *window)
{
- hide(canvas);
+ hide(window);
}
-void QQuickTrivialWindowManager::renderCanvas(QQuickCanvas *canvas)
+void QQuickTrivialWindowManager::renderWindow(QQuickWindow *window)
{
- if (!canvas->isExposed() || !m_windows.contains(canvas))
+ if (!window->isExposed() || !m_windows.contains(window))
return;
- CanvasData &data = const_cast<CanvasData &>(m_windows[canvas]);
+ WindowData &data = const_cast<WindowData &>(m_windows[window]);
- QQuickCanvas *masterCanvas = 0;
- if (!canvas->isVisible()) {
+ QQuickWindow *masterWindow = 0;
+ if (!window->isVisible()) {
// Find a "proper surface" to bind...
- for (QHash<QQuickCanvas *, CanvasData>::const_iterator it = m_windows.constBegin();
- it != m_windows.constEnd() && !masterCanvas; ++it) {
+ for (QHash<QQuickWindow *, WindowData>::const_iterator it = m_windows.constBegin();
+ it != m_windows.constEnd() && !masterWindow; ++it) {
if (it.key()->isVisible())
- masterCanvas = it.key();
+ masterWindow = it.key();
}
} else {
- masterCanvas = canvas;
+ masterWindow = window;
}
- if (!masterCanvas)
+ if (!masterWindow)
return;
if (!gl) {
gl = new QOpenGLContext();
- gl->setFormat(masterCanvas->requestedFormat());
+ gl->setFormat(masterWindow->requestedFormat());
gl->create();
- if (!gl->makeCurrent(masterCanvas))
- qWarning("QQuickCanvas: makeCurrent() failed...");
+ if (!gl->makeCurrent(masterWindow))
+ qWarning("QQuickWindow: makeCurrent() failed...");
sg->initialize(gl);
} else {
- gl->makeCurrent(masterCanvas);
+ gl->makeCurrent(masterWindow);
}
bool alsoSwap = data.updatePending;
data.updatePending = false;
- QQuickCanvasPrivate *cd = QQuickCanvasPrivate::get(canvas);
+ QQuickWindowPrivate *cd = QQuickWindowPrivate::get(window);
cd->polishItems();
cd->syncSceneGraph();
- cd->renderSceneGraph(canvas->size());
+ cd->renderSceneGraph(window->size());
if (data.grabOnly) {
- grabContent = qt_gl_read_framebuffer(canvas->size(), false, false);
+ grabContent = qt_gl_read_framebuffer(window->size(), false, false);
data.grabOnly = false;
}
- if (alsoSwap && canvas->isVisible()) {
- gl->swapBuffers(canvas);
+ if (alsoSwap && window->isVisible()) {
+ gl->swapBuffers(window);
cd->fireFrameSwapped();
}
// Might have been set during syncSceneGraph()
if (data.updatePending)
- maybeUpdate(canvas);
+ maybeUpdate(window);
}
-void QQuickTrivialWindowManager::exposureChanged(QQuickCanvas *canvas)
+void QQuickTrivialWindowManager::exposureChanged(QQuickWindow *window)
{
- if (canvas->isExposed())
- maybeUpdate(canvas);
+ if (window->isExposed())
+ maybeUpdate(window);
}
-QImage QQuickTrivialWindowManager::grab(QQuickCanvas *canvas)
+QImage QQuickTrivialWindowManager::grab(QQuickWindow *window)
{
- if (!m_windows.contains(canvas))
+ if (!m_windows.contains(window))
return QImage();
- m_windows[canvas].grabOnly = true;
+ m_windows[window].grabOnly = true;
- renderCanvas(canvas);
+ renderWindow(window);
QImage grabbed = grabContent;
grabContent = QImage();
-void QQuickTrivialWindowManager::resize(QQuickCanvas *, const QSize &)
+void QQuickTrivialWindowManager::resize(QQuickWindow *, const QSize &)
{
}
-void QQuickTrivialWindowManager::maybeUpdate(QQuickCanvas *canvas)
+void QQuickTrivialWindowManager::maybeUpdate(QQuickWindow *window)
{
- if (!m_windows.contains(canvas))
+ if (!m_windows.contains(window))
return;
- m_windows[canvas].updatePending = true;
+ m_windows[window].updatePending = true;
if (!eventPending) {
QCoreApplication::postEvent(this, new QEvent(QEvent::User));
{
if (e->type() == QEvent::User) {
eventPending = false;
- for (QHash<QQuickCanvas *, CanvasData>::const_iterator it = m_windows.constBegin();
+ for (QHash<QQuickWindow *, WindowData>::const_iterator it = m_windows.constBegin();
it != m_windows.constEnd(); ++it) {
- const CanvasData &data = it.value();
+ const WindowData &data = it.value();
if (data.updatePending)
- renderCanvas(it.key());
+ renderWindow(it.key());
}
return true;
}
QT_BEGIN_NAMESPACE
-class QQuickCanvas;
+class QQuickWindow;
class QSGContext;
class Q_QUICK_PRIVATE_EXPORT QQuickWindowManager
public:
virtual ~QQuickWindowManager();
- virtual void show(QQuickCanvas *canvas) = 0;
- virtual void hide(QQuickCanvas *canvas) = 0;
+ virtual void show(QQuickWindow *window) = 0;
+ virtual void hide(QQuickWindow *window) = 0;
- virtual void canvasDestroyed(QQuickCanvas *canvas) = 0;
+ virtual void windowDestroyed(QQuickWindow *window) = 0;
- virtual void exposureChanged(QQuickCanvas *canvas) = 0;
- virtual QImage grab(QQuickCanvas *canvas) = 0;
- virtual void resize(QQuickCanvas *canvas, const QSize &size) = 0;
+ virtual void exposureChanged(QQuickWindow *window) = 0;
+ virtual QImage grab(QQuickWindow *window) = 0;
+ virtual void resize(QQuickWindow *window, const QSize &size) = 0;
- virtual void update(QQuickCanvas *canvas) = 0;
- virtual void maybeUpdate(QQuickCanvas *canvas) = 0;
+ virtual void update(QQuickWindow *window) = 0;
+ virtual void maybeUpdate(QQuickWindow *window) = 0;
virtual void wakeup() = 0;
virtual volatile bool *allowMainThreadProcessing() = 0;
#include "qquickwindowmodule_p.h"
#include "qquickscreen_p.h"
-#include <QtQuick/QQuickCanvas>
+#include <QtQuick/QQuickWindow>
QT_BEGIN_NAMESPACE
{
const char uri[] = "QtQuick.Window";
- qmlRegisterType<QQuickCanvas>(uri, 2, 0, "Window");
+ qmlRegisterType<QQuickWindow>(uri, 2, 0, "Window");
qmlRegisterUncreatableType<QQuickScreen>(uri, 2, 0, "Screen", QStringLiteral("Screen can only be used via the attached property."));
}
}
-QSGTexture *QSGContext::textureForFactory(QQuickTextureFactory *factory, QQuickCanvas *canvas)
+QSGTexture *QSGContext::textureForFactory(QQuickTextureFactory *factory, QQuickWindow *window)
{
Q_D(QSGContext);
if (!factory)
if (QQuickDefaultTextureFactory *dtf = qobject_cast<QQuickDefaultTextureFactory *>(factory))
texture = createTexture(dtf->image());
else
- texture = factory->createTexture(canvas);
+ texture = factory->createTexture(window);
d->textures.insert(factory, texture);
connect(factory, SIGNAL(destroyed(QObject *)), this, SLOT(textureFactoryDestroyed(QObject *)), Qt::DirectConnection);
}
class QSGGlyphNode;
class QSGRenderer;
class QSGDistanceFieldGlyphCache;
-class QQuickCanvas;
+class QQuickWindow;
class QSGTexture;
class QSGMaterial;
class QSGMaterialShader;
virtual QSurfaceFormat defaultSurfaceFormat() const;
- QSGTexture *textureForFactory(QQuickTextureFactory *factory, QQuickCanvas *canvas);
+ QSGTexture *textureForFactory(QQuickTextureFactory *factory, QQuickWindow *window);
static QSGContext *createDefaultContext();
#include <qpa/qplatformsharedgraphicscache.h>
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
// #define QSGSHAREDDISTANCEFIELDGLYPHCACHE_DEBUG
this, SLOT(reportItemsInvalidated(QByteArray,QVector<quint32>)),
Qt::DirectConnection);
- QQuickCanvas *canvas = static_cast<QQuickCanvas *>(c->surface());
- Q_ASSERT(canvas != 0);
+ QQuickWindow *window = static_cast<QQuickWindow *>(c->surface());
+ Q_ASSERT(window != 0);
- connect(canvas, SIGNAL(beforeSynchronizing()), this, SLOT(sceneGraphUpdateStarted()),
+ connect(window, SIGNAL(beforeSynchronizing()), this, SLOT(sceneGraphUpdateStarted()),
Qt::DirectConnection);
- connect(canvas, SIGNAL(beforeRendering()), this, SLOT(sceneGraphUpdateDone()),
+ connect(window, SIGNAL(beforeRendering()), this, SLOT(sceneGraphUpdateDone()),
Qt::DirectConnection);
}
masks. The scene graph backend provides a default implementation
of normal color textures. As the implementation of these may be
hardware specific, they are are constructed via the factory
- function QQuickCanvas::createTextureFromImage().
+ function QQuickWindow::createTextureFromImage().
The texture is a wrapper around an OpenGL texture, which texture
id is given by textureId() and which size in pixels is given by
class QQuickImageProviderPrivate;
class QSGTexture;
-class QQuickCanvas;
+class QQuickWindow;
class Q_QUICK_EXPORT QQuickTextureFactory : public QObject
{
QQuickTextureFactory();
virtual ~QQuickTextureFactory();
- virtual QSGTexture *createTexture(QQuickCanvas *canvas) const = 0;
+ virtual QSGTexture *createTexture(QQuickWindow *window) const = 0;
virtual QSize textureSize() const = 0;
virtual int textureByteCount() const = 0;
virtual QImage image() const;
return url.toString(QUrl::RemoveScheme | QUrl::RemoveAuthority).mid(1);
}
-QSGTexture *QQuickDefaultTextureFactory::createTexture(QQuickCanvas *) const
+QSGTexture *QQuickDefaultTextureFactory::createTexture(QQuickWindow *) const
{
QSGPlainTexture *t = new QSGPlainTexture();
t->setImage(im);
{
}
- QSGTexture *createTexture(QQuickCanvas *canvas) const;
+ QSGTexture *createTexture(QQuickWindow *window) const;
QSize textureSize() const { return im.size(); }
int textureByteCount() const { return im.byteCount(); }
QImage image() const { return im; }
QQuickView* createView(const QUrl &filename, int additionalWait=0)
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *view = new QQuickView(0);
- canvas->setSource(filename);
- if (canvas->status() != QQuickView::Ready)
+ view->setSource(filename);
+ if (view->status() != QQuickView::Ready)
return 0;
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ view->show();
+ QTest::qWaitForWindowShown(view);
if (additionalWait)
QTest::qWait(additionalWait);
- return canvas;
+ return view;
}
void ensureAnimTime(int requiredTime, QAbstractAnimation* anim)//With consistentTiming, who knows how long an animation really takes...
QQmlEngine engine;
- QQuickCanvas *canvas;
+ QQuickWindow *window;
};
-tst_examples::tst_examples() : canvas(0)
+tst_examples::tst_examples() : window(0)
{
// Add files to exclude here
excludedFiles << "examples/quick/canvas/tiger/tiger.qml"; // QTBUG-26528
tst_examples::~tst_examples()
{
- delete canvas;
+ delete window;
}
void tst_examples::init()
component.completeCreate();
QVERIFY(root);
- if (!canvas) {
- canvas = new QQuickCanvas();
- canvas->resize(240, 320);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ if (!window) {
+ window = new QQuickWindow();
+ window->resize(240, 320);
+ window->show();
+ QTest::qWaitForWindowShown(window);
}
- root->setParentItem(canvas->rootItem());
+ root->setParentItem(window->rootItem());
component.completeCreate();
qApp->processEvents();
component.completeCreate();
QVERIFY(root);
- if (!canvas) {
- canvas = new QQuickCanvas();
- canvas->resize(240, 320);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ if (!window) {
+ window = new QQuickWindow();
+ window->resize(240, 320);
+ window->show();
+ QTest::qWaitForWindowShown(window);
}
- root->setParentItem(canvas->rootItem());
+ root->setParentItem(window->rootItem());
component.completeCreate();
qApp->processEvents();
QAI app = QAI(QAccessible::queryAccessibleInterface(qApp));
QCOMPARE(app->childCount(), 0);
- QQuickView *canvas = new QQuickView();
- canvas->setSource(testFileUrl("statictext.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView();
+ window->setSource(testFileUrl("statictext.qml"));
+ window->show();
QCOMPARE(app->childCount(), 1);
- QAI iface = QAI(QAccessible::queryAccessibleInterface(canvas));
+ QAI iface = QAI(QAccessible::queryAccessibleInterface(window));
QVERIFY(iface.data());
QCOMPARE(iface->childCount(), 1);
QCOMPARE(iface->indexOfChild(text2.data()), -1);
QCOMPARE(text2->indexOfChild(item.data()), -1);
- delete canvas;
+ delete window;
}
QAI topLevelChildAt(QAccessibleInterface *iface, int x, int y)
void tst_QQuickAccessible::hitTest()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("hittest.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("hittest.qml"));
+ window->show();
- QAI canvasIface = QAI(QAccessible::queryAccessibleInterface(canvas));
- QVERIFY(canvasIface.data());
- QAI rootItem = QAI(canvasIface->child(0));
+ QAI windowIface = QAI(QAccessible::queryAccessibleInterface(window));
+ QVERIFY(windowIface.data());
+ QAI rootItem = QAI(windowIface->child(0));
QRect rootRect = rootItem->rect();
// check the root item from app
QVERIFY(rect201);
QRect rect201Rect = rect201->rect();
- rootItemIface = QAI(canvasIface->childAt(rect201Rect.x() + 20, rect201Rect.y() + 20));
+ rootItemIface = QAI(windowIface->childAt(rect201Rect.x() + 20, rect201Rect.y() + 20));
QVERIFY(rootItemIface);
QCOMPARE(rootItemIface->rect(), rect201Rect);
QCOMPARE(rootItemIface->text(QAccessible::Name), QLatin1String("rect201"));
- delete canvas;
+ delete window;
}
void tst_QQuickAccessible::checkableTest()
{
- QQuickView *canvas = new QQuickView();
- canvas->setSource(testFileUrl("checkbuttons.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView();
+ window->setSource(testFileUrl("checkbuttons.qml"));
+ window->show();
- QAI iface = QAI(QAccessible::queryAccessibleInterface(canvas));
+ QAI iface = QAI(QAccessible::queryAccessibleInterface(window));
QVERIFY(iface.data());
QAI root = QAI(iface->child(0));
void tst_qquickanimatedimage::cleanup()
{
- QQuickCanvas canvas;
- canvas.releaseResources();
+ QQuickWindow window;
+ window.releaseResources();
}
void tst_qquickanimatedimage::play()
{
// test where mirror is set to true after animation has started
- QQuickView canvas;
- canvas.show();
+ QQuickView window;
+ window.show();
- canvas.setSource(testFileUrl("hearts.qml"));
- QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(canvas.rootObject());
+ window.setSource(testFileUrl("hearts.qml"));
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(window.rootObject());
QVERIFY(anim);
int width = anim->property("width").toInt();
QCOMPARE(anim->currentFrame(), 0);
- QPixmap frame0 = QPixmap::fromImage(canvas.grabFrameBuffer());
+ QPixmap frame0 = QPixmap::fromImage(window.grabWindow());
anim->setCurrentFrame(1);
- QPixmap frame1 = QPixmap::fromImage(canvas.grabFrameBuffer());
+ QPixmap frame1 = QPixmap::fromImage(window.grabWindow());
anim->setCurrentFrame(0);
anim->setProperty("mirror", true);
QCOMPARE(anim->currentFrame(), 1);
- QPixmap frame1_flipped = QPixmap::fromImage(canvas.grabFrameBuffer());
+ QPixmap frame1_flipped = QPixmap::fromImage(window.grabWindow());
QTRY_VERIFY(spy.count() == 1); spy.clear();
QCOMPARE(anim->currentFrame(), 0); // animation only has 2 frames, should cycle back to first
- QPixmap frame0_flipped = QPixmap::fromImage(canvas.grabFrameBuffer());
+ QPixmap frame0_flipped = QPixmap::fromImage(window.grabWindow());
QSKIP("Skip while QTBUG-19351 and QTBUG-19252 are not resolved");
{
QFETCH(QUrl, fileUrl);
- QQuickView canvas;
- canvas.show();
+ QQuickView window;
+ window.show();
- canvas.setSource(fileUrl);
- QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(canvas.rootObject());
+ window.setSource(fileUrl);
+ QQuickAnimatedImage *anim = qobject_cast<QQuickAnimatedImage *>(window.rootObject());
QVERIFY(anim);
int width = anim->property("width").toInt();
- QPixmap screenshot = QPixmap::fromImage(canvas.grabFrameBuffer());
+ QPixmap screenshot = QPixmap::fromImage(window.grabWindow());
QTransform transform;
transform.translate(width, 0).scale(-1, 1.0);
bool paused = anim->isPlaying();
anim->setProperty("mirror", true);
- screenshot = QPixmap::fromImage(canvas.grabFrameBuffer());
+ screenshot = QPixmap::fromImage(window.grabWindow());
QCOMPARE(screenshot, expected);
void tst_qquickanimatedsprite::test_properties()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
- canvas->setSource(testFileUrl("basic.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("basic.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QVERIFY(canvas->rootObject());
- QQuickAnimatedSprite* sprite = canvas->rootObject()->findChild<QQuickAnimatedSprite*>("sprite");
+ QVERIFY(window->rootObject());
+ QQuickAnimatedSprite* sprite = window->rootObject()->findChild<QQuickAnimatedSprite*>("sprite");
QVERIFY(sprite);
QVERIFY(sprite->running());
sprite->setInterpolate(false);
QVERIFY(!sprite->interpolate());
- delete canvas;
+ delete window;
}
void tst_qquickanimatedsprite::test_frameChangedSignal()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
- canvas->setSource(testFileUrl("frameChange.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("frameChange.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QVERIFY(canvas->rootObject());
- QQuickAnimatedSprite* sprite = canvas->rootObject()->findChild<QQuickAnimatedSprite*>("sprite");
+ QVERIFY(window->rootObject());
+ QQuickAnimatedSprite* sprite = window->rootObject()->findChild<QQuickAnimatedSprite*>("sprite");
QVERIFY(sprite);
QVERIFY(!sprite->running());
QTRY_COMPARE(frameChangedSpy.count(), 3*6);
QTRY_VERIFY(!sprite->running());
- delete canvas;
+ delete window;
}
QTEST_MAIN(tst_qquickanimatedsprite)
"}", QUrl::fromLocalFile(""));
QQuickItem *item = qobject_cast<QQuickItem *>(component.create());
QVERIFY(item);
- QQuickCanvas canvas;
- item->setParentItem(canvas.rootItem());
+ QQuickWindow window;
+ item->setParentItem(window.rootItem());
// not active
QVERIFY(!item->property("active").toBool());
QVERIFY(!item->property("active2").toBool());
// active
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
- QVERIFY(QGuiApplication::focusWindow() == &canvas);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
+ QVERIFY(QGuiApplication::focusWindow() == &window);
QVERIFY(item->property("active").toBool());
QVERIFY(item->property("active2").toBool());
// not active again
QWindowSystemInterface::handleWindowActivated(0);
- QTRY_VERIFY(QGuiApplication::focusWindow() != &canvas);
+ QTRY_VERIFY(QGuiApplication::focusWindow() != &window);
QVERIFY(!item->property("active").toBool());
QVERIFY(!item->property("active2").toBool());
}
void tst_qquickborderimage::cleanup()
{
- QQuickCanvas canvas;
- canvas.releaseResources();
+ QQuickWindow window;
+ window.releaseResources();
engine.clearComponentCache();
}
void tst_qquickborderimage::mirror()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("mirror.qml"));
- QQuickBorderImage *image = qobject_cast<QQuickBorderImage*>(canvas->rootObject());
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("mirror.qml"));
+ QQuickBorderImage *image = qobject_cast<QQuickBorderImage*>(window->rootObject());
QVERIFY(image != 0);
- QImage screenshot = canvas->grabFrameBuffer();
+ QImage screenshot = window->grabWindow();
QImage srcPixmap(screenshot);
QTransform transform;
srcPixmap = srcPixmap.transformed(transform);
image->setProperty("mirror", true);
- screenshot = canvas->grabFrameBuffer();
+ screenshot = window->grabWindow();
QCOMPARE(screenshot, srcPixmap);
- delete canvas;
+ delete window;
}
void tst_qquickborderimage::tileModes()
void tst_QQuickDrag::active()
{
- QQuickCanvas canvas;
- TestDropTarget dropTarget(canvas.rootItem());
+ QQuickWindow window;
+ TestDropTarget dropTarget(window.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QQmlComponent component(&engine);
component.setData(
void tst_QQuickDrag::drop()
{
- QQuickCanvas canvas;
- TestDropTarget outerTarget(canvas.rootItem());
+ QQuickWindow window;
+ TestDropTarget outerTarget(window.rootItem());
outerTarget.setSize(QSizeF(100, 100));
outerTarget.acceptAction = Qt::CopyAction;
TestDropTarget innerTarget(&outerTarget);
void tst_QQuickDrag::move()
{
- QQuickCanvas canvas;
- TestDropTarget outerTarget(canvas.rootItem());
+ QQuickWindow window;
+ TestDropTarget outerTarget(window.rootItem());
outerTarget.setSize(QSizeF(100, 100));
TestDropTarget leftTarget(&outerTarget);
leftTarget.setPos(QPointF(0, 35));
void tst_QQuickDrag::parentChange()
{
- QQuickCanvas canvas1;
- TestDropTarget dropTarget1(canvas1.rootItem());
+ QQuickWindow window1;
+ TestDropTarget dropTarget1(window1.rootItem());
dropTarget1.setSize(QSizeF(100, 100));
- QQuickCanvas canvas2;
- TestDropTarget dropTarget2(canvas2.rootItem());
+ QQuickWindow window2;
+ TestDropTarget dropTarget2(window2.rootItem());
dropTarget2.setSize(QSizeF(100, 100));
QQmlComponent component(&engine);
QCOMPARE(evaluate<bool>(item, "Drag.active"), true);
// Verify setting a parent item for an item with an active drag sends an enter event.
- item->setParentItem(canvas1.rootItem());
+ item->setParentItem(window1.rootItem());
QCOMPARE(dropTarget1.enterEvents, 0);
QCoreApplication::processEvents();
QCOMPARE(dropTarget1.enterEvents, 1);
- // Changing the parent within the same canvas should send a move event.
+ // Changing the parent within the same window should send a move event.
item->setParentItem(&dropTarget1);
QCOMPARE(dropTarget1.enterEvents, 1);
QCOMPARE(dropTarget1.moveEvents, 0);
QCOMPARE(dropTarget1.enterEvents, 1);
QCOMPARE(dropTarget1.moveEvents, 1);
- // Changing the parent to an item in another canvas sends a leave event in the old canvas
- // and an enter on the new canvas.
- item->setParentItem(canvas2.rootItem());
+ // Changing the parent to an item in another window sends a leave event in the old window
+ // and an enter on the new window.
+ item->setParentItem(window2.rootItem());
QCOMPARE(dropTarget1.enterEvents, 1);
QCOMPARE(dropTarget1.moveEvents, 1);
QCOMPARE(dropTarget1.leaveEvents, 0);
// Go around again and verify no events if active is false.
evaluate<void>(item, "Drag.active = false");
- item->setParentItem(canvas1.rootItem());
+ item->setParentItem(window1.rootItem());
QCoreApplication::processEvents();
item->setParentItem(&dropTarget1);
QCoreApplication::processEvents();
- item->setParentItem(canvas2.rootItem());
+ item->setParentItem(window2.rootItem());
QCoreApplication::processEvents();
item->setParentItem(0);
void tst_QQuickDrag::hotSpot()
{
- QQuickCanvas canvas;
- TestDropTarget dropTarget(canvas.rootItem());
+ QQuickWindow window;
+ TestDropTarget dropTarget(window.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QQmlComponent component(&engine);
component.setData(
void tst_QQuickDrag::supportedActions()
{
- QQuickCanvas canvas;
- TestDropTarget dropTarget(canvas.rootItem());
+ QQuickWindow window;
+ TestDropTarget dropTarget(window.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QQmlComponent component(&engine);
component.setData(
void tst_QQuickDrag::proposedAction()
{
- QQuickCanvas canvas;
- TestDropTarget dropTarget(canvas.rootItem());
+ QQuickWindow window;
+ TestDropTarget dropTarget(window.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QQmlComponent component(&engine);
component.setData(
QCOMPARE(item->property("keys").toStringList(), QStringList() << "red" << "blue");
// Test changing the keys restarts a drag.
- QQuickCanvas canvas;
- item->setParentItem(canvas.rootItem());
- TestDropTarget dropTarget(canvas.rootItem());
+ QQuickWindow window;
+ item->setParentItem(window.rootItem());
+ TestDropTarget dropTarget(window.rootItem());
dropTarget.setSize(QSizeF(100, 100));
evaluate<void>(item, "Drag.start()");
QCOMPARE(evaluate<QObject *>(item, "source"), static_cast<QObject *>(item));
// Test changing the source restarts a drag.
- QQuickCanvas canvas;
- item->setParentItem(canvas.rootItem());
- TestDropTarget dropTarget(canvas.rootItem());
+ QQuickWindow window;
+ item->setParentItem(window.rootItem());
+ TestDropTarget dropTarget(window.rootItem());
dropTarget.setSize(QSizeF(100, 100));
evaluate<void>(item, "Drag.start()");
if (!warning.isEmpty())
QTest::ignoreMessage(QtWarningMsg, warning.constData());
- QQuickCanvas canvas;
- RecursingDropTarget dropTarget(script, type, canvas.rootItem());
+ QQuickWindow window;
+ RecursingDropTarget dropTarget(script, type, window.rootItem());
dropTarget.setSize(QSizeF(100, 100));
QQmlComponent component(&engine);
component.setData(
QScopedPointer<QObject> object(component.create());
QQuickItem *item = qobject_cast<QQuickItem *>(object.data());
QVERIFY(item);
- item->setParentItem(canvas.rootItem());
+ item->setParentItem(window.rootItem());
dropTarget.setItem(item);
void tst_QQuickDropArea::containsDrag_internal()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
void tst_QQuickDropArea::containsDrag_external()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QMimeData data;
- QQuickCanvas alternateCanvas;
+ QQuickWindow alternateWindow;
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(150, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(150, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 0);
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
evaluate<void>(dropArea, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(150, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(150, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(evaluate<bool>(dropArea, "hasDrag"), false);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea, "exitEvents"), 1);
- QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(150, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrop(&window, &data, QPoint(150, 50), Qt::CopyAction);
}
void tst_QQuickDropArea::keys_internal()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
void tst_QQuickDropArea::keys_external()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
"}", QUrl());
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QMimeData data;
- QQuickCanvas alternateCanvas;
+ QQuickWindow alternateWindow;
data.setData("text/x-red", "red");
data.setData("text/x-blue", "blue");
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
evaluate<void>(dropArea, "keys = \"text/x-blue\"");
QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-blue");
QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-blue");
evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
evaluate<void>(dropArea, "keys = \"text/x-red\"");
QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-red");
QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-red");
evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
evaluate<void>(dropArea, "keys = \"text/x-green\"");
QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-green");
QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-green");
evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
evaluate<void>(dropArea, "keys = [\"text/x-red\", \"text/x-green\"]");
QCOMPARE(dropArea->property("keys").toStringList(), QStringList() << "text/x-red" << "text/x-green");
QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList() << "text/x-red" << "text/x-green");
evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
data.removeFormat("text/x-red");
data.removeFormat("text/x-blue");
evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), false);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
evaluate<void>(dropArea, "keys = []");
QCOMPARE(dropArea->property("keys").toStringList(), QStringList());
QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList());
evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList());
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
data.setData("text/x-red", "red");
data.setData("text/x-blue", "blue");
QCOMPARE(dropArea->property("keys").toStringList(), QStringList());
QCOMPARE(dropArea->property("dropKeys").toStringList(), QStringList());
evaluate<void>(dropArea, "{ enterEvents = 0; dragKeys = undefined }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(dropArea->property("dragKeys").toStringList(), QStringList() << "text/x-red" << "text/x-blue");
- QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrop(&window, &data, QPoint(50, 50), Qt::CopyAction);
}
void tst_QQuickDropArea::source_internal()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
void tst_QQuickDropArea::position_internal()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
void tst_QQuickDropArea::position_external()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QMimeData data;
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 1);
QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(50));
QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(50));
evaluate<void>(dropArea, "{ enterEvents = 0; moveEvents = 0; eventX = -1; eventY = -1 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(40, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(40, 50), Qt::CopyAction);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(40));
QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(50));
evaluate<void>(dropArea, "{ enterEvents = 0; moveEvents = 0; eventX = -1; eventY = -1 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(75, 25), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(75, 25), Qt::CopyAction);
QCOMPARE(evaluate<int>(dropArea, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea, "moveEvents"), 1);
QCOMPARE(evaluate<qreal>(dropArea, "drag.x"), qreal(75));
QCOMPARE(evaluate<qreal>(dropArea, "eventX"), qreal(75));
QCOMPARE(evaluate<qreal>(dropArea, "eventY"), qreal(25));
- QWindowSystemInterface::handleDrop(&canvas, &data, QPoint(75, 25), Qt::CopyAction);
+ QWindowSystemInterface::handleDrop(&window, &data, QPoint(75, 25), Qt::CopyAction);
}
void tst_QQuickDropArea::drop_internal()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea);
- dropArea->setParentItem(canvas.rootItem());
+ dropArea->setParentItem(window.rootItem());
QQuickItem *dragItem = dropArea->findChild<QQuickItem *>("dragItem");
QVERIFY(dragItem);
void tst_QQuickDropArea::simultaneousDrags()
{
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.setData(
"import QtQuick 2.0\n"
QScopedPointer<QObject> object(component.create());
QQuickItem *dropArea1 = qobject_cast<QQuickItem *>(object.data());
QVERIFY(dropArea1);
- dropArea1->setParentItem(canvas.rootItem());
+ dropArea1->setParentItem(window.rootItem());
QQuickItem *dropArea2 = dropArea1->findChild<QQuickItem *>("dropArea2");
QVERIFY(dropArea2);
data.setData("text/x-red", "red");
data.setData("text/x-blue", "blue");
- QQuickCanvas alternateCanvas;
+ QQuickWindow alternateWindow;
// Mixed internal drags.
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
// external then internal.
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 1);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 0);
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 1);
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&canvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&window, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), true);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
evaluate<void>(dropArea1, "{ enterEvents = 0; exitEvents = 0 }");
evaluate<void>(dropArea2, "{ enterEvents = 0; exitEvents = 0 }");
- QWindowSystemInterface::handleDrag(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrag(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
QCOMPARE(evaluate<bool>(dropArea1, "containsDrag"), false);
QCOMPARE(evaluate<int>(dropArea1, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea1, "exitEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "enterEvents"), 0);
QCOMPARE(evaluate<int>(dropArea2, "exitEvents"), 1);
- QWindowSystemInterface::handleDrop(&alternateCanvas, &data, QPoint(50, 50), Qt::CopyAction);
+ QWindowSystemInterface::handleDrop(&alternateWindow, &data, QPoint(50, 50), Qt::CopyAction);
}
QTEST_MAIN(tst_QQuickDropArea)
QSKIP("Producing flicks on Mac CI impossible due to timing problems");
#endif
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("rebound.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("rebound.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
- QQuickTransition *rebound = canvas->rootObject()->findChild<QQuickTransition*>("rebound");
+ QQuickTransition *rebound = window->rootObject()->findChild<QQuickTransition*>("rebound");
QVERIFY(rebound);
QSignalSpy reboundSpy(rebound, SIGNAL(runningChanged()));
QSignalSpy hMoveSpy(flickable, SIGNAL(movingHorizontallyChanged()));
// flick and test the transition is run
- flick(canvas, QPoint(20,20), QPoint(120,120), 200);
+ flick(window, QPoint(20,20), QPoint(120,120), 200);
- QTRY_COMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 2);
+ QTRY_COMPARE(window->rootObject()->property("transitionsStarted").toInt(), 2);
QCOMPARE(hMoveSpy.count(), 1);
QCOMPARE(vMoveSpy.count(), 1);
QCOMPARE(movementStartedSpy.count(), 1);
QCOMPARE(vMoveSpy.count(), 2);
QCOMPARE(movementStartedSpy.count(), 1);
QCOMPARE(movementEndedSpy.count(), 1);
- QCOMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("transitionsStarted").toInt(), 2);
QVERIFY(!rebound->running());
QCOMPARE(reboundSpy.count(), 2);
vMoveSpy.clear();
movementStartedSpy.clear();
movementEndedSpy.clear();
- canvas->rootObject()->setProperty("transitionsStarted", 0);
- canvas->rootObject()->setProperty("transitionsFinished", 0);
+ window->rootObject()->setProperty("transitionsStarted", 0);
+ window->rootObject()->setProperty("transitionsFinished", 0);
// flick and trigger the transition multiple times
// (moving signals are emitted as soon as the first transition starts)
- flick(canvas, QPoint(20,20), QPoint(120,120), 200); // both x and y will bounce back
- flick(canvas, QPoint(20,120), QPoint(120,20), 200); // only x will bounce back
+ flick(window, QPoint(20,20), QPoint(120,120), 200); // both x and y will bounce back
+ flick(window, QPoint(20,120), QPoint(120,20), 200); // only x will bounce back
QVERIFY(flickable->isMoving());
- QVERIFY(canvas->rootObject()->property("transitionsStarted").toInt() >= 1);
+ QVERIFY(window->rootObject()->property("transitionsStarted").toInt() >= 1);
QCOMPARE(hMoveSpy.count(), 1);
QCOMPARE(vMoveSpy.count(), 1);
QCOMPARE(movementStartedSpy.count(), 1);
vMoveSpy.clear();
movementStartedSpy.clear();
movementEndedSpy.clear();
- canvas->rootObject()->setProperty("transitionsStarted", 0);
- canvas->rootObject()->setProperty("transitionsFinished", 0);
+ window->rootObject()->setProperty("transitionsStarted", 0);
+ window->rootObject()->setProperty("transitionsFinished", 0);
// disable and the default transition should run
// (i.e. moving but transition->running = false)
- canvas->rootObject()->setProperty("transitionEnabled", false);
+ window->rootObject()->setProperty("transitionEnabled", false);
- flick(canvas, QPoint(20,20), QPoint(120,120), 200);
- QCOMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 0);
+ flick(window, QPoint(20,20), QPoint(120,120), 200);
+ QCOMPARE(window->rootObject()->property("transitionsStarted").toInt(), 0);
QCOMPARE(hMoveSpy.count(), 1);
QCOMPARE(vMoveSpy.count(), 1);
QCOMPARE(movementStartedSpy.count(), 1);
QCOMPARE(vMoveSpy.count(), 2);
QCOMPARE(movementStartedSpy.count(), 1);
QCOMPARE(movementEndedSpy.count(), 1);
- QCOMPARE(canvas->rootObject()->property("transitionsStarted").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("transitionsStarted").toInt(), 0);
- delete canvas;
+ delete window;
}
void tst_qquickflickable::maximumFlickVelocity()
// QTBUG-17361
void tst_qquickflickable::nestedPressDelay()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("nestedPressDelay.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("nestedPressDelay.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *outer = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *outer = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(outer != 0);
- QQuickFlickable *inner = canvas->rootObject()->findChild<QQuickFlickable*>("innerFlickable");
+ QQuickFlickable *inner = window->rootObject()->findChild<QQuickFlickable*>("innerFlickable");
QVERIFY(inner != 0);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(150, 150));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(150, 150));
// the MouseArea is not pressed immediately
QVERIFY(outer->property("pressed").toBool() == false);
// QTRY_VERIFY() has 5sec timeout, so will timeout well within 10sec.
QTRY_VERIFY(outer->property("pressed").toBool() == true);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(150, 150));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(150, 150));
- delete canvas;
+ delete window;
}
void tst_qquickflickable::flickableDirection()
{
QFETCH(bool, setRebound);
- QQuickView *canvas = new QQuickView;
- canvas->rootContext()->setContextProperty("setRebound", setRebound);
- canvas->setSource(testFileUrl("resize.qml"));
- QVERIFY(canvas->rootObject() != 0);
- QQuickFlickable *obj = findItem<QQuickFlickable>(canvas->rootObject(), "flick");
+ QQuickView *window = new QQuickView;
+ window->rootContext()->setContextProperty("setRebound", setRebound);
+ window->setSource(testFileUrl("resize.qml"));
+ QVERIFY(window->rootObject() != 0);
+ QQuickFlickable *obj = findItem<QQuickFlickable>(window->rootObject(), "flick");
- QQuickTransition *rebound = canvas->rootObject()->findChild<QQuickTransition*>("rebound");
+ QQuickTransition *rebound = window->rootObject()->findChild<QQuickTransition*>("rebound");
QVERIFY(rebound);
QSignalSpy reboundSpy(rebound, SIGNAL(runningChanged()));
QTRY_COMPARE(obj->contentX(), 100.);
QTRY_COMPARE(obj->contentY(), 400.);
- QMetaObject::invokeMethod(canvas->rootObject(), "returnToBounds");
+ QMetaObject::invokeMethod(window->rootObject(), "returnToBounds");
if (setRebound)
QTRY_VERIFY(rebound->running());
QVERIFY(!rebound->running());
QCOMPARE(reboundSpy.count(), setRebound ? 2 : 0);
- delete canvas;
+ delete window;
}
void tst_qquickflickable::returnToBounds_data()
void tst_qquickflickable::wheel()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("wheel.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("wheel.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flick = canvas->rootObject()->findChild<QQuickFlickable*>("flick");
+ QQuickFlickable *flick = window->rootObject()->findChild<QQuickFlickable*>("flick");
QVERIFY(flick != 0);
{
QPoint pos(200, 200);
- QWheelEvent event(pos, canvas->mapToGlobal(pos), QPoint(), QPoint(0,-120), -120, Qt::Vertical, Qt::NoButton, Qt::NoModifier);
+ QWheelEvent event(pos, window->mapToGlobal(pos), QPoint(), QPoint(0,-120), -120, Qt::Vertical, Qt::NoButton, Qt::NoModifier);
event.setAccepted(false);
- QGuiApplication::sendEvent(canvas, &event);
+ QGuiApplication::sendEvent(window, &event);
}
QTRY_VERIFY(flick->contentY() > 0);
{
QPoint pos(200, 200);
- QWheelEvent event(pos, canvas->mapToGlobal(pos), QPoint(), QPoint(-120,0), -120, Qt::Horizontal, Qt::NoButton, Qt::NoModifier);
+ QWheelEvent event(pos, window->mapToGlobal(pos), QPoint(), QPoint(-120,0), -120, Qt::Horizontal, Qt::NoButton, Qt::NoModifier);
event.setAccepted(false);
- QGuiApplication::sendEvent(canvas, &event);
+ QGuiApplication::sendEvent(window, &event);
}
QTRY_VERIFY(flick->contentX() > 0);
QVERIFY(flick->contentY() == 0);
- delete canvas;
+ delete window;
}
void tst_qquickflickable::movingAndFlicking_data()
const QPoint flickFrom(50, 200); // centre
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("flickable03.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowActive(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("flickable03.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowActive(window);
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
QSignalSpy vMoveSpy(flickable, SIGNAL(movingVerticallyChanged()));
QSignalSpy flickEndSpy(flickable, SIGNAL(flickEnded()));
// do a flick that keeps the view within the bounds
- flick(canvas, flickFrom, flickToWithoutSnapBack, 200);
+ flick(window, flickFrom, flickToWithoutSnapBack, 200);
QVERIFY(flickable->isMoving());
QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled);
flickable->setContentX(0);
flickable->setContentY(0);
QTRY_VERIFY(!flickable->isMoving());
- flick(canvas, flickFrom, flickToWithSnapBack, 200);
+ flick(window, flickFrom, flickToWithSnapBack, 200);
QVERIFY(flickable->isMoving());
QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled);
QCOMPARE(flickable->contentX(), 0.0);
QCOMPARE(flickable->contentY(), 0.0);
- delete canvas;
+ delete window;
}
const QPoint moveFrom(50, 200); // centre
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("flickable03.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("flickable03.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
QSignalSpy vDragSpy(flickable, SIGNAL(draggingVerticallyChanged()));
QSignalSpy moveEndSpy(flickable, SIGNAL(movementEnded()));
// start the drag
- QTest::mousePress(canvas, Qt::LeftButton, 0, moveFrom);
- QTest::mouseMove(canvas, moveFrom + moveByWithoutSnapBack);
- QTest::mouseMove(canvas, moveFrom + moveByWithoutSnapBack*2);
- QTest::mouseMove(canvas, moveFrom + moveByWithoutSnapBack*3);
+ QTest::mousePress(window, Qt::LeftButton, 0, moveFrom);
+ QTest::mouseMove(window, moveFrom + moveByWithoutSnapBack);
+ QTest::mouseMove(window, moveFrom + moveByWithoutSnapBack*2);
+ QTest::mouseMove(window, moveFrom + moveByWithoutSnapBack*3);
QVERIFY(flickable->isMoving());
QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled);
QCOMPARE(moveStartSpy.count(), 1);
QCOMPARE(dragStartSpy.count(), 1);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, moveFrom + moveByWithoutSnapBack*3);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, moveFrom + moveByWithoutSnapBack*3);
QVERIFY(!flickable->isDragging());
QVERIFY(!flickable->isDraggingHorizontally());
flickable->setContentX(0);
flickable->setContentY(0);
QTRY_VERIFY(!flickable->isMoving());
- QTest::mousePress(canvas, Qt::LeftButton, 0, moveFrom);
- QTest::mouseMove(canvas, moveFrom + moveByWithSnapBack);
- QTest::mouseMove(canvas, moveFrom + moveByWithSnapBack*2);
- QTest::mouseMove(canvas, moveFrom + moveByWithSnapBack*3);
+ QTest::mousePress(window, Qt::LeftButton, 0, moveFrom);
+ QTest::mouseMove(window, moveFrom + moveByWithSnapBack);
+ QTest::mouseMove(window, moveFrom + moveByWithSnapBack*2);
+ QTest::mouseMove(window, moveFrom + moveByWithSnapBack*3);
QVERIFY(flickable->isMoving());
QCOMPARE(flickable->isMovingHorizontally(), horizontalEnabled);
QCOMPARE(dragStartSpy.count(), 1);
QCOMPARE(dragEndSpy.count(), 0);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, moveFrom + moveByWithSnapBack*3);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, moveFrom + moveByWithSnapBack*3);
// should now start snapping back to bounds (moving but not dragging)
QVERIFY(flickable->isMoving());
QCOMPARE(flickable->contentX(), 0.0);
QCOMPARE(flickable->contentY(), 0.0);
- delete canvas;
+ delete window;
}
void tst_qquickflickable::flickOnRelease()
#ifdef Q_OS_MAC
QSKIP("Producing flicks on Mac CI impossible due to timing problems");
#endif
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("flickable03.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
-
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("flickable03.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->rootObject() != 0);
+
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
// Vertical with a quick press-move-release: should cause a flick in release.
// underlying drivers will hopefully provide a pre-calculated velocity
// (based on more data than what the UI gets), thus making this use case
// working even with small movements.
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50, 300));
- QTest::mouseMove(canvas, QPoint(50, 10), 10);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50, 10), 10);
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50, 300));
+ QTest::mouseMove(window, QPoint(50, 10), 10);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50, 10), 10);
QCOMPARE(vFlickSpy.count(), 1);
// Stop on a full pixel after user interaction
QCOMPARE(flickable->contentY(), (qreal)qRound(flickable->contentY()));
- delete canvas;
+ delete window;
}
void tst_qquickflickable::pressWhileFlicking()
QSKIP("Producing flicks on Mac CI impossible due to timing problems");
#endif
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("flickable03.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("flickable03.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
QSignalSpy vMoveSpy(flickable, SIGNAL(movingVerticallyChanged()));
// flick then press while it is still moving
// flicking == false, moving == true;
- flick(canvas, QPoint(20,190), QPoint(20, 50), 200);
+ flick(window, QPoint(20,190), QPoint(20, 50), 200);
QVERIFY(flickable->verticalVelocity() > 0.0);
QVERIFY(flickable->isFlicking());
QVERIFY(flickable->isFlickingVertically());
QCOMPARE(hFlickSpy.count(), 0);
QCOMPARE(flickSpy.count(), 1);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(20, 50));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(20, 50));
QTRY_VERIFY(!flickable->isFlicking());
QVERIFY(!flickable->isFlickingVertically());
QVERIFY(flickable->isMoving());
QVERIFY(flickable->isMovingVertically());
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(20,50));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(20,50));
QVERIFY(!flickable->isFlicking());
QVERIFY(!flickable->isFlickingVertically());
QTRY_VERIFY(!flickable->isMoving());
// Stop on a full pixel after user interaction
QCOMPARE(flickable->contentX(), (qreal)qRound(flickable->contentX()));
- delete canvas;
+ delete window;
}
void tst_qquickflickable::disabled()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("disabled.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("disabled.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flick = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
+ QQuickFlickable *flick = window->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flick != 0);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50, 90));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50, 90));
- QTest::mouseMove(canvas, QPoint(50, 80));
- QTest::mouseMove(canvas, QPoint(50, 70));
- QTest::mouseMove(canvas, QPoint(50, 60));
+ QTest::mouseMove(window, QPoint(50, 80));
+ QTest::mouseMove(window, QPoint(50, 70));
+ QTest::mouseMove(window, QPoint(50, 60));
QVERIFY(flick->isMoving() == false);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50, 60));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50, 60));
// verify that mouse clicks on other elements still work (QTBUG-20584)
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50, 10));
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50, 10));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50, 10));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50, 10));
- QTRY_VERIFY(canvas->rootObject()->property("clicked").toBool() == true);
+ QTRY_VERIFY(window->rootObject()->property("clicked").toBool() == true);
}
void tst_qquickflickable::flickVelocity()
QSKIP("Producing flicks on Mac CI impossible due to timing problems");
#endif
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("flickable03.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("flickable03.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
// flick up
- flick(canvas, QPoint(20,190), QPoint(20, 50), 200);
+ flick(window, QPoint(20,190), QPoint(20, 50), 200);
QVERIFY(flickable->verticalVelocity() > 0.0);
QTRY_VERIFY(flickable->verticalVelocity() == 0.0);
// flick down
- flick(canvas, QPoint(20,10), QPoint(20, 140), 200);
+ flick(window, QPoint(20,10), QPoint(20, 140), 200);
QVERIFY(flickable->verticalVelocity() < 0.0);
QTRY_VERIFY(flickable->verticalVelocity() == 0.0);
QQuickFlickablePrivate *fp = QQuickFlickablePrivate::get(flickable);
bool boosted = false;
for (int i = 0; i < 6; ++i) {
- flick(canvas, QPoint(20,390), QPoint(20, 50), 100);
+ flick(window, QPoint(20,390), QPoint(20, 50), 100);
boosted |= fp->flickBoost > 1.0;
}
QVERIFY(boosted);
// Flick in opposite direction -> boost cancelled.
- flick(canvas, QPoint(20,10), QPoint(20, 340), 200);
+ flick(window, QPoint(20,10), QPoint(20, 340), 200);
QTRY_VERIFY(flickable->verticalVelocity() < 0.0);
QVERIFY(fp->flickBoost == 1.0);
- delete canvas;
+ delete window;
}
void tst_qquickflickable::margins()
void tst_qquickflickable::cancelOnMouseGrab()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("cancel.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("cancel.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(10, 10));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(10, 10));
// drag out of bounds
- QTest::mouseMove(canvas, QPoint(50, 50));
- QTest::mouseMove(canvas, QPoint(100, 100));
- QTest::mouseMove(canvas, QPoint(150, 150));
+ QTest::mouseMove(window, QPoint(50, 50));
+ QTest::mouseMove(window, QPoint(100, 100));
+ QTest::mouseMove(window, QPoint(150, 150));
QVERIFY(flickable->contentX() != 0);
QVERIFY(flickable->contentY() != 0);
QVERIFY(flickable->isDragging());
// grabbing mouse will cancel flickable interaction.
- QQuickItem *item = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *item = window->rootObject()->findChild<QQuickItem*>("row");
item->grabMouse();
QTRY_COMPARE(flickable->contentX(), 0.);
QTRY_VERIFY(!flickable->isMoving());
QTRY_VERIFY(!flickable->isDragging());
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50, 10));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50, 10));
}
void tst_qquickflickable::clickAndDragWhenTransformed()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("transformedFlickable.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
-
- QQuickFlickable *flickable = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
+ QQuickView *view = new QQuickView;
+ view->setSource(testFileUrl("transformedFlickable.qml"));
+ view->show();
+ view->requestActivateWindow();
+ QTest::qWaitForWindowShown(view);
+ QVERIFY(view->rootObject() != 0);
+
+ QQuickFlickable *flickable = view->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flickable != 0);
// click outside child rect
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(190, 190));
+ QTest::mousePress(view, Qt::LeftButton, 0, QPoint(190, 190));
QTest::qWait(10);
QCOMPARE(flickable->property("itemPressed").toBool(), false);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(190, 190));
+ QTest::mouseRelease(view, Qt::LeftButton, 0, QPoint(190, 190));
// click inside child rect
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(200, 200));
+ QTest::mousePress(view, Qt::LeftButton, 0, QPoint(200, 200));
QTest::qWait(10);
QCOMPARE(flickable->property("itemPressed").toBool(), true);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(200, 200));
+ QTest::mouseRelease(view, Qt::LeftButton, 0, QPoint(200, 200));
const int threshold = qApp->styleHints()->startDragDistance();
// drag outside bounds
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(160, 160));
+ QTest::mousePress(view, Qt::LeftButton, 0, QPoint(160, 160));
QTest::qWait(10);
- QTest::mouseMove(canvas, QPoint(160 + threshold * 2, 160));
- QTest::mouseMove(canvas, QPoint(160 + threshold * 3, 160));
+ QTest::mouseMove(view, QPoint(160 + threshold * 2, 160));
+ QTest::mouseMove(view, QPoint(160 + threshold * 3, 160));
QCOMPARE(flickable->isDragging(), false);
QCOMPARE(flickable->property("itemPressed").toBool(), false);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(180, 160));
+ QTest::mouseRelease(view, Qt::LeftButton, 0, QPoint(180, 160));
// drag inside bounds
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(200, 140));
+ QTest::mousePress(view, Qt::LeftButton, 0, QPoint(200, 140));
QTest::qWait(10);
- QTest::mouseMove(canvas, QPoint(200 + threshold * 2, 140));
- QTest::mouseMove(canvas, QPoint(200 + threshold * 3, 140));
+ QTest::mouseMove(view, QPoint(200 + threshold * 2, 140));
+ QTest::mouseMove(view, QPoint(200 + threshold * 3, 140));
QCOMPARE(flickable->isDragging(), true);
QCOMPARE(flickable->property("itemPressed").toBool(), false);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(220, 140));
+ QTest::mouseRelease(view, Qt::LeftButton, 0, QPoint(220, 140));
- delete canvas;
+ delete view;
}
QTEST_MAIN(tst_qquickflickable)
void tst_qquickflipable::QTBUG_9161_crash()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("crash.qml"));
- QQuickItem *root = canvas->rootObject();
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("crash.qml"));
+ QQuickItem *root = window->rootObject();
QVERIFY(root != 0);
- canvas->show();
- delete canvas;
+ window->show();
+ delete window;
}
void tst_qquickflipable::QTBUG_8474_qgv_abort()
{
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("flipable-abort.qml"));
- QQuickItem *root = canvas->rootObject();
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("flipable-abort.qml"));
+ QQuickItem *root = window->rootObject();
QVERIFY(root != 0);
- canvas->show();
- delete canvas;
+ window->show();
+ delete window;
}
QTEST_MAIN(tst_qquickflipable)
QTest::qWaitForWindowShown(view);
QTRY_VERIFY(view == qGuiApp->focusWindow());
- // Now the canvas has focus, active focus given to item1
+ // Now the window has focus, active focus given to item1
QCOMPARE(rootItem->hasFocus(), true);
QCOMPARE(rootItem->hasActiveFocus(), true);
QCOMPARE(scope1->hasFocus(), true);
QCOMPARE(item1ActiveFocusSpy.count(), 2);
- // canvas does not have focus, so item2 will not get active focus
+ // window does not have focus, so item2 will not get active focus
item2->forceActiveFocus();
QCOMPARE(rootItem->hasFocus(), false);
QCOMPARE(item2FocusSpy.count(), 1);
QCOMPARE(item2ActiveFocusSpy.count(), 0);
- // give the canvas focus, and item2 will get active focus
+ // give the window focus, and item2 will get active focus
view->show();
view->requestActivateWindow();
QTest::qWaitForWindowShown(view);
#if defined(Q_OS_WIN)
QSKIP("Windows doesn't support font loading.");
#endif
- QQuickView canvas(testFileUrl("qtbug-20268.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowShown(&canvas);
- QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
+ QQuickView window(testFileUrl("qtbug-20268.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowShown(&window);
+ QTRY_COMPARE(&window, qGuiApp->focusWindow());
- QQuickFontLoader *fontObject = qobject_cast<QQuickFontLoader*>(qvariant_cast<QObject *>(canvas.rootObject()->property("fontloader")));
+ QQuickFontLoader *fontObject = qobject_cast<QQuickFontLoader*>(qvariant_cast<QObject *>(window.rootObject()->property("fontloader")));
QVERIFY(fontObject != 0);
QTRY_VERIFY(fontObject->status() == QQuickFontLoader::Ready);
QVERIFY(fontObject->source() != QUrl(""));
QTRY_COMPARE(fontObject->name(), QString("OCRA"));
- canvas.rootObject()->setProperty("usename", true);
+ window.rootObject()->setProperty("usename", true);
// This warning should probably not be printed once QTBUG-20268 is fixed
QString warning = QString(testFileUrl("qtbug-20268.qml").toString()) +
QEXPECT_FAIL("", "QTBUG-20268", Abort);
QTRY_VERIFY(fontObject->status() == QQuickFontLoader::Ready);
- QCOMPARE(canvas.rootObject()->property("name").toString(), QString("Tahoma"));
+ QCOMPARE(window.rootObject()->property("name").toString(), QString("Tahoma"));
}
QTEST_MAIN(tst_qquickfontloader)
void tst_QQuickGridView::items()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
model.addItem("Fred", "12345");
model.addItem("Ben", "04321");
model.addItem("Jim", "0780");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
+ window->setSource(testFileUrl("gridview1.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(gridview->count(), model.count());
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
for (int i = 0; i < model.count(); ++i) {
int itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QTRY_VERIFY(itemCount == 0);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::changed()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
model.addItem("Fred", "12345");
model.addItem("Ben", "04321");
model.addItem("Jim", "0780");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
+ window->setSource(testFileUrl("gridview1.qml"));
qApp->processEvents();
- QQuickFlickable *gridview = findItem<QQuickFlickable>(canvas->rootObject(), "grid");
+ QQuickFlickable *gridview = findItem<QQuickFlickable>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::inserted_basic()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
model.addItem("Fred", "12345");
model.addItem("John", "2345");
model.addItem("Bob", "54321");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
model.insertItem(1, "Will", "9876");
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_COMPARE(number->text(), model.number(1));
// Checks that onAdd is called
- int added = canvas->rootObject()->property("added").toInt();
+ int added = window->rootObject()->property("added").toInt();
QTRY_COMPARE(added, 1);
// Confirm items positioned correctly
QTRY_VERIFY(gridview->contentY() == 120);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::inserted_defaultLayout(QQuickGridView::Flow flow,
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testTopToBottom", flow == QQuickGridView::FlowTopToBottom);
ctxt->setContextProperty("testRightToLeft", horizLayout == Qt::RightToLeft);
ctxt->setContextProperty("testBottomToTop", verticalLayout == QQuickGridView::BottomToTop);
- canvas->setSource(testFileUrl("layouts.qml"));
- canvas->show();
+ window->setSource(testFileUrl("layouts.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::inserted_defaultLayout_data()
QFETCH(int, cacheBuffer);
QQuickText *name;
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
- canvas->show();
+ window->setSource(testFileUrl("gridview1.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::insertBeforeVisible_data()
void tst_QQuickGridView::removed_basic()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
model.removeItem(1);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
// Checks that onRemove is called
- QString removed = canvas->rootObject()->property("removed").toString();
+ QString removed = window->rootObject()->property("removed").toString();
QTRY_COMPARE(removed, QString("Item1"));
// Confirm items positioned correctly
// Remove first item (which is the current item);
model.removeItem(0);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
// Remove items not visible
model.removeItem(25);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
// Confirm items positioned correctly
itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QTRY_COMPARE(gridview->contentY(), 120.0);
model.removeItem(1);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
// Confirm items positioned correctly
for (int i = 6; i < 18; ++i) {
// Remove currentIndex
QQuickItem *oldCurrent = gridview->currentItem();
model.removeItem(9);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(gridview->currentIndex(), 9);
QTRY_VERIFY(gridview->currentItem() != oldCurrent);
QTRY_COMPARE(gridview->currentIndex(), 7);
QTRY_VERIFY(gridview->currentItem() == oldCurrent);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::removed_defaultLayout(QQuickGridView::Flow flow,
QFETCH(QString, firstVisible);
QFETCH(QString, firstVisible_ttb);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testTopToBottom", flow == QQuickGridView::FlowTopToBottom);
ctxt->setContextProperty("testRightToLeft", horizLayout == Qt::RightToLeft);
ctxt->setContextProperty("testBottomToTop", verticalLayout == QQuickGridView::BottomToTop);
- canvas->setSource(testFileUrl("layouts.qml"));
- canvas->show();
+ window->setSource(testFileUrl("layouts.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::removed_defaultLayout_data()
QFETCH(bool, doAdd);
QFETCH(qreal, newTopContentY);
- QQuickView *canvas = getView();
- canvas->show();
+ QQuickView *window = getView();
+ window->show();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_VERIFY(item->y() == (i/3)*60 + newTopContentY);
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::addOrRemoveBeforeVisible_data()
void tst_QQuickGridView::clear()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
- canvas->show();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QVERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QVERIFY(gridview->currentItem() != 0);
QVERIFY(gridview->currentIndex() == 0);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::moved_defaultLayout(QQuickGridView::Flow flow,
QFETCH(int, count_ttb);
QFETCH(qreal, rowOffsetAfterMove);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testTopToBottom", flow == QQuickGridView::FlowTopToBottom);
ctxt->setContextProperty("testRightToLeft", horizLayout == Qt::RightToLeft);
ctxt->setContextProperty("testBottomToTop", verticalLayout == QQuickGridView::BottomToTop);
- canvas->setSource(testFileUrl("layouts.qml"));
- canvas->show();
+ window->setSource(testFileUrl("layouts.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(gridview->currentIndex(), i);
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::moved_defaultLayout_data()
QFETCH(int, newCount);
QFETCH(int, newCurrentIndex);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QaimModel model;
for (int i = 0; i < startCount; i++)
model.addItem("Item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
- canvas->show();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
QTRY_COMPARE(number->text(), model.number(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::multipleChanges_data()
void tst_QQuickGridView::swapWithFirstItem()
{
// QTBUG_9697
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
- canvas->show();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
// ensure content position is stable
model.moveItem(10, 0);
QTRY_VERIFY(gridview->contentY() == 0);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::currentIndex()
for (int i = 0; i < 60; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
+ window->show();
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
QString filename(testFile("gridview-initCurrent.qml"));
- canvas->setSource(QUrl::fromLocalFile(filename));
+ window->setSource(QUrl::fromLocalFile(filename));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QVERIFY(gridview != 0);
QTRY_VERIFY(!QQuickItemPrivate::get(gridview)->polishScheduled);
QTRY_VERIFY(gridview->verticalVelocity() != 0.0);
// footer should become visible if it is out of view, and then current index moves to the first row
- canvas->rootObject()->setProperty("showFooter", true);
+ window->rootObject()->setProperty("showFooter", true);
QTRY_VERIFY(gridview->footerItem());
gridview->setCurrentIndex(model.count()-3);
QTRY_VERIFY(gridview->footerItem()->y() > gridview->contentY() + gridview->height());
gridview->setCurrentIndex(model.count()-2);
QTRY_COMPARE(gridview->contentY() + gridview->height(), (60.0 * model.count()/3) + gridview->footerItem()->height());
- canvas->rootObject()->setProperty("showFooter", false);
+ window->rootObject()->setProperty("showFooter", false);
// header should become visible if it is out of view, and then current index moves to the last row
- canvas->rootObject()->setProperty("showHeader", true);
+ window->rootObject()->setProperty("showHeader", true);
QTRY_VERIFY(gridview->headerItem());
gridview->setCurrentIndex(3);
QTRY_VERIFY(gridview->headerItem()->y() + gridview->headerItem()->height() < gridview->contentY());
gridview->setCurrentIndex(1);
QTRY_COMPARE(gridview->contentY(), -gridview->headerItem()->height());
- canvas->rootObject()->setProperty("showHeader", false);
+ window->rootObject()->setProperty("showHeader", false);
// turn off auto highlight
gridview->setHighlightFollowsCurrentItem(false);
// insert item before currentIndex
gridview->setCurrentIndex(28);
model.insertItem(0, "Foo", "1111");
- QTRY_COMPARE(canvas->rootObject()->property("current").toInt(), 29);
+ QTRY_COMPARE(window->rootObject()->property("current").toInt(), 29);
// check removing highlight by setting currentIndex to -1;
gridview->setCurrentIndex(-1);
gridview->setContentY(200);
QTRY_VERIFY(!delegateVisible(gridview->currentItem()));
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::noCurrentIndex()
for (int i = 0; i < 60; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
QString filename(testFile("gridview-noCurrent.qml"));
- canvas->setSource(QUrl::fromLocalFile(filename));
- canvas->show();
+ window->setSource(QUrl::fromLocalFile(filename));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QVERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QVERIFY(gridview->currentItem());
QVERIFY(gridview->highlightItem());
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::keyNavigation()
for (int i = 0; i < 18; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = getView();
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
- canvas->show();
- QTest::qWaitForWindowActive(canvas);
+ QQuickView *window = getView();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
+ window->show();
+ QTest::qWaitForWindowActive(window);
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
gridview->setVerticalLayoutDirection(verticalLayoutDirection);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
- canvas->requestActivateWindow();
- QTest::qWaitForWindowActive(canvas);
- QTRY_VERIFY(qGuiApp->focusWindow() == canvas);
+ window->requestActivateWindow();
+ QTest::qWaitForWindowActive(window);
+ QTRY_VERIFY(qGuiApp->focusWindow() == window);
QCOMPARE(gridview->currentIndex(), 0);
- QTest::keyClick(canvas, forwardsKey);
+ QTest::keyClick(window, forwardsKey);
QCOMPARE(gridview->currentIndex(), 1);
- QTest::keyClick(canvas, backwardsKey);
+ QTest::keyClick(window, backwardsKey);
QCOMPARE(gridview->currentIndex(), 0);
gridview->setCurrentIndex(7);
QCOMPARE(gridview->currentIndex(), indexDownFrom7);
gridview->setCurrentIndex(7);
- QTest::keyClick(canvas, Qt::Key_Right);
+ QTest::keyClick(window, Qt::Key_Right);
QCOMPARE(gridview->currentIndex(), indexRightOf7);
- QTest::keyClick(canvas, Qt::Key_Left);
+ QTest::keyClick(window, Qt::Key_Left);
QCOMPARE(gridview->currentIndex(), 7);
- QTest::keyClick(canvas, Qt::Key_Left);
+ QTest::keyClick(window, Qt::Key_Left);
QCOMPARE(gridview->currentIndex(), indexLeftOf7);
- QTest::keyClick(canvas, Qt::Key_Right);
+ QTest::keyClick(window, Qt::Key_Right);
QCOMPARE(gridview->currentIndex(), 7);
- QTest::keyClick(canvas, Qt::Key_Up);
+ QTest::keyClick(window, Qt::Key_Up);
QCOMPARE(gridview->currentIndex(), indexUpFrom7);
- QTest::keyClick(canvas, Qt::Key_Down);
+ QTest::keyClick(window, Qt::Key_Down);
QCOMPARE(gridview->currentIndex(), 7);
- QTest::keyClick(canvas, Qt::Key_Down);
+ QTest::keyClick(window, Qt::Key_Down);
QCOMPARE(gridview->currentIndex(), indexDownFrom7);
// hold down a key to go forwards
gridview->setCurrentIndex(0);
for (int i=0; i<model.count()-1; i++) {
// QTest::qWait(500);
- QTest::simulateEvent(canvas, true, forwardsKey, Qt::NoModifier, "", true);
+ QTest::simulateEvent(window, true, forwardsKey, Qt::NoModifier, "", true);
QTRY_COMPARE(gridview->currentIndex(), i+1);
}
- QTest::keyRelease(canvas, forwardsKey);
+ QTest::keyRelease(window, forwardsKey);
QTRY_COMPARE(gridview->currentIndex(), model.count()-1);
QTRY_COMPARE(gridview->contentX(), contentPosAtLastItem.x());
QTRY_COMPARE(gridview->contentY(), contentPosAtLastItem.y());
// hold down a key to go backwards
for (int i=model.count()-1; i > 0; i--) {
- QTest::simulateEvent(canvas, true, backwardsKey, Qt::NoModifier, "", true);
+ QTest::simulateEvent(window, true, backwardsKey, Qt::NoModifier, "", true);
QTRY_COMPARE(gridview->currentIndex(), i-1);
}
- QTest::keyRelease(canvas, backwardsKey);
+ QTest::keyRelease(window, backwardsKey);
QTRY_COMPARE(gridview->currentIndex(), 0);
QTRY_COMPARE(gridview->contentX(), contentPosAtFirstItem.x());
QTRY_COMPARE(gridview->contentY(), contentPosAtFirstItem.y());
// no wrap
QVERIFY(!gridview->isWrapEnabled());
- QTest::keyClick(canvas, forwardsKey);
+ QTest::keyClick(window, forwardsKey);
QCOMPARE(gridview->currentIndex(), 1);
- QTest::keyClick(canvas, backwardsKey);
+ QTest::keyClick(window, backwardsKey);
QCOMPARE(gridview->currentIndex(), 0);
- QTest::keyClick(canvas, backwardsKey);
+ QTest::keyClick(window, backwardsKey);
QCOMPARE(gridview->currentIndex(), 0);
// with wrap
gridview->setWrapEnabled(true);
QVERIFY(gridview->isWrapEnabled());
- QTest::keyClick(canvas, backwardsKey);
+ QTest::keyClick(window, backwardsKey);
QCOMPARE(gridview->currentIndex(), model.count()-1);
QTRY_COMPARE(gridview->contentX(), contentPosAtLastItem.x());
QTRY_COMPARE(gridview->contentY(), contentPosAtLastItem.y());
- QTest::keyClick(canvas, forwardsKey);
+ QTest::keyClick(window, forwardsKey);
QCOMPARE(gridview->currentIndex(), 0);
QTRY_COMPARE(gridview->contentX(), contentPosAtFirstItem.x());
QTRY_COMPARE(gridview->contentY(), contentPosAtFirstItem.y());
// Test key press still accepted when position wraps to same index.
- canvas->rootObject()->setProperty("lastKey", 0);
+ window->rootObject()->setProperty("lastKey", 0);
model.removeItems(1, model.count() - 1);
- QTest::keyClick(canvas, backwardsKey);
- QCOMPARE(canvas->rootObject()->property("lastKey").toInt(), 0);
+ QTest::keyClick(window, backwardsKey);
+ QCOMPARE(window->rootObject()->property("lastKey").toInt(), 0);
- QTest::keyClick(canvas, forwardsKey);
- QCOMPARE(canvas->rootObject()->property("lastKey").toInt(), 0);
+ QTest::keyClick(window, forwardsKey);
+ QCOMPARE(window->rootObject()->property("lastKey").toInt(), 0);
// Test key press not accepted at limits when wrap is disabled.
gridview->setWrapEnabled(false);
- QTest::keyClick(canvas, backwardsKey);
- QCOMPARE(canvas->rootObject()->property("lastKey").toInt(), int(backwardsKey));
+ QTest::keyClick(window, backwardsKey);
+ QCOMPARE(window->rootObject()->property("lastKey").toInt(), int(backwardsKey));
- QTest::keyClick(canvas, forwardsKey);
- QCOMPARE(canvas->rootObject()->property("lastKey").toInt(), int(forwardsKey));
+ QTest::keyClick(window, forwardsKey);
+ QCOMPARE(window->rootObject()->property("lastKey").toInt(), int(forwardsKey));
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::keyNavigation_data()
void tst_QQuickGridView::changeFlow()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testRightToLeft", QVariant(false));
ctxt->setContextProperty("testTopToBottom", QVariant(false));
ctxt->setContextProperty("testBottomToTop", QVariant(false));
- canvas->setSource(testFileUrl("layouts.qml"));
+ window->setSource(testFileUrl("layouts.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_COMPARE(number->text(), model.number(i));
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::defaultValues()
void tst_QQuickGridView::propertyChanges()
{
- QQuickView *canvas = createView();
- QTRY_VERIFY(canvas);
- canvas->setSource(testFileUrl("propertychangestest.qml"));
+ QQuickView *window = createView();
+ QTRY_VERIFY(window);
+ window->setSource(testFileUrl("propertychangestest.qml"));
- QQuickGridView *gridView = canvas->rootObject()->findChild<QQuickGridView*>("gridView");
+ QQuickGridView *gridView = window->rootObject()->findChild<QQuickGridView*>("gridView");
QTRY_VERIFY(gridView);
QSignalSpy keyNavigationWrapsSpy(gridView, SIGNAL(keyNavigationWrapsChanged()));
gridView->setFlow(QQuickGridView::FlowTopToBottom);
QTRY_COMPARE(flowSpy.count(),3);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::componentChanges()
{
- QQuickView *canvas = createView();
- QTRY_VERIFY(canvas);
- canvas->setSource(testFileUrl("propertychangestest.qml"));
+ QQuickView *window = createView();
+ QTRY_VERIFY(window);
+ window->setSource(testFileUrl("propertychangestest.qml"));
- QQuickGridView *gridView = canvas->rootObject()->findChild<QQuickGridView*>("gridView");
+ QQuickGridView *gridView = window->rootObject()->findChild<QQuickGridView*>("gridView");
QTRY_VERIFY(gridView);
- QQmlComponent component(canvas->engine());
+ QQmlComponent component(window->engine());
component.setData("import QtQuick 2.0; Rectangle { color: \"blue\"; }", QUrl::fromLocalFile(""));
- QQmlComponent delegateComponent(canvas->engine());
+ QQmlComponent delegateComponent(window->engine());
delegateComponent.setData("import QtQuick 2.0; Text { text: '<b>Name:</b> ' + name }", QUrl::fromLocalFile(""));
QSignalSpy highlightSpy(gridView, SIGNAL(highlightChanged()));
QTRY_COMPARE(headerItemSpy.count(),1);
QTRY_COMPARE(footerItemSpy.count(),1);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::modelChanges()
{
- QQuickView *canvas = createView();
- QTRY_VERIFY(canvas);
- canvas->setSource(testFileUrl("propertychangestest.qml"));
+ QQuickView *window = createView();
+ QTRY_VERIFY(window);
+ window->setSource(testFileUrl("propertychangestest.qml"));
- QQuickGridView *gridView = canvas->rootObject()->findChild<QQuickGridView*>("gridView");
+ QQuickGridView *gridView = window->rootObject()->findChild<QQuickGridView*>("gridView");
QTRY_VERIFY(gridView);
- QQuickListModel *alternateModel = canvas->rootObject()->findChild<QQuickListModel*>("alternateModel");
+ QQuickListModel *alternateModel = window->rootObject()->findChild<QQuickListModel*>("alternateModel");
QTRY_VERIFY(alternateModel);
QVariant modelVariant = QVariant::fromValue<QObject *>(alternateModel);
QSignalSpy modelSpy(gridView, SIGNAL(modelChanged()));
gridView->setModel(QVariant());
QTRY_COMPARE(modelSpy.count(),2);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::positionViewAtIndex()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testRightToLeft", QVariant(false));
ctxt->setContextProperty("testTopToBottom", QVariant(false));
ctxt->setContextProperty("testBottomToTop", QVariant(false));
- canvas->setSource(testFileUrl("layouts.qml"));
- canvas->show();
+ window->setSource(testFileUrl("layouts.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(gridview->contentX(), 0.);
gridview->setContentX(80);
- canvas->rootObject()->setProperty("showHeader", true);
+ window->rootObject()->setProperty("showHeader", true);
gridview->positionViewAtBeginning();
QTRY_COMPARE(gridview->contentX(), -30.);
QTRY_COMPARE(gridview->contentX(), 400.); // 8*80 - 240 (8 columns)
gridview->setContentX(80);
- canvas->rootObject()->setProperty("showFooter", true);
+ window->rootObject()->setProperty("showFooter", true);
gridview->positionViewAtEnd();
QTRY_COMPARE(gridview->contentX(), 430.);
QVERIFY(gridview->highlightItem());
QCOMPARE(gridview->highlightItem()->x(), 80.);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::snapping()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setHeight(220);
gridview->positionViewAtIndex(15, QQuickGridView::End);
QCOMPARE(gridview->contentY(), 120.);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::mirroring()
{
- QQuickView *canvasA = createView();
- canvasA->setSource(testFileUrl("mirroring.qml"));
- QQuickGridView *gridviewA = findItem<QQuickGridView>(canvasA->rootObject(), "view");
+ QQuickView *windowA = createView();
+ windowA->setSource(testFileUrl("mirroring.qml"));
+ QQuickGridView *gridviewA = findItem<QQuickGridView>(windowA->rootObject(), "view");
QTRY_VERIFY(gridviewA != 0);
- QQuickView *canvasB = createView();
- canvasB->setSource(testFileUrl("mirroring.qml"));
- QQuickGridView *gridviewB = findItem<QQuickGridView>(canvasB->rootObject(), "view");
+ QQuickView *windowB = createView();
+ windowB->setSource(testFileUrl("mirroring.qml"));
+ QQuickGridView *gridviewB = findItem<QQuickGridView>(windowB->rootObject(), "view");
QTRY_VERIFY(gridviewA != 0);
qApp->processEvents();
foreach (const QString objectName, objectNames)
QCOMPARE(findItem<QQuickItem>(gridviewA, objectName)->x(), findItem<QQuickItem>(gridviewB, objectName)->x());
- delete canvasA;
- delete canvasB;
+ delete windowA;
+ delete windowB;
}
void tst_QQuickGridView::positionViewAtIndex_rightToLeft()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testTopToBottom", QVariant(true));
ctxt->setContextProperty("testRightToLeft", QVariant(true));
ctxt->setContextProperty("testBottomToTop", QVariant(false));
- canvas->setSource(testFileUrl("layouts.qml"));
+ window->setSource(testFileUrl("layouts.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
gridview->positionViewAtIndex(20, QQuickGridView::Contain);
QTRY_COMPARE(gridview->contentX(), -560.);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::resetModel()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QStringList strings;
strings << "one" << "two" << "three";
QStringListModel model(strings);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("displaygrid.qml"));
- canvas->show();
+ window->setSource(testFileUrl("displaygrid.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(display->text(), strings.at(i));
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::enforceRange()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testRightToLeft", QVariant(false));
ctxt->setContextProperty("testTopToBottom", QVariant(false));
- canvas->setSource(testFileUrl("gridview-enforcerange.qml"));
- canvas->show();
+ window->setSource(testFileUrl("gridview-enforcerange.qml"));
+ window->show();
qApp->processEvents();
- QVERIFY(canvas->rootObject() != 0);
+ QVERIFY(window->rootObject() != 0);
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QTRY_COMPARE(gridview->preferredHighlightBegin(), 100.0);
ctxt->setContextProperty("testModel", &model2);
QCOMPARE(gridview->count(), 5);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::enforceRange_rightToLeft()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testRightToLeft", QVariant(true));
ctxt->setContextProperty("testTopToBottom", QVariant(true));
- canvas->setSource(testFileUrl("gridview-enforcerange.qml"));
+ window->setSource(testFileUrl("gridview-enforcerange.qml"));
qApp->processEvents();
- QVERIFY(canvas->rootObject() != 0);
+ QVERIFY(window->rootObject() != 0);
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QCOMPARE(gridview->preferredHighlightBegin(), 100.0);
ctxt->setContextProperty("testModel", &model2);
QCOMPARE(gridview->count(), 5);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::QTBUG_8456()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("setindex.qml"));
+ window->setSource(testFileUrl("setindex.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QTRY_COMPARE(gridview->currentIndex(), 0);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::manualHighlight()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QString filename(testFile("manual-highlight.qml"));
- canvas->setSource(QUrl::fromLocalFile(filename));
+ window->setSource(QUrl::fromLocalFile(filename));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_COMPARE(gridview->highlightItem()->y() - 5, gridview->currentItem()->y());
QTRY_COMPARE(gridview->highlightItem()->x() - 5, gridview->currentItem()->x());
- delete canvas;
+ delete window;
}
QFETCH(QPointF, firstDelegatePos);
QFETCH(QPointF, resizeContentPos);
- QQuickView *canvas = getView();
- canvas->show();
+ QQuickView *window = getView();
+ window->show();
QaimModel model;
for (int i = 0; i < 7; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("footer.qml"));
+ window->setSource(testFileUrl("footer.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
QTRY_COMPARE(footer->pos(), posWhenNoItems);
// if header is toggled, it shouldn't affect the footer position
- canvas->rootObject()->setProperty("showHeader", true);
+ window->rootObject()->setProperty("showHeader", true);
QVERIFY(findItem<QQuickItem>(contentItem, "header") != 0);
QTRY_COMPARE(footer->pos(), posWhenNoItems);
- canvas->rootObject()->setProperty("showHeader", false);
+ window->rootObject()->setProperty("showHeader", false);
// add 30 items
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
QSignalSpy footerItemSpy(gridview, SIGNAL(footerItemChanged()));
- QMetaObject::invokeMethod(canvas->rootObject(), "changeFooter");
+ QMetaObject::invokeMethod(window->rootObject(), "changeFooter");
QCOMPARE(footerItemSpy.count(), 1);
footer->setWidth(40);
QTRY_COMPARE(QPointF(gridview->contentX(), gridview->contentY()), resizeContentPos);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::footer_data()
void tst_QQuickGridView::initialZValues()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("initialZValues.qml"));
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("initialZValues.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QVERIFY(gridview->footerItem());
QTRY_COMPARE(gridview->footerItem()->z(), gridview->property("initialZ").toReal());
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::header()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = getView();
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->rootContext()->setContextProperty("initialViewWidth", 240);
- canvas->rootContext()->setContextProperty("initialViewHeight", 320);
- canvas->setSource(testFileUrl("header.qml"));
- canvas->show();
+ QQuickView *window = getView();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("initialViewWidth", 240);
+ window->rootContext()->setContextProperty("initialViewHeight", 320);
+ window->setSource(testFileUrl("header.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
model.addItem("Item" + QString::number(i), "");
QSignalSpy headerItemSpy(gridview, SIGNAL(headerItemChanged()));
- QMetaObject::invokeMethod(canvas->rootObject(), "changeHeader");
+ QMetaObject::invokeMethod(window->rootObject(), "changeHeader");
QCOMPARE(headerItemSpy.count(), 1);
header->setWidth(40);
QTRY_COMPARE(QPointF(gridview->contentX(), gridview->contentY()), resizeContentPos);
- releaseView(canvas);
+ releaseView(window);
// QTBUG-21207 header should become visible if view resizes from initial empty size
- canvas = getView();
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->rootContext()->setContextProperty("initialViewWidth", 240);
- canvas->rootContext()->setContextProperty("initialViewHeight", 320);
- canvas->setSource(testFileUrl("header.qml"));
- canvas->show();
+ window = getView();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("initialViewWidth", 240);
+ window->rootContext()->setContextProperty("initialViewHeight", 320);
+ window->setSource(testFileUrl("header.qml"));
+ window->show();
qApp->processEvents();
- gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
QTRY_COMPARE(gridview->headerItem()->pos(), initialHeaderPos);
QCOMPARE(QPointF(gridview->contentX(), gridview->contentY()), initialContentPos);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::header_data()
QFETCH(QPointF, origin_empty);
QFETCH(QPointF, origin_nonEmpty);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QmlListModel model;
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("headerfooter.qml"));
- canvas->show();
+ window->setSource(testFileUrl("headerfooter.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = qobject_cast<QQuickGridView*>(canvas->rootObject());
+ QQuickGridView *gridview = qobject_cast<QQuickGridView*>(window->rootObject());
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
gridview->setLayoutDirection(layoutDirection);
QCOMPARE(gridview->originX(), origin_nonEmpty.x());
QCOMPARE(gridview->originY(), origin_nonEmpty.y());
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::extents_data()
{
// Resetting a model shouldn't crash in views with header/footer
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 6; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("headerfooter.qml"));
+ window->setSource(testFileUrl("headerfooter.qml"));
qApp->processEvents();
- QQuickGridView *gridview = qobject_cast<QQuickGridView*>(canvas->rootObject());
+ QQuickGridView *gridview = qobject_cast<QQuickGridView*>(window->rootObject());
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(footer);
QCOMPARE(footer->y(), 60.*2);
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::resizeViewAndRepaint()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("initialWidth", 240);
ctxt->setContextProperty("initialHeight", 100);
- canvas->setSource(testFileUrl("resizeview.qml"));
- canvas->show();
+ window->setSource(testFileUrl("resizeview.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(delegateVisible(item), i < 6); // inside view visible, outside not visible
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::resizeGrid()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testTopToBottom", flow == QQuickGridView::FlowTopToBottom);
ctxt->setContextProperty("testRightToLeft", layoutDirection == Qt::RightToLeft);
ctxt->setContextProperty("testBottomToTop", verticalLayoutDirection == QQuickGridView::BottomToTop);
- canvas->setSource(testFileUrl("resizegrid.qml"));
- canvas->show();
+ window->setSource(testFileUrl("resizegrid.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
// set the width to slightly larger than 3 items across, to test
// items are aligned correctly in right-to-left
- canvas->rootObject()->setWidth(260);
- canvas->rootObject()->setHeight(320);
+ window->rootObject()->setWidth(260);
+ window->rootObject()->setHeight(320);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
QCOMPARE(gridview->contentX(), initialContentPos.x());
}
// change from 3x5 grid to 4x7
- canvas->rootObject()->setWidth(canvas->rootObject()->width() + 80);
- canvas->rootObject()->setHeight(canvas->rootObject()->height() + 60*2);
+ window->rootObject()->setWidth(window->rootObject()->width() + 80);
+ window->rootObject()->setHeight(window->rootObject()->height() + 60*2);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
// other than in LeftToRight+RightToLeft layout, the first item should not move
QCOMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::resizeGrid_data()
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = createView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("initialWidth", 100);
ctxt->setContextProperty("initialHeight", 320);
- canvas->setSource(testFileUrl("resizeview.qml"));
- canvas->show();
+ window->setSource(testFileUrl("resizeview.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(item->y(), qreal(i*60));
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::indexAt_itemAt_data()
QFETCH(qreal, y);
QFETCH(int, index);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QaimModel model;
model.addItem("Fred", "12345");
model.addItem("Ben", "04321");
model.addItem("Jim", "0780");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QCOMPARE(gridview->indexAt(x, y), index);
QVERIFY(gridview->itemAt(x, y) == item);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::onAdd()
const int delegateWidth = 50;
const int delegateHeight = 100;
QaimModel model;
- QQuickView *canvas = getView();
- canvas->setGeometry(0,0,5 * delegateWidth, 5 * delegateHeight); // just ensure all items fit
+ QQuickView *window = getView();
+ window->setGeometry(0,0,5 * delegateWidth, 5 * delegateHeight); // just ensure all items fit
// these initial items should not trigger GridView.onAdd
for (int i=0; i<initialItemCount; i++)
model.addItem("dummy value", "dummy value");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("delegateWidth", delegateWidth);
ctxt->setContextProperty("delegateHeight", delegateHeight);
- canvas->setSource(testFileUrl("attachedSignals.qml"));
+ window->setSource(testFileUrl("attachedSignals.qml"));
- QObject *object = canvas->rootObject();
- object->setProperty("width", canvas->width());
- object->setProperty("height", canvas->height());
+ QObject *object = window->rootObject();
+ object->setProperty("width", window->width());
+ object->setProperty("height", window->height());
qApp->processEvents();
QList<QPair<QString, QString> > items;
items << qMakePair(QString("value %1").arg(i), QString::number(i));
model.addItems(items);
- QTRY_COMPARE(model.count(), qobject_cast<QQuickGridView*>(canvas->rootObject())->count());
+ QTRY_COMPARE(model.count(), qobject_cast<QQuickGridView*>(window->rootObject())->count());
qApp->processEvents();
QVariantList result = object->property("addedDelegates").toList();
for (int i=0; i<items.count(); i++)
QCOMPARE(result[i].toString(), items[i].first);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::onAdd_data()
for (int i=0; i<initialItemCount; i++)
model.addItem(QString("value %1").arg(i), "dummy value");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("delegateWidth", delegateWidth);
ctxt->setContextProperty("delegateHeight", delegateHeight);
- canvas->setSource(testFileUrl("attachedSignals.qml"));
- QObject *object = canvas->rootObject();
+ window->setSource(testFileUrl("attachedSignals.qml"));
+ QObject *object = window->rootObject();
model.removeItems(indexToRemove, removeCount);
- QTRY_COMPARE(model.count(), qobject_cast<QQuickGridView*>(canvas->rootObject())->count());
+ QTRY_COMPARE(model.count(), qobject_cast<QQuickGridView*>(window->rootObject())->count());
QCOMPARE(object->property("removedDelegateCount"), QVariant(removeCount));
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::onRemove_data()
void tst_QQuickGridView::columnCount()
{
- QQuickView canvas;
- canvas.setSource(testFileUrl("gridview4.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowShown(&canvas);
+ QQuickView window;
+ window.setSource(testFileUrl("gridview4.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowShown(&window);
- QQuickGridView *view = qobject_cast<QQuickGridView*>(canvas.rootObject());
+ QQuickGridView *view = qobject_cast<QQuickGridView*>(window.rootObject());
QCOMPARE(view->cellWidth(), qreal(405)/qreal(9));
QCOMPARE(view->cellHeight(), qreal(100));
void tst_QQuickGridView::margins()
{
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testRightToLeft", QVariant(false));
- canvas->setSource(testFileUrl("margins.qml"));
- canvas->show();
+ window->setSource(testFileUrl("margins.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(gridview->originX(), 0.);
QTRY_COMPARE(gridview->contentX(), pos-10);
- delete canvas;
+ delete window;
}
{
//RTL
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testRightToLeft", QVariant(true));
- canvas->setSource(testFileUrl("margins.qml"));
+ window->setSource(testFileUrl("margins.qml"));
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QCOMPARE(gridview->originX(), -900.);
QTRY_COMPARE(gridview->contentX(), pos+10);
- delete canvas;
+ delete window;
}
}
void tst_QQuickGridView::creationContext()
{
- QQuickView canvas;
- canvas.setGeometry(0,0,240,320);
- canvas.setSource(testFileUrl("creationContext.qml"));
+ QQuickView window;
+ window.setGeometry(0,0,240,320);
+ window.setSource(testFileUrl("creationContext.qml"));
qApp->processEvents();
- QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(window.rootObject());
QVERIFY(rootItem);
QVERIFY(rootItem->property("count").toInt() > 0);
QFETCH(qreal, endExtent);
QFETCH(qreal, startExtent);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
- canvas->setSource(testFileUrl("snapToRow.qml"));
- canvas->show();
+ window->setSource(testFileUrl("snapToRow.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
QTRY_VERIFY(contentItem != 0);
// confirm that a flick hits an item boundary
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
if (flow == QQuickGridView::FlowLeftToRight)
QCOMPARE(qreal(fmod(gridview->contentY(),80.0)), snapAlignment);
// flick to end
do {
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
} while (flow == QQuickGridView::FlowLeftToRight
? !gridview->isAtYEnd()
// flick to start
do {
- flick(canvas, flickEnd, flickStart, 180);
+ flick(window, flickEnd, flickStart, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
} while (flow == QQuickGridView::FlowLeftToRight
? !gridview->isAtYBeginning()
else
QCOMPARE(gridview->contentX(), startExtent);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::snapOneRow_data()
QFETCH(qreal, endExtent);
QFETCH(qreal, startExtent);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
- canvas->setSource(testFileUrl("snapOneRow.qml"));
- canvas->show();
+ window->setSource(testFileUrl("snapOneRow.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
gridview->setFlow(flow);
QSignalSpy currentIndexSpy(gridview, SIGNAL(currentIndexChanged()));
// confirm that a flick hits next row boundary
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
if (flow == QQuickGridView::FlowLeftToRight)
QCOMPARE(gridview->contentY(), snapAlignment);
// flick to end
do {
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
} while (flow == QQuickGridView::FlowLeftToRight
? !gridview->isAtYEnd()
// flick to start
do {
- flick(canvas, flickEnd, flickStart, 180);
+ flick(window, flickEnd, flickStart, 180);
QTRY_VERIFY(gridview->isMoving() == false); // wait until it stops
} while (flow == QQuickGridView::FlowLeftToRight
? !gridview->isAtYBeginning()
QCOMPARE(currentIndexSpy.count(), 6);
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::unaligned()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
for (int i = 0; i < 10; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("unaligned.qml"));
+ window->setSource(testFileUrl("unaligned.qml"));
qApp->processEvents();
- QQuickGridView *gridview = qobject_cast<QQuickGridView*>(canvas->rootObject());
+ QQuickGridView *gridview = qobject_cast<QQuickGridView*>(window->rootObject());
QVERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QCOMPARE(item->y(), qreal(i/9)*gridview->cellHeight());
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::populateTransitions()
model.addItem("item" + QString::number(i), "");
}
- QQuickView *canvas = getView();
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->rootContext()->setContextProperty("usePopulateTransition", usePopulateTransition);
- canvas->rootContext()->setContextProperty("dynamicallyPopulate", dynamicallyPopulate);
- canvas->rootContext()->setContextProperty("transitionFrom", transitionFrom);
- canvas->rootContext()->setContextProperty("transitionVia", transitionVia);
- canvas->rootContext()->setContextProperty("model_transitionFrom", &model_transitionFrom);
- canvas->rootContext()->setContextProperty("model_transitionVia", &model_transitionVia);
- canvas->setSource(testFileUrl("populateTransitions.qml"));
- canvas->show();
-
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickView *window = getView();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("usePopulateTransition", usePopulateTransition);
+ window->rootContext()->setContextProperty("dynamicallyPopulate", dynamicallyPopulate);
+ window->rootContext()->setContextProperty("transitionFrom", transitionFrom);
+ window->rootContext()->setContextProperty("transitionVia", transitionVia);
+ window->rootContext()->setContextProperty("model_transitionFrom", &model_transitionFrom);
+ window->rootContext()->setContextProperty("model_transitionVia", &model_transitionVia);
+ window->setSource(testFileUrl("populateTransitions.qml"));
+ window->show();
+
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QVERIFY(gridview);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem);
QTRY_COMPARE(gridview->property("countPopulateTransitions").toInt(), 0);
// clear the model
- canvas->rootContext()->setContextProperty("testModel", QVariant());
+ window->rootContext()->setContextProperty("testModel", QVariant());
QTRY_COMPARE(gridview->count(), 0);
QTRY_COMPARE(findItems<QQuickItem>(contentItem, "wrapper").count(), 0);
gridview->setProperty("countPopulateTransitions", 0);
model.clear();
for (int i = 0; i < 30; i++)
model.addItem("item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("testModel", &model);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
QTRY_COMPARE(gridview->property("countPopulateTransitions").toInt(), usePopulateTransition ? 18 : 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::populateTransitions_data()
QaimModel model_targetItems_transitionFrom;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("model_targetItems_transitionFrom", &model_targetItems_transitionFrom);
ctxt->setContextProperty("model_displacedItems_transitionVia", &model_displacedItems_transitionVia);
ctxt->setContextProperty("targetItems_transitionFrom", targetItems_transitionFrom);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
- canvas->setSource(testFileUrl("addTransitions.qml"));
- canvas->show();
+ window->setSource(testFileUrl("addTransitions.qml"));
+ window->show();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QCOMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::addTransitions_data()
QaimModel model_targetItems_transitionVia;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("model_targetItems_transitionVia", &model_targetItems_transitionVia);
ctxt->setContextProperty("model_displacedItems_transitionVia", &model_displacedItems_transitionVia);
ctxt->setContextProperty("targetItems_transitionVia", targetItems_transitionVia);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
- canvas->setSource(testFileUrl("moveTransitions.qml"));
- canvas->show();
+ window->setSource(testFileUrl("moveTransitions.qml"));
+ window->show();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::moveTransitions_data()
QaimModel model_targetItems_transitionTo;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("model_targetItems_transitionTo", &model_targetItems_transitionTo);
ctxt->setContextProperty("model_displacedItems_transitionVia", &model_displacedItems_transitionVia);
ctxt->setContextProperty("targetItems_transitionTo", targetItems_transitionTo);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
- canvas->setSource(testFileUrl("removeTransitions.qml"));
- canvas->show();
+ window->setSource(testFileUrl("removeTransitions.qml"));
+ window->show();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::removeTransitions_data()
QPointF moveDisplaced_transitionVia(50, -100);
QPointF removeDisplaced_transitionVia(150, 100);
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("model_displaced_transitionVia", &model_displaced_transitionVia);
ctxt->setContextProperty("model_addDisplaced_transitionVia", &model_addDisplaced_transitionVia);
ctxt->setContextProperty("moveDisplacedEnabled", moveDisplacedEnabled);
ctxt->setContextProperty("useRemoveDisplaced", useRemoveDisplaced);
ctxt->setContextProperty("removeDisplacedEnabled", removeDisplacedEnabled);
- canvas->setSource(testFileUrl("displacedTransitions.qml"));
- canvas->show();
+ window->setSource(testFileUrl("displacedTransitions.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::displacedTransitions_data()
for (int i = 0; i < initialCount; i++)
model.addItem("Original item" + QString::number(i), "");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("addTargets_transitionFrom", addTargets_transitionFrom);
ctxt->setContextProperty("addDisplaced_transitionFrom", addDisplaced_transitionFrom);
ctxt->setContextProperty("enableMoveTransitions", enableMoveTransitions);
ctxt->setContextProperty("enableRemoveTransitions", enableRemoveTransitions);
ctxt->setContextProperty("rippleAddDisplaced", rippleAddDisplaced);
- canvas->setSource(testFileUrl("multipleTransitions.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("multipleTransitions.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
}
- int timeBetweenActions = canvas->rootObject()->property("timeBetweenActions").toInt();
+ int timeBetweenActions = window->rootObject()->property("timeBetweenActions").toInt();
for (int i=0; i<changes.count(); i++) {
switch (changes[i].type) {
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickGridView::multipleTransitions_data()
for (int i = 0; i < 30; i++)
model.addItem("Original item" + QString::number(i), "");
- QQuickView *canvas = createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = createView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("multipleDisplaced.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("multipleDisplaced.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QTRY_VERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(QQuickItemPrivate::get(gridview)->polishScheduled, false);
model.moveItems(12, 8, 1);
- QTest::qWait(canvas->rootObject()->property("duration").toInt() / 2);
+ QTest::qWait(window->rootObject()->property("duration").toInt() / 2);
model.moveItems(8, 3, 1);
QTRY_VERIFY(gridview->property("displaceTransitionsDone").toBool());
QTRY_COMPARE(name->text(), model.name(i));
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::cacheBuffer()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 90; i++)
model.addItem("Item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("gridview1.qml"));
- canvas->show();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("gridview1.qml"));
+ window->show();
qApp->processEvents();
- QQuickGridView *gridview = findItem<QQuickGridView>(canvas->rootObject(), "grid");
+ QQuickGridView *gridview = findItem<QQuickGridView>(window->rootObject(), "grid");
QVERIFY(gridview != 0);
QQuickItem *contentItem = gridview->contentItem();
}
QQmlIncubationController controller;
- canvas->engine()->setIncubationController(&controller);
+ window->engine()->setIncubationController(&controller);
- canvas->rootObject()->setProperty("cacheBuffer", 200);
+ window->rootObject()->setProperty("cacheBuffer", 200);
QTRY_VERIFY(gridview->cacheBuffer() == 200);
// items will be created one at a time
controller.incubateWhile(&b);
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::asynchronous()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QQmlIncubationController controller;
- canvas->engine()->setIncubationController(&controller);
+ window->engine()->setIncubationController(&controller);
- canvas->setSource(testFileUrl("asyncloader.qml"));
+ window->setSource(testFileUrl("asyncloader.qml"));
- QQuickItem *rootObject = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootObject = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootObject);
QQuickGridView *gridview = 0;
QVERIFY(item->y() == (i/3)*100);
}
- delete canvas;
+ delete window;
}
void tst_QQuickGridView::unrequestedVisibility()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testWrap", QVariant(false));
- canvas->setSource(testFileUrl("unrequestedItems.qml"));
+ window->setSource(testFileUrl("unrequestedItems.qml"));
- canvas->show();
+ window->show();
qApp->processEvents();
- QQuickGridView *leftview = findItem<QQuickGridView>(canvas->rootObject(), "leftGrid");
+ QQuickGridView *leftview = findItem<QQuickGridView>(window->rootObject(), "leftGrid");
QTRY_VERIFY(leftview != 0);
- QQuickGridView *rightview = findItem<QQuickGridView>(canvas->rootObject(), "rightGrid");
+ QQuickGridView *rightview = findItem<QQuickGridView>(window->rootObject(), "rightGrid");
QTRY_VERIFY(rightview != 0);
QQuickItem *leftContent = leftview->contentItem();
QVERIFY(item = findItem<QQuickItem>(rightContent, "wrapper", 10));
QCOMPARE(delegateVisible(item), false);
- delete canvas;
+ delete window;
}
#include <QtTest/QSignalSpy>
#include <QtGui/QPainter>
#include <QtGui/QImageReader>
-#include <QQuickCanvas>
+#include <QQuickWindow>
#include "../../shared/util.h"
#include "../../shared/testhttpserver.h"
void tst_qquickimage::cleanup()
{
- QQuickCanvas canvas;
- canvas.releaseResources();
+ QQuickWindow window;
+ window.releaseResources();
engine.clearComponentCache();
}
void tst_qquickimage::preserveAspectRatio()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->show();
- canvas->setSource(testFileUrl("aspectratio.qml"));
- QQuickImage *image = qobject_cast<QQuickImage*>(canvas->rootObject());
+ window->setSource(testFileUrl("aspectratio.qml"));
+ QQuickImage *image = qobject_cast<QQuickImage*>(window->rootObject());
QVERIFY(image != 0);
image->setWidth(80.0);
QCOMPARE(image->width(), 80.);
QCOMPARE(image->height(), 80.);
- canvas->setSource(testFileUrl("aspectratio.qml"));
- image = qobject_cast<QQuickImage*>(canvas->rootObject());
+ window->setSource(testFileUrl("aspectratio.qml"));
+ image = qobject_cast<QQuickImage*>(window->rootObject());
image->setHeight(60.0);
QVERIFY(image != 0);
QCOMPARE(image->height(), 60.);
QCOMPARE(image->width(), 60.);
- delete canvas;
+ delete window;
}
void tst_qquickimage::smooth()
qreal height = 250;
foreach (QQuickImage::FillMode fillMode, fillModes) {
- QQuickView *canvas = new QQuickView;
- canvas->setSource(testFileUrl("mirror.qml"));
+ QQuickView *window = new QQuickView;
+ window->setSource(testFileUrl("mirror.qml"));
- QQuickImage *obj = canvas->rootObject()->findChild<QQuickImage*>("image");
+ QQuickImage *obj = window->rootObject()->findChild<QQuickImage*>("image");
QVERIFY(obj != 0);
obj->setFillMode(fillMode);
obj->setProperty("mirror", true);
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
- QImage screenshot = canvas->grabFrameBuffer();
+ QImage screenshot = window->grabWindow();
screenshots[fillMode] = screenshot;
- delete canvas;
+ delete window;
}
foreach (QQuickImage::FillMode fillMode, fillModes) {
QQuickImage *tiling = findItem<QQuickImage>(view.rootObject(), "tiling");
QVERIFY(tiling != 0);
- QImage img = view.grabFrameBuffer();
+ QImage img = view.grabWindow();
for (int x = 0; x < tiling->width(); ++x) {
for (int y = 0; y < tiling->height(); ++y) {
QVERIFY(img.pixel(x, y) == qRgb(0, 255, 0));
void tst_qquickimage::sourceSize_QTBUG_16389()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("qtbug_16389.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("qtbug_16389.qml"));
+ window->show();
qApp->processEvents();
- QQuickImage *image = findItem<QQuickImage>(canvas->rootObject(), "iconImage");
- QQuickItem *handle = findItem<QQuickItem>(canvas->rootObject(), "blueHandle");
+ QQuickImage *image = findItem<QQuickImage>(window->rootObject(), "iconImage");
+ QQuickItem *handle = findItem<QQuickItem>(window->rootObject(), "blueHandle");
QCOMPARE(image->sourceSize().width(), 200);
QCOMPARE(image->sourceSize().height(), 200);
QCOMPARE(image->paintedWidth(), 20.0);
QCOMPARE(image->paintedHeight(), 20.0);
- delete canvas;
+ delete window;
}
static int numberOfWarnings = 0;
// QTBUG-15690
void tst_qquickimage::nullPixmapPaint()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("nullpixmap.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("nullpixmap.qml"));
+ window->show();
- QQuickImage *image = qobject_cast<QQuickImage*>(canvas->rootObject());
+ QQuickImage *image = qobject_cast<QQuickImage*>(window->rootObject());
QTRY_VERIFY(image != 0);
image->setSource(SERVER_ADDR + QString("/no-such-file.png"));
QtMsgHandler previousMsgHandler = qInstallMsgHandler(checkWarnings);
// used to print "QTransform::translate with NaN called"
- QPixmap pm = QPixmap::fromImage(canvas->grabFrameBuffer());
+ QPixmap pm = QPixmap::fromImage(window->grabWindow());
qInstallMsgHandler(previousMsgHandler);
QVERIFY(numberOfWarnings == 0);
delete image;
- delete canvas;
+ delete window;
}
void tst_qquickimage::imageCrash_QTBUG_22125()
QFETCH(qreal, implicitWidth);
QFETCH(qreal, implicitHeight);
- QQuickView *canvas = new QQuickView(0);
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = new QQuickView(0);
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("srcWidth", sourceWidth);
ctxt->setContextProperty("srcHeight", sourceHeight);
- canvas->setSource(testFileUrl("sourceSize.qml"));
- canvas->show();
+ window->setSource(testFileUrl("sourceSize.qml"));
+ window->show();
qApp->processEvents();
- QQuickImage *image = qobject_cast<QQuickImage*>(canvas->rootObject());
+ QQuickImage *image = qobject_cast<QQuickImage*>(window->rootObject());
QVERIFY(image);
QCOMPARE(image->sourceSize().width(), sourceWidth);
QCOMPARE(image->implicitWidth(), implicitWidth);
QCOMPARE(image->implicitHeight(), implicitHeight);
- delete canvas;
+ delete window;
}
void tst_qquickimage::sourceSizeChanges()
#include <qtest.h>
#include <QtQuick/qquickitem.h>
-#include <QtQuick/qquickcanvas.h>
+#include <QtQuick/qquickwindow.h>
#include <QtQuick/qquickview.h>
#include <QtWidgets/QGraphicsSceneMouseEvent>
#include "private/qquickfocusscope_p.h"
virtual void wheelEvent(QWheelEvent *event) { event->accept(); ++wheelCount; }
};
-class TestCanvas: public QQuickCanvas
+class TestWindow: public QQuickWindow
{
public:
- TestCanvas()
- : QQuickCanvas()
+ TestWindow()
+ : QQuickWindow()
{}
virtual bool event(QEvent *event)
{
- return QQuickCanvas::event(event);
+ return QQuickWindow::event(event);
}
};
private slots:
void initTestCase();
- void noCanvas();
+ void noWindow();
void simpleFocus();
void scopedFocus();
- void addedToCanvas();
+ void addedToWindow();
void changeParent();
void multipleFocusClears();
void focusSubItemInNonFocusScope();
qmlRegisterType<TestPolishItem>("Qt.test", 1, 0, "TestPolishItem");
}
-// Focus still updates when outside a canvas
-void tst_qquickitem::noCanvas()
+// Focus still updates when outside a window
+void tst_qquickitem::noWindow()
{
QQuickItem *root = new TestItem;
QQuickItem *child = new TestItem(root);
#define FVERIFY() \
do { \
if (focusState.activeFocusItem) { \
- QCOMPARE(canvas.activeFocusItem(), focusState.activeFocusItem); \
- if (qobject_cast<TestItem *>(canvas.activeFocusItem())) \
- QCOMPARE(qobject_cast<TestItem *>(canvas.activeFocusItem())->focused, true); \
- else if (qobject_cast<TestFocusScope *>(canvas.activeFocusItem())) \
- QCOMPARE(qobject_cast<TestFocusScope *>(canvas.activeFocusItem())->focused, true); \
+ QCOMPARE(window.activeFocusItem(), focusState.activeFocusItem); \
+ if (qobject_cast<TestItem *>(window.activeFocusItem())) \
+ QCOMPARE(qobject_cast<TestItem *>(window.activeFocusItem())->focused, true); \
+ else if (qobject_cast<TestFocusScope *>(window.activeFocusItem())) \
+ QCOMPARE(qobject_cast<TestFocusScope *>(window.activeFocusItem())->focused, true); \
} else { \
- QCOMPARE(canvas.activeFocusItem(), canvas.rootItem()); \
+ QCOMPARE(window.activeFocusItem(), window.rootItem()); \
} \
for (QHash<QQuickItem *, FocusData>::Iterator iter = focusState.begin(); \
iter != focusState.end(); \
// Tests a simple set of top-level scoped items
void tst_qquickitem::simpleFocus()
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
#ifdef Q_OS_MAC
QSKIP("QTBUG-24094: fails on Mac OS X 10.7");
#endif
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
- QQuickItem *l1c1 = new TestItem(canvas.rootItem());
- QQuickItem *l1c2 = new TestItem(canvas.rootItem());
- QQuickItem *l1c3 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c1 = new TestItem(window.rootItem());
+ QQuickItem *l1c2 = new TestItem(window.rootItem());
+ QQuickItem *l1c3 = new TestItem(window.rootItem());
QQuickItem *l2c1 = new TestItem(l1c1);
QQuickItem *l2c2 = new TestItem(l1c1);
// Items with a focus scope
void tst_qquickitem::scopedFocus()
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
- QQuickItem *l1c1 = new TestItem(canvas.rootItem());
- QQuickItem *l1c2 = new TestItem(canvas.rootItem());
- QQuickItem *l1c3 = new TestItem(canvas.rootItem());
+ QQuickItem *l1c1 = new TestItem(window.rootItem());
+ QQuickItem *l1c2 = new TestItem(window.rootItem());
+ QQuickItem *l1c3 = new TestItem(window.rootItem());
QQuickItem *l2c1 = new TestItem(l1c1);
QQuickItem *l2c2 = new TestItem(l1c1);
FVERIFY();
}
-// Tests focus corrects itself when a tree is added to a canvas for the first time
-void tst_qquickitem::addedToCanvas()
+// Tests focus corrects itself when a tree is added to a window for the first time
+void tst_qquickitem::addedToWindow()
{
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
QQuickItem *item = new TestItem;
focusState[item].set(true, false);
FVERIFY();
- item->setParentItem(canvas.rootItem());
+ item->setParentItem(window.rootItem());
focusState[item].set(true, true);
focusState.active(item);
FVERIFY();
}
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
- QQuickItem *item = new TestItem(canvas.rootItem());
+ QQuickItem *item = new TestItem(window.rootItem());
QQuickItem *tree = new TestItem;
QQuickItem *c1 = new TestItem(tree);
}
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
QQuickItem *tree = new TestItem;
QQuickItem *c1 = new TestItem(tree);
focusState[c2].set(true, false);
FVERIFY();
- tree->setParentItem(canvas.rootItem());
+ tree->setParentItem(window.rootItem());
focusState[c1].set(false, false);
focusState[c2].set(true, true);
focusState.active(c2);
}
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
QQuickItem *tree = new TestFocusScope;
QQuickItem *c1 = new TestItem(tree);
QQuickItem *c2 = new TestItem(tree);
focusState[c2].set(true, false);
FVERIFY();
- tree->setParentItem(canvas.rootItem());
+ tree->setParentItem(window.rootItem());
focusState[c1].set(false, false);
focusState[c2].set(true, false);
FVERIFY();
}
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
QQuickItem *tree = new TestFocusScope;
QQuickItem *c1 = new TestItem(tree);
QQuickItem *c2 = new TestItem(tree);
focusState[c2].set(true, false);
FVERIFY();
- tree->setParentItem(canvas.rootItem());
+ tree->setParentItem(window.rootItem());
focusState[tree].set(true, true);
focusState[c1].set(false, false);
focusState[c2].set(true, true);
}
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
- QQuickItem *child = new TestItem(canvas.rootItem());
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+ QQuickItem *child = new TestItem(window.rootItem());
QQuickItem *tree = new TestFocusScope;
QQuickItem *c1 = new TestItem(tree);
QQuickItem *c2 = new TestItem(tree);
focusState.active(child);
FVERIFY();
- tree->setParentItem(canvas.rootItem());
+ tree->setParentItem(window.rootItem());
focusState[tree].set(false, false);
focusState[c1].set(false, false);
focusState[c2].set(true, false);
{
// Parent to no parent
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
- QQuickItem *child = new TestItem(canvas.rootItem());
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+ QQuickItem *child = new TestItem(window.rootItem());
FocusState focusState;
focusState << child;
// Different parent, same focus scope
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
- QQuickItem *child = new TestItem(canvas.rootItem());
- QQuickItem *child2 = new TestItem(canvas.rootItem());
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+ QQuickItem *child = new TestItem(window.rootItem());
+ QQuickItem *child2 = new TestItem(window.rootItem());
FocusState focusState;
focusState << child << child2;
// Different parent, different focus scope
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
- QQuickItem *child = new TestItem(canvas.rootItem());
- QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+ QQuickItem *child = new TestItem(window.rootItem());
+ QQuickItem *child2 = new TestFocusScope(window.rootItem());
QQuickItem *item = new TestItem(child);
FocusState focusState;
FVERIFY();
}
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
- QQuickItem *child = new TestItem(canvas.rootItem());
- QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+ QQuickItem *child = new TestItem(window.rootItem());
+ QQuickItem *child2 = new TestFocusScope(window.rootItem());
QQuickItem *item = new TestItem(child2);
FocusState focusState;
FVERIFY();
}
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
- QQuickItem *child = new TestItem(canvas.rootItem());
- QQuickItem *child2 = new TestFocusScope(canvas.rootItem());
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+ QQuickItem *child = new TestItem(window.rootItem());
+ QQuickItem *child2 = new TestFocusScope(window.rootItem());
QQuickItem *item = new TestItem(child2);
FocusState focusState;
// child has active focus, then its fs parent changes parent to 0, then
// child is deleted, then its parent changes again to a valid parent
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
- QQuickItem *item = new TestFocusScope(canvas.rootItem());
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
+ QQuickItem *item = new TestFocusScope(window.rootItem());
QQuickItem *child = new TestItem(item);
QQuickItem *child2 = new TestItem;
focusState.remove(child);
delete child;
- item->setParentItem(canvas.rootItem());
+ item->setParentItem(window.rootItem());
focusState[item].set(true, true);
focusState.active(item);
FVERIFY();
void tst_qquickitem::parentItemWithFocus()
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
{
QQuickItem parent;
QQuickItem child;
focusState[&child].set(false, false);
FVERIFY();
- parent.setParentItem(canvas.rootItem());
+ parent.setParentItem(window.rootItem());
focusState[&parent].set(true, true);
focusState[&child].set(false, false);
focusState.active(&parent);
focusState[&grandchild].set(false, false);
FVERIFY();
- parent.setParentItem(canvas.rootItem());
+ parent.setParentItem(window.rootItem());
focusState[&parent].set(true, true);
focusState[&child].set(false, false);
focusState[&grandchild].set(false, false);
void tst_qquickitem::reparentFocusedItem()
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == &canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == &window);
- QQuickItem parent(canvas.rootItem());
+ QQuickItem parent(window.rootItem());
QQuickItem child(&parent);
QQuickItem sibling(&parent);
QQuickItem grandchild(&child);
void tst_qquickitem::enabledFocus()
{
- QQuickCanvas canvas;
- ensureFocus(&canvas);
+ QQuickWindow window;
+ ensureFocus(&window);
QQuickFocusScope root;
QCOMPARE(root.hasFocus(), true);
QCOMPARE(root.hasActiveFocus(), false);
- root.setParentItem(canvas.rootItem());
+ root.setParentItem(window.rootItem());
QCOMPARE(root.isEnabled(), false);
QCOMPARE(root.hasFocus(), true);
QCOMPARE(root.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+ QCOMPARE(window.activeFocusItem(), window.rootItem());
root.setEnabled(true);
QCOMPARE(root.isEnabled(), true);
QCOMPARE(root.hasFocus(), true);
QCOMPARE(root.hasActiveFocus(), true);
- QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+ QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
QQuickItem child1;
child1.setParentItem(&root);
QCOMPARE(child1.isEnabled(), true);
QCOMPARE(child1.hasFocus(), false);
QCOMPARE(child1.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+ QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
QQuickItem child2;
child2.setFocus(true);
QCOMPARE(child2.isEnabled(), true);
QCOMPARE(child2.hasFocus(), true);
QCOMPARE(child2.hasActiveFocus(), true);
- QCOMPARE(canvas.activeFocusItem(), &child2);
+ QCOMPARE(window.activeFocusItem(), &child2);
child2.setEnabled(false);
QCOMPARE(child2.isEnabled(), false);
QCOMPARE(child2.hasFocus(), true);
QCOMPARE(child2.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+ QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
child1.setEnabled(false);
QCOMPARE(child1.isEnabled(), false);
QCOMPARE(child2.isEnabled(), false);
QCOMPARE(child2.hasFocus(), false);
QCOMPARE(child2.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+ QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
child1.setEnabled(true);
QCOMPARE(child1.isEnabled(), true);
QCOMPARE(child1.hasFocus(), true);
QCOMPARE(child1.hasActiveFocus(), true);
- QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&child1));
+ QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&child1));
root.setFocus(false);
QCOMPARE(root.isEnabled(), true);
QCOMPARE(child1.isEnabled(), true);
QCOMPARE(child1.hasFocus(), true);
QCOMPARE(child1.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+ QCOMPARE(window.activeFocusItem(), window.rootItem());
child2.forceActiveFocus();
QCOMPARE(root.isEnabled(), true);
QCOMPARE(child2.isEnabled(), false);
QCOMPARE(child2.hasFocus(), true);
QCOMPARE(child2.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&root));
+ QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&root));
root.setEnabled(false);
QCOMPARE(root.isEnabled(), false);
QCOMPARE(child2.isEnabled(), false);
QCOMPARE(child2.hasFocus(), true);
QCOMPARE(child2.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+ QCOMPARE(window.activeFocusItem(), window.rootItem());
child1.forceActiveFocus();
QCOMPARE(root.isEnabled(), false);
QCOMPARE(child2.isEnabled(), false);
QCOMPARE(child2.hasFocus(), false);
QCOMPARE(child2.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), canvas.rootItem());
+ QCOMPARE(window.activeFocusItem(), window.rootItem());
root.setEnabled(true);
QCOMPARE(root.isEnabled(), true);
QCOMPARE(child2.isEnabled(), false);
QCOMPARE(child2.hasFocus(), false);
QCOMPARE(child2.hasActiveFocus(), false);
- QCOMPARE(canvas.activeFocusItem(), static_cast<QQuickItem *>(&child1));
+ QCOMPARE(window.activeFocusItem(), static_cast<QQuickItem *>(&child1));
}
void tst_qquickitem::mouseGrab()
{
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(200, 200);
- canvas->show();
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(200, 200);
+ window->show();
TestItem *child1 = new TestItem;
child1->setAcceptedMouseButtons(Qt::LeftButton);
child1->setSize(QSizeF(200, 100));
- child1->setParentItem(canvas->rootItem());
+ child1->setParentItem(window->rootItem());
TestItem *child2 = new TestItem;
child2->setAcceptedMouseButtons(Qt::LeftButton);
child2->setY(51);
child2->setSize(QSizeF(200, 100));
- child2->setParentItem(canvas->rootItem());
+ child2->setParentItem(window->rootItem());
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(100);
- QVERIFY(canvas->mouseGrabberItem() == child1);
+ QVERIFY(window->mouseGrabberItem() == child1);
QTest::qWait(100);
QCOMPARE(child1->pressCount, 1);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
- QVERIFY(canvas->mouseGrabberItem() == 0);
+ QVERIFY(window->mouseGrabberItem() == 0);
QCOMPARE(child1->releaseCount, 1);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
- QVERIFY(canvas->mouseGrabberItem() == child1);
+ QVERIFY(window->mouseGrabberItem() == child1);
QCOMPARE(child1->pressCount, 2);
child1->setEnabled(false);
- QVERIFY(canvas->mouseGrabberItem() == 0);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QVERIFY(window->mouseGrabberItem() == 0);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
QCOMPARE(child1->releaseCount, 1);
child1->setEnabled(true);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
- QVERIFY(canvas->mouseGrabberItem() == child1);
+ QVERIFY(window->mouseGrabberItem() == child1);
QCOMPARE(child1->pressCount, 3);
child1->setVisible(false);
- QVERIFY(canvas->mouseGrabberItem() == 0);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QVERIFY(window->mouseGrabberItem() == 0);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
QCOMPARE(child1->releaseCount, 1);
child1->setVisible(true);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
- QVERIFY(canvas->mouseGrabberItem() == child1);
+ QVERIFY(window->mouseGrabberItem() == child1);
QCOMPARE(child1->pressCount, 4);
child2->grabMouse();
- QVERIFY(canvas->mouseGrabberItem() == child2);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QVERIFY(window->mouseGrabberItem() == child2);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
QCOMPARE(child1->releaseCount, 1);
QCOMPARE(child2->releaseCount, 1);
child2->grabMouse();
- QVERIFY(canvas->mouseGrabberItem() == child2);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QVERIFY(window->mouseGrabberItem() == child2);
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
QCOMPARE(child1->pressCount, 4);
QCOMPARE(child2->pressCount, 1);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50,50));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50,50));
QTest::qWait(50);
QCOMPARE(child1->releaseCount, 1);
QCOMPARE(child2->releaseCount, 2);
delete child1;
delete child2;
- delete canvas;
+ delete window;
}
void tst_qquickitem::touchEventAcceptIgnore_data()
{
QFETCH(bool, itemSupportsTouch);
- TestCanvas *canvas = new TestCanvas;
- canvas->resize(100, 100);
- canvas->show();
+ TestWindow *window = new TestWindow;
+ window->resize(100, 100);
+ window->show();
TestItem *item = new TestItem;
item->setSize(QSizeF(100, 100));
- item->setParentItem(canvas->rootItem());
+ item->setParentItem(window->rootItem());
item->acceptIncomingTouchEvents = itemSupportsTouch;
static QTouchDevice* device = 0;
item->touchEventReached = false;
- bool accepted = canvas->event(&event);
+ bool accepted = window->event(&event);
QVERIFY(item->touchEventReached);
QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
item->touchEventReached = false;
- bool accepted = canvas->event(&event);
+ bool accepted = window->event(&event);
QCOMPARE(item->touchEventReached, itemSupportsTouch);
QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
item->touchEventReached = false;
- bool accepted = canvas->event(&event);
+ bool accepted = window->event(&event);
QCOMPARE(item->touchEventReached, itemSupportsTouch);
QCOMPARE(accepted && event.isAccepted(), itemSupportsTouch);
}
delete item;
- delete canvas;
+ delete window;
}
void tst_qquickitem::polishOutsideAnimation()
{
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(200, 200);
- canvas->show();
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(200, 200);
+ window->show();
- TestPolishItem *item = new TestPolishItem(canvas->rootItem());
+ TestPolishItem *item = new TestPolishItem(window->rootItem());
item->setSize(QSizeF(200, 100));
QTest::qWait(50);
QTRY_VERIFY(item->wasPolished);
delete item;
- delete canvas;
+ delete window;
}
void tst_qquickitem::polishOnCompleted()
const bool shouldReceiveWheelEvents = visible && enabled;
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(200, 200);
- canvas->show();
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(200, 200);
+ window->show();
TestItem *item = new TestItem;
item->setSize(QSizeF(200, 100));
- item->setParentItem(canvas->rootItem());
+ item->setParentItem(window->rootItem());
item->setEnabled(enabled);
item->setVisible(visible);
QWheelEvent event(QPoint(100, 50), -120, Qt::NoButton, Qt::NoModifier, Qt::Vertical);
event.setAccepted(false);
- QGuiApplication::sendEvent(canvas, &event);
+ QGuiApplication::sendEvent(window, &event);
if (shouldReceiveWheelEvents) {
QVERIFY(event.isAccepted());
QCOMPARE(item->wheelCount, 0);
}
- delete canvas;
+ delete window;
}
class HoverItem : public QQuickItem
QFETCH(bool, enabled);
QFETCH(bool, acceptHoverEvents);
- QQuickCanvas *canvas = new QQuickCanvas();
- canvas->resize(200, 200);
- canvas->show();
+ QQuickWindow *window = new QQuickWindow();
+ window->resize(200, 200);
+ window->show();
HoverItem *item = new HoverItem;
item->setSize(QSizeF(100, 100));
- item->setParentItem(canvas->rootItem());
+ item->setParentItem(window->rootItem());
item->setEnabled(enabled);
item->setVisible(visible);
const QPoint inside(50, 50);
const QPoint anotherInside(51, 51);
- sendMouseMove(canvas, outside);
+ sendMouseMove(window, outside);
item->resetCounters();
// Enter, then move twice inside, then leave.
- sendMouseMove(canvas, inside);
- sendMouseMove(canvas, anotherInside);
- sendMouseMove(canvas, inside);
- sendMouseMove(canvas, outside);
+ sendMouseMove(window, inside);
+ sendMouseMove(window, anotherInside);
+ sendMouseMove(window, inside);
+ sendMouseMove(window, outside);
const bool shouldReceiveHoverEvents = visible && enabled && acceptHoverEvents;
if (shouldReceiveHoverEvents) {
QCOMPARE(item->hoverLeaveCount, 0);
}
- delete canvas;
+ delete window;
}
void tst_qquickitem::hoverEventInParent()
{
- QQuickCanvas *canvas = new QQuickCanvas();
- canvas->resize(200, 200);
- canvas->show();
+ QQuickWindow *window = new QQuickWindow();
+ window->resize(200, 200);
+ window->show();
- HoverItem *parentItem = new HoverItem(canvas->rootItem());
+ HoverItem *parentItem = new HoverItem(window->rootItem());
parentItem->setSize(QSizeF(200, 200));
parentItem->setAcceptHoverEvents(true);
const QPoint insideLeft(50, 100);
const QPoint insideRight(150, 100);
- sendMouseMove(canvas, insideLeft);
+ sendMouseMove(window, insideLeft);
parentItem->resetCounters();
leftItem->resetCounters();
rightItem->resetCounters();
- sendMouseMove(canvas, insideRight);
+ sendMouseMove(window, insideRight);
QCOMPARE(parentItem->hoverEnterCount, 0);
QCOMPARE(parentItem->hoverLeaveCount, 0);
QCOMPARE(leftItem->hoverEnterCount, 0);
QCOMPARE(rightItem->hoverEnterCount, 1);
QCOMPARE(rightItem->hoverLeaveCount, 0);
- sendMouseMove(canvas, insideLeft);
+ sendMouseMove(window, insideLeft);
QCOMPARE(parentItem->hoverEnterCount, 0);
QCOMPARE(parentItem->hoverLeaveCount, 0);
QCOMPARE(leftItem->hoverEnterCount, 1);
QCOMPARE(rightItem->hoverEnterCount, 1);
QCOMPARE(rightItem->hoverLeaveCount, 1);
- delete canvas;
+ delete window;
}
void tst_qquickitem::paintOrder_data()
TestItem item;
QCOMPARE(item.acceptedMouseButtons(), Qt::MouseButtons(Qt::NoButton));
- QQuickCanvas canvas;
+ QQuickWindow window;
item.setSize(QSizeF(200,100));
- item.setParentItem(canvas.rootItem());
+ item.setParentItem(window.rootItem());
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 0);
QCOMPARE(item.releaseCount, 0);
- QTest::mousePress(&canvas, Qt::RightButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::RightButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::RightButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::RightButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 0);
QCOMPARE(item.releaseCount, 0);
- QTest::mousePress(&canvas, Qt::MiddleButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::MiddleButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::MiddleButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 0);
QCOMPARE(item.releaseCount, 0);
item.setAcceptedMouseButtons(Qt::LeftButton);
QCOMPARE(item.acceptedMouseButtons(), Qt::MouseButtons(Qt::LeftButton));
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 1);
QCOMPARE(item.releaseCount, 1);
- QTest::mousePress(&canvas, Qt::RightButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::RightButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::RightButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::RightButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 1);
QCOMPARE(item.releaseCount, 1);
- QTest::mousePress(&canvas, Qt::MiddleButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::MiddleButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::MiddleButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 1);
QCOMPARE(item.releaseCount, 1);
item.setAcceptedMouseButtons(Qt::RightButton | Qt::MiddleButton);
QCOMPARE(item.acceptedMouseButtons(), Qt::MouseButtons(Qt::RightButton | Qt::MiddleButton));
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 1);
QCOMPARE(item.releaseCount, 1);
- QTest::mousePress(&canvas, Qt::RightButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::RightButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::RightButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::RightButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 2);
QCOMPARE(item.releaseCount, 2);
- QTest::mousePress(&canvas, Qt::MiddleButton, 0, QPoint(50, 50));
- QTest::mouseRelease(&canvas, Qt::MiddleButton, 0, QPoint(50, 50));
+ QTest::mousePress(&window, Qt::MiddleButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(&window, Qt::MiddleButton, 0, QPoint(50, 50));
QCOMPARE(item.pressCount, 3);
QCOMPARE(item.releaseCount, 3);
}
void tst_QQuickItem::keys()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
KeysTestObject *testObject = new KeysTestObject;
- canvas->rootContext()->setContextProperty("keysTestObject", testObject);
+ window->rootContext()->setContextProperty("keysTestObject", testObject);
- canvas->rootContext()->setContextProperty("enableKeyHanding", QVariant(true));
- canvas->rootContext()->setContextProperty("forwardeeVisible", QVariant(true));
+ window->rootContext()->setContextProperty("enableKeyHanding", QVariant(true));
+ window->rootContext()->setContextProperty("forwardeeVisible", QVariant(true));
- canvas->setSource(testFileUrl("keystest.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ window->setSource(testFileUrl("keystest.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- QVERIFY(canvas->rootObject());
- QCOMPARE(canvas->rootObject()->property("isEnabled").toBool(), true);
+ QVERIFY(window->rootObject());
+ QCOMPARE(window->rootObject()->property("isEnabled").toBool(), true);
QKeyEvent key(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier, "A", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_A));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_A));
QCOMPARE(testObject->mText, QLatin1String("A"));
testObject->reset();
key = QKeyEvent(QEvent::KeyRelease, Qt::Key_A, Qt::ShiftModifier, "A", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_A));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_A));
QCOMPARE(testObject->mText, QLatin1String("A"));
testObject->reset();
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_Return));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_Return));
QCOMPARE(testObject->mText, QLatin1String("Return"));
testObject->reset();
key = QKeyEvent(QEvent::KeyPress, Qt::Key_0, Qt::NoModifier, "0", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_0));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_0));
QCOMPARE(testObject->mText, QLatin1String("0"));
testObject->reset();
key = QKeyEvent(QEvent::KeyPress, Qt::Key_9, Qt::NoModifier, "9", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_9));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_9));
QCOMPARE(testObject->mText, QLatin1String("9"));
testObject->reset();
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_Tab));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_Tab));
QCOMPARE(testObject->mText, QLatin1String("Tab"));
testObject->reset();
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_Backtab));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_Backtab));
QCOMPARE(testObject->mText, QLatin1String("Backtab"));
testObject->reset();
key = QKeyEvent(QEvent::KeyPress, Qt::Key_VolumeUp, Qt::NoModifier, 1234, 0, 0);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_VolumeUp));
QCOMPARE(testObject->mForwardedKey, int(Qt::Key_VolumeUp));
QVERIFY(testObject->mModifiers == Qt::NoModifier);
testObject->reset();
- canvas->rootContext()->setContextProperty("forwardeeVisible", QVariant(false));
+ window->rootContext()->setContextProperty("forwardeeVisible", QVariant(false));
key = QKeyEvent(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier, "A", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_A));
QCOMPARE(testObject->mForwardedKey, 0);
QCOMPARE(testObject->mText, QLatin1String("A"));
testObject->reset();
- canvas->rootContext()->setContextProperty("enableKeyHanding", QVariant(false));
- QCOMPARE(canvas->rootObject()->property("isEnabled").toBool(), false);
+ window->rootContext()->setContextProperty("enableKeyHanding", QVariant(false));
+ QCOMPARE(window->rootObject()->property("isEnabled").toBool(), false);
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, 0);
QVERIFY(!key.isAccepted());
- canvas->rootContext()->setContextProperty("enableKeyHanding", QVariant(true));
- QCOMPARE(canvas->rootObject()->property("isEnabled").toBool(), true);
+ window->rootContext()->setContextProperty("enableKeyHanding", QVariant(true));
+ QCOMPARE(window->rootObject()->property("isEnabled").toBool(), true);
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_Return));
QVERIFY(key.isAccepted());
- delete canvas;
+ delete window;
delete testObject;
}
void tst_QQuickItem::keysProcessingOrder()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
KeysTestObject *testObject = new KeysTestObject;
- canvas->rootContext()->setContextProperty("keysTestObject", testObject);
+ window->rootContext()->setContextProperty("keysTestObject", testObject);
- canvas->setSource(testFileUrl("keyspriority.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ window->setSource(testFileUrl("keyspriority.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- KeyTestItem *testItem = qobject_cast<KeyTestItem*>(canvas->rootObject());
+ KeyTestItem *testItem = qobject_cast<KeyTestItem*>(window->rootObject());
QVERIFY(testItem);
QCOMPARE(testItem->property("priorityTest").toInt(), 0);
QKeyEvent key(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier, "A", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_A));
QCOMPARE(testObject->mText, QLatin1String("A"));
QVERIFY(testObject->mModifiers == Qt::NoModifier);
QCOMPARE(testItem->property("priorityTest").toInt(), 1);
key = QKeyEvent(QEvent::KeyPress, Qt::Key_A, Qt::NoModifier, "A", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, 0);
QVERIFY(key.isAccepted());
testObject->reset();
key = QKeyEvent(QEvent::KeyPress, Qt::Key_B, Qt::NoModifier, "B", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, int(Qt::Key_B));
QCOMPARE(testObject->mText, QLatin1String("B"));
QVERIFY(testObject->mModifiers == Qt::NoModifier);
testObject->reset();
key = QKeyEvent(QEvent::KeyRelease, Qt::Key_B, Qt::NoModifier, "B", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QCOMPARE(testObject->mKey, 0);
QVERIFY(key.isAccepted());
- delete canvas;
+ delete window;
delete testObject;
}
QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod());
inputMethodPrivate->testContext = &platformInputContext;
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
- canvas->setSource(testFileUrl("keysim.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ window->setSource(testFileUrl("keysim.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- QVERIFY(canvas->rootObject());
- QVERIFY(canvas->rootObject()->hasFocus() && canvas->rootObject()->hasActiveFocus());
+ QVERIFY(window->rootObject());
+ QVERIFY(window->rootObject()->hasFocus() && window->rootObject()->hasActiveFocus());
- QQuickTextInput *input = canvas->rootObject()->findChild<QQuickTextInput*>();
+ QQuickTextInput *input = window->rootObject()->findChild<QQuickTextInput*>();
QVERIFY(input);
QInputMethodEvent ev("Hello world!", QList<QInputMethodEvent::Attribute>());
QEXPECT_FAIL("", "QTBUG-24280", Continue);
QCOMPARE(input->text(), QLatin1String("Hello world!"));
- delete canvas;
+ delete window;
}
QQuickItemPrivate *childPrivate(QQuickItem *rootItem, const char * itemString)
void tst_QQuickItem::layoutMirroring()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("layoutmirroring.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("layoutmirroring.qml"));
+ window->show();
- QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootItem);
QQuickItemPrivate *rootPrivate = QQuickItemPrivate::get(rootItem);
QVERIFY(rootPrivate);
void tst_QQuickItem::keyNavigation()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
- canvas->setSource(testFileUrl("keynavigationtest.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ window->setSource(testFileUrl("keynavigationtest.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QVariant result;
- QVERIFY(QMetaObject::invokeMethod(canvas->rootObject(), "verify",
+ QVERIFY(QMetaObject::invokeMethod(window->rootObject(), "verify",
Q_RETURN_ARG(QVariant, result)));
QVERIFY(result.toBool());
// right
QKeyEvent key(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(window->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// down
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Down, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(window->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// left
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(window->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// up
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Up, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// tab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(window->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// backtab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
- delete canvas;
+ delete window;
}
void tst_QQuickItem::keyNavigation_RightToLeft()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
- canvas->setSource(testFileUrl("keynavigationtest.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ window->setSource(testFileUrl("keynavigationtest.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootItem);
QQuickItemPrivate* rootItemPrivate = QQuickItemPrivate::get(rootItem);
rootItemPrivate->resolveLayoutMirror();
QEvent wa(QEvent::WindowActivate);
- QGuiApplication::sendEvent(canvas, &wa);
+ QGuiApplication::sendEvent(window, &wa);
QFocusEvent fe(QEvent::FocusIn);
- QGuiApplication::sendEvent(canvas, &fe);
+ QGuiApplication::sendEvent(window, &fe);
- QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QVariant result;
- QVERIFY(QMetaObject::invokeMethod(canvas->rootObject(), "verify",
+ QVERIFY(QMetaObject::invokeMethod(window->rootObject(), "verify",
Q_RETURN_ARG(QVariant, result)));
QVERIFY(result.toBool());
// right
QKeyEvent key(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(window->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// left
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
- delete canvas;
+ delete window;
}
void tst_QQuickItem::keyNavigation_skipNotVisible()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
- canvas->setSource(testFileUrl("keynavigationtest.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ window->setSource(testFileUrl("keynavigationtest.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// Set item 2 to not visible
- item = findItem<QQuickItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(window->rootObject(), "item2");
QVERIFY(item);
item->setVisible(false);
QVERIFY(!item->isVisible());
// right
QKeyEvent key(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// tab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(window->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// backtab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
//Set item 3 to not visible
- item = findItem<QQuickItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(window->rootObject(), "item3");
QVERIFY(item);
item->setVisible(false);
QVERIFY(!item->isVisible());
// tab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(window->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// backtab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
- delete canvas;
+ delete window;
}
void tst_QQuickItem::keyNavigation_implicitSetting()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
- canvas->setSource(testFileUrl("keynavigationtest_implicit.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ window->setSource(testFileUrl("keynavigationtest_implicit.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
QEvent wa(QEvent::WindowActivate);
- QGuiApplication::sendEvent(canvas, &wa);
+ QGuiApplication::sendEvent(window, &wa);
QFocusEvent fe(QEvent::FocusIn);
- QGuiApplication::sendEvent(canvas, &fe);
+ QGuiApplication::sendEvent(window, &fe);
- QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ QQuickItem *item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
QVariant result;
- QVERIFY(QMetaObject::invokeMethod(canvas->rootObject(), "verify",
+ QVERIFY(QMetaObject::invokeMethod(window->rootObject(), "verify",
Q_RETURN_ARG(QVariant, result)));
QVERIFY(result.toBool());
// right
QKeyEvent key(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(window->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// back to item1
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// down
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Down, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(window->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// move to item4
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(window->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// left
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(window->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// back to item4
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(window->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// up
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Up, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item2");
+ item = findItem<QQuickItem>(window->rootObject(), "item2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// back to item4
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Down, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(window->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// tab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item1");
+ item = findItem<QQuickItem>(window->rootObject(), "item1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// back to item4
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item4");
+ item = findItem<QQuickItem>(window->rootObject(), "item4");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// backtab
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Backtab, Qt::NoModifier, "", false, 1);
- QGuiApplication::sendEvent(canvas, &key);
+ QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
- item = findItem<QQuickItem>(canvas->rootObject(), "item3");
+ item = findItem<QQuickItem>(window->rootObject(), "item3");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
- delete canvas;
+ delete window;
}
void tst_QQuickItem::smooth()
QFETCH(int, x);
QFETCH(int, y);
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(300, 300));
- canvas->setSource(testFileUrl("mapCoordinates.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(300, 300));
+ window->setSource(testFileUrl("mapCoordinates.qml"));
+ window->show();
qApp->processEvents();
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root != 0);
- QQuickItem *a = findItem<QQuickItem>(canvas->rootObject(), "itemA");
+ QQuickItem *a = findItem<QQuickItem>(window->rootObject(), "itemA");
QVERIFY(a != 0);
- QQuickItem *b = findItem<QQuickItem>(canvas->rootObject(), "itemB");
+ QQuickItem *b = findItem<QQuickItem>(window->rootObject(), "itemB");
QVERIFY(b != 0);
QVariant result;
Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y)));
QVERIFY(result.toBool());
- delete canvas;
+ delete window;
}
void tst_QQuickItem::mapCoordinates_data()
QFETCH(int, width);
QFETCH(int, height);
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(300, 300));
- canvas->setSource(testFileUrl("mapCoordinatesRect.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(300, 300));
+ window->setSource(testFileUrl("mapCoordinatesRect.qml"));
+ window->show();
qApp->processEvents();
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root != 0);
- QQuickItem *a = findItem<QQuickItem>(canvas->rootObject(), "itemA");
+ QQuickItem *a = findItem<QQuickItem>(window->rootObject(), "itemA");
QVERIFY(a != 0);
- QQuickItem *b = findItem<QQuickItem>(canvas->rootObject(), "itemB");
+ QQuickItem *b = findItem<QQuickItem>(window->rootObject(), "itemB");
QVERIFY(b != 0);
QVariant result;
Q_RETURN_ARG(QVariant, result), Q_ARG(QVariant, x), Q_ARG(QVariant, y), Q_ARG(QVariant, width), Q_ARG(QVariant, height)));
QVERIFY(result.toBool());
- delete canvas;
+ delete window;
}
void tst_QQuickItem::mapCoordinatesRect_data()
void tst_QQuickItem::propertyChanges()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(300, 300));
- canvas->setSource(testFileUrl("propertychanges.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(300, 300));
+ window->setSource(testFileUrl("propertychanges.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- QQuickItem *item = findItem<QQuickItem>(canvas->rootObject(), "item");
- QQuickItem *parentItem = findItem<QQuickItem>(canvas->rootObject(), "parentItem");
+ QQuickItem *item = findItem<QQuickItem>(window->rootObject(), "item");
+ QQuickItem *parentItem = findItem<QQuickItem>(window->rootObject(), "parentItem");
QVERIFY(item);
QVERIFY(parentItem);
QCOMPARE(item->y(), 10.0);
QCOMPARE(ySpy.count(), 1);
- delete canvas;
+ delete window;
}
void tst_QQuickItem::childrenRect()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("childrenRect.qml"));
- canvas->setBaseSize(QSize(240,320));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("childrenRect.qml"));
+ window->setBaseSize(QSize(240,320));
+ window->show();
- QQuickItem *o = canvas->rootObject();
+ QQuickItem *o = window->rootObject();
QQuickItem *item = o->findChild<QQuickItem*>("testItem");
QCOMPARE(item->width(), qreal(0));
QCOMPARE(item->height(), qreal(0));
QCOMPARE(item->height(), qreal(0));
delete o;
- delete canvas;
+ delete window;
}
// QTBUG-11383
void tst_QQuickItem::childrenRectBug()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
QString warning = testFileUrl("childrenRectBug.qml").toString() + ":7:5: QML Item: Binding loop detected for property \"height\"";
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
- canvas->setSource(testFileUrl("childrenRectBug.qml"));
- canvas->show();
+ window->setSource(testFileUrl("childrenRectBug.qml"));
+ window->show();
- QQuickItem *o = canvas->rootObject();
+ QQuickItem *o = window->rootObject();
QQuickItem *item = o->findChild<QQuickItem*>("theItem");
QCOMPARE(item->width(), qreal(200));
QCOMPARE(item->height(), qreal(100));
QCOMPARE(item->x(), qreal(100));
- delete canvas;
+ delete window;
}
// QTBUG-11465
void tst_QQuickItem::childrenRectBug2()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
QString warning1 = testFileUrl("childrenRectBug2.qml").toString() + ":7:5: QML Item: Binding loop detected for property \"width\"";
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning1));
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning2));
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning2));
- canvas->setSource(testFileUrl("childrenRectBug2.qml"));
- canvas->show();
+ window->setSource(testFileUrl("childrenRectBug2.qml"));
+ window->show();
- QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(canvas->rootObject());
+ QQuickRectangle *rect = qobject_cast<QQuickRectangle*>(window->rootObject());
QVERIFY(rect);
QQuickItem *item = rect->findChild<QQuickItem*>("theItem");
QCOMPARE(item->width(), qreal(100));
QCOMPARE(item->height(), qreal(50));
QCOMPARE(item->x(), qreal(75));
- delete canvas;
+ delete window;
}
// QTBUG-12722
void tst_QQuickItem::childrenRectBug3()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("childrenRectBug3.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("childrenRectBug3.qml"));
+ window->show();
//don't crash on delete
- delete canvas;
+ delete window;
}
// QTBUG-13893
void tst_QQuickItem::transformCrash()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("transformCrash.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("transformCrash.qml"));
+ window->show();
- delete canvas;
+ delete window;
}
void tst_QQuickItem::implicitSize()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("implicitsize.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("implicitsize.qml"));
+ window->show();
- QQuickItem *item = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *item = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(item);
QCOMPARE(item->width(), qreal(80));
QCOMPARE(item->height(), qreal(60));
QCOMPARE(item->width(), qreal(150));
QCOMPARE(item->height(), qreal(80));
- delete canvas;
+ delete window;
}
void tst_QQuickItem::qtbug_16871()
void tst_QQuickItem::visibleChildren()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl("visiblechildren.qml"));
- canvas->show();
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl("visiblechildren.qml"));
+ window->show();
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root);
QCOMPARE(root->property("test1_1").toBool(), true);
QCOMPARE(root->property("test8_4").toBool(), true);
QCOMPARE(root->property("test8_5").toBool(), true);
- delete canvas;
+ delete window;
}
void tst_QQuickItem::parentLoop()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
QTest::ignoreMessage(QtWarningMsg, "QQuickItem::setParentItem: Parent is already part of this items subtree.");
- canvas->setSource(testFileUrl("parentLoop.qml"));
+ window->setSource(testFileUrl("parentLoop.qml"));
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root);
QQuickItem *item1 = root->findChild<QQuickItem*>("item1");
QVERIFY(item2);
QCOMPARE(item2->parentItem(), item1);
- delete canvas;
+ delete window;
}
void tst_QQuickItem::contains_data()
QFETCH(bool, insideTarget);
QFETCH(QList<QPoint>, points);
- QQuickView *canvas = new QQuickView(0);
- canvas->rootContext()->setContextProperty("circleShapeTest", circleTest);
- canvas->setBaseSize(QSize(400, 400));
- canvas->setSource(testFileUrl("hollowTestItem.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_VERIFY(QGuiApplication::focusWindow() == canvas);
+ QQuickView *window = new QQuickView(0);
+ window->rootContext()->setContextProperty("circleShapeTest", circleTest);
+ window->setBaseSize(QSize(400, 400));
+ window->setSource(testFileUrl("hollowTestItem.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_VERIFY(QGuiApplication::focusWindow() == window);
- QQuickItem *root = qobject_cast<QQuickItem *>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem *>(window->rootObject());
QVERIFY(root);
HollowTestItem *hollowItem = root->findChild<HollowTestItem *>("hollowItem");
foreach (const QPoint &point, points) {
// check mouse hover
- QTest::mouseMove(canvas, point);
+ QTest::mouseMove(window, point);
QTest::qWait(10);
QCOMPARE(hollowItem->isHovered(), insideTarget);
// check mouse press
- QTest::mousePress(canvas, Qt::LeftButton, 0, point);
+ QTest::mousePress(window, Qt::LeftButton, 0, point);
QTest::qWait(10);
QCOMPARE(hollowItem->isPressed(), insideTarget);
// check mouse release
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, point);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, point);
QTest::qWait(10);
QCOMPARE(hollowItem->isPressed(), false);
}
- delete canvas;
+ delete window;
}
view.show();
QTest::qWaitForWindowShown(&view);
- return view.grabFrameBuffer();
+ return view.grabWindow();
}
private slots:
QTest::qWaitForWindowActive(&view);
- QImage fb = view.grabFrameBuffer();
+ QImage fb = view.grabWindow();
uint pixel = fb.pixel(0, 0);
if (!visible || opacity == 0) {
QTest::qWaitForWindowShown(&view);
- QImage fb = view.grabFrameBuffer();
+ QImage fb = view.grabWindow();
QCOMPARE(fb.pixel(50, 50), qRgb(0, 0, 0xff));
QCOMPARE(fb.pixel(150, 150), qRgb(0, 0xff, 00));
QTest::qWaitForWindowShown(&view);
- QImage fb = view.grabFrameBuffer();
+ QImage fb = view.grabWindow();
QRgb topLeft = fb.pixel(50, 50);
QRgb topRight = fb.pixel(150, 50);
template <class T>
void tst_QQuickListView::items(const QUrl &source, bool forceLayout)
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
T model;
model.addItem("Fred", "12345");
model.addItem("John", "2345");
model.addItem("Bob", "54321");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(source);
+ window->setSource(source);
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QTRY_VERIFY(testObject->error() == false);
QTRY_VERIFY(listview->highlightItem() != 0);
QTRY_COMPARE(listview->count(), model.count());
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
// current item should be first item
// switch to other delegate
testObject->setAnimate(true);
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QTRY_VERIFY(testObject->error() == false);
QTRY_VERIFY(listview->currentItem());
// set invalid highlight
testObject->setInvalidHighlight(true);
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QTRY_VERIFY(testObject->error() == false);
QTRY_VERIFY(listview->currentItem());
QTRY_VERIFY(listview->highlightItem() == 0);
// back to normal highlight
testObject->setInvalidHighlight(false);
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QTRY_VERIFY(testObject->error() == false);
QTRY_VERIFY(listview->currentItem());
QTRY_VERIFY(listview->highlightItem() != 0);
QTRY_COMPARE(listview->highlightResizeVelocity(), 1000.0);
QTRY_COMPARE(listview->highlightMoveVelocity(), 1000.0);
- delete canvas;
+ delete window;
delete testObject;
}
template <class T>
void tst_QQuickListView::changed(const QUrl &source, bool forceLayout)
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
T model;
model.addItem("Fred", "12345");
model.addItem("John", "2345");
model.addItem("Bob", "54321");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(source);
+ window->setSource(source);
qApp->processEvents();
- QQuickFlickable *listview = findItem<QQuickFlickable>(canvas->rootObject(), "list");
+ QQuickFlickable *listview = findItem<QQuickFlickable>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(number != 0);
QTRY_COMPARE(number->text(), model.number(1));
- delete canvas;
+ delete window;
delete testObject;
}
template <class T>
void tst_QQuickListView::inserted(const QUrl &source)
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
T model;
model.addItem("Fred", "12345");
model.addItem("John", "2345");
model.addItem("Bob", "54321");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(source);
+ window->setSource(source);
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
model.insertItem(1, "Will", "9876");
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
model.insertItem(0, "Foo", "1111"); // zero index, and current item
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QTRY_COMPARE(contentItem->childItems().count(), model.count()+1); // assumes all are visible, +1 for the (default) highlight item
name = findItem<QQuickText>(contentItem, "textName", 0);
// QTBUG-19675
model.clear();
model.insertItem(0, "Hello", "1234");
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QQuickItem *item = findItem<QQuickItem>(contentItem, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->y(), 0.);
QTRY_VERIFY(listview->contentY() == 0);
- delete canvas;
+ delete window;
delete testObject;
}
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
QFETCH(int, cacheBuffer);
QQuickText *name;
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
template <class T>
void tst_QQuickListView::removed(const QUrl &source, bool /* animated */)
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
T model;
for (int i = 0; i < 50; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(source);
- canvas->show();
+ window->setSource(source);
+ window->show();
qApp->processEvents();
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
model.removeItem(1);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QQuickText *name = findItem<QQuickText>(contentItem, "textName", 1);
QTRY_VERIFY(name != 0);
// Remove first item (which is the current item);
model.removeItem(0);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
name = findItem<QQuickText>(contentItem, "textName", 0);
QTRY_VERIFY(name != 0);
// Remove items not visible
model.removeItem(18);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
// Confirm items positioned correctly
itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
listview->setCurrentIndex(10);
model.removeItem(1); // post: top item will be at 20
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
// Confirm items positioned correctly
for (int i = 2; i < 18; ++i) {
model.removeItems(model.count() - 1, 1);
QTRY_VERIFY(findItems<QQuickItem>(contentItem, "wrapper").count() > 16);
- delete canvas;
+ delete window;
delete testObject;
}
QFETCH(int, removeCount);
QFETCH(qreal, itemsOffsetAfterMove);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
T model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(source);
- canvas->show();
+ window->setSource(source);
+ window->show();
qApp->processEvents();
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(number->text(), model.number(i));
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
template <class T>
void tst_QQuickListView::clear(const QUrl &source, QQuickItemView::VerticalLayoutDirection verticalLayoutDirection)
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
T model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(source);
- canvas->show();
+ window->setSource(source);
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QVERIFY(listview->currentItem() != 0);
QVERIFY(listview->currentIndex() == 0);
- delete canvas;
+ delete window;
delete testObject;
}
QQuickText *name;
QQuickText *number;
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
T model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(source);
- canvas->show();
+ window->setSource(source);
+ window->show();
qApp->processEvents();
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(listview->currentIndex(), i);
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
QFETCH(int, newCount);
QFETCH(int, newCurrentIndex);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QmlListModel model;
for (int i = 0; i < startCount; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
}
delete testObject;
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::multipleChanges_data()
void tst_QQuickListView::swapWithFirstItem()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
QTRY_VERIFY(listview->contentY() == 0);
delete testObject;
- delete canvas;
+ delete window;
}
void tst_QQuickListView::enforceRange()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("listview-enforcerange.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listview-enforcerange.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QTRY_COMPARE(listview->preferredHighlightBegin(), 100.0);
ctxt->setContextProperty("testModel", &model2);
QCOMPARE(listview->count(), 5);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::enforceRange_withoutHighlight()
// to the correct position (i.e. to the next/previous item, not next/previous section)
// when moving up/down via incrementCurrentIndex() and decrementCurrentIndex()
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
model.addItem("Item 0", "a");
model.addItem("Item 2", "b");
model.addItem("Item 3", "c");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("listview-enforcerange-nohighlight.qml"));
- canvas->show();
- QTest::qWaitForWindowExposed(canvas);
+ window->setSource(testFileUrl("listview-enforcerange-nohighlight.qml"));
+ window->show();
+ QTest::qWaitForWindowExposed(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
QTRY_COMPARE(listview->contentY(), expectedPos);
expectedPos += 20 + 10; // scroll past 1st section and section delegate of 2nd section
- QTest::keyClick(canvas, Qt::Key_Down);
+ QTest::keyClick(window, Qt::Key_Down);
QTRY_COMPARE(listview->contentY(), expectedPos);
expectedPos += 20; // scroll past 1st item of 2nd section
- QTest::keyClick(canvas, Qt::Key_Down);
+ QTest::keyClick(window, Qt::Key_Down);
QTRY_COMPARE(listview->contentY(), expectedPos);
expectedPos += 20 + 10; // scroll past 2nd item of 2nd section and section delegate of 3rd section
- QTest::keyClick(canvas, Qt::Key_Down);
+ QTest::keyClick(window, Qt::Key_Down);
QTRY_COMPARE(listview->contentY(), expectedPos);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::spacing()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_COMPARE(item->y(), i*20.0);
}
- delete canvas;
+ delete window;
delete testObject;
}
template <typename T>
void tst_QQuickListView::sections(const QUrl &source)
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
T model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i/5));
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(source);
- canvas->show();
+ window->setSource(source);
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(item);
QTRY_COMPARE(item->height(), 40.0);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::sectionsDelegate()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i/5));
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("listview-sections_delegate.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listview-sections_delegate.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
model.modifyItem(11, "Two", "aaa");
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
QTRY_COMPARE(findItems<QQuickItem>(contentItem, "sect_aaa").count(), 1);
- canvas->rootObject()->setProperty("sectionProperty", "name");
+ window->rootObject()->setProperty("sectionProperty", "name");
// ensure view has settled.
QTRY_COMPARE(findItems<QQuickItem>(contentItem, "sect_Four").count(), 1);
for (int i = 0; i < 4; ++i) {
QTRY_COMPARE(item->y(), qreal(i*20*4));
}
- delete canvas;
+ delete window;
}
void tst_QQuickListView::sectionsDragOutsideBounds_data()
QFETCH(int, distance);
QFETCH(int, cacheBuffer);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QmlListModel model;
for (int i = 0; i < 10; i++)
model.addItem("Item" + QString::number(i), QString::number(i/5));
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("listview-sections_delegate.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listview-sections_delegate.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setCacheBuffer(cacheBuffer);
// QTBUG-17769
// Drag view up beyond bounds
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(20,20));
- QTest::mouseMove(canvas, QPoint(20,0));
- QTest::mouseMove(canvas, QPoint(20,-50));
- QTest::mouseMove(canvas, QPoint(20,-distance));
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(20,-distance));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(20,20));
+ QTest::mouseMove(window, QPoint(20,0));
+ QTest::mouseMove(window, QPoint(20,-50));
+ QTest::mouseMove(window, QPoint(20,-distance));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(20,-distance));
// view should settle back at 0
QTRY_COMPARE(listview->contentY(), 0.0);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(20,0));
- QTest::mouseMove(canvas, QPoint(20,20));
- QTest::mouseMove(canvas, QPoint(20,70));
- QTest::mouseMove(canvas, QPoint(20,distance));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(20,0));
+ QTest::mouseMove(window, QPoint(20,20));
+ QTest::mouseMove(window, QPoint(20,70));
+ QTest::mouseMove(window, QPoint(20,distance));
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(20,distance));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(20,distance));
// view should settle back at 0
QTRY_COMPARE(listview->contentY(), 0.0);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::sectionsDelegate_headerVisibility()
{
QSKIP("QTBUG-24395");
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i/5));
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("listview-sections_delegate.qml"));
- canvas->show();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->setSource(testFileUrl("listview-sections_delegate.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
listview->setCurrentIndex(0);
QTRY_COMPARE(listview->contentY(), 0.0);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::sectionsPositioning()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i/5));
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("listview-sections_delegate.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listview-sections_delegate.qml"));
+ window->show();
qApp->processEvents();
- canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart | QQuickViewSection::NextLabelAtEnd)));
+ window->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart | QQuickViewSection::NextLabelAtEnd)));
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
// Turn sticky footer off
listview->setContentY(20);
- canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart)));
+ window->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart)));
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
QTRY_VERIFY(item = findVisibleChild(contentItem, "sect_new")); // inline label restored
QCOMPARE(item->y(), 340.);
// Turn sticky header off
listview->setContentY(30);
- canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels)));
+ window->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels)));
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
QTRY_VERIFY(item = findVisibleChild(contentItem, "sect_aaa")); // inline label restored
QCOMPARE(item->y(), 0.);
// if an empty model is set the header/footer should be cleaned up
- canvas->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart | QQuickViewSection::NextLabelAtEnd)));
+ window->rootObject()->setProperty("sectionPositioning", QVariant(int(QQuickViewSection::InlineLabels | QQuickViewSection::CurrentLabelAtStart | QQuickViewSection::NextLabelAtEnd)));
QTRY_VERIFY(findVisibleChild(contentItem, "sect_aaa")); // section header
QTRY_VERIFY(findVisibleChild(contentItem, "sect_new")); // section footer
QmlListModel model1;
QTRY_VERIFY(!findVisibleChild(contentItem, "sect_aaa")); // section header
QTRY_VERIFY(!findVisibleChild(contentItem, "sect_new")); // section footer
- delete canvas;
+ delete window;
}
void tst_QQuickListView::sectionPropertyChange()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("sectionpropertychange.qml"));
- canvas->show();
+ window->setSource(testFileUrl("sectionpropertychange.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_COMPARE(item->y(), qreal(25. + i*75.));
}
- QMetaObject::invokeMethod(canvas->rootObject(), "switchGroups");
+ QMetaObject::invokeMethod(window->rootObject(), "switchGroups");
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
// Confirm items positioned correctly
QTRY_COMPARE(item->y(), qreal(25. + i*75.));
}
- QMetaObject::invokeMethod(canvas->rootObject(), "switchGroups");
+ QMetaObject::invokeMethod(window->rootObject(), "switchGroups");
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
// Confirm items positioned correctly
QTRY_COMPARE(item->y(), qreal(25. + i*75.));
}
- QMetaObject::invokeMethod(canvas->rootObject(), "switchGrouped");
+ QMetaObject::invokeMethod(window->rootObject(), "switchGrouped");
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
// Confirm items positioned correctly
QTRY_COMPARE(item->y(), qreal(25. + i*50.));
}
- QMetaObject::invokeMethod(canvas->rootObject(), "switchGrouped");
+ QMetaObject::invokeMethod(window->rootObject(), "switchGrouped");
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
// Confirm items positioned correctly
QTRY_COMPARE(item->y(), qreal(25. + i*75.));
}
- delete canvas;
+ delete window;
}
void tst_QQuickListView::sectionDelegateChange()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("sectiondelegatechange.qml"));
- canvas->show();
+ window->setSource(testFileUrl("sectiondelegatechange.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = qobject_cast<QQuickListView *>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView *>(window->rootObject());
QVERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_COMPARE(item->y(), qreal(25. + i*50.));
}
- QMetaObject::invokeMethod(canvas->rootObject(), "switchDelegates");
+ QMetaObject::invokeMethod(window->rootObject(), "switchDelegates");
QQUICK_VERIFY_POLISH(listview);
QCOMPARE(findItems<QQuickItem>(contentItem, "section1").count(), 0);
QTRY_COMPARE(item->y(), qreal(50. + i*75.));
}
- delete canvas;
+ delete window;
}
void tst_QQuickListView::currentIndex_delayedItemCreation()
{
QFETCH(bool, setCurrentToZero);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
// test currentIndexChanged() is emitted even if currentIndex = 0 on start up
// (since the currentItem will have changed and that shares the same index)
- canvas->rootContext()->setContextProperty("setCurrentToZero", setCurrentToZero);
+ window->rootContext()->setContextProperty("setCurrentToZero", setCurrentToZero);
- canvas->setSource(testFileUrl("fillModelOnComponentCompleted.qml"));
+ window->setSource(testFileUrl("fillModelOnComponentCompleted.qml"));
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(listview->currentIndex(), 0);
QTRY_COMPARE(spy.count(), 1);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::currentIndex_delayedItemCreation_data()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testWrap", QVariant(false));
QString filename(testFile("listview-initCurrent.qml"));
- canvas->setSource(QUrl::fromLocalFile(filename));
- canvas->show();
+ window->setSource(QUrl::fromLocalFile(filename));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_VERIFY(listview->verticalVelocity() != 0.0);
// footer should become visible if it is out of view, and then current index is set to count-1
- canvas->rootObject()->setProperty("showFooter", true);
+ window->rootObject()->setProperty("showFooter", true);
QTRY_VERIFY(listview->footerItem());
listview->setCurrentIndex(model.count()-2);
QTRY_VERIFY(listview->footerItem()->y() > listview->contentY() + listview->height());
listview->setCurrentIndex(model.count()-1);
QTRY_COMPARE(listview->contentY() + listview->height(), (20.0 * model.count()) + listview->footerItem()->height());
- canvas->rootObject()->setProperty("showFooter", false);
+ window->rootObject()->setProperty("showFooter", false);
// header should become visible if it is out of view, and then current index is set to 0
- canvas->rootObject()->setProperty("showHeader", true);
+ window->rootObject()->setProperty("showHeader", true);
QTRY_VERIFY(listview->headerItem());
listview->setCurrentIndex(1);
QTRY_VERIFY(listview->headerItem()->y() + listview->headerItem()->height() < listview->contentY());
listview->setCurrentIndex(0);
QTRY_COMPARE(listview->contentY(), -listview->headerItem()->height());
- canvas->rootObject()->setProperty("showHeader", false);
+ window->rootObject()->setProperty("showHeader", false);
// turn off auto highlight
listview->setHighlightFollowsCurrentItem(false);
// insert item before currentIndex
listview->setCurrentIndex(28);
model.insertItem(0, "Foo", "1111");
- QTRY_COMPARE(canvas->rootObject()->property("current").toInt(), 29);
+ QTRY_COMPARE(window->rootObject()->property("current").toInt(), 29);
// check removing highlight by setting currentIndex to -1;
listview->setCurrentIndex(-1);
listview->setContentY(200);
QTRY_VERIFY(!delegateVisible(listview->currentItem()));
- delete canvas;
+ delete window;
}
void tst_QQuickListView::noCurrentIndex()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
QString filename(testFile("listview-noCurrent.qml"));
- canvas->setSource(QUrl::fromLocalFile(filename));
- canvas->show();
+ window->setSource(QUrl::fromLocalFile(filename));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QVERIFY(listview->highlightItem());
QVERIFY(listview->currentItem());
- delete canvas;
+ delete window;
}
void tst_QQuickListView::keyNavigation()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
TestObject *testObject = new TestObject;
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->rootContext()->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
- QTest::qWaitForWindowActive(canvas);
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("testObject", testObject);
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
+ QTest::qWaitForWindowActive(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setVerticalLayoutDirection(verticalLayoutDirection);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
- canvas->requestActivateWindow();
- QTest::qWaitForWindowActive(canvas);
- QTRY_VERIFY(qGuiApp->focusWindow() == canvas);
- QCOMPARE(listview->currentIndex(), 0);
+ window->requestActivateWindow();
+ QTest::qWaitForWindowActive(window);
+ QTRY_VERIFY(qGuiApp->focusWindow() == window);
- QTest::keyClick(canvas, forwardsKey);
+ QTest::keyClick(window, forwardsKey);
QCOMPARE(listview->currentIndex(), 1);
- QTest::keyClick(canvas, backwardsKey);
+ QTest::keyClick(window, backwardsKey);
QCOMPARE(listview->currentIndex(), 0);
// hold down a key to go forwards
for (int i=0; i<model.count()-1; i++) {
- QTest::simulateEvent(canvas, true, forwardsKey, Qt::NoModifier, "", true);
+ QTest::simulateEvent(window, true, forwardsKey, Qt::NoModifier, "", true);
QTRY_COMPARE(listview->currentIndex(), i+1);
}
- QTest::keyRelease(canvas, forwardsKey);
+ QTest::keyRelease(window, forwardsKey);
QTRY_COMPARE(listview->currentIndex(), model.count()-1);
QTRY_COMPARE(listview->contentX(), contentPosAtLastItem.x());
QTRY_COMPARE(listview->contentY(), contentPosAtLastItem.y());
// hold down a key to go backwards
for (int i=model.count()-1; i > 0; i--) {
- QTest::simulateEvent(canvas, true, backwardsKey, Qt::NoModifier, "", true);
+ QTest::simulateEvent(window, true, backwardsKey, Qt::NoModifier, "", true);
QTRY_COMPARE(listview->currentIndex(), i-1);
}
- QTest::keyRelease(canvas, backwardsKey);
+ QTest::keyRelease(window, backwardsKey);
QTRY_COMPARE(listview->currentIndex(), 0);
QTRY_COMPARE(listview->contentX(), contentPosAtFirstItem.x());
QTRY_COMPARE(listview->contentY(), contentPosAtFirstItem.y());
QTRY_COMPARE(listview->contentX(), contentPosAtFirstItem.x());
QTRY_COMPARE(listview->contentY(), contentPosAtFirstItem.y());
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
void tst_QQuickListView::itemList()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("itemlist.qml"));
- canvas->show();
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("itemlist.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "view");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "view");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QQuickVisualItemModel *model = canvas->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
+ QQuickVisualItemModel *model = window->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);
QTRY_VERIFY(text);
QTRY_COMPARE(text->text(), QLatin1String("index: 2"));
- delete canvas;
+ delete window;
}
void tst_QQuickListView::itemListFlicker()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("itemlist-flicker.qml"));
- canvas->show();
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("itemlist-flicker.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "view");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "view");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
- QQuickVisualItemModel *model = canvas->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
+ QQuickVisualItemModel *model = window->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);
QVERIFY(item = findItem<QQuickItem>(contentItem, "item3"));
QVERIFY(delegateVisible(item));
- delete canvas;
+ delete window;
}
void tst_QQuickListView::cacheBuffer()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 90; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
}
QQmlIncubationController controller;
- canvas->engine()->setIncubationController(&controller);
+ window->engine()->setIncubationController(&controller);
testObject->setCacheBuffer(200);
QTRY_VERIFY(listview->cacheBuffer() == 200);
controller.incubateWhile(&b);
}
- delete canvas;
+ delete window;
delete testObject;
}
void tst_QQuickListView::positionViewAtIndex()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->show();
- canvas->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(listview->contentY(), 0.);
listview->setContentY(80);
- canvas->rootObject()->setProperty("showHeader", true);
+ window->rootObject()->setProperty("showHeader", true);
listview->positionViewAtBeginning();
QTRY_COMPARE(listview->contentY(), -30.);
QTRY_COMPARE(listview->contentY(), 480.); // 40*20 - 320
listview->setContentY(80);
- canvas->rootObject()->setProperty("showFooter", true);
+ window->rootObject()->setProperty("showFooter", true);
listview->positionViewAtEnd();
QTRY_COMPARE(listview->contentY(), 510.);
QVERIFY(listview->highlightItem());
QCOMPARE(listview->highlightItem()->y(), 20.);
- delete canvas;
+ delete window;
delete testObject;
}
void tst_QQuickListView::resetModel()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QStringList strings;
strings << "one" << "two" << "three";
QStringListModel model(strings);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("displaylist.qml"));
- canvas->show();
+ window->setSource(testFileUrl("displaylist.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(display->text(), strings.at(i));
}
- delete canvas;
+ delete window;
}
void tst_QQuickListView::propertyChanges()
{
- QQuickView *canvas = createView();
- QTRY_VERIFY(canvas);
- canvas->setSource(testFileUrl("propertychangestest.qml"));
+ QQuickView *window = createView();
+ QTRY_VERIFY(window);
+ window->setSource(testFileUrl("propertychangestest.qml"));
- QQuickListView *listView = canvas->rootObject()->findChild<QQuickListView*>("listView");
+ QQuickListView *listView = window->rootObject()->findChild<QQuickListView*>("listView");
QTRY_VERIFY(listView);
QSignalSpy highlightFollowsCurrentItemSpy(listView, SIGNAL(highlightFollowsCurrentItemChanged()));
QTRY_COMPARE(cacheBufferSpy.count(),1);
QTRY_COMPARE(snapModeSpy.count(),1);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::componentChanges()
{
- QQuickView *canvas = createView();
- QTRY_VERIFY(canvas);
- canvas->setSource(testFileUrl("propertychangestest.qml"));
+ QQuickView *window = createView();
+ QTRY_VERIFY(window);
+ window->setSource(testFileUrl("propertychangestest.qml"));
- QQuickListView *listView = canvas->rootObject()->findChild<QQuickListView*>("listView");
+ QQuickListView *listView = window->rootObject()->findChild<QQuickListView*>("listView");
QTRY_VERIFY(listView);
- QQmlComponent component(canvas->engine());
+ QQmlComponent component(window->engine());
component.setData("import QtQuick 2.0; Rectangle { color: \"blue\"; }", QUrl::fromLocalFile(""));
- QQmlComponent delegateComponent(canvas->engine());
+ QQmlComponent delegateComponent(window->engine());
delegateComponent.setData("import QtQuick 2.0; Text { text: '<b>Name:</b> ' + name }", QUrl::fromLocalFile(""));
QSignalSpy highlightSpy(listView, SIGNAL(highlightChanged()));
QTRY_COMPARE(headerSpy.count(),1);
QTRY_COMPARE(footerSpy.count(),1);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::modelChanges()
{
- QQuickView *canvas = createView();
- QTRY_VERIFY(canvas);
- canvas->setSource(testFileUrl("propertychangestest.qml"));
+ QQuickView *window = createView();
+ QTRY_VERIFY(window);
+ window->setSource(testFileUrl("propertychangestest.qml"));
- QQuickListView *listView = canvas->rootObject()->findChild<QQuickListView*>("listView");
+ QQuickListView *listView = window->rootObject()->findChild<QQuickListView*>("listView");
QTRY_VERIFY(listView);
- QQuickListModel *alternateModel = canvas->rootObject()->findChild<QQuickListModel*>("alternateModel");
+ QQuickListModel *alternateModel = window->rootObject()->findChild<QQuickListModel*>("alternateModel");
QTRY_VERIFY(alternateModel);
QVariant modelVariant = QVariant::fromValue<QObject *>(alternateModel);
QSignalSpy modelSpy(listView, SIGNAL(modelChanged()));
listView->setModel(QVariant());
QTRY_COMPARE(modelSpy.count(),2);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::QTBUG_9791()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("strictlyenforcerange.qml"));
+ window->setSource(testFileUrl("strictlyenforcerange.qml"));
qApp->processEvents();
- QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(window->rootObject());
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
// check that view is positioned correctly
QTRY_COMPARE(listview->contentX(), 590.0);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::manualHighlight()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
QString filename(testFile("manual-highlight.qml"));
- canvas->setSource(QUrl::fromLocalFile(filename));
+ window->setSource(QUrl::fromLocalFile(filename));
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_COMPARE(listview->currentItem(), findItem<QQuickItem>(contentItem, "wrapper", 2));
QTRY_COMPARE(listview->highlightItem()->y() - 5, listview->currentItem()->y());
- delete canvas;
+ delete window;
}
void tst_QQuickListView::QTBUG_11105()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
itemCount = findItems<QQuickItem>(contentItem, "wrapper").count();
QCOMPARE(itemCount, 5);
- delete canvas;
+ delete window;
delete testObject;
}
void tst_QQuickListView::initialZValues()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("initialZValues.qml"));
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("initialZValues.qml"));
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QVERIFY(listview->footerItem());
QTRY_COMPARE(listview->footerItem()->z(), listview->property("initialZ").toReal());
- delete canvas;
+ delete window;
}
void tst_QQuickListView::header()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQuickView *canvas = getView();
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->rootContext()->setContextProperty("initialViewWidth", 240);
- canvas->rootContext()->setContextProperty("initialViewHeight", 320);
- canvas->setSource(testFileUrl("header.qml"));
- canvas->show();
+ QQuickView *window = getView();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("initialViewWidth", 240);
+ window->rootContext()->setContextProperty("initialViewHeight", 320);
+ window->setSource(testFileUrl("header.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
model.addItem("Item" + QString::number(i), "");
QSignalSpy headerItemSpy(listview, SIGNAL(headerItemChanged()));
- QMetaObject::invokeMethod(canvas->rootObject(), "changeHeader");
+ QMetaObject::invokeMethod(window->rootObject(), "changeHeader");
QCOMPARE(headerItemSpy.count(), 1);
header->setWidth(40);
QTRY_COMPARE(QPointF(listview->contentX(), listview->contentY()), resizeContentPos);
- releaseView(canvas);
+ releaseView(window);
// QTBUG-21207 header should become visible if view resizes from initial empty size
- canvas = getView();
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->rootContext()->setContextProperty("initialViewWidth", 0.0);
- canvas->rootContext()->setContextProperty("initialViewHeight", 0.0);
- canvas->setSource(testFileUrl("header.qml"));
- canvas->show();
+ window = getView();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("initialViewWidth", 0.0);
+ window->rootContext()->setContextProperty("initialViewHeight", 0.0);
+ window->setSource(testFileUrl("header.qml"));
+ window->show();
qApp->processEvents();
- listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
QTRY_COMPARE(listview->headerItem()->pos(), initialHeaderPos);
QCOMPARE(QPointF(listview->contentX(), listview->contentY()), initialContentPos);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::header_data()
void tst_QQuickListView::header_delayItemCreation()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
- canvas->rootContext()->setContextProperty("setCurrentToZero", QVariant(false));
- canvas->setSource(testFileUrl("fillModelOnComponentCompleted.qml"));
+ window->rootContext()->setContextProperty("setCurrentToZero", QVariant(false));
+ window->setSource(testFileUrl("fillModelOnComponentCompleted.qml"));
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
model.clear();
QTRY_COMPARE(header->y(), -header->height());
- delete canvas;
+ delete window;
}
void tst_QQuickListView::footer()
QFETCH(QPointF, changedContentPos);
QFETCH(QPointF, resizeContentPos);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QmlListModel model;
for (int i = 0; i < 3; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("footer.qml"));
- canvas->show();
+ window->setSource(testFileUrl("footer.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
QTRY_COMPARE(footer->pos(), posWhenNoItems);
// if header is present, it's at a negative pos, so the footer should not move
- canvas->rootObject()->setProperty("showHeader", true);
+ window->rootObject()->setProperty("showHeader", true);
QTRY_COMPARE(footer->pos(), posWhenNoItems);
- canvas->rootObject()->setProperty("showHeader", false);
+ window->rootObject()->setProperty("showHeader", false);
// add 30 items
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
QSignalSpy footerItemSpy(listview, SIGNAL(footerItemChanged()));
- QMetaObject::invokeMethod(canvas->rootObject(), "changeFooter");
+ QMetaObject::invokeMethod(window->rootObject(), "changeFooter");
QCOMPARE(footerItemSpy.count(), 1);
footer->setWidth(40);
QTRY_COMPARE(QPointF(listview->contentX(), listview->contentY()), resizeContentPos);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::footer_data()
QFETCH(QPointF, origin_empty);
QFETCH(QPointF, origin_nonEmpty);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QmlListModel model;
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("headerfooter.qml"));
- canvas->show();
+ window->setSource(testFileUrl("headerfooter.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(window->rootObject());
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
listview->setLayoutDirection(layoutDirection);
QCOMPARE(listview->originX(), origin_nonEmpty.x());
QCOMPARE(listview->originY(), origin_nonEmpty.y());
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::extents_data()
{
// Resetting a model shouldn't crash in views with header/footer
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 4; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("headerfooter.qml"));
+ window->setSource(testFileUrl("headerfooter.qml"));
qApp->processEvents();
- QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(window->rootObject());
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(footer);
QCOMPARE(footer->y(), 30.*4);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::resizeView()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
}
QVariant heightRatio;
- QMetaObject::invokeMethod(canvas->rootObject(), "heightRatio", Q_RETURN_ARG(QVariant, heightRatio));
+ QMetaObject::invokeMethod(window->rootObject(), "heightRatio", Q_RETURN_ARG(QVariant, heightRatio));
QCOMPARE(heightRatio.toReal(), 0.4);
listview->setHeight(200);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
- QMetaObject::invokeMethod(canvas->rootObject(), "heightRatio", Q_RETURN_ARG(QVariant, heightRatio));
+ QMetaObject::invokeMethod(window->rootObject(), "heightRatio", Q_RETURN_ARG(QVariant, heightRatio));
QCOMPARE(heightRatio.toReal(), 0.25);
// Ensure we handle -ve sizes
QCOMPARE(delegateVisible(item), i < 6); // inside view visible, outside not visible
}
- delete canvas;
+ delete window;
delete testObject;
}
void tst_QQuickListView::resizeViewAndRepaint()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 40; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("initialHeight", 100);
- canvas->setSource(testFileUrl("resizeview.qml"));
- canvas->show();
+ window->setSource(testFileUrl("resizeview.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
listview->setHeight(100);
QTRY_VERIFY(!findItem<QQuickItem>(contentItem, "wrapper", 10));
- delete canvas;
+ delete window;
}
void tst_QQuickListView::sizeLessThan1()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("sizelessthan1.qml"));
- canvas->show();
+ window->setSource(testFileUrl("sizelessthan1.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QTRY_COMPARE(item->y(), i*0.5);
}
- delete canvas;
+ delete window;
delete testObject;
}
void tst_QQuickListView::QTBUG_14821()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("qtbug14821.qml"));
+ window->setSource(testFileUrl("qtbug14821.qml"));
qApp->processEvents();
- QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(window->rootObject());
QVERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
listview->incrementCurrentIndex();
QCOMPARE(listview->currentIndex(), 0);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::resizeDelegate()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QStringList strings;
for (int i = 0; i < 30; ++i)
strings << QString::number(i);
QStringListModel model(strings);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("displaylist.qml"));
- canvas->show();
+ window->setSource(testFileUrl("displaylist.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QVERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QCOMPARE(listview->currentItem()->y(), 500.0);
QTRY_COMPARE(listview->highlightItem()->y(), 500.0);
- canvas->rootObject()->setProperty("delegateHeight", 30);
+ window->rootObject()->setProperty("delegateHeight", 30);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
for (int i = 0; i < 11; ++i) {
QTRY_COMPARE(listview->currentItem()->y(), 30.0);
QTRY_COMPARE(listview->highlightItem()->y(), 30.0);
- canvas->rootObject()->setProperty("delegateHeight", 20);
+ window->rootObject()->setProperty("delegateHeight", 20);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
for (int i = 5; i < 11; ++i) {
QTRY_COMPARE(listview->currentItem()->y(), 70.0);
QTRY_COMPARE(listview->highlightItem()->y(), 70.0);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::resizeFirstDelegate()
// QTBUG-20712: Content Y jumps constantly if first delegate height == 0
// and other delegates have height > 0
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
// bug only occurs when all items in the model are visible
QmlListModel model;
for (int i = 0; i < 10; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QVERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
}
delete testObject;
- delete canvas;
+ delete window;
}
void tst_QQuickListView::repositionResizedDelegate()
QFETCH(QRectF, origPositionerRect);
QFETCH(QRectF, resizedPositionerRect);
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testHorizontal", orientation == QQuickListView::Horizontal);
ctxt->setContextProperty("testRightToLeft", layoutDirection == Qt::RightToLeft);
ctxt->setContextProperty("testBottomToTop", verticalLayoutDirection == QQuickListView::BottomToTop);
- canvas->setSource(testFileUrl("repositionResizedDelegate.qml"));
- canvas->show();
+ window->setSource(testFileUrl("repositionResizedDelegate.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(window->rootObject());
QTRY_VERIFY(listview != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
- QQuickItem *positioner = findItem<QQuickItem>(canvas->rootObject(), "positioner");
+ QQuickItem *positioner = findItem<QQuickItem>(window->rootObject(), "positioner");
QVERIFY(positioner);
QTRY_COMPARE(positioner->boundingRect().size(), origPositionerRect.size());
QTRY_COMPARE(positioner->pos(), origPositionerRect.topLeft());
listview->setContentY(contentPos_itemFirstHalfVisible.y());
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
prevSpyCount = spy.count();
- QVERIFY(QMetaObject::invokeMethod(canvas->rootObject(), "incrementRepeater"));
+ QVERIFY(QMetaObject::invokeMethod(window->rootObject(), "incrementRepeater"));
QTRY_COMPARE(positioner->boundingRect().size(), resizedPositionerRect.size());
QTRY_COMPARE(positioner->pos(), resizedPositionerRect.topLeft());
QCOMPARE(listview->contentX(), contentPos_itemFirstHalfVisible.x());
QCOMPARE(listview->contentY(), contentPos_itemFirstHalfVisible.y());
QCOMPARE(spy.count(), prevSpyCount);
- QVERIFY(QMetaObject::invokeMethod(canvas->rootObject(), "decrementRepeater"));
+ QVERIFY(QMetaObject::invokeMethod(window->rootObject(), "decrementRepeater"));
QTRY_COMPARE(positioner->boundingRect().size(), origPositionerRect.size());
QTRY_COMPARE(positioner->pos(), origPositionerRect.topLeft());
QCOMPARE(listview->contentX(), contentPos_itemFirstHalfVisible.x());
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
prevSpyCount = spy.count();
- QVERIFY(QMetaObject::invokeMethod(canvas->rootObject(), "incrementRepeater"));
- positioner = findItem<QQuickItem>(canvas->rootObject(), "positioner");
+ QVERIFY(QMetaObject::invokeMethod(window->rootObject(), "incrementRepeater"));
+ positioner = findItem<QQuickItem>(window->rootObject(), "positioner");
QTRY_COMPARE(positioner->boundingRect().size(), resizedPositionerRect.size());
QTRY_COMPARE(positioner->pos(), resizedPositionerRect.topLeft());
QCOMPARE(listview->contentX(), contentPos_itemSecondHalfVisible.x());
qApp->processEvents();
QCOMPARE(spy.count(), prevSpyCount);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::repositionResizedDelegate_data()
void tst_QQuickListView::QTBUG_16037()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
- canvas->setSource(testFileUrl("qtbug16037.qml"));
+ window->setSource(testFileUrl("qtbug16037.qml"));
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "listview");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "listview");
QTRY_VERIFY(listview != 0);
QVERIFY(listview->contentHeight() <= 0.0);
- QMetaObject::invokeMethod(canvas->rootObject(), "setModel");
+ QMetaObject::invokeMethod(window->rootObject(), "setModel");
QTRY_COMPARE(listview->contentHeight(), 80.0);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::indexAt_itemAt_data()
QFETCH(qreal, y);
QFETCH(int, index);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
QmlListModel model;
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("listviewtest.qml"));
- canvas->show();
+ window->setSource(testFileUrl("listviewtest.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QCOMPARE(listview->indexAt(x,y), index);
QVERIFY(listview->itemAt(x,y) == item);
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
void tst_QQuickListView::incrementalModel()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
IncrementalModel model;
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("displaylist.qml"));
+ window->setSource(testFileUrl("displaylist.qml"));
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_COMPARE(listview->count(), 25);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::onAdd()
for (int i=0; i<initialItemCount; i++)
model.addItem("dummy value", "dummy value");
- QQuickView *canvas = createView();
- canvas->setGeometry(0,0,200, delegateHeight * (initialItemCount + itemsToAdd));
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = createView();
+ window->setGeometry(0,0,200, delegateHeight * (initialItemCount + itemsToAdd));
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("delegateHeight", delegateHeight);
- canvas->setSource(testFileUrl("attachedSignals.qml"));
+ window->setSource(testFileUrl("attachedSignals.qml"));
- QObject *object = canvas->rootObject();
- object->setProperty("width", canvas->width());
- object->setProperty("height", canvas->height());
+ QObject *object = window->rootObject();
+ object->setProperty("width", window->width());
+ object->setProperty("height", window->height());
qApp->processEvents();
QList<QPair<QString, QString> > items;
for (int i=0; i<itemsToAdd; i++)
items << qMakePair(QString("value %1").arg(i), QString::number(i));
model.addItems(items);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QVariantList result = object->property("addedDelegates").toList();
QCOMPARE(result.count(), items.count());
for (int i=0; i<items.count(); i++)
QCOMPARE(result[i].toString(), items[i].first);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::onAdd_data()
for (int i=0; i<initialItemCount; i++)
model.addItem(QString("value %1").arg(i), "dummy value");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("delegateHeight", delegateHeight);
- canvas->setSource(testFileUrl("attachedSignals.qml"));
+ window->setSource(testFileUrl("attachedSignals.qml"));
- QObject *object = canvas->rootObject();
+ QObject *object = window->rootObject();
model.removeItems(indexToRemove, removeCount);
- QTRY_COMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("count").toInt(), model.count());
QCOMPARE(object->property("removedDelegateCount"), QVariant(removeCount));
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::onRemove_data()
void tst_QQuickListView::rightToLeft()
{
- QQuickView *canvas = createView();
- canvas->setGeometry(0,0,640,320);
- canvas->setSource(testFileUrl("rightToLeft.qml"));
- canvas->show();
+ QQuickView *window = createView();
+ window->setGeometry(0,0,640,320);
+ window->setSource(testFileUrl("rightToLeft.qml"));
+ window->show();
qApp->processEvents();
- QVERIFY(canvas->rootObject() != 0);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "view");
+ QVERIFY(window->rootObject() != 0);
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "view");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
- QQuickVisualItemModel *model = canvas->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
+ QQuickVisualItemModel *model = window->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);
QCOMPARE(listview->contentX(), -640.);
// Ensure resizing maintains position relative to right edge
- qobject_cast<QQuickItem*>(canvas->rootObject())->setWidth(600);
+ qobject_cast<QQuickItem*>(window->rootObject())->setWidth(600);
QTRY_COMPARE(listview->contentX(), -600.);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::test_mirroring()
{
- QQuickView *canvasA = createView();
- canvasA->setSource(testFileUrl("rightToLeft.qml"));
- QQuickListView *listviewA = findItem<QQuickListView>(canvasA->rootObject(), "view");
+ QQuickView *windowA = createView();
+ windowA->setSource(testFileUrl("rightToLeft.qml"));
+ QQuickListView *listviewA = findItem<QQuickListView>(windowA->rootObject(), "view");
QTRY_VERIFY(listviewA != 0);
- QQuickView *canvasB = createView();
- canvasB->setSource(testFileUrl("rightToLeft.qml"));
- QQuickListView *listviewB = findItem<QQuickListView>(canvasB->rootObject(), "view");
+ QQuickView *windowB = createView();
+ windowB->setSource(testFileUrl("rightToLeft.qml"));
+ QQuickListView *listviewB = findItem<QQuickListView>(windowB->rootObject(), "view");
QTRY_VERIFY(listviewA != 0);
qApp->processEvents();
foreach (const QString objectName, objectNames)
QCOMPARE(findItem<QQuickItem>(listviewA, objectName)->x(), findItem<QQuickItem>(listviewB, objectName)->x());
- delete canvasA;
- delete canvasB;
+ delete windowA;
+ delete windowB;
}
void tst_QQuickListView::margins()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
for (int i = 0; i < 50; i++)
model.addItem("Item" + QString::number(i), "");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("margins.qml"));
- canvas->show();
+ window->setSource(testFileUrl("margins.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QCOMPARE(listview->originY(), 20.);
QTRY_COMPARE(listview->contentY(), pos-10);
- delete canvas;
+ delete window;
}
// QTBUG-24028
else
flickStart.rx() += (layoutDirection == Qt::LeftToRight) ? 180 : -180;
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
- canvas->setSource(testFileUrl("margins2.qml"));
- canvas->show();
+ window->setSource(testFileUrl("margins2.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "listview");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "listview");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
QTRY_COMPARE(listview->contentX(), end);
// flick past the end and check content pos still settles on correct extents
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(listview->isMoving() == false);
if (orientation == QQuickListView::Vertical)
QTRY_COMPARE(listview->contentY(), end);
QTRY_COMPARE(listview->contentX(), start);
// flick past the beginning and check content pos still settles on correct extents
- flick(canvas, flickEnd, flickStart, 180);
+ flick(window, flickEnd, flickStart, 180);
QTRY_VERIFY(listview->isMoving() == false);
if (orientation == QQuickListView::Vertical)
QTRY_COMPARE(listview->contentY(), start);
else
QTRY_COMPARE(listview->contentX(), start);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::marginsResize_data()
QFETCH(qreal, endExtent);
QFETCH(qreal, startExtent);
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
- canvas->setSource(testFileUrl("snapToItem.qml"));
- canvas->show();
+ window->setSource(testFileUrl("snapToItem.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
QTRY_VERIFY(contentItem != 0);
// confirm that a flick hits an item boundary
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
if (orientation == QQuickListView::Vertical)
QCOMPARE(qreal(fmod(listview->contentY(),80.0)), snapAlignment);
// flick to end
do {
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
} while (orientation == QQuickListView::Vertical
? verticalLayoutDirection == QQuickItemView::TopToBottom ? !listview->isAtYEnd() : !listview->isAtYBeginning()
// flick to start
do {
- flick(canvas, flickEnd, flickStart, 180);
+ flick(window, flickEnd, flickStart, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
} while (orientation == QQuickListView::Vertical
? verticalLayoutDirection == QQuickItemView::TopToBottom ? !listview->isAtYBeginning() : !listview->isAtYEnd()
else
QCOMPARE(listview->contentX(), startExtent);
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::qListModelInterface_items()
void tst_QQuickListView::creationContext()
{
- QQuickView canvas;
- canvas.setGeometry(0,0,240,320);
- canvas.setSource(testFileUrl("creationContext.qml"));
+ QQuickView window;
+ window.setGeometry(0,0,240,320);
+ window.setSource(testFileUrl("creationContext.qml"));
qApp->processEvents();
- QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(window.rootObject());
QVERIFY(rootItem);
QVERIFY(rootItem->property("count").toInt() > 0);
void tst_QQuickListView::QTBUG_21742()
{
- QQuickView canvas;
- canvas.setGeometry(0,0,200,200);
- canvas.setSource(testFileUrl("qtbug-21742.qml"));
+ QQuickView window;
+ window.setGeometry(0,0,200,200);
+ window.setSource(testFileUrl("qtbug-21742.qml"));
qApp->processEvents();
- QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(window.rootObject());
QVERIFY(rootItem);
QCOMPARE(rootItem->property("count").toInt(), 1);
}
void tst_QQuickListView::asynchronous()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QQmlIncubationController controller;
- canvas->engine()->setIncubationController(&controller);
+ window->engine()->setIncubationController(&controller);
- canvas->setSource(testFileUrl("asyncloader.qml"));
+ window->setSource(testFileUrl("asyncloader.qml"));
- QQuickItem *rootObject = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootObject = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootObject);
QQuickListView *listview = 0;
QTRY_COMPARE(item->y(), i*50.0);
}
- delete canvas;
+ delete window;
}
void tst_QQuickListView::snapOneItem_data()
QSKIP("QTBUG-24338");
#endif
- QQuickView *canvas = getView();
+ QQuickView *window = getView();
- canvas->setSource(testFileUrl("snapOneItem.qml"));
- canvas->show();
+ window->setSource(testFileUrl("snapOneItem.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
listview->setOrientation(orientation);
QSignalSpy currentIndexSpy(listview, SIGNAL(currentIndexChanged()));
// confirm that a flick hits the next item boundary
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
if (orientation == QQuickListView::Vertical)
QCOMPARE(listview->contentY(), snapAlignment);
// flick to end
do {
- flick(canvas, flickStart, flickEnd, 180);
+ flick(window, flickStart, flickEnd, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
} while (orientation == QQuickListView::Vertical
? verticalLayoutDirection == QQuickItemView::TopToBottom ? !listview->isAtYEnd() : !listview->isAtYBeginning()
// flick to start
do {
- flick(canvas, flickEnd, flickStart, 180);
+ flick(window, flickEnd, flickStart, 180);
QTRY_VERIFY(listview->isMoving() == false); // wait until it stops
} while (orientation == QQuickListView::Vertical
? verticalLayoutDirection == QQuickItemView::TopToBottom ? !listview->isAtYBeginning() : !listview->isAtYEnd()
QCOMPARE(currentIndexSpy.count(), 6);
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::unrequestedVisibility()
for (int i = 0; i < 30; i++)
model.addItem("Item" + QString::number(i), QString::number(i));
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testWrap", QVariant(false));
- canvas->setSource(testFileUrl("unrequestedItems.qml"));
- canvas->show();
+ window->setSource(testFileUrl("unrequestedItems.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *leftview = findItem<QQuickListView>(canvas->rootObject(), "leftList");
+ QQuickListView *leftview = findItem<QQuickListView>(window->rootObject(), "leftList");
QTRY_VERIFY(leftview != 0);
- QQuickListView *rightview = findItem<QQuickListView>(canvas->rootObject(), "rightList");
+ QQuickListView *rightview = findItem<QQuickListView>(window->rootObject(), "rightList");
QTRY_VERIFY(rightview != 0);
QQuickItem *leftContent = leftview->contentItem();
QVERIFY(item = findItem<QQuickItem>(rightContent, "wrapper", 17));
QCOMPARE(delegateVisible(item), false);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::populateTransitions()
model.addItem("item" + QString::number(i), "");
}
- QQuickView *canvas = getView();
- canvas->rootContext()->setContextProperty("testModel", &model);
- canvas->rootContext()->setContextProperty("testObject", new TestObject(canvas->rootContext()));
- canvas->rootContext()->setContextProperty("usePopulateTransition", usePopulateTransition);
- canvas->rootContext()->setContextProperty("dynamicallyPopulate", dynamicallyPopulate);
- canvas->rootContext()->setContextProperty("transitionFrom", transitionFrom);
- canvas->rootContext()->setContextProperty("transitionVia", transitionVia);
- canvas->rootContext()->setContextProperty("model_transitionFrom", &model_transitionFrom);
- canvas->rootContext()->setContextProperty("model_transitionVia", &model_transitionVia);
- canvas->setSource(testFileUrl("populateTransitions.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
-
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickView *window = getView();
+ window->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("testObject", new TestObject(window->rootContext()));
+ window->rootContext()->setContextProperty("usePopulateTransition", usePopulateTransition);
+ window->rootContext()->setContextProperty("dynamicallyPopulate", dynamicallyPopulate);
+ window->rootContext()->setContextProperty("transitionFrom", transitionFrom);
+ window->rootContext()->setContextProperty("transitionVia", transitionVia);
+ window->rootContext()->setContextProperty("model_transitionFrom", &model_transitionFrom);
+ window->rootContext()->setContextProperty("model_transitionVia", &model_transitionVia);
+ window->setSource(testFileUrl("populateTransitions.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
+
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QVERIFY(listview);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem);
QTRY_COMPARE(listview->property("countPopulateTransitions").toInt(), 0);
// clear the model
- canvas->rootContext()->setContextProperty("testModel", QVariant());
+ window->rootContext()->setContextProperty("testModel", QVariant());
QTRY_COMPARE(listview->count(), 0);
QTRY_COMPARE(findItems<QQuickItem>(contentItem, "wrapper").count(), 0);
listview->setProperty("countPopulateTransitions", 0);
model.clear();
for (int i = 0; i < 30; i++)
model.addItem("item" + QString::number(i), "");
- canvas->rootContext()->setContextProperty("testModel", &model);
+ window->rootContext()->setContextProperty("testModel", &model);
QTRY_COMPARE(listview->property("countPopulateTransitions").toInt(), usePopulateTransition ? 16 : 0);
QTRY_COMPARE(listview->property("countAddTransitions").toInt(), 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::populateTransitions_data()
QaimModel model_targetItems_transitionFrom;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("model_targetItems_transitionFrom", &model_targetItems_transitionFrom);
ctxt->setContextProperty("targetItems_transitionFrom", targetItems_transitionFrom);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("addTransitions.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("addTransitions.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
QaimModel model_targetItems_transitionVia;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("model_targetItems_transitionVia", &model_targetItems_transitionVia);
ctxt->setContextProperty("targetItems_transitionVia", targetItems_transitionVia);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("moveTransitions.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("moveTransitions.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
QaimModel model_targetItems_transitionTo;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("model_targetItems_transitionTo", &model_targetItems_transitionTo);
ctxt->setContextProperty("targetItems_transitionTo", targetItems_transitionTo);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("removeTransitions.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("removeTransitions.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
QPointF moveDisplaced_transitionVia(50, -100);
QPointF removeDisplaced_transitionVia(150, 100);
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
- TestObject *testObject = new TestObject(canvas);
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
+ TestObject *testObject = new TestObject(window);
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testObject", testObject);
ctxt->setContextProperty("model_displaced_transitionVia", &model_displaced_transitionVia);
ctxt->setContextProperty("moveDisplacedEnabled", moveDisplacedEnabled);
ctxt->setContextProperty("useRemoveDisplaced", useRemoveDisplaced);
ctxt->setContextProperty("removeDisplacedEnabled", removeDisplacedEnabled);
- canvas->setSource(testFileUrl("displacedTransitions.qml"));
- canvas->show();
+ window->setSource(testFileUrl("displacedTransitions.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
void tst_QQuickListView::displacedTransitions_data()
for (int i = 0; i < initialCount; i++)
model.addItem("Original item" + QString::number(i), "");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testModel", &model);
ctxt->setContextProperty("testObject", testObject);
ctxt->setContextProperty("enableMoveTransitions", enableMoveTransitions);
ctxt->setContextProperty("enableRemoveTransitions", enableRemoveTransitions);
ctxt->setContextProperty("rippleAddDisplaced", rippleAddDisplaced);
- canvas->setSource(testFileUrl("multipleTransitions.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("multipleTransitions.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
}
- int timeBetweenActions = canvas->rootObject()->property("timeBetweenActions").toInt();
+ int timeBetweenActions = window->rootObject()->property("timeBetweenActions").toInt();
for (int i=0; i<changes.count(); i++) {
switch (changes[i].type) {
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
delete testObject;
}
for (int i = 0; i < 30; i++)
model.addItem("Original item" + QString::number(i), "");
- QQuickView *canvas = getView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = getView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- ctxt->setContextProperty("testObject", new TestObject(canvas));
- canvas->setSource(testFileUrl("multipleDisplaced.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ ctxt->setContextProperty("testObject", new TestObject(window));
+ window->setSource(testFileUrl("multipleDisplaced.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
model.moveItems(12, 8, 1);
- QTest::qWait(canvas->rootObject()->property("duration").toInt() / 2);
+ QTest::qWait(window->rootObject()->property("duration").toInt() / 2);
model.moveItems(8, 3, 1);
QTRY_VERIFY(listview->property("displaceTransitionsDone").toBool());
QTRY_COMPARE(name->text(), model.name(i));
}
- releaseView(canvas);
+ releaseView(window);
}
QList<int> tst_QQuickListView::toIntList(const QVariantList &list)
void tst_QQuickListView::flickBeyondBounds()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("flickBeyondBoundsBug.qml"));
- canvas->show();
+ window->setSource(testFileUrl("flickBeyondBoundsBug.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QTRY_VERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
// Flick view up beyond bounds
- flick(canvas, QPoint(10, 10), QPoint(10, -1000), 180);
+ flick(window, QPoint(10, 10), QPoint(10, -1000), 180);
QTRY_VERIFY(findItems<QQuickItem>(contentItem, "wrapper").count() == 0);
// We're really testing that we don't get stuck in a loop,
QTRY_VERIFY(item->y() == i*45);
}
- delete canvas;
+ delete window;
}
void tst_QQuickListView::destroyItemOnCreation()
{
QmlListModel model;
- QQuickView *canvas = createView();
- canvas->rootContext()->setContextProperty("testModel", &model);
+ QQuickView *window = createView();
+ window->rootContext()->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("destroyItemOnCreation.qml"));
- canvas->show();
+ window->setSource(testFileUrl("destroyItemOnCreation.qml"));
+ window->show();
qApp->processEvents();
- QQuickListView *listview = findItem<QQuickListView>(canvas->rootObject(), "list");
+ QQuickListView *listview = findItem<QQuickListView>(window->rootObject(), "list");
QVERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
- QCOMPARE(canvas->rootObject()->property("createdIndex").toInt(), -1);
+ QCOMPARE(window->rootObject()->property("createdIndex").toInt(), -1);
model.addItem("new item", "");
- QTRY_COMPARE(canvas->rootObject()->property("createdIndex").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("createdIndex").toInt(), 0);
QTRY_COMPARE(findItems<QQuickItem>(contentItem, "wrapper").count(), 0);
QCOMPARE(model.count(), 0);
- delete canvas;
+ delete window;
}
void tst_QQuickListView::parentBinding()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
m_errorCount = 0;
QtMsgHandler old = qInstallMsgHandler(errorMsgHandler);
- canvas->setSource(testFileUrl("parentBinding.qml"));
- canvas->show();
- QTest::qWaitForWindowExposed(canvas);
+ window->setSource(testFileUrl("parentBinding.qml"));
+ window->show();
+ QTest::qWaitForWindowExposed(window);
- QQuickListView *listview = qobject_cast<QQuickListView*>(canvas->rootObject());
+ QQuickListView *listview = qobject_cast<QQuickListView*>(window->rootObject());
QVERIFY(listview != 0);
QQuickItem *contentItem = listview->contentItem();
qInstallMsgHandler(old);
- delete canvas;
+ delete window;
}
QTEST_MAIN(tst_QQuickListView)
void tst_QQuickMouseArea::dragProperties()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("dragproperties.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window->setSource(testFileUrl("dragproperties.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = window->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
- QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootItem != 0);
QSignalSpy targetSpy(drag, SIGNAL(targetChanged()));
drag->setTarget(rootItem);
drag->setFilterChildren(true);
QCOMPARE(filterChildrenSpy.count(), 1);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::resetDrag()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->rootContext()->setContextProperty("haveTarget", QVariant(true));
- canvas->setSource(testFileUrl("dragreset.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window->rootContext()->setContextProperty("haveTarget", QVariant(true));
+ window->setSource(testFileUrl("dragreset.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = window->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
- QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootItem != 0);
QSignalSpy targetSpy(drag, SIGNAL(targetChanged()));
QVERIFY(drag->target() != 0);
- canvas->rootContext()->setContextProperty("haveTarget", QVariant(false));
+ window->rootContext()->setContextProperty("haveTarget", QVariant(false));
QCOMPARE(targetSpy.count(),1);
QVERIFY(drag->target() == 0);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::dragging()
QFETCH(Qt::MouseButtons, acceptedButtons);
QFETCH(Qt::MouseButton, button);
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("dragging.qml"));
- canvas->show();
- canvas->requestActivateWindow();
+ window->setSource(testFileUrl("dragging.qml"));
+ window->show();
+ window->requestActivateWindow();
QTest::qWait(20);
- QVERIFY(canvas->rootObject() != 0);
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = window->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
mouseRegion->setAcceptedButtons(acceptedButtons);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
QVERIFY(!drag->active());
- QTest::mousePress(canvas, button, 0, QPoint(100,100));
+ QTest::mousePress(window, button, 0, QPoint(100,100));
QVERIFY(!drag->active());
QCOMPARE(blackRect->x(), 50.0);
// First move event triggers drag, second is acted upon.
// This is due to possibility of higher stacked area taking precedence.
- QTest::mouseMove(canvas, QPoint(111,111));
+ QTest::mouseMove(window, QPoint(111,111));
QTest::qWait(50);
- QTest::mouseMove(canvas, QPoint(122,122));
+ QTest::mouseMove(window, QPoint(122,122));
QTest::qWait(50);
QVERIFY(drag->active());
QCOMPARE(blackRect->x(), 72.0);
QCOMPARE(blackRect->y(), 72.0);
- QTest::mouseRelease(canvas, button, 0, QPoint(122,122));
+ QTest::mouseRelease(window, button, 0, QPoint(122,122));
QTest::qWait(50);
QVERIFY(!drag->active());
QCOMPARE(blackRect->x(), 72.0);
QCOMPARE(blackRect->y(), 72.0);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::invalidDrag()
QFETCH(Qt::MouseButtons, acceptedButtons);
QFETCH(Qt::MouseButton, button);
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("dragging.qml"));
- canvas->show();
- canvas->requestActivateWindow();
+ window->setSource(testFileUrl("dragging.qml"));
+ window->show();
+ window->requestActivateWindow();
QTest::qWait(20);
- QVERIFY(canvas->rootObject() != 0);
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = window->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
mouseRegion->setAcceptedButtons(acceptedButtons);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
QVERIFY(!drag->active());
- QTest::mousePress(canvas, button, 0, QPoint(100,100));
+ QTest::mousePress(window, button, 0, QPoint(100,100));
QVERIFY(!drag->active());
QCOMPARE(blackRect->x(), 50.0);
// First move event triggers drag, second is acted upon.
// This is due to possibility of higher stacked area taking precedence.
- QTest::mouseMove(canvas, QPoint(111,111));
+ QTest::mouseMove(window, QPoint(111,111));
QTest::qWait(50);
- QTest::mouseMove(canvas, QPoint(122,122));
+ QTest::mouseMove(window, QPoint(122,122));
QTest::qWait(50);
QVERIFY(!drag->active());
QCOMPARE(blackRect->x(), 50.0);
QCOMPARE(blackRect->y(), 50.0);
- QTest::mouseRelease(canvas, button, 0, QPoint(122,122));
+ QTest::mouseRelease(window, button, 0, QPoint(122,122));
QTest::qWait(50);
QVERIFY(!drag->active());
QCOMPARE(blackRect->x(), 50.0);
QCOMPARE(blackRect->y(), 50.0);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::setDragOnPressed()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("setDragOnPressed.qml"));
- canvas->show();
- canvas->requestActivateWindow();
+ window->setSource(testFileUrl("setDragOnPressed.qml"));
+ window->show();
+ window->requestActivateWindow();
QTest::qWait(20);
- QVERIFY(canvas->rootObject() != 0);
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseArea = qobject_cast<QQuickMouseArea *>(canvas->rootObject());
+ QQuickMouseArea *mouseArea = qobject_cast<QQuickMouseArea *>(window->rootObject());
QVERIFY(mouseArea);
// target
QQuickItem *target = mouseArea->findChild<QQuickItem*>("target");
QVERIFY(target);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
QQuickDrag *drag = mouseArea->drag();
QVERIFY(drag);
// First move event triggers drag, second is acted upon.
// This is due to possibility of higher stacked area taking precedence.
- QTest::mouseMove(canvas, QPoint(111,102));
+ QTest::mouseMove(window, QPoint(111,102));
QTest::qWait(50);
- QTest::mouseMove(canvas, QPoint(122,122));
+ QTest::mouseMove(window, QPoint(122,122));
QTest::qWait(50);
QVERIFY(drag->active());
QCOMPARE(target->x(), 72.0);
QCOMPARE(target->y(), 50.0);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(122,122));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(122,122));
QTest::qWait(50);
QVERIFY(!drag->active());
QCOMPARE(target->x(), 72.0);
QCOMPARE(target->y(), 50.0);
- delete canvas;
+ delete window;
}
QQuickView *tst_QQuickMouseArea::createView()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setBaseSize(QSize(240,320));
+ QQuickView *window = new QQuickView(0);
+ window->setBaseSize(QSize(240,320));
- return canvas;
+ return window;
}
void tst_QQuickMouseArea::updateMouseAreaPosOnClick()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("updateMousePosOnClick.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("updateMousePosOnClick.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = window->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QVERIFY(mouseRegion != 0);
- QQuickRectangle *rect = canvas->rootObject()->findChild<QQuickRectangle*>("ball");
+ QQuickRectangle *rect = window->rootObject()->findChild<QQuickRectangle*>("ball");
QVERIFY(rect != 0);
QCOMPARE(mouseRegion->mouseX(), rect->x());
QCOMPARE(mouseRegion->mouseY(), rect->y());
QMouseEvent event(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &event);
+ QGuiApplication::sendEvent(window, &event);
QCOMPARE(mouseRegion->mouseX(), 100.0);
QCOMPARE(mouseRegion->mouseY(), 100.0);
QCOMPARE(mouseRegion->mouseX(), rect->x());
QCOMPARE(mouseRegion->mouseY(), rect->y());
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::updateMouseAreaPosOnResize()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("updateMousePosOnResize.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("updateMousePosOnResize.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = window->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QVERIFY(mouseRegion != 0);
- QQuickRectangle *rect = canvas->rootObject()->findChild<QQuickRectangle*>("brother");
+ QQuickRectangle *rect = window->rootObject()->findChild<QQuickRectangle*>("brother");
QVERIFY(rect != 0);
QCOMPARE(mouseRegion->mouseX(), 0.0);
QCOMPARE(mouseRegion->mouseY(), 0.0);
QMouseEvent event(QEvent::MouseButtonPress, rect->pos().toPoint(), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &event);
+ QGuiApplication::sendEvent(window, &event);
QVERIFY(!mouseRegion->property("emitPositionChanged").toBool());
QVERIFY(mouseRegion->property("mouseMatchesPos").toBool());
QCOMPARE(mouseRegion->mouseX(), rect->x());
QCOMPARE(mouseRegion->mouseY(), rect->y());
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::noOnClickedWithPressAndHold()
{
{
// We handle onPressAndHold, therefore no onClicked
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("clickandhold.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("clickandhold.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
- QVERIFY(!canvas->rootObject()->property("clicked").toBool());
- QVERIFY(!canvas->rootObject()->property("held").toBool());
+ QVERIFY(!window->rootObject()->property("clicked").toBool());
+ QVERIFY(!window->rootObject()->property("held").toBool());
QTest::qWait(1000);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QVERIFY(!canvas->rootObject()->property("clicked").toBool());
- QVERIFY(canvas->rootObject()->property("held").toBool());
+ QVERIFY(!window->rootObject()->property("clicked").toBool());
+ QVERIFY(window->rootObject()->property("held").toBool());
- delete canvas;
+ delete window;
}
{
// We do not handle onPressAndHold, therefore we get onClicked
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("noclickandhold.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("noclickandhold.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
- QVERIFY(!canvas->rootObject()->property("clicked").toBool());
+ QVERIFY(!window->rootObject()->property("clicked").toBool());
QTest::qWait(1000);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QVERIFY(canvas->rootObject()->property("clicked").toBool());
+ QVERIFY(window->rootObject()->property("clicked").toBool());
- delete canvas;
+ delete window;
}
}
void tst_QQuickMouseArea::onMousePressRejected()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("rejectEvent.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
- QVERIFY(canvas->rootObject()->property("enabled").toBool());
-
- QVERIFY(!canvas->rootObject()->property("mr1_pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("mr1_released").toBool());
- QVERIFY(!canvas->rootObject()->property("mr1_canceled").toBool());
- QVERIFY(!canvas->rootObject()->property("mr2_pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("mr2_released").toBool());
- QVERIFY(!canvas->rootObject()->property("mr2_canceled").toBool());
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("rejectEvent.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
+ QVERIFY(window->rootObject()->property("enabled").toBool());
+
+ QVERIFY(!window->rootObject()->property("mr1_pressed").toBool());
+ QVERIFY(!window->rootObject()->property("mr1_released").toBool());
+ QVERIFY(!window->rootObject()->property("mr1_canceled").toBool());
+ QVERIFY(!window->rootObject()->property("mr2_pressed").toBool());
+ QVERIFY(!window->rootObject()->property("mr2_released").toBool());
+ QVERIFY(!window->rootObject()->property("mr2_canceled").toBool());
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
- QVERIFY(canvas->rootObject()->property("mr1_pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("mr1_released").toBool());
- QVERIFY(!canvas->rootObject()->property("mr1_canceled").toBool());
- QVERIFY(canvas->rootObject()->property("mr2_pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("mr2_released").toBool());
- QVERIFY(canvas->rootObject()->property("mr2_canceled").toBool());
+ QVERIFY(window->rootObject()->property("mr1_pressed").toBool());
+ QVERIFY(!window->rootObject()->property("mr1_released").toBool());
+ QVERIFY(!window->rootObject()->property("mr1_canceled").toBool());
+ QVERIFY(window->rootObject()->property("mr2_pressed").toBool());
+ QVERIFY(!window->rootObject()->property("mr2_released").toBool());
+ QVERIFY(window->rootObject()->property("mr2_canceled").toBool());
QTest::qWait(200);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QVERIFY(canvas->rootObject()->property("mr1_released").toBool());
- QVERIFY(!canvas->rootObject()->property("mr1_canceled").toBool());
- QVERIFY(!canvas->rootObject()->property("mr2_released").toBool());
+ QVERIFY(window->rootObject()->property("mr1_released").toBool());
+ QVERIFY(!window->rootObject()->property("mr1_canceled").toBool());
+ QVERIFY(!window->rootObject()->property("mr2_released").toBool());
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::pressedCanceledOnWindowDeactivate()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("pressedCanceled.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
- QVERIFY(!canvas->rootObject()->property("pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("canceled").toBool());
- QVERIFY(!canvas->rootObject()->property("released").toBool());
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("pressedCanceled.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
+ QVERIFY(!window->rootObject()->property("pressed").toBool());
+ QVERIFY(!window->rootObject()->property("canceled").toBool());
+ QVERIFY(!window->rootObject()->property("released").toBool());
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
- QVERIFY(canvas->rootObject()->property("pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("canceled").toBool());
- QVERIFY(!canvas->rootObject()->property("released").toBool());
+ QVERIFY(window->rootObject()->property("pressed").toBool());
+ QVERIFY(!window->rootObject()->property("canceled").toBool());
+ QVERIFY(!window->rootObject()->property("released").toBool());
QTest::qWait(200);
QEvent windowDeactivateEvent(QEvent::WindowDeactivate);
- QGuiApplication::sendEvent(canvas, &windowDeactivateEvent);
- QVERIFY(!canvas->rootObject()->property("pressed").toBool());
- QVERIFY(canvas->rootObject()->property("canceled").toBool());
- QVERIFY(!canvas->rootObject()->property("released").toBool());
+ QGuiApplication::sendEvent(window, &windowDeactivateEvent);
+ QVERIFY(!window->rootObject()->property("pressed").toBool());
+ QVERIFY(window->rootObject()->property("canceled").toBool());
+ QVERIFY(!window->rootObject()->property("released").toBool());
QTest::qWait(200);
//press again
- QGuiApplication::sendEvent(canvas, &pressEvent);
- QVERIFY(canvas->rootObject()->property("pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("canceled").toBool());
- QVERIFY(!canvas->rootObject()->property("released").toBool());
+ QGuiApplication::sendEvent(window, &pressEvent);
+ QVERIFY(window->rootObject()->property("pressed").toBool());
+ QVERIFY(!window->rootObject()->property("canceled").toBool());
+ QVERIFY(!window->rootObject()->property("released").toBool());
QTest::qWait(200);
//release
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
- QVERIFY(!canvas->rootObject()->property("pressed").toBool());
- QVERIFY(!canvas->rootObject()->property("canceled").toBool());
- QVERIFY(canvas->rootObject()->property("released").toBool());
+ QGuiApplication::sendEvent(window, &releaseEvent);
+ QVERIFY(!window->rootObject()->property("pressed").toBool());
+ QVERIFY(!window->rootObject()->property("canceled").toBool());
+ QVERIFY(window->rootObject()->property("released").toBool());
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::doubleClick()
QFETCH(Qt::MouseButtons, acceptedButtons);
QFETCH(Qt::MouseButton, button);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("doubleclick.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("doubleclick.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea *>("mousearea");
+ QQuickMouseArea *mouseArea = window->rootObject()->findChild<QQuickMouseArea *>("mousearea");
QVERIFY(mouseArea);
mouseArea->setAcceptedButtons(acceptedButtons);
// The sequence for a double click is:
// press, release, (click), press, double click, release
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QCOMPARE(canvas->rootObject()->property("released").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("released").toInt(), 1);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QCOMPARE(canvas->rootObject()->property("clicked").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("doubleClicked").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("released").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("clicked").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("doubleClicked").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("released").toInt(), 2);
- delete canvas;
+ delete window;
}
// QTBUG-14832
QFETCH(Qt::MouseButtons, acceptedButtons);
QFETCH(Qt::MouseButton, button);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("clicktwice.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("clicktwice.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea *>("mousearea");
+ QQuickMouseArea *mouseArea = window->rootObject()->findChild<QQuickMouseArea *>("mousearea");
QVERIFY(mouseArea);
mouseArea->setAcceptedButtons(acceptedButtons);
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QCOMPARE(canvas->rootObject()->property("pressed").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("released").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("clicked").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("pressed").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("released").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("clicked").toInt(), 1);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QCOMPARE(canvas->rootObject()->property("pressed").toInt(), 2);
- QCOMPARE(canvas->rootObject()->property("released").toInt(), 2);
- QCOMPARE(canvas->rootObject()->property("clicked").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("pressed").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("released").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("clicked").toInt(), 2);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::invalidClick()
QFETCH(Qt::MouseButtons, acceptedButtons);
QFETCH(Qt::MouseButton, button);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("doubleclick.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("doubleclick.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea *>("mousearea");
+ QQuickMouseArea *mouseArea = window->rootObject()->findChild<QQuickMouseArea *>("mousearea");
QVERIFY(mouseArea);
mouseArea->setAcceptedButtons(acceptedButtons);
// The sequence for a double click is:
// press, release, (click), press, double click, release
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QCOMPARE(canvas->rootObject()->property("released").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("released").toInt(), 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QCOMPARE(canvas->rootObject()->property("clicked").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("doubleClicked").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("released").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("clicked").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("doubleClicked").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("released").toInt(), 0);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::pressedOrdering()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("pressedOrdering.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("pressedOrdering.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QCOMPARE(canvas->rootObject()->property("value").toString(), QLatin1String("base"));
+ QCOMPARE(window->rootObject()->property("value").toString(), QLatin1String("base"));
QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
- QCOMPARE(canvas->rootObject()->property("value").toString(), QLatin1String("pressed"));
+ QCOMPARE(window->rootObject()->property("value").toString(), QLatin1String("pressed"));
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, 0);
- QGuiApplication::sendEvent(canvas, &releaseEvent);
+ QGuiApplication::sendEvent(window, &releaseEvent);
- QCOMPARE(canvas->rootObject()->property("value").toString(), QLatin1String("toggled"));
+ QCOMPARE(window->rootObject()->property("value").toString(), QLatin1String("toggled"));
- QGuiApplication::sendEvent(canvas, &pressEvent);
+ QGuiApplication::sendEvent(window, &pressEvent);
- QCOMPARE(canvas->rootObject()->property("value").toString(), QLatin1String("pressed"));
+ QCOMPARE(window->rootObject()->property("value").toString(), QLatin1String("pressed"));
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::preventStealing()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("preventstealing.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window->setSource(testFileUrl("preventstealing.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(window->rootObject());
QVERIFY(flickable != 0);
- QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea*>("mousearea");
+ QQuickMouseArea *mouseArea = window->rootObject()->findChild<QQuickMouseArea*>("mousearea");
QVERIFY(mouseArea != 0);
QSignalSpy mousePositionSpy(mouseArea, SIGNAL(positionChanged(QQuickMouseEvent*)));
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(80, 80));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(80, 80));
// Without preventStealing, mouse movement over MouseArea would
// cause the Flickable to steal mouse and trigger content movement.
- QTest::mouseMove(canvas,QPoint(69,69));
- QTest::mouseMove(canvas,QPoint(58,58));
- QTest::mouseMove(canvas,QPoint(47,47));
+ QTest::mouseMove(window,QPoint(69,69));
+ QTest::mouseMove(window,QPoint(58,58));
+ QTest::mouseMove(window,QPoint(47,47));
// We should have received all three move events
QCOMPARE(mousePositionSpy.count(), 3);
QCOMPARE(flickable->contentX(), 0.);
QCOMPARE(flickable->contentY(), 0.);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(47, 47));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(47, 47));
// Now allow stealing and confirm Flickable does its thing.
- canvas->rootObject()->setProperty("stealing", false);
+ window->rootObject()->setProperty("stealing", false);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(80, 80));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(80, 80));
// Without preventStealing, mouse movement over MouseArea would
// cause the Flickable to steal mouse and trigger content movement.
- QTest::mouseMove(canvas,QPoint(69,69));
- QTest::mouseMove(canvas,QPoint(58,58));
- QTest::mouseMove(canvas,QPoint(47,47));
+ QTest::mouseMove(window,QPoint(69,69));
+ QTest::mouseMove(window,QPoint(58,58));
+ QTest::mouseMove(window,QPoint(47,47));
// We should only have received the first move event
QCOMPARE(mousePositionSpy.count(), 4);
QCOMPARE(flickable->contentX(), 11.);
QCOMPARE(flickable->contentY(), 11.);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(50, 50));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(50, 50));
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::clickThrough()
{
QSKIP("QTBUG-23976 Unstable");
//With no handlers defined click, doubleClick and PressAndHold should propagate to those with handlers
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("clickThrough.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("clickThrough.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
- QTRY_COMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("clicks").toInt(), 1);
+ QTRY_COMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("clicks").toInt(), 1);
// to avoid generating a double click.
int doubleClickInterval = qApp->styleHints()->mouseDoubleClickInterval() + 10;
QTest::qWait(doubleClickInterval);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(1000);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
- QTRY_COMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("clicks").toInt(), 1);
- QTRY_COMPARE(canvas->rootObject()->property("pressAndHolds").toInt(), 1);
+ QTRY_COMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("clicks").toInt(), 1);
+ QTRY_COMPARE(window->rootObject()->property("pressAndHolds").toInt(), 1);
- QTest::mouseDClick(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseDClick(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(100);
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("clicks").toInt(), 2);
- QTRY_COMPARE(canvas->rootObject()->property("doubleClicks").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("pressAndHolds").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("clicks").toInt(), 2);
+ QTRY_COMPARE(window->rootObject()->property("doubleClicks").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("pressAndHolds").toInt(), 1);
- delete canvas;
+ delete window;
//With handlers defined click, doubleClick and PressAndHold should propagate only when explicitly ignored
- canvas = createView();
- canvas->setSource(testFileUrl("clickThrough2.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window = createView();
+ window->setSource(testFileUrl("clickThrough2.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("clicks").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("clicks").toInt(), 0);
QTest::qWait(doubleClickInterval); // to avoid generating a double click.
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(1000);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(100);
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("clicks").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("pressAndHolds").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("clicks").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("pressAndHolds").toInt(), 0);
- QTest::mouseDClick(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseDClick(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(100);
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("clicks").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("doubleClicks").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("pressAndHolds").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("clicks").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("doubleClicks").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("pressAndHolds").toInt(), 0);
- canvas->rootObject()->setProperty("letThrough", QVariant(true));
+ window->rootObject()->setProperty("letThrough", QVariant(true));
QTest::qWait(doubleClickInterval); // to avoid generating a double click.
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("clicks").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("clicks").toInt(), 1);
QTest::qWait(doubleClickInterval); // to avoid generating a double click.
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(1000);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(100);
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("clicks").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("pressAndHolds").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("clicks").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("pressAndHolds").toInt(), 1);
- QTest::mouseDClick(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseDClick(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(100);
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("clicks").toInt(), 2);
- QCOMPARE(canvas->rootObject()->property("doubleClicks").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("pressAndHolds").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("clicks").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("doubleClicks").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("pressAndHolds").toInt(), 1);
- canvas->rootObject()->setProperty("noPropagation", QVariant(true));
+ window->rootObject()->setProperty("noPropagation", QVariant(true));
QTest::qWait(doubleClickInterval); // to avoid generating a double click.
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(doubleClickInterval); // to avoid generating a double click.
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(1000);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(100);
- QTest::mouseDClick(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mouseDClick(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(100);
- QCOMPARE(canvas->rootObject()->property("presses").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("clicks").toInt(), 2);
- QCOMPARE(canvas->rootObject()->property("doubleClicks").toInt(), 1);
- QCOMPARE(canvas->rootObject()->property("pressAndHolds").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("presses").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("clicks").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("doubleClicks").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("pressAndHolds").toInt(), 1);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::hoverPosition()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("hoverPosition.qml"));
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("hoverPosition.qml"));
- QQuickItem *root = canvas->rootObject();
+ QQuickItem *root = window->rootObject();
QVERIFY(root != 0);
QCOMPARE(root->property("mouseX").toReal(), qreal(0));
QCOMPARE(root->property("mouseY").toReal(), qreal(0));
- QTest::mouseMove(canvas,QPoint(10,32));
+ QTest::mouseMove(window,QPoint(10,32));
QCOMPARE(root->property("mouseX").toReal(), qreal(10));
QCOMPARE(root->property("mouseY").toReal(), qreal(32));
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::hoverPropagation()
{
//QTBUG-18175, to behave like GV did.
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("hoverPropagation.qml"));
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("hoverPropagation.qml"));
- QQuickItem *root = canvas->rootObject();
+ QQuickItem *root = window->rootObject();
QVERIFY(root != 0);
QCOMPARE(root->property("point1").toBool(), false);
QCOMPARE(root->property("point2").toBool(), false);
QMouseEvent moveEvent(QEvent::MouseMove, QPoint(32, 32), Qt::NoButton, Qt::NoButton, 0);
- QGuiApplication::sendEvent(canvas, &moveEvent);
+ QGuiApplication::sendEvent(window, &moveEvent);
QCOMPARE(root->property("point1").toBool(), true);
QCOMPARE(root->property("point2").toBool(), false);
QMouseEvent moveEvent2(QEvent::MouseMove, QPoint(232, 32), Qt::NoButton, Qt::NoButton, 0);
- QGuiApplication::sendEvent(canvas, &moveEvent2);
+ QGuiApplication::sendEvent(window, &moveEvent2);
QCOMPARE(root->property("point1").toBool(), false);
QCOMPARE(root->property("point2").toBool(), true);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::hoverVisible()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("hoverVisible.qml"));
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("hoverVisible.qml"));
- QQuickItem *root = canvas->rootObject();
+ QQuickItem *root = window->rootObject();
QVERIFY(root != 0);
- QQuickMouseArea *mouseTracker = canvas->rootObject()->findChild<QQuickMouseArea*>("mousetracker");
+ QQuickMouseArea *mouseTracker = window->rootObject()->findChild<QQuickMouseArea*>("mousetracker");
QVERIFY(mouseTracker != 0);
QSignalSpy enteredSpy(mouseTracker, SIGNAL(entered()));
// Note: We need to use a position that is different from the position in the last event
// generated in the previous test case. Otherwise it is not interpreted as a move.
- QTest::mouseMove(canvas,QPoint(11,33));
+ QTest::mouseMove(window,QPoint(11,33));
QCOMPARE(mouseTracker->hovered(), false);
QCOMPARE(enteredSpy.count(), 0);
QCOMPARE(QPointF(mouseTracker->mouseX(), mouseTracker->mouseY()), QPointF(11,33));
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::disableAfterPress()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("dragging.qml"));
- canvas->show();
- canvas->requestActivateWindow();
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("dragging.qml"));
+ window->show();
+ window->requestActivateWindow();
QTest::qWait(20);
- QVERIFY(canvas->rootObject() != 0);
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseArea = window->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QQuickDrag *drag = mouseArea->drag();
QVERIFY(mouseArea != 0);
QVERIFY(drag != 0);
QSignalSpy mouseReleaseSpy(mouseArea, SIGNAL(released(QQuickMouseEvent*)));
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
QVERIFY(!drag->active());
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
QTRY_COMPARE(mousePressSpy.count(), 1);
// First move event triggers drag, second is acted upon.
// This is due to possibility of higher stacked area taking precedence.
- QTest::mouseMove(canvas, QPoint(111,111));
+ QTest::mouseMove(window, QPoint(111,111));
QTest::qWait(50);
- QTest::mouseMove(canvas, QPoint(122,122));
+ QTest::mouseMove(window, QPoint(122,122));
QTRY_COMPARE(mousePositionSpy.count(), 2);
mouseArea->setEnabled(false);
// move should still be acted upon
- QTest::mouseMove(canvas, QPoint(133,133));
+ QTest::mouseMove(window, QPoint(133,133));
QTest::qWait(50);
- QTest::mouseMove(canvas, QPoint(144,144));
+ QTest::mouseMove(window, QPoint(144,144));
QTRY_COMPARE(mousePositionSpy.count(), 4);
QVERIFY(mouseArea->pressed());
QVERIFY(mouseArea->hovered());
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(144,144));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(144,144));
QTRY_COMPARE(mouseReleaseSpy.count(), 1);
mousePositionSpy.clear();
mouseReleaseSpy.clear();
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(100,100));
QTest::qWait(50);
QCOMPARE(mousePressSpy.count(), 0);
- QTest::mouseMove(canvas, QPoint(111,111));
+ QTest::mouseMove(window, QPoint(111,111));
QTest::qWait(50);
- QTest::mouseMove(canvas, QPoint(122,122));
+ QTest::mouseMove(window, QPoint(122,122));
QTest::qWait(50);
QCOMPARE(mousePositionSpy.count(), 0);
QCOMPARE(blackRect->x(), 50.0);
QCOMPARE(blackRect->y(), 50.0);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(122,122));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(122,122));
QTest::qWait(50);
QCOMPARE(mouseReleaseSpy.count(), 0);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::onWheel()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("wheel.qml"));
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("wheel.qml"));
- QQuickItem *root = canvas->rootObject();
+ QQuickItem *root = window->rootObject();
QVERIFY(root != 0);
QWheelEvent wheelEvent(QPoint(10, 32), QPoint(10, 32), QPoint(60, 20), QPoint(0, 120),
0, Qt::Vertical,Qt::NoButton, Qt::ControlModifier);
- QGuiApplication::sendEvent(canvas, &wheelEvent);
+ QGuiApplication::sendEvent(window, &wheelEvent);
QCOMPARE(root->property("angleDeltaY").toInt(), 120);
QCOMPARE(root->property("mouseX").toReal(), qreal(10));
QCOMPARE(root->property("mouseY").toReal(), qreal(32));
QCOMPARE(root->property("controlPressed").toBool(), true);
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::transformedMouseArea_data()
QFETCH(bool, insideTarget);
QFETCH(QList<QPoint>, points);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("transformedMouseArea.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("transformedMouseArea.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea *>("mouseArea");
+ QQuickMouseArea *mouseArea = window->rootObject()->findChild<QQuickMouseArea *>("mouseArea");
QVERIFY(mouseArea != 0);
foreach (const QPoint &point, points) {
// check hover
- QTest::mouseMove(canvas, point);
+ QTest::mouseMove(window, point);
QTest::qWait(10);
QCOMPARE(mouseArea->property("containsMouse").toBool(), insideTarget);
// check mouse press
- QTest::mousePress(canvas, Qt::LeftButton, 0, point);
+ QTest::mousePress(window, Qt::LeftButton, 0, point);
QTest::qWait(10);
QCOMPARE(mouseArea->property("pressed").toBool(), insideTarget);
// check mouse release
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, point);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, point);
QTest::qWait(10);
QCOMPARE(mouseArea->property("pressed").toBool(), false);
}
- delete canvas;
+ delete window;
}
void tst_QQuickMouseArea::pressedMultipleButtons_data()
QFETCH(QList<Qt::MouseButtons>, pressedButtons);
QFETCH(int, changeCount);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("simple.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *view = createView();
+ view->setSource(testFileUrl("simple.qml"));
+ view->show();
+ view->requestActivateWindow();
+ QVERIFY(view->rootObject() != 0);
- QQuickMouseArea *mouseArea = canvas->rootObject()->findChild<QQuickMouseArea *>("mousearea");
+ QQuickMouseArea *mouseArea = view->rootObject()->findChild<QQuickMouseArea *>("mousearea");
QVERIFY(mouseArea != 0);
QSignalSpy pressedSpy(mouseArea, SIGNAL(pressedChanged()));
int btns = buttons.at(i);
// The windowsysteminterface takes care of sending releases
- QTest::mousePress(canvas, (Qt::MouseButton)btns, 0, point);
+ QTest::mousePress(view, (Qt::MouseButton)btns, 0, point);
QCOMPARE(mouseArea->pressed(), pressed.at(i));
QCOMPARE(mouseArea->pressedButtons(), pressedButtons.at(i));
prevButtons = buttons.at(i);
}
- QTest::mousePress(canvas, Qt::NoButton, 0, point);
+ QTest::mousePress(view, Qt::NoButton, 0, point);
QCOMPARE(mouseArea->pressed(), false);
QCOMPARE(pressedSpy.count(), 2);
QCOMPARE(pressedButtonsSpy.count(), changeCount);
- delete canvas;
+ delete view;
}
void tst_QQuickMouseArea::changeAxis()
{
- QQuickView *canvas = createView();
+ QQuickView *view = createView();
- canvas->setSource(testFileUrl("changeAxis.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTRY_VERIFY(canvas->rootObject() != 0);
+ view->setSource(testFileUrl("changeAxis.qml"));
+ view->show();
+ view->requestActivateWindow();
+ QTRY_VERIFY(view->rootObject() != 0);
- QQuickMouseArea *mouseRegion = canvas->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
+ QQuickMouseArea *mouseRegion = view->rootObject()->findChild<QQuickMouseArea*>("mouseregion");
QQuickDrag *drag = mouseRegion->drag();
QVERIFY(mouseRegion != 0);
QVERIFY(drag != 0);
mouseRegion->setAcceptedButtons(Qt::LeftButton);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = view->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == drag->target());
QVERIFY(!drag->active());
// Start a diagonal drag
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(100, 100));
+ QTest::mousePress(view, Qt::LeftButton, 0, QPoint(100, 100));
QVERIFY(!drag->active());
QCOMPARE(blackRect->x(), 50.0);
QCOMPARE(blackRect->y(), 50.0);
- QTest::mouseMove(canvas, QPoint(111, 111));
+ QTest::mouseMove(view, QPoint(111, 111));
QTest::qWait(50);
- QTest::mouseMove(canvas, QPoint(122, 122));
+ QTest::mouseMove(view, QPoint(122, 122));
QTRY_VERIFY(drag->active());
QCOMPARE(blackRect->x(), 72.0);
/* When blackRect.x becomes bigger than 75, the drag axis is changed to
* Drag.YAxis by the QML code. Verify that this happens, and that the drag
* movement is effectively constrained to the Y axis. */
- QTest::mouseMove(canvas, QPoint(133, 133));
+ QTest::mouseMove(view, QPoint(133, 133));
QTRY_COMPARE(blackRect->x(), 83.0);
QTRY_COMPARE(blackRect->y(), 83.0);
QTRY_COMPARE(drag->axis(), QQuickDrag::YAxis);
- QTest::mouseMove(canvas, QPoint(144, 144));
+ QTest::mouseMove(view, QPoint(144, 144));
QTRY_COMPARE(blackRect->y(), 94.0);
QCOMPARE(blackRect->x(), 83.0);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(144, 144));
+ QTest::mouseRelease(view, Qt::LeftButton, 0, QPoint(144, 144));
QTRY_VERIFY(!drag->active());
QCOMPARE(blackRect->x(), 83.0);
QCOMPARE(blackRect->y(), 94.0);
- delete canvas;
+ delete view;
}
QTEST_MAIN(tst_QQuickMouseArea)
void tst_QQuickMultiPointTouchArea::properties()
{
- QQuickView *canvas = createAndShowView("properties.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("properties.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickMultiPointTouchArea *area = qobject_cast<QQuickMultiPointTouchArea *>(canvas->rootObject());
+ QQuickMultiPointTouchArea *area = qobject_cast<QQuickMultiPointTouchArea *>(window->rootObject());
QVERIFY(area != 0);
QCOMPARE(area->minimumTouchPoints(), 2);
QQmlListReference ref(area, "touchPoints");
QCOMPARE(ref.count(), 4);
- delete canvas;
+ delete window;
}
void tst_QQuickMultiPointTouchArea::signalTest()
{
- QQuickView *canvas = createAndShowView("signalTest.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("signalTest.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickMultiPointTouchArea *area = qobject_cast<QQuickMultiPointTouchArea *>(canvas->rootObject());
+ QQuickMultiPointTouchArea *area = qobject_cast<QQuickMultiPointTouchArea *>(window->rootObject());
QVERIFY(area != 0);
QPoint p1(20,100);
QPoint p4(80,100);
QPoint p5(100,100);
- QTest::QTouchEventSequence sequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence sequence = QTest::touchEvent(window, device);
sequence.press(0, p1).press(1, p2).commit();
QCOMPARE(area->property("touchUpdatedHandled").toBool(), true);
QMetaObject::invokeMethod(area, "clearCounts");
- delete canvas;
+ delete window;
}
void tst_QQuickMultiPointTouchArea::release()
{
- QQuickView *canvas = createAndShowView("basic.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("basic.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickTouchPoint *point1 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point1");
+ QQuickTouchPoint *point1 = window->rootObject()->findChild<QQuickTouchPoint*>("point1");
QCOMPARE(point1->pressed(), false);
QPoint p1(20,100);
- QTest::QTouchEventSequence sequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence sequence = QTest::touchEvent(window, device);
sequence.press(0, p1).commit();
QCOMPARE(point1->pressed(), false);
QCOMPARE(point1->x(), qreal(24)); QCOMPARE(point1->y(), qreal(120));
- delete canvas;
+ delete window;
}
void tst_QQuickMultiPointTouchArea::reuse()
{
- QQuickView *canvas = createAndShowView("basic.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("basic.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickTouchPoint *point1 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point1");
- QQuickTouchPoint *point2 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point2");
- QQuickTouchPoint *point3 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point3");
+ QQuickTouchPoint *point1 = window->rootObject()->findChild<QQuickTouchPoint*>("point1");
+ QQuickTouchPoint *point2 = window->rootObject()->findChild<QQuickTouchPoint*>("point2");
+ QQuickTouchPoint *point3 = window->rootObject()->findChild<QQuickTouchPoint*>("point3");
QCOMPARE(point1->pressed(), false);
QCOMPARE(point2->pressed(), false);
QPoint p3(60,100);
QPoint p4(80,100);
- QTest::QTouchEventSequence sequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence sequence = QTest::touchEvent(window, device);
sequence.press(0, p1).press(1, p2).commit();
QCOMPARE(point1->x(), qreal(80)); QCOMPARE(point1->y(), qreal(100));
- delete canvas;
+ delete window;
}
void tst_QQuickMultiPointTouchArea::nonOverlapping()
{
- QQuickView *canvas = createAndShowView("nonOverlapping.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("nonOverlapping.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickTouchPoint *point11 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point11");
- QQuickTouchPoint *point12 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point12");
- QQuickTouchPoint *point21 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point21");
- QQuickTouchPoint *point22 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point22");
- QQuickTouchPoint *point23 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point23");
+ QQuickTouchPoint *point11 = window->rootObject()->findChild<QQuickTouchPoint*>("point11");
+ QQuickTouchPoint *point12 = window->rootObject()->findChild<QQuickTouchPoint*>("point12");
+ QQuickTouchPoint *point21 = window->rootObject()->findChild<QQuickTouchPoint*>("point21");
+ QQuickTouchPoint *point22 = window->rootObject()->findChild<QQuickTouchPoint*>("point22");
+ QQuickTouchPoint *point23 = window->rootObject()->findChild<QQuickTouchPoint*>("point23");
QCOMPARE(point11->pressed(), false);
QCOMPARE(point12->pressed(), false);
QPoint p4(80,180);
QPoint p5(100,180);
- QTest::QTouchEventSequence sequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence sequence = QTest::touchEvent(window, device);
sequence.press(0, p1).commit();
QCOMPARE(point22->pressed(), false);
QCOMPARE(point23->pressed(), false);
- delete canvas;
+ delete window;
}
void tst_QQuickMultiPointTouchArea::nested()
{
- QQuickView *canvas = createAndShowView("nested.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("nested.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickTouchPoint *point11 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point11");
- QQuickTouchPoint *point12 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point12");
- QQuickTouchPoint *point21 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point21");
- QQuickTouchPoint *point22 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point22");
- QQuickTouchPoint *point23 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point23");
+ QQuickTouchPoint *point11 = window->rootObject()->findChild<QQuickTouchPoint*>("point11");
+ QQuickTouchPoint *point12 = window->rootObject()->findChild<QQuickTouchPoint*>("point12");
+ QQuickTouchPoint *point21 = window->rootObject()->findChild<QQuickTouchPoint*>("point21");
+ QQuickTouchPoint *point22 = window->rootObject()->findChild<QQuickTouchPoint*>("point22");
+ QQuickTouchPoint *point23 = window->rootObject()->findChild<QQuickTouchPoint*>("point23");
QCOMPARE(point11->pressed(), false);
QCOMPARE(point12->pressed(), false);
QPoint p2(40,100);
QPoint p3(60,180);
- QTest::QTouchEventSequence sequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence sequence = QTest::touchEvent(window, device);
sequence.press(0, p1).commit();
sequence.release(0, p1).commit();
//test with grabbing turned off
- canvas->rootObject()->setProperty("grabInnerArea", false);
+ window->rootObject()->setProperty("grabInnerArea", false);
sequence.press(0, p1).press(1, p2).press(2, p3).commit();
sequence.release(0, p1).release(1, p2).release(2, p3).commit();
- delete canvas;
+ delete window;
}
void tst_QQuickMultiPointTouchArea::inFlickable()
{
- QQuickView *canvas = createAndShowView("inFlickable.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("inFlickable.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = qobject_cast<QQuickFlickable *>(canvas->rootObject());
+ QQuickFlickable *flickable = qobject_cast<QQuickFlickable *>(window->rootObject());
QVERIFY(flickable != 0);
- QQuickTouchPoint *point11 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point1");
- QQuickTouchPoint *point12 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point2");
+ QQuickTouchPoint *point11 = window->rootObject()->findChild<QQuickTouchPoint*>("point1");
+ QQuickTouchPoint *point12 = window->rootObject()->findChild<QQuickTouchPoint*>("point2");
QCOMPARE(point11->pressed(), false);
QCOMPARE(point12->pressed(), false);
QPoint p2(40,100);
//moving one point vertically
- QTest::touchEvent(canvas, device).press(0, p1);
+ QTest::touchEvent(window, device).press(0, p1);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
QVERIFY(flickable->contentY() < 0);
QCOMPARE(point11->pressed(), false);
QCOMPARE(point12->pressed(), false);
- QTest::touchEvent(canvas, device).release(0, p1);
+ QTest::touchEvent(window, device).release(0, p1);
QTest::qWait(50);
QTRY_VERIFY(!flickable->isMoving());
//moving two points vertically
p1 = QPoint(20,100);
- QTest::touchEvent(canvas, device).press(0, p1).press(1, p2);
- QTest::mousePress(canvas, Qt::LeftButton, 0, p1);
+ QTest::touchEvent(window, device).press(0, p1).press(1, p2);
+ QTest::mousePress(window, Qt::LeftButton, 0, p1);
QCOMPARE(point11->pressed(), true);
QCOMPARE(point12->pressed(), true);
QCOMPARE(flickable->property("touchCount").toInt(), 2);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
QVERIFY(flickable->contentY() < 0);
QCOMPARE(point11->pressed(), false);
QCOMPARE(flickable->property("cancelCount").toInt(), 2);
QCOMPARE(flickable->property("touchCount").toInt(), 0);
- QTest::touchEvent(canvas, device).release(0, p1).release(1, p2);
- QTest::mouseRelease(canvas,Qt::LeftButton, 0, p1);
+ QTest::touchEvent(window, device).release(0, p1).release(1, p2);
+ QTest::mouseRelease(window,Qt::LeftButton, 0, p1);
QTest::qWait(50);
QTRY_VERIFY(!flickable->isMoving());
//moving two points horizontally, then one point vertically
p1 = QPoint(20,100);
p2 = QPoint(40,100);
- QTest::touchEvent(canvas, device).press(0, p1).press(1, p2);
- QTest::mousePress(canvas, Qt::LeftButton, 0, p1);
+ QTest::touchEvent(window, device).press(0, p1).press(1, p2);
+ QTest::mousePress(window, Qt::LeftButton, 0, p1);
QCOMPARE(point11->pressed(), true);
QCOMPARE(point12->pressed(), true);
p1 += QPoint(15,0); p2 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(15,0); p2 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(15,0); p2 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(15,0); p2 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
p1 += QPoint(0,15); p2 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1).move(1, p2);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1).move(1, p2);
+ QTest::mouseMove(window, p1);
QVERIFY(flickable->contentY() == 0);
QCOMPARE(point11->pressed(), true);
QCOMPARE(point12->pressed(), true);
- QTest::touchEvent(canvas, device).release(0, p1).release(1, p2);
- QTest::mouseRelease(canvas,Qt::LeftButton, 0, p1);
+ QTest::touchEvent(window, device).release(0, p1).release(1, p2);
+ QTest::mouseRelease(window,Qt::LeftButton, 0, p1);
QTest::qWait(50);
- delete canvas;
+ delete window;
}
// test that dragging out of a Flickable containing a MPTA doesn't harm Flickable's state.
void tst_QQuickMultiPointTouchArea::inFlickable2()
{
- QQuickView *canvas = createAndShowView("inFlickable2.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("inFlickable2.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
+ QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flickable != 0);
- QQuickTouchPoint *point11 = canvas->rootObject()->findChild<QQuickTouchPoint*>("point1");
+ QQuickTouchPoint *point11 = window->rootObject()->findChild<QQuickTouchPoint*>("point1");
QVERIFY(point11);
QCOMPARE(point11->pressed(), false);
QPoint p1(50,100);
// move point horizontally, out of Flickable area
- QTest::touchEvent(canvas, device).press(0, p1);
- QTest::mousePress(canvas, Qt::LeftButton, 0, p1);
+ QTest::touchEvent(window, device).press(0, p1);
+ QTest::mousePress(window, Qt::LeftButton, 0, p1);
p1 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1);
+ QTest::mouseMove(window, p1);
p1 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1);
+ QTest::mouseMove(window, p1);
p1 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1);
+ QTest::mouseMove(window, p1);
p1 += QPoint(15,0);
- QTest::touchEvent(canvas, device).move(0, p1);
- QTest::mouseMove(canvas, p1);
+ QTest::touchEvent(window, device).move(0, p1);
+ QTest::mouseMove(window, p1);
QVERIFY(!flickable->isMoving());
QVERIFY(point11->pressed());
- QTest::touchEvent(canvas, device).release(0, p1);
- QTest::mouseRelease(canvas,Qt::LeftButton, 0, p1);
+ QTest::touchEvent(window, device).release(0, p1);
+ QTest::mouseRelease(window,Qt::LeftButton, 0, p1);
QTest::qWait(50);
QTRY_VERIFY(!flickable->isMoving());
// Check that we can still move the Flickable
p1 = QPoint(50,100);
- QTest::touchEvent(canvas, device).press(0, p1);
+ QTest::touchEvent(window, device).press(0, p1);
QCOMPARE(point11->pressed(), true);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
p1 += QPoint(0,15);
- QTest::touchEvent(canvas, device).move(0, p1);
+ QTest::touchEvent(window, device).move(0, p1);
QVERIFY(flickable->contentY() < 0);
QVERIFY(flickable->isMoving());
QCOMPARE(point11->pressed(), true);
- QTest::touchEvent(canvas, device).release(0, p1);
+ QTest::touchEvent(window, device).release(0, p1);
QTest::qWait(50);
QTRY_VERIFY(!flickable->isMoving());
- delete canvas;
+ delete window;
}
// QTBUG-23327
void tst_QQuickMultiPointTouchArea::invisible()
{
- QQuickView *canvas = createAndShowView("signalTest.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createAndShowView("signalTest.qml");
+ QVERIFY(window->rootObject() != 0);
- QQuickMultiPointTouchArea *area = qobject_cast<QQuickMultiPointTouchArea *>(canvas->rootObject());
+ QQuickMultiPointTouchArea *area = qobject_cast<QQuickMultiPointTouchArea *>(window->rootObject());
QVERIFY(area != 0);
area->setVisible(false);
QPoint p1(20,100);
QPoint p2(40,100);
- QTest::QTouchEventSequence sequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence sequence = QTest::touchEvent(window, device);
sequence.press(0, p1).press(1, p2).commit();
QCOMPARE(area->property("touchPointReleaseCount").toInt(), 0);
QCOMPARE(area->property("touchCount").toInt(), 0);
- delete canvas;
+ delete window;
}
void tst_QQuickMultiPointTouchArea::transformedTouchArea_data()
QFETCH(int, total2);
QFETCH(int, total3);
- QQuickView *canvas = createAndShowView("transformedMultiPointTouchArea.qml");
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *view = createAndShowView("transformedMultiPointTouchArea.qml");
+ QVERIFY(view->rootObject() != 0);
- QQuickMultiPointTouchArea *area = canvas->rootObject()->findChild<QQuickMultiPointTouchArea *>("touchArea");
+ QQuickMultiPointTouchArea *area = view->rootObject()->findChild<QQuickMultiPointTouchArea *>("touchArea");
QVERIFY(area != 0);
- QTest::QTouchEventSequence sequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence sequence = QTest::touchEvent(view, device);
sequence.press(0, p1).commit();
QCOMPARE(area->property("pointCount").toInt(), total1);
sequence.stationary(0).stationary(1).press(2, p3).commit();
QCOMPARE(area->property("pointCount").toInt(), total3);
- delete canvas;
+ delete view;
}
QQuickView *tst_QQuickMultiPointTouchArea::createAndShowView(const QString &file)
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setSource(testFileUrl(file));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
+ QQuickView *window = new QQuickView(0);
+ window->setSource(testFileUrl(file));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
- return canvas;
+ return window;
}
QTEST_MAIN(tst_QQuickMultiPointTouchArea)
void tst_QQuickPathView::items()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QaimModel model;
model.addItem("Fred", "12345");
model.addItem("Bob", "54321");
model.addItem("Bill", "4321");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathview0.qml"));
+ window->setSource(testFileUrl("pathview0.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
QCOMPARE(pathview->count(), model.count());
- QCOMPARE(canvas->rootObject()->property("count").toInt(), model.count());
+ QCOMPARE(window->rootObject()->property("count").toInt(), model.count());
QCOMPARE(pathview->childItems().count(), model.count()+1); // assumes all are visible, including highlight
for (int i = 0; i < model.count(); ++i) {
offset.setY(pathview->highlightItem()->height()/2);
QCOMPARE(pathview->highlightItem()->pos() + offset, start);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::pathview2()
QFETCH(qreal, offset);
QFETCH(int, currentIndex);
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
model.addItem("Ben", "12345");
model.addItem("Jimmy", "3535");
model.addItem("Barb", "9039");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathview0.qml"));
+ window->setSource(testFileUrl("pathview0.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
pathview->setHighlightRangeMode((QQuickPathView::HighlightRangeMode)mode);
QCOMPARE(pathview->currentIndex(), currentIndex);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::removeModel_data()
QFETCH(qreal, offset);
QFETCH(int, currentIndex);
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
model.addItem("Ben", "12345");
model.addItem("Jimmy", "3535");
model.addItem("Barb", "9039");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathview0.qml"));
+ window->setSource(testFileUrl("pathview0.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
pathview->setHighlightRangeMode((QQuickPathView::HighlightRangeMode)mode);
QCOMPARE(pathview->currentIndex(), currentIndex);
- delete canvas;
+ delete window;
}
QFETCH(qreal, offset);
QFETCH(int, currentIndex);
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
model.addItem("Ben", "12345");
model.addItem("Jimmy", "3535");
model.addItem("Barb", "9039");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathview0.qml"));
+ window->setSource(testFileUrl("pathview0.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
pathview->setHighlightRangeMode((QQuickPathView::HighlightRangeMode)mode);
QCOMPARE(pathview->currentIndex(), currentIndex);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::consecutiveModelChanges_data()
QFETCH(qreal, offset);
QFETCH(int, currentIndex);
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
model.addItem("Ben", "12345");
model.addItem("Jimmy", "3535");
model.addItem("Barb", "9039");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathview0.qml"));
+ window->setSource(testFileUrl("pathview0.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
pathview->setHighlightRangeMode(mode);
QCOMPARE(pathview->currentIndex(), currentIndex);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::path()
void tst_QQuickPathView::dataModel()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
ctxt->setContextProperty("testData", &model);
- canvas->setSource(testFileUrl("datamodel.qml"));
+ window->setSource(testFileUrl("datamodel.qml"));
qApp->processEvents();
- QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(window->rootObject());
QVERIFY(pathview != 0);
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QVERIFY(testObject->error() == false);
QQuickItem *item = findItem<QQuickItem>(pathview, "wrapper", 0);
model.insertItem(4, "orange", "10");
QTest::qWait(100);
- QCOMPARE(canvas->rootObject()->property("viewCount").toInt(), model.count());
+ QCOMPARE(window->rootObject()->property("viewCount").toInt(), model.count());
QTRY_COMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 14);
QVERIFY(pathview->currentIndex() == 0);
QCOMPARE(text->text(), model.name(4));
model.removeItem(2);
- QCOMPARE(canvas->rootObject()->property("viewCount").toInt(), model.count());
+ QCOMPARE(window->rootObject()->property("viewCount").toInt(), model.count());
text = findItem<QQuickText>(pathview, "myText", 2);
QVERIFY(text);
QCOMPARE(text->text(), model.name(2));
QCOMPARE(pathview->currentItem(), findItem<QQuickItem>(pathview, "wrapper", 0));
testObject->setPathItemCount(5);
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QVERIFY(testObject->error() == false);
QTRY_COMPARE(findItems<QQuickItem>(pathview, "wrapper").count(), 5);
model.removeItem(model.count()-1);
QCOMPARE(pathview->currentIndex(), model.count()-1);
- delete canvas;
+ delete window;
delete testObject;
}
void tst_QQuickPathView::pathMoved()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
model.addItem("Ben", "12345");
model.addItem("Bob", "54321");
model.addItem("Bill", "4321");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathview0.qml"));
+ window->setSource(testFileUrl("pathview0.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
QQuickRectangle *firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
// Change delegate size
pathview->setOffset(0.1);
pathview->setOffset(0.0);
- canvas->rootObject()->setProperty("delegateWidth", 30);
+ window->rootObject()->setProperty("delegateWidth", 30);
QCOMPARE(firstItem->width(), 30.0);
offset.setX(firstItem->width()/2);
QTRY_COMPARE(firstItem->pos() + offset, start);
// Change delegate scale
pathview->setOffset(0.1);
pathview->setOffset(0.0);
- canvas->rootObject()->setProperty("delegateScale", 1.2);
+ window->rootObject()->setProperty("delegateScale", 1.2);
QTRY_COMPARE(firstItem->pos() + offset, start);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::offset_data()
void tst_QQuickPathView::setCurrentIndex()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
model.addItem("Ben", "12345");
model.addItem("Bob", "54321");
model.addItem("Bill", "4321");
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathview0.qml"));
+ window->setSource(testFileUrl("pathview0.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
QQuickRectangle *firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 0);
offset.setX(firstItem->width()/2);
offset.setY(firstItem->height()/2);
QCOMPARE(firstItem->pos() + offset, start);
- QCOMPARE(canvas->rootObject()->property("currentA").toInt(), 0);
- QCOMPARE(canvas->rootObject()->property("currentB").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("currentA").toInt(), 0);
+ QCOMPARE(window->rootObject()->property("currentB").toInt(), 0);
pathview->setCurrentIndex(2);
firstItem = findItem<QQuickRectangle>(pathview, "wrapper", 2);
QTRY_COMPARE(firstItem->pos() + offset, start);
- QCOMPARE(canvas->rootObject()->property("currentA").toInt(), 2);
- QCOMPARE(canvas->rootObject()->property("currentB").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("currentA").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("currentB").toInt(), 2);
QCOMPARE(pathview->currentItem(), firstItem);
QCOMPARE(firstItem->property("onPath"), QVariant(true));
QCOMPARE(pathview->currentItem(), firstItem);
QCOMPARE(firstItem->property("onPath"), QVariant(true));
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::resetModel()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QStringList strings;
strings << "one" << "two" << "three";
QStringListModel model(strings);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("displaypath.qml"));
+ window->setSource(testFileUrl("displaypath.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
QCOMPARE(pathview->count(), model.rowCount());
QCOMPARE(display->text(), strings.at(i));
}
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::propertyChanges()
{
- QQuickView *canvas = createView();
- QVERIFY(canvas);
- canvas->setSource(testFileUrl("propertychanges.qml"));
+ QQuickView *window = createView();
+ QVERIFY(window);
+ window->setSource(testFileUrl("propertychanges.qml"));
- QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
+ QQuickPathView *pathView = window->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
QSignalSpy snapPositionSpy(pathView, SIGNAL(preferredHighlightBeginChanged()));
pathView->setMaximumFlickVelocity(1000);
QCOMPARE(maximumFlickVelocitySpy.count(), 1);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::pathChanges()
{
- QQuickView *canvas = createView();
- QVERIFY(canvas);
- canvas->setSource(testFileUrl("propertychanges.qml"));
+ QQuickView *window = createView();
+ QVERIFY(window);
+ window->setSource(testFileUrl("propertychanges.qml"));
- QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
+ QQuickPathView *pathView = window->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
- QQuickPath *path = canvas->rootObject()->findChild<QQuickPath*>("path");
+ QQuickPath *path = window->rootObject()->findChild<QQuickPath*>("path");
QVERIFY(path);
QSignalSpy startXSpy(path, SIGNAL(startXChanged()));
QCOMPARE(startXSpy.count(),1);
QCOMPARE(startYSpy.count(),1);
- QQuickPath *alternatePath = canvas->rootObject()->findChild<QQuickPath*>("alternatePath");
+ QQuickPath *alternatePath = window->rootObject()->findChild<QQuickPath*>("alternatePath");
QVERIFY(alternatePath);
QSignalSpy pathSpy(pathView, SIGNAL(pathChanged()));
pathView->setPath(alternatePath);
QCOMPARE(pathSpy.count(),1);
- QQuickPathAttribute *pathAttribute = canvas->rootObject()->findChild<QQuickPathAttribute*>("pathAttribute");
+ QQuickPathAttribute *pathAttribute = window->rootObject()->findChild<QQuickPathAttribute*>("pathAttribute");
QVERIFY(pathAttribute);
QSignalSpy nameSpy(pathAttribute, SIGNAL(nameChanged()));
pathAttribute->setName("scale");
QCOMPARE(nameSpy.count(),1);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::componentChanges()
{
- QQuickView *canvas = createView();
- QVERIFY(canvas);
- canvas->setSource(testFileUrl("propertychanges.qml"));
+ QQuickView *window = createView();
+ QVERIFY(window);
+ window->setSource(testFileUrl("propertychanges.qml"));
- QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
+ QQuickPathView *pathView = window->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
- QQmlComponent delegateComponent(canvas->engine());
+ QQmlComponent delegateComponent(window->engine());
delegateComponent.setData("import QtQuick 2.0; Text { text: '<b>Name:</b> ' + name }", QUrl::fromLocalFile(""));
QSignalSpy delegateSpy(pathView, SIGNAL(delegateChanged()));
pathView->setDelegate(&delegateComponent);
QCOMPARE(delegateSpy.count(),1);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::modelChanges()
{
- QQuickView *canvas = createView();
- QVERIFY(canvas);
- canvas->setSource(testFileUrl("propertychanges.qml"));
+ QQuickView *window = createView();
+ QVERIFY(window);
+ window->setSource(testFileUrl("propertychanges.qml"));
- QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
+ QQuickPathView *pathView = window->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
- QQuickListModel *alternateModel = canvas->rootObject()->findChild<QQuickListModel*>("alternateModel");
+ QQuickListModel *alternateModel = window->rootObject()->findChild<QQuickListModel*>("alternateModel");
QVERIFY(alternateModel);
QVariant modelVariant = QVariant::fromValue<QObject *>(alternateModel);
QSignalSpy modelSpy(pathView, SIGNAL(modelChanged()));
pathView->setModel(QVariant());
QCOMPARE(modelSpy.count(),2);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::pathUpdateOnStartChanged()
{
- QQuickView *canvas = createView();
- QVERIFY(canvas);
- canvas->setSource(testFileUrl("pathUpdateOnStartChanged.qml"));
+ QQuickView *window = createView();
+ QVERIFY(window);
+ window->setSource(testFileUrl("pathUpdateOnStartChanged.qml"));
- QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
+ QQuickPathView *pathView = window->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
- QQuickPath *path = canvas->rootObject()->findChild<QQuickPath*>("path");
+ QQuickPath *path = window->rootObject()->findChild<QQuickPath*>("path");
QVERIFY(path);
QCOMPARE(path->startX(), 400.0);
QCOMPARE(path->startY(), 300.0);
QCOMPARE(item->x(), path->startX() - item->width() / 2.0);
QCOMPARE(item->y(), path->startY() - item->height() / 2.0);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::package()
{
- QQuickView *canvas = createView();
- QVERIFY(canvas);
- canvas->setSource(testFileUrl("pathview_package.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickView *window = createView();
+ QVERIFY(window);
+ window->setSource(testFileUrl("pathview_package.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("photoPathView");
+ QQuickPathView *pathView = window->rootObject()->findChild<QQuickPathView*>("photoPathView");
QVERIFY(pathView);
#ifdef Q_OS_MAC
QVERIFY(item);
QVERIFY(item->scale() != 1.0);
- delete canvas;
+ delete window;
}
//QTBUG-13017
void tst_QQuickPathView::emptyModel()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QStringListModel model;
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("emptyModel", &model);
- canvas->setSource(testFileUrl("emptymodel.qml"));
+ window->setSource(testFileUrl("emptymodel.qml"));
qApp->processEvents();
- QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(window->rootObject());
QVERIFY(pathview != 0);
QCOMPARE(pathview->offset(), qreal(0.0));
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::closed()
// QTBUG-14239
void tst_QQuickPathView::pathUpdate()
{
- QQuickView *canvas = createView();
- QVERIFY(canvas);
- canvas->setSource(testFileUrl("pathUpdate.qml"));
+ QQuickView *window = createView();
+ QVERIFY(window);
+ window->setSource(testFileUrl("pathUpdate.qml"));
- QQuickPathView *pathView = canvas->rootObject()->findChild<QQuickPathView*>("pathView");
+ QQuickPathView *pathView = window->rootObject()->findChild<QQuickPathView*>("pathView");
QVERIFY(pathView);
QQuickItem *item = findItem<QQuickItem>(pathView, "wrapper", 0);
QVERIFY(item);
QCOMPARE(item->x(), 150.0);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::visualDataModel()
void tst_QQuickPathView::mouseDrag()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("dragpath.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_COMPARE(canvas, qGuiApp->focusWindow());
-
- QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("dragpath.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_COMPARE(window, qGuiApp->focusWindow());
+
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(window->rootObject());
QVERIFY(pathview != 0);
QSignalSpy movingSpy(pathview, SIGNAL(movingChanged()));
int current = pathview->currentIndex();
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(10,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(10,100));
QTest::qWait(100);
{
QMouseEvent mv(QEvent::MouseMove, QPoint(30,100), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
- QGuiApplication::sendEvent(canvas, &mv);
+ QGuiApplication::sendEvent(window, &mv);
}
// first move beyond threshold does not trigger drag
QVERIFY(!pathview->isMoving());
{
QMouseEvent mv(QEvent::MouseMove, QPoint(90,100), Qt::LeftButton, Qt::LeftButton,Qt::NoModifier);
- QGuiApplication::sendEvent(canvas, &mv);
+ QGuiApplication::sendEvent(window, &mv);
}
// next move beyond threshold does trigger drag
QVERIFY(pathview->isMoving());
QVERIFY(pathview->currentIndex() != current);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(40,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(40,100));
QVERIFY(!pathview->isDragging());
QCOMPARE(draggingSpy.count(), 2);
QCOMPARE(dragStartedSpy.count(), 1);
QTRY_COMPARE(moveEndedSpy.count(), 1);
QCOMPARE(moveStartedSpy.count(), 1);
- delete canvas;
+ delete window;
}
#ifndef QT_NO_WIDGETS
void tst_QQuickPathView::treeModel()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QStandardItemModel model;
initStandardTreeModel(&model);
- canvas->engine()->rootContext()->setContextProperty("myModel", &model);
+ window->engine()->rootContext()->setContextProperty("myModel", &model);
- canvas->setSource(testFileUrl("treemodel.qml"));
+ window->setSource(testFileUrl("treemodel.qml"));
- QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(window->rootObject());
QVERIFY(pathview != 0);
QCOMPARE(pathview->count(), 3);
QTRY_VERIFY(item = findItem<QQuickText>(pathview, "wrapper", 0));
QTRY_COMPARE(item->text(), QLatin1String("Row 2 Child Item"));
- delete canvas;
+ delete window;
}
#endif
void tst_QQuickPathView::changePreferredHighlight()
{
- QQuickView *canvas = createView();
- canvas->setGeometry(0,0,400,200);
- canvas->setSource(testFileUrl("dragpath.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_COMPARE(canvas, qGuiApp->focusWindow());
-
- QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
+ QQuickView *window = createView();
+ window->setGeometry(0,0,400,200);
+ window->setSource(testFileUrl("dragpath.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_COMPARE(window, qGuiApp->focusWindow());
+
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(window->rootObject());
QVERIFY(pathview != 0);
int current = pathview->currentIndex();
QTRY_COMPARE(firstItem->pos() + offset, start);
QCOMPARE(pathview->currentIndex(), 0);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::creationContext()
{
- QQuickView canvas;
- canvas.setGeometry(0,0,240,320);
- canvas.setSource(testFileUrl("creationContext.qml"));
+ QQuickView window;
+ window.setGeometry(0,0,240,320);
+ window.setSource(testFileUrl("creationContext.qml"));
- QQuickItem *rootItem = qobject_cast<QQuickItem *>(canvas.rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem *>(window.rootObject());
QVERIFY(rootItem);
QVERIFY(rootItem->property("count").toInt() > 0);
// QTBUG-21320
void tst_QQuickPathView::currentOffsetOnInsertion()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QaimModel model;
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testModel", &model);
- canvas->setSource(testFileUrl("pathline.qml"));
+ window->setSource(testFileUrl("pathline.qml"));
qApp->processEvents();
- QQuickPathView *pathview = findItem<QQuickPathView>(canvas->rootObject(), "view");
+ QQuickPathView *pathview = findItem<QQuickPathView>(window->rootObject(), "view");
QVERIFY(pathview != 0);
pathview->setPreferredHighlightBegin(0.5);
// verify that current item (item 1) is still at offset 0.5
QCOMPARE(item->pos() + offset, start);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::asynchronous()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QQmlIncubationController controller;
- canvas->engine()->setIncubationController(&controller);
+ window->engine()->setIncubationController(&controller);
- canvas->setSource(testFileUrl("asyncloader.qml"));
+ window->setSource(testFileUrl("asyncloader.qml"));
- QQuickItem *rootObject = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootObject = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootObject);
QQuickPathView *pathview = 0;
QCOMPARE(curItem->pos() + offset, itemPos);
}
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::missingPercent()
void tst_QQuickPathView::cancelDrag()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("dragpath.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_COMPARE(canvas, qGuiApp->focusWindow());
-
- QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("dragpath.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_COMPARE(window, qGuiApp->focusWindow());
+
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(window->rootObject());
QVERIFY(pathview != 0);
QSignalSpy draggingSpy(pathview, SIGNAL(draggingChanged()));
QSignalSpy dragEndedSpy(pathview, SIGNAL(dragEnded()));
// drag between snap points
- QTest::mousePress(canvas, Qt::LeftButton, 0, QPoint(10,100));
+ QTest::mousePress(window, Qt::LeftButton, 0, QPoint(10,100));
QTest::qWait(100);
- QTest::mouseMove(canvas, QPoint(30, 100));
- QTest::mouseMove(canvas, QPoint(85, 100));
+ QTest::mouseMove(window, QPoint(30, 100));
+ QTest::mouseMove(window, QPoint(85, 100));
QTRY_VERIFY(pathview->offset() != qFloor(pathview->offset()));
QTRY_VERIFY(pathview->isMoving());
QCOMPARE(dragEndedSpy.count(), 0);
// steal mouse grab - cancels PathView dragging
- QQuickItem *item = canvas->rootObject()->findChild<QQuickItem*>("text");
+ QQuickItem *item = window->rootObject()->findChild<QQuickItem*>("text");
item->grabMouse();
// returns to a snap point.
QCOMPARE(dragStartedSpy.count(), 1);
QCOMPARE(dragEndedSpy.count(), 1);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, QPoint(40,100));
+ QTest::mouseRelease(window, Qt::LeftButton, 0, QPoint(40,100));
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::maximumFlickVelocity()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("dragpath.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_COMPARE(canvas, qGuiApp->focusWindow());
-
- QQuickPathView *pathview = qobject_cast<QQuickPathView*>(canvas->rootObject());
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("dragpath.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_COMPARE(window, qGuiApp->focusWindow());
+
+ QQuickPathView *pathview = qobject_cast<QQuickPathView*>(window->rootObject());
QVERIFY(pathview != 0);
pathview->setMaximumFlickVelocity(700);
- flick(canvas, QPoint(200,10), QPoint(10,10), 180);
+ flick(window, QPoint(200,10), QPoint(10,10), 180);
QVERIFY(pathview->isMoving());
QVERIFY(pathview->isFlicking());
QTRY_VERIFY(!pathview->isMoving());
pathview->setOffset(0.);
pathview->setMaximumFlickVelocity(300);
- flick(canvas, QPoint(200,10), QPoint(10,10), 180);
+ flick(window, QPoint(200,10), QPoint(10,10), 180);
QVERIFY(pathview->isMoving());
QVERIFY(pathview->isFlicking());
QTRY_VERIFY(!pathview->isMoving());
pathview->setOffset(0.);
pathview->setMaximumFlickVelocity(500);
- flick(canvas, QPoint(200,10), QPoint(10,10), 180);
+ flick(window, QPoint(200,10), QPoint(10,10), 180);
QVERIFY(pathview->isMoving());
QVERIFY(pathview->isFlicking());
QTRY_VERIFY(!pathview->isMoving());
QVERIFY(dist3 > dist2);
QVERIFY(dist2 < dist1);
- delete canvas;
+ delete window;
}
void tst_QQuickPathView::snapToItem()
{
QFETCH(bool, enforceRange);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("panels.qml"));
- QQuickPathView *pathview = canvas->rootObject()->findChild<QQuickPathView*>("view");
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("panels.qml"));
+ QQuickPathView *pathview = window->rootObject()->findChild<QQuickPathView*>("view");
QVERIFY(pathview != 0);
- canvas->rootObject()->setProperty("enforceRange", enforceRange);
+ window->rootObject()->setProperty("enforceRange", enforceRange);
QTRY_VERIFY(!pathview->isMoving()); // ensure stable
int currentIndex = pathview->currentIndex();
QSignalSpy snapModeSpy(pathview, SIGNAL(snapModeChanged()));
- flick(canvas, QPoint(200,10), QPoint(10,10), 180);
+ flick(window, QPoint(200,10), QPoint(10,10), 180);
QVERIFY(pathview->isMoving());
QTRY_VERIFY(!pathview->isMoving());
{
QFETCH(bool, enforceRange);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("panels.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QTRY_COMPARE(canvas, qGuiApp->focusWindow());
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("panels.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QTRY_COMPARE(window, qGuiApp->focusWindow());
- QQuickPathView *pathview = canvas->rootObject()->findChild<QQuickPathView*>("view");
+ QQuickPathView *pathview = window->rootObject()->findChild<QQuickPathView*>("view");
QVERIFY(pathview != 0);
- canvas->rootObject()->setProperty("enforceRange", enforceRange);
+ window->rootObject()->setProperty("enforceRange", enforceRange);
QSignalSpy snapModeSpy(pathview, SIGNAL(snapModeChanged()));
- canvas->rootObject()->setProperty("snapOne", true);
+ window->rootObject()->setProperty("snapOne", true);
QVERIFY(snapModeSpy.count() == 1);
QTRY_VERIFY(!pathview->isMoving()); // ensure stable
int currentIndex = pathview->currentIndex();
double startOffset = pathview->offset();
- flick(canvas, QPoint(200,10), QPoint(10,10), 180);
+ flick(window, QPoint(200,10), QPoint(10,10), 180);
QVERIFY(pathview->isMoving());
QTRY_VERIFY(!pathview->isMoving());
}
void tst_QQuickPinchArea::pinchProperties()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("pinchproperties.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("pinchproperties.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QVERIFY(blackRect == pinch->target());
- QQuickItem *rootItem = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootItem = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootItem != 0);
QSignalSpy targetSpy(pinch, SIGNAL(targetChanged()));
pinch->setTarget(rootItem);
QCOMPARE(rotMinSpy.count(),1);
QCOMPARE(rotMaxSpy.count(),1);
- delete canvas;
+ delete window;
}
QTouchEvent::TouchPoint makeTouchPoint(int id, QPoint p, QQuickView *v, QQuickItem *i)
void tst_QQuickPinchArea::scale()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("pinchproperties.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("pinchproperties.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->rootObject() != 0);
qApp->processEvents();
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root != 0);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QPoint p1(80, 80);
QPoint p2(100, 100);
{
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
- pinchSequence.press(0, p1, canvas).commit();
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(window, device);
+ pinchSequence.press(0, p1, window).commit();
// In order for the stationary point to remember its previous position,
// we have to reuse the same pinchSequence object. Otherwise if we let it
// be destroyed and then start a new sequence, point 0 will default to being
// stationary at 0, 0, and PinchArea will filter out that touchpoint because
// it is outside its bounds.
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1,canvas).move(1, p2,canvas).commit();
+ pinchSequence.move(0, p1,window).move(1, p2,window).commit();
QCOMPARE(root->property("scale").toReal(), 1.0);
QVERIFY(root->property("pinchActive").toBool());
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1,canvas).move(1, p2,canvas).commit();
+ pinchSequence.move(0, p1,window).move(1, p2,window).commit();
QCOMPARE(root->property("scale").toReal(), 1.5);
QCOMPARE(root->property("center").toPointF(), QPointF(40, 40)); // blackrect is at 50,50
p1 -= QPoint(50,50);
p2 += QPoint(50,50);
{
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(window, device);
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
QCOMPARE(blackRect->scale(), 2.0);
- pinchSequence.release(0, p1, canvas).release(1, p2, canvas).commit();
+ pinchSequence.release(0, p1, window).release(1, p2, window).commit();
}
QVERIFY(!root->property("pinchActive").toBool());
- delete canvas;
+ delete window;
}
void tst_QQuickPinchArea::pan()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("pinchproperties.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("pinchproperties.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->rootObject() != 0);
qApp->processEvents();
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root != 0);
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QPoint p1(80, 80);
QPoint p2(100, 100);
{
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
- pinchSequence.press(0, p1, canvas).commit();
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(window, device);
+ pinchSequence.press(0, p1, window).commit();
// In order for the stationary point to remember its previous position,
// we have to reuse the same pinchSequence object.
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
p1 += QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1,canvas).move(1, p2,canvas).commit();
+ pinchSequence.move(0, p1,window).move(1, p2,window).commit();
QCOMPARE(root->property("scale").toReal(), 1.0);
QVERIFY(root->property("pinchActive").toBool());
p1 += QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1,canvas).move(1, p2,canvas).commit();
+ pinchSequence.move(0, p1,window).move(1, p2,window).commit();
}
QCOMPARE(root->property("center").toPointF(), QPointF(60, 60)); // blackrect is at 50,50
// pan x beyond bound
p1 += QPoint(100,100);
p2 += QPoint(100,100);
- QTest::touchEvent(canvas, device).move(0, p1, canvas).move(1, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window).move(1, p2, window);
QCOMPARE(blackRect->x(), 140.0);
QCOMPARE(blackRect->y(), 160.0);
- QTest::touchEvent(canvas, device).release(0, p1, canvas).release(1, p2, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window).release(1, p2, window);
QVERIFY(!root->property("pinchActive").toBool());
- delete canvas;
+ delete window;
}
// test pinch, release one point, touch again to continue pinch
void tst_QQuickPinchArea::retouch()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("pinchproperties.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("pinchproperties.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->rootObject() != 0);
qApp->processEvents();
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QQuickPinch *pinch = pinchArea->pinch();
QVERIFY(pinchArea != 0);
QVERIFY(pinch != 0);
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root != 0);
QSignalSpy startedSpy(pinchArea, SIGNAL(pinchStarted(QQuickPinchEvent *)));
QSignalSpy finishedSpy(pinchArea, SIGNAL(pinchFinished(QQuickPinchEvent *)));
// target
- QQuickItem *blackRect = canvas->rootObject()->findChild<QQuickItem*>("blackrect");
+ QQuickItem *blackRect = window->rootObject()->findChild<QQuickItem*>("blackrect");
QVERIFY(blackRect != 0);
QPoint p1(80, 80);
QPoint p2(100, 100);
{
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
- pinchSequence.press(0, p1, canvas).commit();
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(window, device);
+ pinchSequence.press(0, p1, window).commit();
// In order for the stationary point to remember its previous position,
// we have to reuse the same pinchSequence object.
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1,canvas).move(1, p2,canvas).commit();
+ pinchSequence.move(0, p1,window).move(1, p2,window).commit();
QCOMPARE(root->property("scale").toReal(), 1.0);
QVERIFY(root->property("pinchActive").toBool());
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1,canvas).move(1, p2,canvas).commit();
+ pinchSequence.move(0, p1,window).move(1, p2,window).commit();
QCOMPARE(startedSpy.count(), 1);
QCOMPARE(root->property("center").toPointF(), QPointF(40, 40)); // blackrect is at 50,50
QCOMPARE(blackRect->scale(), 1.5);
- QCOMPARE(canvas->rootObject()->property("pointCount").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("pointCount").toInt(), 2);
QCOMPARE(startedSpy.count(), 1);
QCOMPARE(finishedSpy.count(), 0);
// Hold down the first finger but release the second one
- pinchSequence.stationary(0).release(1, p2, canvas).commit();
+ pinchSequence.stationary(0).release(1, p2, window).commit();
QCOMPARE(startedSpy.count(), 1);
QCOMPARE(finishedSpy.count(), 0);
- QCOMPARE(canvas->rootObject()->property("pointCount").toInt(), 1);
+ QCOMPARE(window->rootObject()->property("pointCount").toInt(), 1);
// Keep holding down the first finger and re-touch the second one, then move them both
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
// Lifting and retouching results in onPinchStarted being called again
QCOMPARE(startedSpy.count(), 2);
QCOMPARE(finishedSpy.count(), 0);
- QCOMPARE(canvas->rootObject()->property("pointCount").toInt(), 2);
+ QCOMPARE(window->rootObject()->property("pointCount").toInt(), 2);
- pinchSequence.release(0, p1, canvas).release(1, p2, canvas).commit();
+ pinchSequence.release(0, p1, window).release(1, p2, window).commit();
QVERIFY(!root->property("pinchActive").toBool());
QCOMPARE(startedSpy.count(), 2);
QCOMPARE(finishedSpy.count(), 1);
}
- delete canvas;
+ delete window;
}
void tst_QQuickPinchArea::transformedPinchArea_data()
QFETCH(QPoint, p2);
QFETCH(bool, shouldPinch);
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("transformedPinchArea.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *view = createView();
+ view->setSource(testFileUrl("transformedPinchArea.qml"));
+ view->show();
+ view->requestActivateWindow();
+ QTest::qWaitForWindowShown(view);
+ QVERIFY(view->rootObject() != 0);
qApp->processEvents();
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pinchArea");
+ QQuickPinchArea *pinchArea = view->rootObject()->findChild<QQuickPinchArea*>("pinchArea");
QVERIFY(pinchArea != 0);
const int threshold = qApp->styleHints()->startDragDistance();
{
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(view, device);
// start pinch
- pinchSequence.press(0, p1, canvas).commit();
+ pinchSequence.press(0, p1, view).commit();
// In order for the stationary point to remember its previous position,
// we have to reuse the same pinchSequence object.
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
- pinchSequence.stationary(0).move(1, p2 + QPoint(threshold * 2, 0), canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, view).commit();
+ pinchSequence.stationary(0).move(1, p2 + QPoint(threshold * 2, 0), view).commit();
QCOMPARE(pinchArea->property("pinching").toBool(), shouldPinch);
// release pinch
- pinchSequence.release(0, p1, canvas).release(1, p2, canvas).commit();
+ pinchSequence.release(0, p1, view).release(1, p2, view).commit();
QCOMPARE(pinchArea->property("pinching").toBool(), false);
}
- delete canvas;
+ delete view;
}
QQuickView *tst_QQuickPinchArea::createView()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- return canvas;
+ return window;
}
QTEST_MAIN(tst_QQuickPinchArea)
void tst_qquickpositioners::test_horizontal()
{
- QQuickView *canvas = createView(testFile("horizontal.qml"));
+ QQuickView *window = createView(testFile("horizontal.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", false);
+ window->rootObject()->setProperty("testRightToLeft", false);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 70.0);
QCOMPARE(three->y(), 0.0);
- QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *row = window->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 110.0);
QCOMPARE(row->height(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_horizontal_rtl()
{
- QQuickView *canvas = createView(testFile("horizontal.qml"));
+ QQuickView *window = createView(testFile("horizontal.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", true);
+ window->rootObject()->setProperty("testRightToLeft", true);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 60.0);
QCOMPARE(three->x(), 0.0);
QCOMPARE(three->y(), 0.0);
- QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *row = window->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 110.0);
QCOMPARE(row->height(), 50.0);
QCOMPARE(three->x(), 90.0);
QCOMPARE(three->y(), 0.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_horizontal_spacing()
{
- QQuickView *canvas = createView(testFile("horizontal-spacing.qml"));
+ QQuickView *window = createView(testFile("horizontal-spacing.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", false);
+ window->rootObject()->setProperty("testRightToLeft", false);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 90.0);
QCOMPARE(three->y(), 0.0);
- QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *row = window->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 130.0);
QCOMPARE(row->height(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_horizontal_spacing_rightToLeft()
{
- QQuickView *canvas = createView(testFile("horizontal-spacing.qml"));
+ QQuickView *window = createView(testFile("horizontal-spacing.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", true);
+ window->rootObject()->setProperty("testRightToLeft", true);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 80.0);
QCOMPARE(three->x(), 00.0);
QCOMPARE(three->y(), 0.0);
- QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *row = window->rootObject()->findChild<QQuickItem*>("row");
QCOMPARE(row->width(), 130.0);
QCOMPARE(row->height(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_horizontal_animated()
{
- QQuickView *canvas = createView(testFile("horizontal-animated.qml"), false);
+ QQuickView *window = createView(testFile("horizontal-animated.qml"), false);
- canvas->rootObject()->setProperty("testRightToLeft", false);
+ window->rootObject()->setProperty("testRightToLeft", false);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
//Note that they animate in
QCOMPARE(two->x(), -100.0);
QCOMPARE(three->x(), -100.0);
- QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
+ QTest::qWaitForWindowShown(window); //It may not relayout until the next frame, so it needs to be drawn
- QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *row = window->rootObject()->findChild<QQuickItem*>("row");
QVERIFY(row);
QCOMPARE(row->width(), 100.0);
QCOMPARE(row->height(), 50.0);
QTRY_COMPARE(two->x(), 50.0);
QTRY_COMPARE(three->x(), 100.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_horizontal_animated_rightToLeft()
{
- QQuickView *canvas = createView(testFile("horizontal-animated.qml"), false);
+ QQuickView *window = createView(testFile("horizontal-animated.qml"), false);
- canvas->rootObject()->setProperty("testRightToLeft", true);
+ window->rootObject()->setProperty("testRightToLeft", true);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
//Note that they animate in
QCOMPARE(two->x(), -100.0);
QCOMPARE(three->x(), -100.0);
- QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
+ QTest::qWaitForWindowShown(window); //It may not relayout until the next frame, so it needs to be drawn
- QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *row = window->rootObject()->findChild<QQuickItem*>("row");
QVERIFY(row);
QCOMPARE(row->width(), 100.0);
QCOMPARE(row->height(), 50.0);
QTRY_COMPARE(one->x(), 100.0);
QTRY_COMPARE(two->x(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_horizontal_animated_disabled()
{
- QQuickView *canvas = createView(testFile("horizontal-animated-disabled.qml"));
+ QQuickView *window = createView(testFile("horizontal-animated-disabled.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickItem *row = canvas->rootObject()->findChild<QQuickItem*>("row");
+ QQuickItem *row = window->rootObject()->findChild<QQuickItem*>("row");
QVERIFY(row);
qApp->processEvents();
QTRY_COMPARE(two->x(), 50.0);
QTRY_COMPARE(three->x(), 100.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::populateTransitions(const QString &positionerObjectName)
QaimModel model_targetItems_transitionFrom;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = QQuickViewTestUtil::createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = QQuickViewTestUtil::createView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("usePopulateTransition", usePopulateTransition);
ctxt->setContextProperty("enableAddTransition", true);
ctxt->setContextProperty("dynamicallyPopulate", dynamicallyPopulate);
ctxt->setContextProperty("targetItems_transitionFrom", targetItems_transitionFrom);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
ctxt->setContextProperty("testedPositioner", positionerObjectName);
- canvas->setSource(testFileUrl("transitions.qml"));
+ window->setSource(testFileUrl("transitions.qml"));
- QQuickItem *positioner = canvas->rootObject()->findChild<QQuickItem*>(positionerObjectName);
+ QQuickItem *positioner = window->rootObject()->findChild<QQuickItem*>(positionerObjectName);
QVERIFY(positioner);
- canvas->show();
+ window->show();
qApp->processEvents();
if (!dynamicallyPopulate && usePopulateTransition) {
- QTRY_COMPARE(canvas->rootObject()->property("populateTransitionsDone").toInt(), model.count());
- QTRY_COMPARE(canvas->rootObject()->property("addTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("populateTransitionsDone").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("addTransitionsDone").toInt(), 0);
QList<QPair<QString, QString> > targetData;
QList<int> targetIndexes;
}
QList<QQuickItem *> targetItems = findItems<QQuickItem>(positioner, "wrapper", targetIndexes);
model_targetItems_transitionFrom.matchAgainst(targetData, "wasn't animated from target 'from' pos", "shouldn't have been animated from target 'from' pos");
- matchItemsAndIndexes(canvas->rootObject()->property("targetTrans_items").toMap(), model, targetIndexes);
- matchIndexLists(canvas->rootObject()->property("targetTrans_targetIndexes").toList(), targetIndexes);
- matchItemLists(canvas->rootObject()->property("targetTrans_targetItems").toList(), targetItems);
+ matchItemsAndIndexes(window->rootObject()->property("targetTrans_items").toMap(), model, targetIndexes);
+ matchIndexLists(window->rootObject()->property("targetTrans_targetIndexes").toList(), targetIndexes);
+ matchItemLists(window->rootObject()->property("targetTrans_targetItems").toList(), targetItems);
} else if (dynamicallyPopulate) {
- QTRY_COMPARE(canvas->rootObject()->property("populateTransitionsDone").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("addTransitionsDone").toInt(), model.count());
+ QTRY_COMPARE(window->rootObject()->property("populateTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("addTransitionsDone").toInt(), model.count());
} else {
QTRY_COMPARE(QQuickItemPrivate::get(positioner)->polishScheduled, false);
- QTRY_COMPARE(canvas->rootObject()->property("populateTransitionsDone").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("addTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("populateTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("addTransitionsDone").toInt(), 0);
}
- checkItemPositions(positioner, &model, canvas->rootObject()->property("incrementalSize").toInt());
+ checkItemPositions(positioner, &model, window->rootObject()->property("incrementalSize").toInt());
// add an item and check this is done with add transition, not populate
- canvas->rootObject()->setProperty("populateTransitionsDone", 0);
- canvas->rootObject()->setProperty("addTransitionsDone", 0);
+ window->rootObject()->setProperty("populateTransitionsDone", 0);
+ window->rootObject()->setProperty("addTransitionsDone", 0);
model.insertItem(0, "new item", "");
- QTRY_COMPARE(canvas->rootObject()->property("addTransitionsDone").toInt(), 1);
- QTRY_COMPARE(canvas->rootObject()->property("populateTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("addTransitionsDone").toInt(), 1);
+ QTRY_COMPARE(window->rootObject()->property("populateTransitionsDone").toInt(), 0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::populateTransitions_data()
QaimModel model_targetItems_transitionFrom;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = QQuickViewTestUtil::createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = QQuickViewTestUtil::createView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("usePopulateTransition", QVariant(false));
ctxt->setContextProperty("enableAddTransition", QVariant(true));
ctxt->setContextProperty("model_targetItems_transitionFrom", &model_targetItems_transitionFrom);
ctxt->setContextProperty("model_displacedItems_transitionVia", &model_displacedItems_transitionVia);
ctxt->setContextProperty("targetItems_transitionFrom", targetItems_transitionFrom);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
- canvas->setSource(testFileUrl("transitions.qml"));
- canvas->show();
+ window->setSource(testFileUrl("transitions.qml"));
+ window->show();
qApp->processEvents();
- QQuickItem *positioner = canvas->rootObject()->findChild<QQuickItem*>(positionerObjectName);
+ QQuickItem *positioner = window->rootObject()->findChild<QQuickItem*>(positionerObjectName);
QVERIFY(positioner);
positioner->findChild<QQuickItem*>("repeater")->setProperty("model", QVariant::fromValue(&model));
QTRY_COMPARE(QQuickItemPrivate::get(positioner)->polishScheduled, false);
QList<QQuickItem *> targetItems = findItems<QQuickItem>(positioner, "wrapper", targetIndexes);
// check add transition was run for first lot of added items
- QTRY_COMPARE(canvas->rootObject()->property("populateTransitionsDone").toInt(), 0);
- QTRY_COMPARE(canvas->rootObject()->property("addTransitionsDone").toInt(), initialItemCount);
- QTRY_COMPARE(canvas->rootObject()->property("displaceTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("populateTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("addTransitionsDone").toInt(), initialItemCount);
+ QTRY_COMPARE(window->rootObject()->property("displaceTransitionsDone").toInt(), 0);
model_targetItems_transitionFrom.matchAgainst(targetData, "wasn't animated from target 'from' pos", "shouldn't have been animated from target 'from' pos");
- matchItemsAndIndexes(canvas->rootObject()->property("targetTrans_items").toMap(), model, targetIndexes);
- matchIndexLists(canvas->rootObject()->property("targetTrans_targetIndexes").toList(), targetIndexes);
- matchItemLists(canvas->rootObject()->property("targetTrans_targetItems").toList(), targetItems);
+ matchItemsAndIndexes(window->rootObject()->property("targetTrans_items").toMap(), model, targetIndexes);
+ matchIndexLists(window->rootObject()->property("targetTrans_targetIndexes").toList(), targetIndexes);
+ matchItemLists(window->rootObject()->property("targetTrans_targetItems").toList(), targetItems);
model_targetItems_transitionFrom.clear();
- canvas->rootObject()->setProperty("addTransitionsDone", 0);
- canvas->rootObject()->setProperty("targetTrans_items", QVariantMap());
- canvas->rootObject()->setProperty("targetTrans_targetIndexes", QVariantList());
- canvas->rootObject()->setProperty("targetTrans_targetItems", QVariantList());
+ window->rootObject()->setProperty("addTransitionsDone", 0);
+ window->rootObject()->setProperty("targetTrans_items", QVariantMap());
+ window->rootObject()->setProperty("targetTrans_targetIndexes", QVariantList());
+ window->rootObject()->setProperty("targetTrans_targetItems", QVariantList());
// do insertion
targetData.clear();
targetItems = findItems<QQuickItem>(positioner, "wrapper", targetIndexes);
- QTRY_COMPARE(canvas->rootObject()->property("addTransitionsDone").toInt(), targetData.count());
- QTRY_COMPARE(canvas->rootObject()->property("displaceTransitionsDone").toInt(), expectedDisplacedIndexes.count());
+ QTRY_COMPARE(window->rootObject()->property("addTransitionsDone").toInt(), targetData.count());
+ QTRY_COMPARE(window->rootObject()->property("displaceTransitionsDone").toInt(), expectedDisplacedIndexes.count());
// check the target and displaced items were animated
model_targetItems_transitionFrom.matchAgainst(targetData, "wasn't animated from target 'from' pos", "shouldn't have been animated from target 'from' pos");
model_displacedItems_transitionVia.matchAgainst(expectedDisplacedValues, "wasn't animated with displaced anim", "shouldn't have been animated with displaced anim");
// check attached properties
- matchItemsAndIndexes(canvas->rootObject()->property("targetTrans_items").toMap(), model, targetIndexes);
- matchIndexLists(canvas->rootObject()->property("targetTrans_targetIndexes").toList(), targetIndexes);
- matchItemLists(canvas->rootObject()->property("targetTrans_targetItems").toList(), targetItems);
+ matchItemsAndIndexes(window->rootObject()->property("targetTrans_items").toMap(), model, targetIndexes);
+ matchIndexLists(window->rootObject()->property("targetTrans_targetIndexes").toList(), targetIndexes);
+ matchItemLists(window->rootObject()->property("targetTrans_targetItems").toList(), targetItems);
if (expectedDisplacedIndexes.isValid()) {
// adjust expectedDisplacedIndexes to their final values after the move
QList<int> displacedIndexes = adjustIndexesForAddDisplaced(expectedDisplacedIndexes.indexes, insertionIndex, insertionCount);
- matchItemsAndIndexes(canvas->rootObject()->property("displacedTrans_items").toMap(), model, displacedIndexes);
- matchIndexLists(canvas->rootObject()->property("displacedTrans_targetIndexes").toList(), targetIndexes);
- matchItemLists(canvas->rootObject()->property("displacedTrans_targetItems").toList(), targetItems);
+ matchItemsAndIndexes(window->rootObject()->property("displacedTrans_items").toMap(), model, displacedIndexes);
+ matchIndexLists(window->rootObject()->property("displacedTrans_targetIndexes").toList(), targetIndexes);
+ matchItemLists(window->rootObject()->property("displacedTrans_targetItems").toList(), targetItems);
}
- checkItemPositions(positioner, &model, canvas->rootObject()->property("incrementalSize").toInt());
+ checkItemPositions(positioner, &model, window->rootObject()->property("incrementalSize").toInt());
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::addTransitions_data()
QaimModel model_targetItems_transitionFrom;
QaimModel model_displacedItems_transitionVia;
- QQuickView *canvas = QQuickViewTestUtil::createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = QQuickViewTestUtil::createView();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("usePopulateTransition", QVariant(false));
ctxt->setContextProperty("enableAddTransition", QVariant(false));
ctxt->setContextProperty("model_targetItems_transitionFrom", &model_targetItems_transitionFrom);
ctxt->setContextProperty("model_displacedItems_transitionVia", &model_displacedItems_transitionVia);
ctxt->setContextProperty("targetItems_transitionFrom", targetItems_transitionFrom);
ctxt->setContextProperty("displacedItems_transitionVia", displacedItems_transitionVia);
- canvas->setSource(testFileUrl("transitions.qml"));
- canvas->show();
+ window->setSource(testFileUrl("transitions.qml"));
+ window->show();
qApp->processEvents();
QList<QPair<QString,QString> > expectedDisplacedValues = expectedDisplacedIndexes.getModelDataValues(model);
- QQuickItem *positioner = canvas->rootObject()->findChild<QQuickItem*>(positionerObjectName);
+ QQuickItem *positioner = window->rootObject()->findChild<QQuickItem*>(positionerObjectName);
QVERIFY(positioner);
positioner->findChild<QQuickItem*>("repeater")->setProperty("model", QVariant::fromValue(&model));
QTRY_COMPARE(QQuickItemPrivate::get(positioner)->polishScheduled, false);
break;
}
- QTRY_COMPARE(canvas->rootObject()->property("displaceTransitionsDone").toInt(), expectedDisplacedIndexes.count());
- QCOMPARE(canvas->rootObject()->property("addTransitionsDone").toInt(), 0);
+ QTRY_COMPARE(window->rootObject()->property("displaceTransitionsDone").toInt(), expectedDisplacedIndexes.count());
+ QCOMPARE(window->rootObject()->property("addTransitionsDone").toInt(), 0);
// check the target and displaced items were animated
QCOMPARE(model_targetItems_transitionFrom.count(), 0);
model_displacedItems_transitionVia.matchAgainst(expectedDisplacedValues, "wasn't animated with displaced anim", "shouldn't have been animated with displaced anim");
// check attached properties
- QCOMPARE(canvas->rootObject()->property("targetTrans_items").toMap().count(), 0);
- QCOMPARE(canvas->rootObject()->property("targetTrans_targetIndexes").toList().count(), 0);
- QCOMPARE(canvas->rootObject()->property("targetTrans_targetItems").toList().count(), 0);
+ QCOMPARE(window->rootObject()->property("targetTrans_items").toMap().count(), 0);
+ QCOMPARE(window->rootObject()->property("targetTrans_targetIndexes").toList().count(), 0);
+ QCOMPARE(window->rootObject()->property("targetTrans_targetItems").toList().count(), 0);
if (expectedDisplacedIndexes.isValid()) {
// adjust expectedDisplacedIndexes to their final values after the move
QList<int> displacedIndexes;
displacedIndexes = adjustIndexesForRemoveDisplaced(expectedDisplacedIndexes.indexes, change.index, change.count);
else
QVERIFY(false);
- matchItemsAndIndexes(canvas->rootObject()->property("displacedTrans_items").toMap(), model, displacedIndexes);
+ matchItemsAndIndexes(window->rootObject()->property("displacedTrans_items").toMap(), model, displacedIndexes);
QVariantList listOfEmptyIntLists;
for (int i=0; i<displacedIndexes.count(); i++)
listOfEmptyIntLists << QVariant::fromValue(QList<int>());
- QCOMPARE(canvas->rootObject()->property("displacedTrans_targetIndexes").toList(), listOfEmptyIntLists);
+ QCOMPARE(window->rootObject()->property("displacedTrans_targetIndexes").toList(), listOfEmptyIntLists);
QVariantList listOfEmptyObjectLists;
for (int i=0; i<displacedIndexes.count(); i++)
listOfEmptyObjectLists.insert(listOfEmptyObjectLists.count(), QVariantList());
- QCOMPARE(canvas->rootObject()->property("displacedTrans_targetItems").toList(), listOfEmptyObjectLists);
+ QCOMPARE(window->rootObject()->property("displacedTrans_targetItems").toList(), listOfEmptyObjectLists);
}
- checkItemPositions(positioner, &model, canvas->rootObject()->property("incrementalSize").toInt());
+ checkItemPositions(positioner, &model, window->rootObject()->property("incrementalSize").toInt());
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::moveTransitions_data()
void tst_qquickpositioners::test_vertical()
{
- QQuickView *canvas = createView(testFile("vertical.qml"));
+ QQuickView *window = createView(testFile("vertical.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 0.0);
QCOMPARE(three->y(), 60.0);
- QQuickItem *column = canvas->rootObject()->findChild<QQuickItem*>("column");
+ QQuickItem *column = window->rootObject()->findChild<QQuickItem*>("column");
QVERIFY(column);
QCOMPARE(column->height(), 80.0);
QCOMPARE(column->width(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_vertical_spacing()
{
- QQuickView *canvas = createView(testFile("vertical-spacing.qml"));
+ QQuickView *window = createView(testFile("vertical-spacing.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 0.0);
QCOMPARE(three->y(), 80.0);
- QQuickItem *column = canvas->rootObject()->findChild<QQuickItem*>("column");
+ QQuickItem *column = window->rootObject()->findChild<QQuickItem*>("column");
QCOMPARE(column->height(), 100.0);
QCOMPARE(column->width(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_vertical_animated()
{
- QQuickView *canvas = createView(testFile("vertical-animated.qml"), false);
+ QQuickView *window = createView(testFile("vertical-animated.qml"), false);
//Note that they animate in
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
QCOMPARE(one->y(), -100.0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
QCOMPARE(two->y(), -100.0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(three->y(), -100.0);
- QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
+ QTest::qWaitForWindowShown(window); //It may not relayout until the next frame, so it needs to be drawn
- QQuickItem *column = canvas->rootObject()->findChild<QQuickItem*>("column");
+ QQuickItem *column = window->rootObject()->findChild<QQuickItem*>("column");
QVERIFY(column);
QCOMPARE(column->height(), 100.0);
QCOMPARE(column->width(), 50.0);
QTRY_COMPARE(two->y(), 50.0);
QTRY_COMPARE(three->y(), 100.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid()
{
- QQuickView *canvas = createView(testFile("gridtest.qml"));
+ QQuickView *window = createView(testFile("gridtest.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 50.0);
QCOMPARE(five->y(), 50.0);
- QQuickGrid *grid = canvas->rootObject()->findChild<QQuickGrid*>("grid");
+ QQuickGrid *grid = window->rootObject()->findChild<QQuickGrid*>("grid");
QCOMPARE(grid->flow(), QQuickGrid::LeftToRight);
QCOMPARE(grid->width(), 100.0);
QCOMPARE(grid->height(), 100.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid_topToBottom()
{
- QQuickView *canvas = createView(testFile("grid-toptobottom.qml"));
+ QQuickView *window = createView(testFile("grid-toptobottom.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 50.0);
QCOMPARE(five->y(), 50.0);
- QQuickGrid *grid = canvas->rootObject()->findChild<QQuickGrid*>("grid");
+ QQuickGrid *grid = window->rootObject()->findChild<QQuickGrid*>("grid");
QCOMPARE(grid->flow(), QQuickGrid::TopToBottom);
QCOMPARE(grid->width(), 100.0);
QCOMPARE(grid->height(), 120.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid_rightToLeft()
{
- QQuickView *canvas = createView(testFile("gridtest.qml"));
+ QQuickView *window = createView(testFile("gridtest.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", true);
+ window->rootObject()->setProperty("testRightToLeft", true);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 50.0);
QCOMPARE(five->x(), 40.0);
QCOMPARE(five->y(), 50.0);
- QQuickGrid *grid = canvas->rootObject()->findChild<QQuickGrid*>("grid");
+ QQuickGrid *grid = window->rootObject()->findChild<QQuickGrid*>("grid");
QCOMPARE(grid->layoutDirection(), Qt::RightToLeft);
QCOMPARE(grid->width(), 100.0);
QCOMPARE(grid->height(), 100.0);
QCOMPARE(five->x(), 140.0);
QCOMPARE(five->y(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid_spacing()
{
- QQuickView *canvas = createView(testFile("grid-spacing.qml"));
+ QQuickView *window = createView(testFile("grid-spacing.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 54.0);
QCOMPARE(five->y(), 54.0);
- QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
+ QQuickItem *grid = window->rootObject()->findChild<QQuickItem*>("grid");
QCOMPARE(grid->width(), 128.0);
QCOMPARE(grid->height(), 104.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid_row_column_spacing()
{
- QQuickView *canvas = createView(testFile("grid-row-column-spacing.qml"));
+ QQuickView *window = createView(testFile("grid-row-column-spacing.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 61.0);
QCOMPARE(five->y(), 57.0);
- QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
+ QQuickItem *grid = window->rootObject()->findChild<QQuickItem*>("grid");
QCOMPARE(grid->width(), 142.0);
QCOMPARE(grid->height(), 107.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid_animated()
{
- QQuickView *canvas = createView(testFile("grid-animated.qml"), false);
+ QQuickView *window = createView(testFile("grid-animated.qml"), false);
- canvas->rootObject()->setProperty("testRightToLeft", false);
+ window->rootObject()->setProperty("testRightToLeft", false);
//Note that all animate in
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
QCOMPARE(one->x(), -100.0);
QCOMPARE(one->y(), -100.0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
QCOMPARE(two->x(), -100.0);
QCOMPARE(two->y(), -100.0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(three->x(), -100.0);
QCOMPARE(three->y(), -100.0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
QCOMPARE(four->x(), -100.0);
QCOMPARE(four->y(), -100.0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(five->x(), -100.0);
QCOMPARE(five->y(), -100.0);
- QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
+ QTest::qWaitForWindowShown(window); //It may not relayout until the next frame, so it needs to be drawn
- QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
+ QQuickItem *grid = window->rootObject()->findChild<QQuickItem*>("grid");
QVERIFY(grid);
QCOMPARE(grid->width(), 150.0);
QCOMPARE(grid->height(), 100.0);
QTRY_COMPARE(five->x(), 50.0);
QTRY_COMPARE(five->y(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid_animated_rightToLeft()
{
- QQuickView *canvas = createView(testFile("grid-animated.qml"), false);
+ QQuickView *window = createView(testFile("grid-animated.qml"), false);
- canvas->rootObject()->setProperty("testRightToLeft", true);
+ window->rootObject()->setProperty("testRightToLeft", true);
//Note that all animate in
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
QCOMPARE(one->x(), -100.0);
QCOMPARE(one->y(), -100.0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
QCOMPARE(two->x(), -100.0);
QCOMPARE(two->y(), -100.0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
QCOMPARE(three->x(), -100.0);
QCOMPARE(three->y(), -100.0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
QCOMPARE(four->x(), -100.0);
QCOMPARE(four->y(), -100.0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(five->x(), -100.0);
QCOMPARE(five->y(), -100.0);
- QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
+ QTest::qWaitForWindowShown(window); //It may not relayout until the next frame, so it needs to be drawn
- QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
+ QQuickItem *grid = window->rootObject()->findChild<QQuickItem*>("grid");
QVERIFY(grid);
QCOMPARE(grid->width(), 150.0);
QCOMPARE(grid->height(), 100.0);
QTRY_COMPARE(five->x(), 50.0);
QTRY_COMPARE(five->y(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_grid_zero_columns()
{
- QQuickView *canvas = createView(testFile("gridzerocolumns.qml"));
+ QQuickView *window = createView(testFile("gridzerocolumns.qml"));
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 0.0);
QCOMPARE(five->y(), 50.0);
- QQuickItem *grid = canvas->rootObject()->findChild<QQuickItem*>("grid");
+ QQuickItem *grid = window->rootObject()->findChild<QQuickItem*>("grid");
QCOMPARE(grid->width(), 170.0);
QCOMPARE(grid->height(), 60.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_propertychanges()
{
- QQuickView *canvas = createView(testFile("propertychangestest.qml"));
+ QQuickView *window = createView(testFile("propertychangestest.qml"));
- QQuickGrid *grid = qobject_cast<QQuickGrid*>(canvas->rootObject());
+ QQuickGrid *grid = qobject_cast<QQuickGrid*>(window->rootObject());
QVERIFY(grid != 0);
- QQuickTransition *rowTransition = canvas->rootObject()->findChild<QQuickTransition*>("rowTransition");
- QQuickTransition *columnTransition = canvas->rootObject()->findChild<QQuickTransition*>("columnTransition");
+ QQuickTransition *rowTransition = window->rootObject()->findChild<QQuickTransition*>("rowTransition");
+ QQuickTransition *columnTransition = window->rootObject()->findChild<QQuickTransition*>("columnTransition");
QSignalSpy addSpy(grid, SIGNAL(addChanged()));
QSignalSpy moveSpy(grid, SIGNAL(moveChanged()));
QCOMPARE(columnsSpy.count(),2);
QCOMPARE(rowsSpy.count(),2);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_repeater()
{
- QQuickView *canvas = createView(testFile("repeatertest.qml"));
+ QQuickView *window = createView(testFile("repeatertest.qml"));
- QQuickRectangle *one = findItem<QQuickRectangle>(canvas->rootItem(), "one");
+ QQuickRectangle *one = findItem<QQuickRectangle>(window->rootItem(), "one");
QVERIFY(one != 0);
- QQuickRectangle *two = findItem<QQuickRectangle>(canvas->rootItem(), "two");
+ QQuickRectangle *two = findItem<QQuickRectangle>(window->rootItem(), "two");
QVERIFY(two != 0);
- QQuickRectangle *three = findItem<QQuickRectangle>(canvas->rootItem(), "three");
+ QQuickRectangle *three = findItem<QQuickRectangle>(window->rootItem(), "three");
QVERIFY(three != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(three->x(), 100.0);
QCOMPARE(three->y(), 0.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_flow()
{
- QQuickView *canvas = createView(testFile("flowtest.qml"));
+ QQuickView *window = createView(testFile("flowtest.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", false);
+ window->rootObject()->setProperty("testRightToLeft", false);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 50.0);
QCOMPARE(five->y(), 70.0);
- QQuickItem *flow = canvas->rootObject()->findChild<QQuickItem*>("flow");
+ QQuickItem *flow = window->rootObject()->findChild<QQuickItem*>("flow");
QVERIFY(flow);
QCOMPARE(flow->width(), 90.0);
QCOMPARE(flow->height(), 120.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_flow_rightToLeft()
{
- QQuickView *canvas = createView(testFile("flowtest.qml"));
+ QQuickView *window = createView(testFile("flowtest.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", true);
+ window->rootObject()->setProperty("testRightToLeft", true);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 40.0);
QCOMPARE(five->x(), 30.0);
QCOMPARE(five->y(), 70.0);
- QQuickItem *flow = canvas->rootObject()->findChild<QQuickItem*>("flow");
+ QQuickItem *flow = window->rootObject()->findChild<QQuickItem*>("flow");
QVERIFY(flow);
QCOMPARE(flow->width(), 90.0);
QCOMPARE(flow->height(), 120.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_flow_topToBottom()
{
- QQuickView *canvas = createView(testFile("flowtest-toptobottom.qml"));
+ QQuickView *window = createView(testFile("flowtest-toptobottom.qml"));
- canvas->rootObject()->setProperty("testRightToLeft", false);
+ window->rootObject()->setProperty("testRightToLeft", false);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 0.0);
QCOMPARE(five->x(), 100.0);
QCOMPARE(five->y(), 50.0);
- QQuickItem *flow = canvas->rootObject()->findChild<QQuickItem*>("flow");
+ QQuickItem *flow = window->rootObject()->findChild<QQuickItem*>("flow");
QVERIFY(flow);
QCOMPARE(flow->height(), 90.0);
QCOMPARE(flow->width(), 150.0);
- canvas->rootObject()->setProperty("testRightToLeft", true);
+ window->rootObject()->setProperty("testRightToLeft", true);
QVERIFY(flow);
QCOMPARE(flow->height(), 90.0);
QCOMPARE(five->x(), 40.0);
QCOMPARE(five->y(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_flow_resize()
{
- QQuickView *canvas = createView(testFile("flowtest.qml"));
+ QQuickView *window = createView(testFile("flowtest.qml"));
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root);
root->setWidth(125);
root->setProperty("testRightToLeft", false);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QVERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QTRY_COMPARE(one->x(), 0.0);
QTRY_COMPARE(five->x(), 50.0);
QTRY_COMPARE(five->y(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_flow_resize_rightToLeft()
{
- QQuickView *canvas = createView(testFile("flowtest.qml"));
+ QQuickView *window = createView(testFile("flowtest.qml"));
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root);
root->setWidth(125);
root->setProperty("testRightToLeft", true);
- QQuickRectangle *one = canvas->rootObject()->findChild<QQuickRectangle*>("one");
+ QQuickRectangle *one = window->rootObject()->findChild<QQuickRectangle*>("one");
QTRY_VERIFY(one != 0);
- QQuickRectangle *two = canvas->rootObject()->findChild<QQuickRectangle*>("two");
+ QQuickRectangle *two = window->rootObject()->findChild<QQuickRectangle*>("two");
QVERIFY(two != 0);
- QQuickRectangle *three = canvas->rootObject()->findChild<QQuickRectangle*>("three");
+ QQuickRectangle *three = window->rootObject()->findChild<QQuickRectangle*>("three");
QVERIFY(three != 0);
- QQuickRectangle *four = canvas->rootObject()->findChild<QQuickRectangle*>("four");
+ QQuickRectangle *four = window->rootObject()->findChild<QQuickRectangle*>("four");
QVERIFY(four != 0);
- QQuickRectangle *five = canvas->rootObject()->findChild<QQuickRectangle*>("five");
+ QQuickRectangle *five = window->rootObject()->findChild<QQuickRectangle*>("five");
QVERIFY(five != 0);
QCOMPARE(one->x(), 75.0);
QCOMPARE(five->x(), 65.0);
QCOMPARE(five->y(), 50.0);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_flow_implicit_resize()
{
- QQuickView *canvas = createView(testFile("flow-testimplicitsize.qml"));
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView(testFile("flow-testimplicitsize.qml"));
+ QVERIFY(window->rootObject() != 0);
- QQuickFlow *flow = canvas->rootObject()->findChild<QQuickFlow*>("flow");
+ QQuickFlow *flow = window->rootObject()->findChild<QQuickFlow*>("flow");
QVERIFY(flow != 0);
QCOMPARE(flow->width(), 100.0);
QCOMPARE(flow->height(), 120.0);
- canvas->rootObject()->setProperty("flowLayout", 0);
+ window->rootObject()->setProperty("flowLayout", 0);
QCOMPARE(flow->flow(), QQuickFlow::LeftToRight);
QCOMPARE(flow->width(), 220.0);
QCOMPARE(flow->height(), 50.0);
- canvas->rootObject()->setProperty("flowLayout", 1);
+ window->rootObject()->setProperty("flowLayout", 1);
QCOMPARE(flow->flow(), QQuickFlow::TopToBottom);
QCOMPARE(flow->width(), 100.0);
QCOMPARE(flow->height(), 120.0);
- canvas->rootObject()->setProperty("flowLayout", 2);
+ window->rootObject()->setProperty("flowLayout", 2);
QCOMPARE(flow->layoutDirection(), Qt::RightToLeft);
QCOMPARE(flow->width(), 220.0);
QCOMPARE(flow->height(), 50.0);
- delete canvas;
+ delete window;
}
QString warningMessage;
objectNames << "one" << "two" << "three" << "four" << "five";
foreach (const QString qmlFile, qmlFiles) {
- QQuickView *canvasA = createView(testFile(qmlFile));
- QQuickItem *rootA = qobject_cast<QQuickItem*>(canvasA->rootObject());
+ QQuickView *windowA = createView(testFile(qmlFile));
+ QQuickItem *rootA = qobject_cast<QQuickItem*>(windowA->rootObject());
- QQuickView *canvasB = createView(testFile(qmlFile));
- QQuickItem *rootB = qobject_cast<QQuickItem*>(canvasB->rootObject());
+ QQuickView *windowB = createView(testFile(qmlFile));
+ QQuickItem *rootB = qobject_cast<QQuickItem*>(windowB->rootObject());
rootA->setProperty("testRightToLeft", true); // layoutDirection: Qt.RightToLeft
QQuickItem *itemB = rootB->findChild<QQuickItem*>(objectName);
QTRY_COMPARE(itemA->x(), itemB->x());
}
- delete canvasA;
- delete canvasB;
+ delete windowA;
+ delete windowB;
}
}
void tst_qquickpositioners::test_allInvisible()
{
//QTBUG-19361
- QQuickView *canvas = createView(testFile("allInvisible.qml"));
+ QQuickView *window = createView(testFile("allInvisible.qml"));
- QQuickItem *root = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *root = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(root);
- QQuickRow *row = canvas->rootObject()->findChild<QQuickRow*>("row");
+ QQuickRow *row = window->rootObject()->findChild<QQuickRow*>("row");
QVERIFY(row != 0);
QVERIFY(row->width() == 0);
QVERIFY(row->height() == 0);
- QQuickColumn *column = canvas->rootObject()->findChild<QQuickColumn*>("column");
+ QQuickColumn *column = window->rootObject()->findChild<QQuickColumn*>("column");
QVERIFY(column != 0);
QVERIFY(column->width() == 0);
QVERIFY(column->height() == 0);
{
QFETCH(QString, filename);
- QQuickView *canvas = createView(filename);
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView(filename);
+ QVERIFY(window->rootObject() != 0);
- QQuickRectangle *greenRect = canvas->rootObject()->findChild<QQuickRectangle *>("greenRect");
+ QQuickRectangle *greenRect = window->rootObject()->findChild<QQuickRectangle *>("greenRect");
QVERIFY(greenRect != 0);
int posIndex = greenRect->property("posIndex").toInt();
bool isLast = greenRect->property("isLastItem").toBool();
QVERIFY(isLast == false);
- QQuickRectangle *yellowRect = canvas->rootObject()->findChild<QQuickRectangle *>("yellowRect");
+ QQuickRectangle *yellowRect = window->rootObject()->findChild<QQuickRectangle *>("yellowRect");
QVERIFY(yellowRect != 0);
posIndex = yellowRect->property("posIndex").toInt();
isLast = yellowRect->property("isLastItem").toBool();
QVERIFY(isLast == true);
- delete canvas;
+ delete window;
}
void tst_qquickpositioners::test_attachedproperties_data()
void tst_qquickpositioners::test_attachedproperties_dynamic()
{
- QQuickView *canvas = createView(testFile("attachedproperties-dynamic.qml"));
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView(testFile("attachedproperties-dynamic.qml"));
+ QVERIFY(window->rootObject() != 0);
- QQuickRow *row = canvas->rootObject()->findChild<QQuickRow *>("pos");
+ QQuickRow *row = window->rootObject()->findChild<QQuickRow *>("pos");
QVERIFY(row != 0);
- QQuickRectangle *rect0 = canvas->rootObject()->findChild<QQuickRectangle *>("rect0");
+ QQuickRectangle *rect0 = window->rootObject()->findChild<QQuickRectangle *>("rect0");
QVERIFY(rect0 != 0);
int posIndex = rect0->property("index").toInt();
bool isLast = rect0->property("lastItem").toBool();
QVERIFY(isLast == false);
- QQuickRectangle *rect1 = canvas->rootObject()->findChild<QQuickRectangle *>("rect1");
+ QQuickRectangle *rect1 = window->rootObject()->findChild<QQuickRectangle *>("rect1");
QVERIFY(rect1 != 0);
posIndex = rect1->property("index").toInt();
QTRY_VERIFY(rect1->property("firstItem").toBool() == false);
QTRY_VERIFY(rect1->property("lastItem").toBool() == false);
- QQuickRectangle *rect2 = canvas->rootObject()->findChild<QQuickRectangle *>("rect2");
+ QQuickRectangle *rect2 = window->rootObject()->findChild<QQuickRectangle *>("rect2");
QVERIFY(rect2 != 0);
posIndex = rect2->property("index").toInt();
QTRY_VERIFY(rect1->property("firstItem").toBool() == false);
QTRY_VERIFY(rect1->property("lastItem").toBool() == true);
- delete canvas;
+ delete window;
}
QQuickView *tst_qquickpositioners::createView(const QString &filename, bool wait)
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
qDebug() << "1";
- canvas->setSource(QUrl::fromLocalFile(filename));
+ window->setSource(QUrl::fromLocalFile(filename));
qDebug() << "2";
- canvas->show();
+ window->show();
qDebug() << "3";
if (wait)
- QTest::qWaitForWindowShown(canvas); //It may not relayout until the next frame, so it needs to be drawn
+ QTest::qWaitForWindowShown(window); //It may not relayout until the next frame, so it needs to be drawn
qDebug() << "4";
- return canvas;
+ return window;
}
void tst_qquickpositioners::matchIndexLists(const QVariantList &indexLists, const QList<int> &expectedIndexes)
void tst_QQuickRepeater::numberModel()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testData", 5);
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("intmodel.qml"));
+ window->setSource(testFileUrl("intmodel.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
QCOMPARE(repeater->parentItem()->childItems().count(), 5+1);
QCOMPARE(repeater->itemAt(i), repeater->parentItem()->childItems().at(i));
QVERIFY(!repeater->itemAt(repeater->count()));
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QVERIFY(testObject->error() == false);
delete testObject;
- delete canvas;
+ delete window;
}
class MyObject : public QObject
void tst_QQuickRepeater::objectList()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QObjectList data;
for (int i=0; i<100; i++)
data << new MyObject(i);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testData", QVariant::fromValue(data));
- canvas->setSource(testFileUrl("objlist.qml"));
+ window->setSource(testFileUrl("objlist.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
QCOMPARE(repeater->property("errors").toInt(), 0);//If this fails either they are out of order or can't find the object's data
QCOMPARE(repeater->property("instantiated").toInt(), 100);
QCOMPARE(removedSpy.count(), data.count());
qDeleteAll(data);
- delete canvas;
+ delete window;
}
/*
*/
void tst_QQuickRepeater::stringList()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QStringList data;
data << "One";
data << "Three";
data << "Four";
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testData", data);
- canvas->setSource(testFileUrl("repeater1.qml"));
+ window->setSource(testFileUrl("repeater1.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), data.count() + 3);
}
QVERIFY(saw_repeater);
- delete canvas;
+ delete window;
}
void tst_QQuickRepeater::dataModel_adding()
{
- QQuickView *canvas = createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = createView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
QaimModel testModel;
ctxt->setContextProperty("testData", &testModel);
- canvas->setSource(testFileUrl("repeater2.qml"));
+ window->setSource(testFileUrl("repeater2.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
QVERIFY(container != 0);
QVERIFY(!repeater->itemAt(0));
delete testObject;
addedSpy.clear();
countSpy.clear();
- delete canvas;
+ delete window;
}
void tst_QQuickRepeater::dataModel_removing()
{
- QQuickView *canvas = createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = createView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
testModel.addItem("five", "5");
ctxt->setContextProperty("testData", &testModel);
- canvas->setSource(testFileUrl("repeater2.qml"));
+ window->setSource(testFileUrl("repeater2.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), repeater->count()+1);
removedSpy.clear();
delete testObject;
- delete canvas;
+ delete window;
}
void tst_QQuickRepeater::dataModel_changes()
{
- QQuickView *canvas = createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = createView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
testModel.addItem("three", "3");
ctxt->setContextProperty("testData", &testModel);
- canvas->setSource(testFileUrl("repeater2.qml"));
+ window->setSource(testFileUrl("repeater2.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), repeater->count()+1);
// Check that model changes are propagated
- QQuickText *text = findItem<QQuickText>(canvas->rootObject(), "myName", 1);
+ QQuickText *text = findItem<QQuickText>(window->rootObject(), "myName", 1);
QVERIFY(text);
QCOMPARE(text->text(), QString("two"));
testModel.modifyItem(1, "Item two", "_2");
- text = findItem<QQuickText>(canvas->rootObject(), "myName", 1);
+ text = findItem<QQuickText>(window->rootObject(), "myName", 1);
QVERIFY(text);
QCOMPARE(text->text(), QString("Item two"));
- text = findItem<QQuickText>(canvas->rootObject(), "myNumber", 1);
+ text = findItem<QQuickText>(window->rootObject(), "myNumber", 1);
QVERIFY(text);
QCOMPARE(text->text(), QString("_2"));
delete testObject;
- delete canvas;
+ delete window;
}
void tst_QQuickRepeater::itemModel()
{
- QQuickView *canvas = createView();
- QQmlContext *ctxt = canvas->rootContext();
+ QQuickView *window = createView();
+ QQmlContext *ctxt = window->rootContext();
TestObject *testObject = new TestObject;
ctxt->setContextProperty("testObject", testObject);
- canvas->setSource(testFileUrl("itemlist.qml"));
+ window->setSource(testFileUrl("itemlist.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(container->childItems().count(), 1);
testObject->setUseModel(true);
- QMetaObject::invokeMethod(canvas->rootObject(), "checkProperties");
+ QMetaObject::invokeMethod(window->rootObject(), "checkProperties");
QVERIFY(testObject->error() == false);
QCOMPARE(container->childItems().count(), 4);
QVERIFY(qobject_cast<QObject*>(container->childItems().at(2))->objectName() == "item3");
QVERIFY(container->childItems().at(3) == repeater);
- QMetaObject::invokeMethod(canvas->rootObject(), "switchModel");
+ QMetaObject::invokeMethod(window->rootObject(), "switchModel");
QCOMPARE(container->childItems().count(), 3);
QVERIFY(qobject_cast<QObject*>(container->childItems().at(0))->objectName() == "item4");
QVERIFY(qobject_cast<QObject*>(container->childItems().at(1))->objectName() == "item5");
QCOMPARE(container->childItems().count(), 1);
delete testObject;
- delete canvas;
+ delete window;
}
void tst_QQuickRepeater::resetModel()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
QStringList dataA;
for (int i=0; i<10; i++)
dataA << QString::number(i);
- QQmlContext *ctxt = canvas->rootContext();
+ QQmlContext *ctxt = window->rootContext();
ctxt->setContextProperty("testData", dataA);
- canvas->setSource(testFileUrl("repeater1.qml"));
+ window->setSource(testFileUrl("repeater1.qml"));
qApp->processEvents();
- QQuickRepeater *repeater = findItem<QQuickRepeater>(canvas->rootObject(), "repeater");
+ QQuickRepeater *repeater = findItem<QQuickRepeater>(window->rootObject(), "repeater");
QVERIFY(repeater != 0);
- QQuickItem *container = findItem<QQuickItem>(canvas->rootObject(), "container");
+ QQuickItem *container = findItem<QQuickItem>(window->rootObject(), "container");
QVERIFY(container != 0);
QCOMPARE(repeater->count(), dataA.count());
removedSpy.clear();
addedSpy.clear();
- delete canvas;
+ delete window;
}
// QTBUG-17156
void tst_QQuickRepeater::asynchronous()
{
- QQuickView *canvas = createView();
- canvas->show();
+ QQuickView *window = createView();
+ window->show();
QQmlIncubationController controller;
- canvas->engine()->setIncubationController(&controller);
+ window->engine()->setIncubationController(&controller);
- canvas->setSource(testFileUrl("asyncloader.qml"));
+ window->setSource(testFileUrl("asyncloader.qml"));
- QQuickItem *rootObject = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickItem *rootObject = qobject_cast<QQuickItem*>(window->rootObject());
QVERIFY(rootObject);
QQuickItem *container = findItem<QQuickItem>(rootObject, "container");
QTRY_COMPARE(item->y(), i * 50.0);
}
- delete canvas;
+ delete window;
}
void tst_QQuickRepeater::initParent()
void tst_qquickspritesequence::test_properties()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
- canvas->setSource(testFileUrl("basic.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("basic.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QVERIFY(canvas->rootObject());
- QQuickSpriteSequence* sprite = canvas->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
+ QVERIFY(window->rootObject());
+ QQuickSpriteSequence* sprite = window->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
QVERIFY(sprite);
QVERIFY(sprite->running());
sprite->setInterpolate(false);
QVERIFY(!sprite->interpolate());
- delete canvas;
+ delete window;
}
void tst_qquickspritesequence::test_framerateAdvance()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
- canvas->setSource(testFileUrl("advance.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("advance.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
- QVERIFY(canvas->rootObject());
- QQuickSpriteSequence* sprite = canvas->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
+ QVERIFY(window->rootObject());
+ QQuickSpriteSequence* sprite = window->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
QVERIFY(sprite);
QTRY_COMPARE(sprite->currentSprite(), QLatin1String("secondState"));
- delete canvas;
+ delete window;
}
void tst_qquickspritesequence::test_jumpToCrash()
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
- canvas->setSource(testFileUrl("crashonstart.qml"));
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->setSource(testFileUrl("crashonstart.qml"));
+ window->show();
+ QTest::qWaitForWindowShown(window);
//verify: Don't crash
- delete canvas;
+ delete window;
}
QTEST_MAIN(tst_qquickspritesequence)
QQuickView *tst_qquicktext::createView(const QString &filename)
{
- QQuickView *canvas = new QQuickView(0);
+ QQuickView *window = new QQuickView(0);
- canvas->setSource(QUrl::fromLocalFile(filename));
- return canvas;
+ window->setSource(QUrl::fromLocalFile(filename));
+ return window;
}
void tst_qquicktext::text()
void tst_qquicktext::multilineElide()
{
QFETCH(QQuickText::TextFormat, format);
- QQuickView *canvas = createView(testFile("multilineelide.qml"));
+ QQuickView *window = createView(testFile("multilineelide.qml"));
- QQuickText *myText = qobject_cast<QQuickText*>(canvas->rootObject());
+ QQuickText *myText = qobject_cast<QQuickText*>(window->rootObject());
QVERIFY(myText != 0);
myText->setTextFormat(format);
myText->setLineHeight(1.1);
QCOMPARE(myText->lineCount(), 1);
- delete canvas;
+ delete window;
}
void tst_qquicktext::implicitElide_data()
QFETCH(int, vAlign);
QFETCH(QString, expectfile);
- QQuickView *canvas = createView(testFile("alignments.qml"));
- canvas->show();
- canvas->requestActivateWindow();
+ QQuickView *window = createView(testFile("alignments.qml"));
+ window->show();
+ window->requestActivateWindow();
QTest::qWait(50);
- QTRY_COMPARE(QGuiApplication::activeWindow(), static_cast<QWidget *>(canvas));
+ QTRY_COMPARE(QGuiApplication::activeWindow(), static_cast<QWidget *>(window));
- QObject *ob = canvas->rootObject();
+ QObject *ob = window->rootObject();
QVERIFY(ob != 0);
ob->setProperty("horizontalAlignment",hAlign);
ob->setProperty("verticalAlignment",vAlign);
QTRY_COMPARE(ob->property("running").toBool(),false);
- QImage actual(canvas->width(), canvas->height(), QImage::Format_RGB32);
+ QImage actual(window->width(), window->height(), QImage::Format_RGB32);
actual.fill(qRgb(255,255,255));
QPainter p(&actual);
- canvas->render(&p);
+ window->render(&p);
QImage expect(expectfile);
if (QGuiApplicationPrivate::graphics_system_name == "raster" || QGuiApplicationPrivate::graphics_system_name == "") {
QCOMPARE(actual,expect);
}
- delete canvas;
+ delete window;
#endif
}
void tst_qquicktext::horizontalAlignment_RightToLeft()
{
- QQuickView *canvas = createView(testFile("horizontalAlignment_RightToLeft.qml"));
- QQuickText *text = canvas->rootObject()->findChild<QQuickText*>("text");
+ QQuickView *window = createView(testFile("horizontalAlignment_RightToLeft.qml"));
+ QQuickText *text = window->rootObject()->findChild<QQuickText*>("text");
QVERIFY(text != 0);
- canvas->show();
+ window->show();
QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(text);
QVERIFY(textPrivate != 0);
// implicit alignment should follow the reading direction of RTL text
QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > window->width()/2);
// explicitly left aligned text
text->setHAlign(QQuickText::AlignLeft);
QCOMPARE(text->hAlign(), QQuickText::AlignLeft);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < window->width()/2);
// explicitly right aligned text
text->setHAlign(QQuickText::AlignRight);
QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > window->width()/2);
// change to rich text
QString textString = text->text();
text->setHAlign(QQuickText::AlignHCenter);
QCOMPARE(text->hAlign(), QQuickText::AlignHCenter);
QCOMPARE(text->effectiveHAlign(), text->hAlign());
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().right() > canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < window->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().right() > window->width()/2);
// reseted alignment should go back to following the text reading direction
text->resetHAlign();
QCOMPARE(text->hAlign(), QQuickText::AlignRight);
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > window->width()/2);
// mirror the text item
QQuickItemPrivate::get(text)->setLayoutMirror(true);
// mirrored implicit alignment should continue to follow the reading direction of the text
QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), QQuickText::AlignRight);
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > window->width()/2);
// mirrored explicitly right aligned behaves as left aligned
text->setHAlign(QQuickText::AlignRight);
QCOMPARE(text->hAlign(), QQuickText::AlignRight);
QCOMPARE(text->effectiveHAlign(), QQuickText::AlignLeft);
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < window->width()/2);
// mirrored explicitly left aligned behaves as right aligned
text->setHAlign(QQuickText::AlignLeft);
QCOMPARE(text->hAlign(), QQuickText::AlignLeft);
QCOMPARE(text->effectiveHAlign(), QQuickText::AlignRight);
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() > window->width()/2);
// disable mirroring
QQuickItemPrivate::get(text)->setLayoutMirror(false);
// English text should be implicitly left aligned
text->setText("Hello world!");
QCOMPARE(text->hAlign(), QQuickText::AlignLeft);
- QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < canvas->width()/2);
+ QVERIFY(textPrivate->layout.lineAt(0).naturalTextRect().left() < window->width()/2);
// empty text with implicit alignment follows the system locale-based
// keyboard input direction from QInputMethod::inputDirection()
text->setHAlign(QQuickText::AlignRight);
QCOMPARE(text->hAlign(), QQuickText::AlignRight);
- delete canvas;
+ delete window;
// alignment of Text with no text set to it
QString componentStr = "import QtQuick 2.0\nText {}";
{
// Left Align
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int left = numberOfNonWhitePixels(0, image.width() / 3, image);
int mid = numberOfNonWhitePixels(image.width() / 3, 2 * image.width() / 3, image);
int right = numberOfNonWhitePixels( 2 * image.width() / 3, image.width(), image);
{
// HCenter Align
text->setHAlign(QQuickText::AlignHCenter);
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int left = numberOfNonWhitePixels(0, image.width() / 3, image);
int mid = numberOfNonWhitePixels(image.width() / 3, 2 * image.width() / 3, image);
int right = numberOfNonWhitePixels( 2 * image.width() / 3, image.width(), image);
{
// Right Align
text->setHAlign(QQuickText::AlignRight);
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int left = numberOfNonWhitePixels(0, image.width() / 3, image);
int mid = numberOfNonWhitePixels(image.width() / 3, 2 * image.width() / 3, image);
int right = numberOfNonWhitePixels( 2 * image.width() / 3, image.width(), image);
void tst_qquicktext::lineCount()
{
- QQuickView *canvas = createView(testFile("lineCount.qml"));
+ QQuickView *window = createView(testFile("lineCount.qml"));
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QVERIFY(myText->lineCount() > 1);
QCOMPARE(myText->truncated(), true);
QCOMPARE(myText->maximumLineCount(), 2);
- delete canvas;
+ delete window;
}
void tst_qquicktext::lineHeight()
{
- QQuickView *canvas = createView(testFile("lineHeight.qml"));
+ QQuickView *window = createView(testFile("lineHeight.qml"));
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QVERIFY(myText->lineHeight() == 1);
myText->setLineHeight(10);
QCOMPARE(myText->height(), myText->lineCount() * 10.0);
- delete canvas;
+ delete window;
}
void tst_qquicktext::implicitSize_data()
void tst_qquicktext::lineLaidOut()
{
- QQuickView *canvas = createView(testFile("lineLayout.qml"));
+ QQuickView *window = createView(testFile("lineLayout.qml"));
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(myText);
}
}
- delete canvas;
+ delete window;
}
void tst_qquicktext::lineLaidOutRelayout()
{
- QQuickView *canvas = createView(testFile("lineLayoutRelayout.qml"));
+ QQuickView *window = createView(testFile("lineLayoutRelayout.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(myText);
}
}
- delete canvas;
+ delete window;
}
void tst_qquicktext::imgTagsBaseUrl_data()
void tst_qquicktext::imgTagsElide()
{
- QQuickView *canvas = createView(testFile("imgTagsElide.qml"));
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickView *window = createView(testFile("imgTagsElide.qml"));
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QQuickTextPrivate *textPrivate = QQuickTextPrivate::get(myText);
QTRY_VERIFY(textPrivate->visibleImgTags.count() == 1);
delete myText;
- delete canvas;
+ delete window;
}
void tst_qquicktext::imgTagsUpdates()
{
- QQuickView *canvas = createView(testFile("imgTagsUpdates.qml"));
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickView *window = createView(testFile("imgTagsUpdates.qml"));
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
QSignalSpy spy(myText, SIGNAL(contentSizeChanged()));
QVERIFY(spy.count() == 3);
delete myText;
- delete canvas;
+ delete window;
}
void tst_qquicktext::imgTagsError()
{
QFETCH(QString, text);
- QScopedPointer<QQuickView> canvas(createView(testFile("fontSizeMode.qml")));
- canvas->show();
+ QScopedPointer<QQuickView> window(createView(testFile("fontSizeMode.qml")));
+ window->show();
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
myText->setText(text);
{
QFETCH(QString, text);
- QScopedPointer<QQuickView> canvas(createView(testFile("fontSizeMode.qml")));
- canvas->show();
+ QScopedPointer<QQuickView> window(createView(testFile("fontSizeMode.qml")));
+ window->show();
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
myText->setText(text);
{
QFETCH(QString, source);
- QScopedPointer<QQuickView> canvas(createView(source));
- canvas->show();
+ QScopedPointer<QQuickView> window(createView(source));
+ window->show();
- QQuickText *myText = canvas->rootObject()->findChild<QQuickText*>("myText");
+ QQuickText *myText = window->rootObject()->findChild<QQuickText*>("myText");
QVERIFY(myText != 0);
const QString longText = "the quick brown fox jumped over the lazy dog";
QFETCH(int, vAlign);
QFETCH(QString, expectfile);
- QQuickView canvas(testFileUrl("alignments.qml"));
+ QQuickView window(testFileUrl("alignments.qml"));
- canvas.show();
- QTest::qWaitForWindowShown(&canvas);
+ window.show();
+ QTest::qWaitForWindowShown(&window);
- QObject *ob = canvas.rootObject();
+ QObject *ob = window.rootObject();
QVERIFY(ob != 0);
ob->setProperty("horizontalAlignment",hAlign);
ob->setProperty("verticalAlignment",vAlign);
QTRY_COMPARE(ob->property("running").toBool(),false);
- QImage actual = canvas.grabFrameBuffer();
+ QImage actual = window.grabWindow();
expectfile = createExpectedFileIfNotFound(expectfile, actual);
QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod());
inputMethodPrivate->testContext = &platformInputContext;
- QQuickView canvas(testFileUrl("horizontalAlignment_RightToLeft.qml"));
- QQuickTextEdit *textEdit = canvas.rootObject()->findChild<QQuickTextEdit*>("text");
+ QQuickView window(testFileUrl("horizontalAlignment_RightToLeft.qml"));
+ QQuickTextEdit *textEdit = window.rootObject()->findChild<QQuickTextEdit*>("text");
QVERIFY(textEdit != 0);
- canvas.show();
+ window.show();
const QString rtlText = textEdit->text();
// implicit alignment should follow the reading direction of text
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// explicitly left aligned
textEdit->setHAlign(QQuickTextEdit::AlignLeft);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
- QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2);
// explicitly right aligned
textEdit->setHAlign(QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
QString textString = textEdit->text();
textEdit->setText(QString("<i>") + textString + QString("</i>"));
// implicitly aligned rich text should follow the reading direction of RTL text
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign());
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// explicitly left aligned rich text
textEdit->setHAlign(QQuickTextEdit::AlignLeft);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign());
- QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2);
// explicitly right aligned rich text
textEdit->setHAlign(QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign());
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
textEdit->setText(textString);
// explicitly center aligned
textEdit->setHAlign(QQuickTextEdit::AlignHCenter);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignHCenter);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// reseted alignment should go back to following the text reading direction
textEdit->resetHAlign();
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// mirror the text item
QQuickItemPrivate::get(textEdit)->setLayoutMirror(true);
// mirrored implicit alignment should continue to follow the reading direction of the text
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// mirrored explicitly right aligned behaves as left aligned
textEdit->setHAlign(QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignLeft);
- QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2);
// mirrored explicitly left aligned behaves as right aligned
textEdit->setHAlign(QQuickTextEdit::AlignLeft);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// disable mirroring
QQuickItemPrivate::get(textEdit)->setLayoutMirror(false);
// English text should be implicitly left aligned
textEdit->setText("Hello world!");
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
- QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2);
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textEdit->hasActiveFocus());
textEdit->setText(QString());
platformInputContext.setInputDirection(Qt::LeftToRight);
QVERIFY(qApp->inputMethod()->inputDirection() == Qt::LeftToRight);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft);
- QVERIFY(textEdit->positionToRectangle(0).x() < canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2);
QSignalSpy cursorRectangleSpy(textEdit, SIGNAL(cursorRectangleChanged()));
QCOMPARE(cursorRectangleSpy.count(), 1);
QVERIFY(qApp->inputMethod()->inputDirection() == Qt::RightToLeft);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// neutral text follows also input method direction
textEdit->resetHAlign();
textEdit->setText(" ()((=<>");
platformInputContext.setInputDirection(Qt::LeftToRight);
QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignLeft);
- QVERIFY(textEdit->cursorRectangle().left() < canvas.width()/2);
+ QVERIFY(textEdit->cursorRectangle().left() < window.width()/2);
platformInputContext.setInputDirection(Qt::RightToLeft);
QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->cursorRectangle().left() > canvas.width()/2);
+ QVERIFY(textEdit->cursorRectangle().left() > window.width()/2);
// set input direction while having content
platformInputContext.setInputDirection(Qt::LeftToRight);
textEdit->setText("a");
textEdit->setCursorPosition(1);
platformInputContext.setInputDirection(Qt::RightToLeft);
- QTest::keyClick(&canvas, Qt::Key_Backspace);
+ QTest::keyClick(&window, Qt::Key_Backspace);
QVERIFY(textEdit->text().isEmpty());
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->cursorRectangle().left() > canvas.width()/2);
+ QVERIFY(textEdit->cursorRectangle().left() > window.width()/2);
// input direction changed while not having focus
platformInputContext.setInputDirection(Qt::LeftToRight);
platformInputContext.setInputDirection(Qt::RightToLeft);
textEdit->setFocus(true);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->cursorRectangle().left() > canvas.width()/2);
+ QVERIFY(textEdit->cursorRectangle().left() > window.width()/2);
textEdit->setHAlign(QQuickTextEdit::AlignRight);
QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(textEdit->positionToRectangle(0).x() > canvas.width()/2);
+ QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2);
// make sure editor doesn't rely on input for updating size
- QQuickTextEdit *emptyEdit = canvas.rootObject()->findChild<QQuickTextEdit*>("emptyTextEdit");
+ QQuickTextEdit *emptyEdit = window.rootObject()->findChild<QQuickTextEdit*>("emptyTextEdit");
QVERIFY(emptyEdit != 0);
platformInputContext.setInputDirection(Qt::RightToLeft);
emptyEdit->setFocus(true);
QCOMPARE(emptyEdit->hAlign(), QQuickTextEdit::AlignRight);
- QVERIFY(emptyEdit->cursorRectangle().left() > canvas.width()/2);
+ QVERIFY(emptyEdit->cursorRectangle().left() > window.width()/2);
}
QVERIFY(text != 0);
{
// Left Align
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int left = numberOfNonWhitePixels(0, image.width() / 3, image);
int mid = numberOfNonWhitePixels(image.width() / 3, 2 * image.width() / 3, image);
int right = numberOfNonWhitePixels( 2 * image.width() / 3, image.width(), image);
{
// HCenter Align
text->setHAlign(QQuickText::AlignHCenter);
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int left = numberOfNonWhitePixels(0, image.width() / 3, image);
int mid = numberOfNonWhitePixels(image.width() / 3, 2 * image.width() / 3, image);
int right = numberOfNonWhitePixels( 2 * image.width() / 3, image.width(), image);
{
// Right Align
text->setHAlign(QQuickText::AlignRight);
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int left = numberOfNonWhitePixels(0, image.width() / 3, image);
int mid = numberOfNonWhitePixels(image.width() / 3, 2 * image.width() / 3, image);
int right = numberOfNonWhitePixels( 2 * image.width() / 3, image.width(), image);
{
// Left Align
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int x = qCeil(text->implicitWidth());
int left = numberOfNonWhitePixels(0, x, image);
int right = numberOfNonWhitePixels(x, image.width() - x, image);
{
// HCenter Align
text->setHAlign(QQuickText::AlignHCenter);
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int x1 = qFloor(image.width() - text->implicitWidth()) / 2;
int x2 = image.width() - x1;
int left = numberOfNonWhitePixels(0, x1, image);
{
// Right Align
text->setHAlign(QQuickText::AlignRight);
- QImage image = view.grabFrameBuffer();
+ QImage image = view.grabWindow();
int x = image.width() - qCeil(text->implicitWidth());
int left = numberOfNonWhitePixels(0, x, image);
int right = numberOfNonWhitePixels(x, image.width() - x, image);
void tst_qquicktextedit::persistentSelection()
{
- QQuickView canvas(testFileUrl("persistentSelection.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("persistentSelection.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(window.rootObject());
QVERIFY(edit);
QVERIFY(edit->hasActiveFocus());
QCOMPARE(textEditObject->focusOnPress(), true);
QCOMPARE(activeFocusOnPressSpy.count(), 0);
- QQuickCanvas canvas;
- canvas.resize(100, 50);
- textEditObject->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ window.resize(100, 50);
+ textEditObject->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QCOMPARE(textEditObject->hasFocus(), false);
QCOMPARE(textEditObject->hasActiveFocus(), false);
- QPoint centerPoint(canvas.width()/2, canvas.height()/2);
+ QPoint centerPoint(window.width()/2, window.height()/2);
Qt::KeyboardModifiers noModifiers = 0;
- QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
QGuiApplication::processEvents();
QCOMPARE(textEditObject->hasFocus(), true);
QCOMPARE(textEditObject->hasActiveFocus(), true);
QCOMPARE(focusSpy.count(), 1);
QCOMPARE(activeFocusSpy.count(), 1);
QCOMPARE(textEditObject->selectedText(), QString());
- QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
textEditObject->setFocusOnPress(false);
QCOMPARE(textEditObject->focusOnPress(), false);
// Wait for double click timeout to expire before clicking again.
QTest::qWait(400);
- QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
QGuiApplication::processEvents();
QCOMPARE(textEditObject->hasFocus(), false);
QCOMPARE(textEditObject->hasActiveFocus(), false);
QCOMPARE(focusSpy.count(), 2);
QCOMPARE(activeFocusSpy.count(), 2);
- QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
textEditObject->setFocusOnPress(true);
QCOMPARE(textEditObject->focusOnPress(), true);
textEditObject->setProperty("selectOnFocus", true);
QTest::qWait(400);
- QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
QGuiApplication::processEvents();
QCOMPARE(textEditObject->hasFocus(), true);
QCOMPARE(textEditObject->hasActiveFocus(), true);
QCOMPARE(focusSpy.count(), 3);
QCOMPARE(activeFocusSpy.count(), 3);
QCOMPARE(textEditObject->selectedText(), textEditObject->text());
- QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
}
void tst_qquicktextedit::selection()
void tst_qquicktextedit::keySelection()
{
- QQuickView canvas(testFileUrl("navigation.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("navigation.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(input != 0);
QVERIFY(input->hasActiveFocus());
QSignalSpy spy(input, SIGNAL(selectedTextChanged()));
- simulateKey(&canvas, Qt::Key_Right, Qt::ShiftModifier);
+ simulateKey(&window, Qt::Key_Right, Qt::ShiftModifier);
QVERIFY(input->hasActiveFocus() == true);
QCOMPARE(input->selectedText(), QString("a"));
QCOMPARE(spy.count(), 1);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == true);
QCOMPARE(input->selectedText(), QString());
QCOMPARE(spy.count(), 2);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == false);
QCOMPARE(input->selectedText(), QString());
QCOMPARE(spy.count(), 2);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == true);
QCOMPARE(spy.count(), 2);
- simulateKey(&canvas, Qt::Key_Left, Qt::ShiftModifier);
+ simulateKey(&window, Qt::Key_Left, Qt::ShiftModifier);
QVERIFY(input->hasActiveFocus() == true);
QCOMPARE(input->selectedText(), QString("a"));
QCOMPARE(spy.count(), 3);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == true);
QCOMPARE(input->selectedText(), QString());
QCOMPARE(spy.count(), 4);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == false);
QCOMPARE(input->selectedText(), QString());
QCOMPARE(spy.count(), 4);
QFETCH(bool, focusOnPress);
QFETCH(int, clicks);
- QQuickView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView window(QUrl::fromLocalFile(qmlfile));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(window.rootObject());
QVERIFY(textEditObject != 0);
textEditObject->setFocus(focus);
QPoint p1 = textEditObject->positionToRectangle(from).center().toPoint();
QPoint p2 = textEditObject->positionToRectangle(to).center().toPoint();
if (clicks == 2)
- QTest::mouseClick(&canvas, Qt::LeftButton, Qt::NoModifier, p1);
+ QTest::mouseClick(&window, Qt::LeftButton, Qt::NoModifier, p1);
else if (clicks == 3)
- QTest::mouseDClick(&canvas, Qt::LeftButton, Qt::NoModifier, p1);
- QTest::mousePress(&canvas, Qt::LeftButton, Qt::NoModifier, p1);
- QTest::mouseMove(&canvas, p2);
- QTest::mouseRelease(&canvas, Qt::LeftButton, Qt::NoModifier, p2);
+ QTest::mouseDClick(&window, Qt::LeftButton, Qt::NoModifier, p1);
+ QTest::mousePress(&window, Qt::LeftButton, Qt::NoModifier, p1);
+ QTest::mouseMove(&window, p2);
+ QTest::mouseRelease(&window, Qt::LeftButton, Qt::NoModifier, p2);
QTRY_COMPARE(textEditObject->selectedText(), selectedText);
// Clicking and shift to clicking between the same points should select the same text.
textEditObject->setCursorPosition(0);
if (clicks > 1)
- QTest::mouseDClick(&canvas, Qt::LeftButton, Qt::NoModifier, p1);
+ QTest::mouseDClick(&window, Qt::LeftButton, Qt::NoModifier, p1);
if (clicks != 2)
- QTest::mouseClick(&canvas, Qt::LeftButton, Qt::NoModifier, p1);
- QTest::mouseClick(&canvas, Qt::LeftButton, Qt::ShiftModifier, p2);
+ QTest::mouseClick(&window, Qt::LeftButton, Qt::NoModifier, p1);
+ QTest::mouseClick(&window, Qt::LeftButton, Qt::ShiftModifier, p2);
QTRY_COMPARE(textEditObject->selectedText(), selectedText);
// ### This is to prevent double click detection from carrying over to the next test.
{
QString qmlfile = testFile("mouseselection_true.qml");
- QQuickView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView window(QUrl::fromLocalFile(qmlfile));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(window.rootObject());
QVERIFY(textEditObject != 0);
// press-and-drag-and-release from x1 to x2
int x1 = 10;
int x2 = 70;
int y = QFontMetrics(textEditObject->font()).height() / 2;
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
- QTest::mouseMove(&canvas, QPoint(x2, y));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+ QTest::mouseMove(&window, QPoint(x2, y));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
QTest::qWait(300);
QString str1;
QTRY_VERIFY((str1 = textEditObject->selectedText()).length() > 3);
// press and drag the current selection.
x1 = 40;
x2 = 100;
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
- QTest::mouseMove(&canvas, QPoint(x2, y));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+ QTest::mouseMove(&window, QPoint(x2, y));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
QTest::qWait(300);
QString str2;
QTRY_VERIFY((str2 = textEditObject->selectedText()).length() > 3);
QString text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
- QQuickView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView window(QUrl::fromLocalFile(qmlfile));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(window.rootObject());
QVERIFY(textEditObject != 0);
// press-and-drag-and-release from x1 to x2
int x1 = 10;
int x2 = 70;
int y = textEditObject->height()/2;
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
- QTest::mouseMove(&canvas, QPoint(x2, y));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+ QTest::mouseMove(&window, QPoint(x2, y));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
QString str = textEditObject->selectedText();
if (selectWords) {
QTRY_COMPARE(textEditObject->selectedText(), text);
void tst_qquicktextedit::inputMethodHints()
{
- QQuickView canvas(testFileUrl("inputmethodhints.qml"));
- canvas.show();
- canvas.requestActivateWindow();
+ QQuickView window(testFileUrl("inputmethodhints.qml"));
+ window.show();
+ window.requestActivateWindow();
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(window.rootObject());
QVERIFY(textEditObject != 0);
QVERIFY(textEditObject->inputMethodHints() & Qt::ImhNoPredictiveText);
QSignalSpy inputMethodHintSpy(textEditObject, SIGNAL(inputMethodHintsChanged()));
QFETCH(QQuickTextEdit::HAlignment, horizontalAlignment);
QFETCH(QQuickTextEdit::VAlignment, verticalAlignment);
- QQuickView canvas(testFileUrl("positionAt.qml"));
- QVERIFY(canvas.rootObject() != 0);
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("positionAt.qml"));
+ QVERIFY(window.rootObject() != 0);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(window.rootObject());
QVERIFY(texteditObject != 0);
texteditObject->setHAlign(horizontalAlignment);
texteditObject->setVAlign(verticalAlignment);
void tst_qquicktextedit::linkActivated()
{
- QQuickView canvas(testFileUrl("linkActivated.qml"));
- QVERIFY(canvas.rootObject() != 0);
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("linkActivated.qml"));
+ QVERIFY(window.rootObject() != 0);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(canvas.rootObject());
+ QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(window.rootObject());
QVERIFY(texteditObject != 0);
QSignalSpy spy(texteditObject, SIGNAL(linkActivated(QString)));
const QPointF linkPos = texteditObject->positionToRectangle(7).center();
const QPointF textPos = texteditObject->positionToRectangle(2).center();
- QTest::mouseClick(&canvas, Qt::LeftButton, 0, linkPos.toPoint());
+ QTest::mouseClick(&window, Qt::LeftButton, 0, linkPos.toPoint());
QTRY_COMPARE(spy.count(), 1);
QCOMPARE(spy.last()[0].toString(), link);
- QTest::mouseClick(&canvas, Qt::LeftButton, 0, textPos.toPoint());
+ QTest::mouseClick(&window, Qt::LeftButton, 0, textPos.toPoint());
QTest::qWait(50);
QCOMPARE(spy.count(), 1);
texteditObject->setReadOnly(true);
- QTest::mouseClick(&canvas, Qt::LeftButton, 0, linkPos.toPoint());
+ QTest::mouseClick(&window, Qt::LeftButton, 0, linkPos.toPoint());
QTRY_COMPARE(spy.count(), 2);
QCOMPARE(spy.last()[0].toString(), link);
- QTest::mouseClick(&canvas, Qt::LeftButton, 0, textPos.toPoint());
+ QTest::mouseClick(&window, Qt::LeftButton, 0, textPos.toPoint());
QTest::qWait(50);
QCOMPARE(spy.count(), 2);
}
*/
void tst_qquicktextedit::navigation()
{
- QQuickView canvas(testFileUrl("navigation.qml"));
- canvas.show();
- canvas.requestActivateWindow();
+ QQuickView window(testFileUrl("navigation.qml"));
+ window.show();
+ window.requestActivateWindow();
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(input != 0);
QTRY_VERIFY(input->hasActiveFocus() == true);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == false);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == true);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == true);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == false);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == true);
// Test left and right navigation works if the TextEdit is empty (QTBUG-25447).
input->setText(QString());
QCOMPARE(input->cursorPosition(), 0);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QCOMPARE(input->hasActiveFocus(), false);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QCOMPARE(input->hasActiveFocus(), true);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QCOMPARE(input->hasActiveFocus(), false);
}
void tst_qquicktextedit::readOnly()
{
- QQuickView canvas(testFileUrl("readOnly.qml"));
- canvas.show();
- canvas.requestActivateWindow();
+ QQuickView window(testFileUrl("readOnly.qml"));
+ window.show();
+ window.requestActivateWindow();
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(edit != 0);
QTRY_VERIFY(edit->hasActiveFocus() == true);
QVERIFY(edit->isReadOnly() == true);
QString initial = edit->text();
for (int k=Qt::Key_0; k<=Qt::Key_Z; k++)
- simulateKey(&canvas, k);
- simulateKey(&canvas, Qt::Key_Return);
- simulateKey(&canvas, Qt::Key_Space);
- simulateKey(&canvas, Qt::Key_Escape);
+ simulateKey(&window, k);
+ simulateKey(&window, Qt::Key_Return);
+ simulateKey(&window, Qt::Key_Space);
+ simulateKey(&window, Qt::Key_Escape);
QCOMPARE(edit->text(), initial);
edit->setCursorPosition(3);
void tst_qquicktextedit::cursorRectangleSize()
{
- QQuickView *canvas = new QQuickView(testFileUrl("positionAt.qml"));
- QVERIFY(canvas->rootObject() != 0);
- QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit *>(canvas->rootObject());
+ QQuickView *window = new QQuickView(testFileUrl("positionAt.qml"));
+ QVERIFY(window->rootObject() != 0);
+ QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit *>(window->rootObject());
// make sure cursor rectangle is not at (0,0)
textEdit->setX(10);
textEdit->setCursorPosition(3);
QVERIFY(textEdit != 0);
textEdit->setFocus(true);
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowActive(canvas);
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowActive(window);
QInputMethodQueryEvent event(Qt::ImCursorRectangle);
qApp->sendEvent(textEdit, &event);
// item cursor rectangle and positionToRectangle calculations match
QCOMPARE(cursorRectFromItem, cursorRectFromPositionToRectangle);
- // item-canvas transform and input item transform match
- QCOMPARE(QQuickItemPrivate::get(textEdit)->itemToCanvasTransform(), qApp->inputMethod()->inputItemTransform());
+ // item-window transform and input item transform match
+ QCOMPARE(QQuickItemPrivate::get(textEdit)->itemToWindowTransform(), qApp->inputMethod()->inputItemTransform());
// input panel cursorRectangle property and tranformed item cursor rectangle match
- QRectF sceneCursorRect = QQuickItemPrivate::get(textEdit)->itemToCanvasTransform().mapRect(cursorRectFromItem);
+ QRectF sceneCursorRect = QQuickItemPrivate::get(textEdit)->itemToWindowTransform().mapRect(cursorRectFromItem);
QCOMPARE(sceneCursorRect, qApp->inputMethod()->cursorRectangle());
- delete canvas;
+ delete window;
}
void tst_qquicktextedit::getText_data()
QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(textEditComponent.create());
QVERIFY(textEdit != 0);
- QQuickCanvas canvas;
- textEdit->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textEdit->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textEdit->hasActiveFocus());
- simulateKey(&canvas, layoutDirection);
+ simulateKey(&window, layoutDirection);
textEdit->select(selectionStart, selectionEnd);
- simulateKeys(&canvas, sequence);
+ simulateKeys(&window, sequence);
QCOMPARE(textEdit->cursorPosition(), cursorPosition);
QCOMPARE(textEdit->text(), expectedText);
QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(textEditComponent.create());
QVERIFY(textEdit != 0);
- QQuickCanvas canvas;
- textEdit->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textEdit->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textEdit->hasActiveFocus());
QVERIFY(!textEdit->canUndo());
}
for (int j = 0; j < insertString.at(i).length(); j++)
- QTest::keyClick(&canvas, insertString.at(i).at(j).toLatin1());
+ QTest::keyClick(&window, insertString.at(i).at(j).toLatin1());
}
QCOMPARE(spy.count(), 1);
QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(textEditComponent.create());
QVERIFY(textEdit != 0);
- QQuickCanvas canvas;
- textEdit->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textEdit->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textEdit->hasActiveFocus());
QVERIFY(!textEdit->canUndo());
if (insertIndex[i] > -1)
textEdit->setCursorPosition(insertIndex[i]);
for (int j = 0; j < insertString.at(i).length(); j++)
- QTest::keyClick(&canvas, insertString.at(i).at(j).toLatin1());
+ QTest::keyClick(&window, insertString.at(i).at(j).toLatin1());
QVERIFY(textEdit->canUndo());
QVERIFY(!textEdit->canRedo());
}
QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(textEditComponent.create());
QVERIFY(textEdit != 0);
- QQuickCanvas canvas;
- textEdit->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textEdit->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textEdit->hasActiveFocus());
- simulateKeys(&canvas, keys);
+ simulateKeys(&window, keys);
for (int i = 0; i < expectedString.size(); ++i) {
QCOMPARE(textEdit->text() , expectedString[i]);
void tst_qquicktextedit::emptytags_QTBUG_22058()
{
- QQuickView canvas(testFileUrl("qtbug-22058.qml"));
- QVERIFY(canvas.rootObject() != 0);
+ QQuickView window(testFileUrl("qtbug-22058.qml"));
+ QVERIFY(window.rootObject() != 0);
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
- QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(canvas.rootObject()->property("inputField")));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
+ QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(qvariant_cast<QObject *>(window.rootObject()->property("inputField")));
QVERIFY(input->hasActiveFocus());
QInputMethodEvent event("", QList<QInputMethodEvent::Attribute>());
void tst_qquicktextinput::persistentSelection()
{
- QQuickView canvas(testFileUrl("persistentSelection.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("persistentSelection.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QQuickTextInput *input = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(window.rootObject());
QVERIFY(input);
QVERIFY(input->hasActiveFocus());
{
QString qmlfile = testFile("mouseselection_true.qml");
- QQuickView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView window(QUrl::fromLocalFile(qmlfile));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
QVERIFY(textInputObject != 0);
// press-and-drag-and-release from x1 to x2
int x1 = 10;
int x2 = 70;
int y = textInputObject->height()/2;
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
- QTest::mouseMove(&canvas, QPoint(x2, y));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+ QTest::mouseMove(&window, QPoint(x2, y));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
QTest::qWait(100);
QString str1;
QVERIFY((str1 = textInputObject->selectedText()).length() > 3);
// press and drag the current selection.
x1 = 40;
x2 = 100;
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
- QTest::mouseMove(&canvas, QPoint(x2, y));
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+ QTest::mouseMove(&window, QPoint(x2, y));
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
QTest::qWait(300);
QString str2 = textInputObject->selectedText();
QVERIFY(str2.length() > 3);
QString text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
- QQuickView canvas(QUrl::fromLocalFile(qmlfile));
+ QQuickView window(QUrl::fromLocalFile(qmlfile));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
QVERIFY(textInputObject != 0);
textInputObject->setFocus(focus);
int x1 = 10;
int x2 = 70;
int y = textInputObject->height()/2;
- QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
- QTest::mouseMove(&canvas, QPoint(x2,y)); // doesn't work
- QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+ QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+ QTest::mouseMove(&window, QPoint(x2,y)); // doesn't work
+ QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
QTest::qWait(300);
if (selectWords) {
QTRY_COMPARE(textInputObject->selectedText(), text);
QFETCH(int, hAlign);
QFETCH(QString, expectfile);
- QQuickView canvas(testFileUrl("horizontalAlignment.qml"));
+ QQuickView window(testFileUrl("horizontalAlignment.qml"));
- canvas.show();
- QTest::qWaitForWindowShown(&canvas);
+ window.show();
+ QTest::qWaitForWindowShown(&window);
- QObject *ob = canvas.rootObject();
+ QObject *ob = window.rootObject();
QVERIFY(ob != 0);
ob->setProperty("horizontalAlignment",hAlign);
- QImage actual = canvas.grabFrameBuffer();
+ QImage actual = window.grabWindow();
expectfile = createExpectedFileIfNotFound(expectfile, actual);
QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod());
inputMethodPrivate->testContext = &platformInputContext;
- QQuickView canvas(testFileUrl("horizontalAlignment_RightToLeft.qml"));
- QQuickTextInput *textInput = canvas.rootObject()->findChild<QQuickTextInput*>("text");
+ QQuickView window(testFileUrl("horizontalAlignment_RightToLeft.qml"));
+ QQuickTextInput *textInput = window.rootObject()->findChild<QQuickTextInput*>("text");
QVERIFY(textInput != 0);
- canvas.show();
+ window.show();
const QString rtlText = textInput->text();
QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignLeft);
QCOMPARE(textInput->boundingRect().left(), qreal(0));
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textInput->hasActiveFocus());
// If there is no commited text, the preedit text should determine the alignment.
platformInputContext.setInputDirection(Qt::LeftToRight);
textInput->setText("a");
platformInputContext.setInputDirection(Qt::RightToLeft);
- QTest::keyClick(&canvas, Qt::Key_Backspace);
+ QTest::keyClick(&window, Qt::Key_Backspace);
QVERIFY(textInput->text().isEmpty());
QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
QVERIFY(textInput->boundingRect().right() >= textInput->width() - 1);
void tst_qquicktextinput::verticalAlignment()
{
- QQuickView canvas(testFileUrl("horizontalAlignment.qml"));
- QQuickTextInput *textInput = canvas.rootObject()->findChild<QQuickTextInput*>("text");
+ QQuickView window(testFileUrl("horizontalAlignment.qml"));
+ QQuickTextInput *textInput = window.rootObject()->findChild<QQuickTextInput*>("text");
QVERIFY(textInput != 0);
- canvas.show();
+ window.show();
QCOMPARE(textInput->vAlign(), QQuickTextInput::AlignTop);
- QVERIFY(textInput->boundingRect().bottom() < canvas.height() / 2);
- QVERIFY(textInput->cursorRectangle().bottom() < canvas.height() / 2);
- QVERIFY(textInput->positionToRectangle(0).bottom() < canvas.height() / 2);
+ QVERIFY(textInput->boundingRect().bottom() < window.height() / 2);
+ QVERIFY(textInput->cursorRectangle().bottom() < window.height() / 2);
+ QVERIFY(textInput->positionToRectangle(0).bottom() < window.height() / 2);
// bottom aligned
textInput->setVAlign(QQuickTextInput::AlignBottom);
QCOMPARE(textInput->vAlign(), QQuickTextInput::AlignBottom);
- QVERIFY(textInput->boundingRect().top() > canvas.height() / 2);
- QVERIFY(textInput->cursorRectangle().top() > canvas.height() / 2);
- QVERIFY(textInput->positionToRectangle(0).top() > canvas.height() / 2);
+ QVERIFY(textInput->boundingRect().top() > window.height() / 2);
+ QVERIFY(textInput->cursorRectangle().top() > window.height() / 2);
+ QVERIFY(textInput->positionToRectangle(0).top() > window.height() / 2);
// explicitly center aligned
textInput->setVAlign(QQuickTextInput::AlignVCenter);
QCOMPARE(textInput->vAlign(), QQuickTextInput::AlignVCenter);
- QVERIFY(textInput->boundingRect().top() < canvas.height() / 2);
- QVERIFY(textInput->boundingRect().bottom() > canvas.height() / 2);
- QVERIFY(textInput->cursorRectangle().top() < canvas.height() / 2);
- QVERIFY(textInput->cursorRectangle().bottom() > canvas.height() / 2);
- QVERIFY(textInput->positionToRectangle(0).top() < canvas.height() / 2);
- QVERIFY(textInput->positionToRectangle(0).bottom() > canvas.height() / 2);
+ QVERIFY(textInput->boundingRect().top() < window.height() / 2);
+ QVERIFY(textInput->boundingRect().bottom() > window.height() / 2);
+ QVERIFY(textInput->cursorRectangle().top() < window.height() / 2);
+ QVERIFY(textInput->cursorRectangle().bottom() > window.height() / 2);
+ QVERIFY(textInput->positionToRectangle(0).top() < window.height() / 2);
+ QVERIFY(textInput->positionToRectangle(0).bottom() > window.height() / 2);
}
void tst_qquicktextinput::clipRect()
void tst_qquicktextinput::positionAt()
{
- QQuickView canvas(testFileUrl("positionAt.qml"));
- QVERIFY(canvas.rootObject() != 0);
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("positionAt.qml"));
+ QVERIFY(window.rootObject() != 0);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
QVERIFY(textinputObject != 0);
// Check autoscrolled...
void tst_qquicktextinput::maxLength()
{
- QQuickView canvas(testFileUrl("maxLength.qml"));
- QVERIFY(canvas.rootObject() != 0);
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("maxLength.qml"));
+ QVERIFY(window.rootObject() != 0);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
QVERIFY(textinputObject != 0);
QVERIFY(textinputObject->text().isEmpty());
QVERIFY(textinputObject->maxLength() == 10);
QTRY_VERIFY(textinputObject->hasActiveFocus() == true);
for (int i=0; i<20; i++) {
QTRY_COMPARE(textinputObject->text().length(), qMin(i,10));
- //simulateKey(&canvas, Qt::Key_A);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ //simulateKey(&window, Qt::Key_A);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
}
}
{
//Not a comprehensive test of the possible masks, that's done elsewhere (QLineEdit)
//QString componentStr = "import QtQuick 2.0\nTextInput { inputMask: 'HHHHhhhh'; }";
- QQuickView canvas(testFileUrl("masks.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+ QQuickView window(testFileUrl("masks.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
QVERIFY(textinputObject != 0);
QTRY_VERIFY(textinputObject->hasActiveFocus() == true);
QVERIFY(textinputObject->text().length() == 0);
QCOMPARE(textinputObject->getText(0, qMin(i, 8)), QString(qMin(i, 8), 'a'));
QCOMPARE(textinputObject->getText(qMin(i, 8), 8), QString(8 - qMin(i, 8), ' '));
QCOMPARE(i>=4, textinputObject->hasAcceptableInput());
- //simulateKey(&canvas, Qt::Key_A);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ //simulateKey(&window, Qt::Key_A);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
}
}
QLocale::setDefault(QLocale(QStringLiteral("C")));
- QQuickView canvas(testFileUrl("validators.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("validators.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
QLocale defaultLocale;
QLocale enLocale("en");
QLocale deLocale("de_DE");
- QQuickTextInput *intInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("intInput")));
+ QQuickTextInput *intInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("intInput")));
QVERIFY(intInput);
QSignalSpy intSpy(intInput, SIGNAL(acceptableInputChanged()));
QTRY_VERIFY(intInput->hasActiveFocus());
QCOMPARE(intInput->hasAcceptableInput(), false);
QCOMPARE(intInput->property("acceptable").toBool(), false);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(intInput->text(), QLatin1String("1"));
QCOMPARE(intInput->hasAcceptableInput(), false);
QCOMPARE(intInput->property("acceptable").toBool(), false);
QCOMPARE(intSpy.count(), 0);
- QTest::keyPress(&canvas, Qt::Key_2);
- QTest::keyRelease(&canvas, Qt::Key_2, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_2);
+ QTest::keyRelease(&window, Qt::Key_2, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(intInput->text(), QLatin1String("1"));
QCOMPARE(intInput->hasAcceptableInput(), false);
QCOMPARE(intInput->property("acceptable").toBool(), false);
QCOMPARE(intSpy.count(), 0);
- QTest::keyPress(&canvas, Qt::Key_Period);
- QTest::keyRelease(&canvas, Qt::Key_Period, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Period);
+ QTest::keyRelease(&window, Qt::Key_Period, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(intInput->text(), QLatin1String("1"));
QCOMPARE(intInput->hasAcceptableInput(), false);
- QTest::keyPress(&canvas, Qt::Key_Comma);
- QTest::keyRelease(&canvas, Qt::Key_Comma, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Comma);
+ QTest::keyRelease(&window, Qt::Key_Comma, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(intInput->text(), QLatin1String("1,"));
QCOMPARE(intInput->hasAcceptableInput(), false);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(intInput->text(), QLatin1String("1"));
QCOMPARE(intInput->hasAcceptableInput(), false);
intValidator->setLocaleName(deLocale.name());
- QTest::keyPress(&canvas, Qt::Key_Period);
- QTest::keyRelease(&canvas, Qt::Key_Period, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Period);
+ QTest::keyRelease(&window, Qt::Key_Period, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(intInput->text(), QLatin1String("1."));
QCOMPARE(intInput->hasAcceptableInput(), false);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(intInput->text(), QLatin1String("1"));
QCOMPARE(intInput->hasAcceptableInput(), false);
intValidator->resetLocaleName();
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QCOMPARE(intInput->text(), QLatin1String("11"));
QCOMPARE(intInput->hasAcceptableInput(), true);
QCOMPARE(intInput->property("acceptable").toBool(), true);
QCOMPARE(intSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_0);
- QTest::keyRelease(&canvas, Qt::Key_0, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_0);
+ QTest::keyRelease(&window, Qt::Key_0, Qt::NoModifier ,10);
QTest::qWait(50);
QCOMPARE(intInput->text(), QLatin1String("11"));
QCOMPARE(intInput->hasAcceptableInput(), true);
QCOMPARE(intInput->property("acceptable").toBool(), true);
QCOMPARE(intSpy.count(), 1);
- QQuickTextInput *dblInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("dblInput")));
+ QQuickTextInput *dblInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("dblInput")));
QVERIFY(dblInput);
QSignalSpy dblSpy(dblInput, SIGNAL(acceptableInputChanged()));
QVERIFY(dblInput->hasActiveFocus() == true);
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("1"));
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
QCOMPARE(dblSpy.count(), 0);
- QTest::keyPress(&canvas, Qt::Key_2);
- QTest::keyRelease(&canvas, Qt::Key_2, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_2);
+ QTest::keyRelease(&window, Qt::Key_2, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
QCOMPARE(dblInput->property("acceptable").toBool(), true);
QCOMPARE(dblSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_Comma);
- QTest::keyRelease(&canvas, Qt::Key_Comma, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Comma);
+ QTest::keyRelease(&window, Qt::Key_Comma, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12,"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12,"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
dblValidator->setLocaleName(deLocale.name());
QCOMPARE(dblInput->hasAcceptableInput(), true);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12,1"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12,11"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12,1"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12,"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
dblValidator->resetLocaleName();
- QTest::keyPress(&canvas, Qt::Key_Period);
- QTest::keyRelease(&canvas, Qt::Key_Period, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Period);
+ QTest::keyRelease(&window, Qt::Key_Period, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12."));
QCOMPARE(dblInput->hasAcceptableInput(), true);
QCOMPARE(dblInput->property("acceptable").toBool(), true);
QCOMPARE(dblSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12.1"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
QCOMPARE(dblInput->property("acceptable").toBool(), true);
QCOMPARE(dblSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12.11"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
QCOMPARE(dblInput->property("acceptable").toBool(), true);
QCOMPARE(dblSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12.11"));
QCOMPARE(dblInput->hasAcceptableInput(), true);
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
QCOMPARE(dblSpy.count(), 2);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12.1"));
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
QCOMPARE(dblSpy.count(), 2);
// Once unacceptable input is in anything goes until it reaches an acceptable state again.
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12.11"));
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblSpy.count(), 2);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12.1"));
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
QCOMPARE(dblSpy.count(), 2);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12."));
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
QCOMPARE(dblSpy.count(), 2);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("12"));
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
QCOMPARE(dblSpy.count(), 2);
- QTest::keyPress(&canvas, Qt::Key_Backspace);
- QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_Backspace);
+ QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(dblInput->text(), QLatin1String("1"));
QCOMPARE(dblInput->hasAcceptableInput(), false);
QCOMPARE(dblInput->property("acceptable").toBool(), false);
QCOMPARE(dblSpy.count(), 2);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QCOMPARE(dblInput->text(), QLatin1String("11"));
QCOMPARE(dblInput->property("acceptable").toBool(), true);
QCOMPARE(dblInput->hasAcceptableInput(), true);
QCOMPARE(dblSpy.count(), 5);
- QQuickTextInput *strInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("strInput")));
+ QQuickTextInput *strInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("strInput")));
QVERIFY(strInput);
QSignalSpy strSpy(strInput, SIGNAL(acceptableInputChanged()));
strInput->setFocus(true);
QVERIFY(strInput->hasActiveFocus() == true);
QCOMPARE(strInput->hasAcceptableInput(), false);
QCOMPARE(strInput->property("acceptable").toBool(), false);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(strInput->text(), QLatin1String(""));
QCOMPARE(strInput->hasAcceptableInput(), false);
QCOMPARE(strInput->property("acceptable").toBool(), false);
QCOMPARE(strSpy.count(), 0);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(strInput->text(), QLatin1String("a"));
QCOMPARE(strInput->hasAcceptableInput(), false);
QCOMPARE(strInput->property("acceptable").toBool(), false);
QCOMPARE(strSpy.count(), 0);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(strInput->text(), QLatin1String("aa"));
QCOMPARE(strInput->hasAcceptableInput(), true);
QCOMPARE(strInput->property("acceptable").toBool(), true);
QCOMPARE(strSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(strInput->text(), QLatin1String("aaa"));
QCOMPARE(strInput->hasAcceptableInput(), true);
QCOMPARE(strInput->property("acceptable").toBool(), true);
QCOMPARE(strSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(strInput->text(), QLatin1String("aaaa"));
QCOMPARE(strInput->hasAcceptableInput(), true);
QCOMPARE(strInput->property("acceptable").toBool(), true);
QCOMPARE(strSpy.count(), 1);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(strInput->text(), QLatin1String("aaaa"));
QCOMPARE(strInput->hasAcceptableInput(), true);
QCOMPARE(strInput->property("acceptable").toBool(), true);
QCOMPARE(strSpy.count(), 1);
- QQuickTextInput *unvalidatedInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("unvalidatedInput")));
+ QQuickTextInput *unvalidatedInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("unvalidatedInput")));
QVERIFY(unvalidatedInput);
QSignalSpy unvalidatedSpy(unvalidatedInput, SIGNAL(acceptableInputChanged()));
unvalidatedInput->setFocus(true);
QVERIFY(unvalidatedInput->hasActiveFocus() == true);
QCOMPARE(unvalidatedInput->hasAcceptableInput(), true);
QCOMPARE(unvalidatedInput->property("acceptable").toBool(), true);
- QTest::keyPress(&canvas, Qt::Key_1);
- QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_1);
+ QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(unvalidatedInput->text(), QLatin1String("1"));
QCOMPARE(unvalidatedInput->hasAcceptableInput(), true);
QCOMPARE(unvalidatedInput->property("acceptable").toBool(), true);
QCOMPARE(unvalidatedSpy.count(), 0);
- QTest::keyPress(&canvas, Qt::Key_A);
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_A);
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QTest::qWait(50);
QTRY_COMPARE(unvalidatedInput->text(), QLatin1String("1a"));
QCOMPARE(unvalidatedInput->hasAcceptableInput(), true);
void tst_qquicktextinput::inputMethods()
{
- QQuickView canvas(testFileUrl("inputmethods.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("inputmethods.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
// test input method hints
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(window.rootObject());
QVERIFY(input != 0);
QVERIFY(input->inputMethodHints() & Qt::ImhNoPredictiveText);
QSignalSpy inputMethodHintSpy(input, SIGNAL(inputMethodHintsChanged()));
*/
void tst_qquicktextinput::navigation()
{
- QQuickView canvas(testFileUrl("navigation.qml"));
- canvas.show();
- canvas.requestActivateWindow();
+ QQuickView window(testFileUrl("navigation.qml"));
+ window.show();
+ window.requestActivateWindow();
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(input != 0);
input->setCursorPosition(0);
QTRY_VERIFY(input->hasActiveFocus() == true);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == false);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == true);
//QT-2944: If text is selected, ensure we deselect upon cursor motion
input->setCursorPosition(input->text().length());
input->select(0,input->text().length());
QVERIFY(input->selectionStart() != input->selectionEnd());
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->selectionStart() == input->selectionEnd());
QVERIFY(input->selectionStart() == input->text().length());
QVERIFY(input->hasActiveFocus() == true);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == false);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == true);
// Up and Down should NOT do Home/End, even on Mac OS X (QTBUG-10438).
input->setCursorPosition(2);
QCOMPARE(input->cursorPosition(),2);
- simulateKey(&canvas, Qt::Key_Up);
+ simulateKey(&window, Qt::Key_Up);
QCOMPARE(input->cursorPosition(),2);
- simulateKey(&canvas, Qt::Key_Down);
+ simulateKey(&window, Qt::Key_Down);
QCOMPARE(input->cursorPosition(),2);
// Test left and right navigation works if the TextInput is empty (QTBUG-25447).
input->setText(QString());
QCOMPARE(input->cursorPosition(), 0);
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QCOMPARE(input->hasActiveFocus(), false);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QCOMPARE(input->hasActiveFocus(), true);
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QCOMPARE(input->hasActiveFocus(), false);
}
void tst_qquicktextinput::navigation_RTL()
{
- QQuickView canvas(testFileUrl("navigation.qml"));
- canvas.show();
- canvas.requestActivateWindow();
+ QQuickView window(testFileUrl("navigation.qml"));
+ window.show();
+ window.requestActivateWindow();
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(input != 0);
const quint16 arabic_str[] = { 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0647};
QTRY_VERIFY(input->hasActiveFocus() == true);
// move off
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == false);
// move back
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == true);
input->setCursorPosition(input->text().length());
QVERIFY(input->hasActiveFocus() == true);
// move off
- simulateKey(&canvas, Qt::Key_Left);
+ simulateKey(&window, Qt::Key_Left);
QVERIFY(input->hasActiveFocus() == false);
// move back
- simulateKey(&canvas, Qt::Key_Right);
+ simulateKey(&window, Qt::Key_Right);
QVERIFY(input->hasActiveFocus() == true);
}
QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
- QQuickCanvas canvas;
- textInput->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textInput->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
// copy and paste
QVERIFY(textInput->hasActiveFocus());
QCOMPARE(textInput->text().length(), 12);
textInput->select(0, textInput->text().length());
- simulateKeys(&canvas, QKeySequence::Copy);
+ simulateKeys(&window, QKeySequence::Copy);
QCOMPARE(textInput->selectedText(), QString("Hello world!"));
QCOMPARE(textInput->selectedText().length(), 12);
textInput->setCursorPosition(0);
QVERIFY(textInput->canPaste());
- simulateKeys(&canvas, QKeySequence::Paste);
+ simulateKeys(&window, QKeySequence::Paste);
QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
QCOMPARE(textInput->text().length(), 24);
// select all and cut
- simulateKeys(&canvas, QKeySequence::SelectAll);
- simulateKeys(&canvas, QKeySequence::Cut);
+ simulateKeys(&window, QKeySequence::SelectAll);
+ simulateKeys(&window, QKeySequence::Cut);
QCOMPARE(textInput->text().length(), 0);
- simulateKeys(&canvas, QKeySequence::Paste);
+ simulateKeys(&window, QKeySequence::Paste);
QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
QCOMPARE(textInput->text().length(), 24);
textInput->setEchoMode(echoMode);
textInput->setText("My password");
textInput->select(0, textInput->text().length());
- simulateKeys(&canvas, QKeySequence::Copy);
+ simulateKeys(&window, QKeySequence::Copy);
if (echoMode == QQuickTextInput::Normal) {
QVERIFY(!clipboard->text().isEmpty());
QCOMPARE(clipboard->text(), QString("My password"));
void tst_qquicktextinput::readOnly()
{
- QQuickView canvas(testFileUrl("readOnly.qml"));
- canvas.show();
- canvas.requestActivateWindow();
+ QQuickView window(testFileUrl("readOnly.qml"));
+ window.show();
+ window.requestActivateWindow();
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(input != 0);
QTRY_VERIFY(input->hasActiveFocus() == true);
QVERIFY(input->isReadOnly() == true);
QString initial = input->text();
for (int k=Qt::Key_0; k<=Qt::Key_Z; k++)
- simulateKey(&canvas, k);
- simulateKey(&canvas, Qt::Key_Return);
- simulateKey(&canvas, Qt::Key_Space);
- simulateKey(&canvas, Qt::Key_Escape);
+ simulateKey(&window, k);
+ simulateKey(&window, Qt::Key_Return);
+ simulateKey(&window, Qt::Key_Space);
+ simulateKey(&window, Qt::Key_Escape);
QCOMPARE(input->text(), initial);
input->setCursorPosition(3);
void tst_qquicktextinput::echoMode()
{
- QQuickView canvas(testFileUrl("echoMode.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("echoMode.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(input != 0);
QTRY_VERIFY(input->hasActiveFocus() == true);
QCOMPARE(input->text(), initial);
QCOMPARE(input->displayText(), QLatin1String("QQQQQQQQ"));
QCOMPARE(input->inputMethodQuery(Qt::ImSurroundingText).toString(), QLatin1String("QQQQQQQQ"));
- QTest::keyPress(&canvas, Qt::Key_A);//Clearing previous entry is part of PasswordEchoOnEdit
- QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+ QTest::keyPress(&window, Qt::Key_A);//Clearing previous entry is part of PasswordEchoOnEdit
+ QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
QCOMPARE(input->text(), QLatin1String("a"));
QCOMPARE(input->displayText(), QLatin1String("a"));
QCOMPARE(input->inputMethodQuery(Qt::ImSurroundingText).toString(), QLatin1String("a"));
int maskDelay = qGuiApp->styleHints()->passwordMaskDelay();
if (maskDelay <= 0)
QSKIP("No mask delay in use");
- QQuickView canvas(testFileUrl("echoMode.qml"));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickView window(testFileUrl("echoMode.qml"));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
- QVERIFY(canvas.rootObject() != 0);
+ QVERIFY(window.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+ QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
QVERIFY(input);
QVERIFY(input->hasActiveFocus());
input->setText(QString());
QCOMPARE(input->displayText(), QString());
- QTest::keyPress(&canvas, '0');
- QTest::keyPress(&canvas, '1');
- QTest::keyPress(&canvas, '2');
+ QTest::keyPress(&window, '0');
+ QTest::keyPress(&window, '1');
+ QTest::keyPress(&window, '2');
QCOMPARE(input->displayText(), QString(2, fillChar) + QLatin1Char('2'));
- QTest::keyPress(&canvas, '3');
- QTest::keyPress(&canvas, '4');
+ QTest::keyPress(&window, '3');
+ QTest::keyPress(&window, '4');
QCOMPARE(input->displayText(), QString(4, fillChar) + QLatin1Char('4'));
- QTest::keyPress(&canvas, Qt::Key_Backspace);
+ QTest::keyPress(&window, Qt::Key_Backspace);
QCOMPARE(input->displayText(), QString(4, fillChar));
- QTest::keyPress(&canvas, '4');
+ QTest::keyPress(&window, '4');
QCOMPARE(input->displayText(), QString(4, fillChar) + QLatin1Char('4'));
QCOMPARE(input->cursorRectangle().topLeft(), cursor->pos());
QCOMPARE(cursorSpy.count(), 1);
QCOMPARE(input->cursorRectangle().topLeft(), cursor->pos());
- QTest::keyPress(&canvas, '5');
+ QTest::keyPress(&window, '5');
QCOMPARE(input->displayText(), QString(5, fillChar) + QLatin1Char('5'));
input->setFocus(false);
QVERIFY(!input->hasFocus());
input->setFocus(true);
QTRY_VERIFY(input->hasFocus());
QCOMPARE(input->displayText(), QString(6, fillChar));
- QTest::keyPress(&canvas, '6');
+ QTest::keyPress(&window, '6');
QCOMPARE(input->displayText(), QString(6, fillChar) + QLatin1Char('6'));
QInputMethodEvent ev;
input->setCursorPosition(3);
QCOMPARE(input->displayText(), QString(7, fillChar) + QLatin1Char('7'));
- QTest::keyPress(&canvas, 'a');
+ QTest::keyPress(&window, 'a');
QCOMPARE(input->displayText(), QString(3, fillChar) + QLatin1Char('a') + QString(5, fillChar));
- QTest::keyPress(&canvas, Qt::Key_Backspace);
+ QTest::keyPress(&window, Qt::Key_Backspace);
QCOMPARE(input->displayText(), QString(8, fillChar));
}
QCOMPARE(textInputObject->focusOnPress(), true);
QCOMPARE(activeFocusOnPressSpy.count(), 0);
- QQuickCanvas canvas;
- canvas.resize(100, 50);
- textInputObject->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ window.resize(100, 50);
+ textInputObject->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QCOMPARE(textInputObject->hasFocus(), false);
QCOMPARE(textInputObject->hasActiveFocus(), false);
- QPoint centerPoint(canvas.width()/2, canvas.height()/2);
+ QPoint centerPoint(window.width()/2, window.height()/2);
Qt::KeyboardModifiers noModifiers = 0;
- QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
QGuiApplication::processEvents();
QCOMPARE(textInputObject->hasFocus(), true);
QCOMPARE(textInputObject->hasActiveFocus(), true);
QCOMPARE(focusSpy.count(), 1);
QCOMPARE(activeFocusSpy.count(), 1);
QCOMPARE(textInputObject->selectedText(), QString());
- QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
textInputObject->setFocusOnPress(false);
QCOMPARE(textInputObject->focusOnPress(), false);
// Wait for double click timeout to expire before clicking again.
QTest::qWait(400);
- QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
QGuiApplication::processEvents();
QCOMPARE(textInputObject->hasFocus(), false);
QCOMPARE(textInputObject->hasActiveFocus(), false);
QCOMPARE(focusSpy.count(), 2);
QCOMPARE(activeFocusSpy.count(), 2);
- QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
textInputObject->setFocusOnPress(true);
QCOMPARE(textInputObject->focusOnPress(), true);
textInputObject->setProperty("selectOnFocus", true);
QTest::qWait(400);
- QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
QGuiApplication::processEvents();
QCOMPARE(textInputObject->hasFocus(), true);
QCOMPARE(textInputObject->hasActiveFocus(), true);
QCOMPARE(focusSpy.count(), 3);
QCOMPARE(activeFocusSpy.count(), 3);
QCOMPARE(textInputObject->selectedText(), textInputObject->text());
- QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+ QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
}
void tst_qquicktextinput::openInputPanel()
void tst_qquicktextinput::cursorRectangleSize()
{
- QQuickView *canvas = new QQuickView(testFileUrl("positionAt.qml"));
- QVERIFY(canvas->rootObject() != 0);
- QQuickTextInput *textInput = qobject_cast<QQuickTextInput *>(canvas->rootObject());
+ QQuickView *window = new QQuickView(testFileUrl("positionAt.qml"));
+ QVERIFY(window->rootObject() != 0);
+ QQuickTextInput *textInput = qobject_cast<QQuickTextInput *>(window->rootObject());
// make sure cursor rectangle is not at (0,0)
textInput->setX(10);
textInput->setCursorPosition(3);
QVERIFY(textInput != 0);
textInput->setFocus(true);
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowActive(canvas);
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowActive(window);
QVERIFY(textInput->hasActiveFocus());
QInputMethodQueryEvent event(Qt::ImCursorRectangle);
// item cursor rectangle and positionToRectangle calculations match
QCOMPARE(cursorRectFromItem, cursorRectFromPositionToRectangle);
- // item-canvas transform and input item transform match
- QCOMPARE(QQuickItemPrivate::get(textInput)->itemToCanvasTransform(), qApp->inputMethod()->inputItemTransform());
+ // item-window transform and input item transform match
+ QCOMPARE(QQuickItemPrivate::get(textInput)->itemToWindowTransform(), qApp->inputMethod()->inputItemTransform());
// input panel cursorRectangle property and tranformed item cursor rectangle match
- QRectF sceneCursorRect = QQuickItemPrivate::get(textInput)->itemToCanvasTransform().mapRect(cursorRectFromItem);
+ QRectF sceneCursorRect = QQuickItemPrivate::get(textInput)->itemToWindowTransform().mapRect(cursorRectFromItem);
QCOMPARE(sceneCursorRect, qApp->inputMethod()->cursorRectangle());
- delete canvas;
+ delete window;
}
void tst_qquicktextinput::tripleClickSelectsAll()
QVERIFY(textInput != 0);
textInput->setEchoMode(echoMode);
- QQuickCanvas canvas;
- textInput->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textInput->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textInput->hasActiveFocus());
- simulateKey(&canvas, layoutDirection);
+ simulateKey(&window, layoutDirection);
textInput->select(selectionStart, selectionEnd);
- simulateKeys(&canvas, sequence);
+ simulateKeys(&window, sequence);
QCOMPARE(textInput->cursorPosition(), cursorPosition);
QCOMPARE(textInput->text(), expectedText);
QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
- QQuickCanvas canvas;
- textInput->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textInput->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textInput->hasActiveFocus());
QVERIFY(!textInput->canUndo());
}
for (int j = 0; j < insertString.at(i).length(); j++)
- QTest::keyClick(&canvas, insertString.at(i).at(j).toLatin1());
+ QTest::keyClick(&window, insertString.at(i).at(j).toLatin1());
}
QCOMPARE(spy.count(), 1);
QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
- QQuickCanvas canvas;
- textInput->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textInput->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textInput->hasActiveFocus());
QVERIFY(!textInput->canUndo());
if (insertIndex[i] > -1)
textInput->setCursorPosition(insertIndex[i]);
for (int j = 0; j < insertString.at(i).length(); j++)
- QTest::keyClick(&canvas, insertString.at(i).at(j).toLatin1());
+ QTest::keyClick(&window, insertString.at(i).at(j).toLatin1());
QVERIFY(textInput->canUndo());
QVERIFY(!textInput->canRedo());
}
QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
- QQuickCanvas canvas;
- textInput->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textInput->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textInput->hasActiveFocus());
- simulateKeys(&canvas, keys);
+ simulateKeys(&window, keys);
for (int i = 0; i < expectedString.size(); ++i) {
QCOMPARE(textInput->text() , expectedString[i]);
{
QFETCH(QString, url);
- QQuickView canvas(testFileUrl(url));
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput*>(canvas.rootObject());
+ QQuickView window(testFileUrl(url));
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextInput *input = qobject_cast<QQuickTextInput*>(window.rootObject());
QVERIFY(input);
input->setFocus(true);
QVERIFY(input->hasActiveFocus());
- QCOMPARE(canvas.rootObject()->property("topvalue").toInt(), 30);
- QCOMPARE(canvas.rootObject()->property("bottomvalue").toInt(), 10);
- QCOMPARE(canvas.rootObject()->property("text").toString(), QString("20"));
- QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+ QCOMPARE(window.rootObject()->property("topvalue").toInt(), 30);
+ QCOMPARE(window.rootObject()->property("bottomvalue").toInt(), 10);
+ QCOMPARE(window.rootObject()->property("text").toString(), QString("20"));
+ QVERIFY(window.rootObject()->property("acceptableInput").toBool());
- canvas.rootObject()->setProperty("topvalue", 15);
- QCOMPARE(canvas.rootObject()->property("topvalue").toInt(), 15);
- QVERIFY(!canvas.rootObject()->property("acceptableInput").toBool());
+ window.rootObject()->setProperty("topvalue", 15);
+ QCOMPARE(window.rootObject()->property("topvalue").toInt(), 15);
+ QVERIFY(!window.rootObject()->property("acceptableInput").toBool());
- canvas.rootObject()->setProperty("topvalue", 25);
- QCOMPARE(canvas.rootObject()->property("topvalue").toInt(), 25);
- QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+ window.rootObject()->setProperty("topvalue", 25);
+ QCOMPARE(window.rootObject()->property("topvalue").toInt(), 25);
+ QVERIFY(window.rootObject()->property("acceptableInput").toBool());
- canvas.rootObject()->setProperty("bottomvalue", 21);
- QCOMPARE(canvas.rootObject()->property("bottomvalue").toInt(), 21);
- QVERIFY(!canvas.rootObject()->property("acceptableInput").toBool());
+ window.rootObject()->setProperty("bottomvalue", 21);
+ QCOMPARE(window.rootObject()->property("bottomvalue").toInt(), 21);
+ QVERIFY(!window.rootObject()->property("acceptableInput").toBool());
- canvas.rootObject()->setProperty("bottomvalue", 10);
- QCOMPARE(canvas.rootObject()->property("bottomvalue").toInt(), 10);
- QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+ window.rootObject()->setProperty("bottomvalue", 10);
+ QCOMPARE(window.rootObject()->property("bottomvalue").toInt(), 10);
+ QVERIFY(window.rootObject()->property("acceptableInput").toBool());
}
void tst_qquicktextinput::QTBUG_19956_regexp()
QString warning = url.toString() + ":11: Unable to assign [undefined] to QRegExp";
QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
- QQuickView canvas(url);
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
- QVERIFY(canvas.rootObject() != 0);
- QQuickTextInput *input = qobject_cast<QQuickTextInput*>(canvas.rootObject());
+ QQuickView window(url);
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
+ QVERIFY(window.rootObject() != 0);
+ QQuickTextInput *input = qobject_cast<QQuickTextInput*>(window.rootObject());
QVERIFY(input);
input->setFocus(true);
QVERIFY(input->hasActiveFocus());
- canvas.rootObject()->setProperty("regexvalue", QRegExp("abc"));
- QCOMPARE(canvas.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
- QCOMPARE(canvas.rootObject()->property("text").toString(), QString("abc"));
- QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+ window.rootObject()->setProperty("regexvalue", QRegExp("abc"));
+ QCOMPARE(window.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
+ QCOMPARE(window.rootObject()->property("text").toString(), QString("abc"));
+ QVERIFY(window.rootObject()->property("acceptableInput").toBool());
- canvas.rootObject()->setProperty("regexvalue", QRegExp("abcd"));
- QCOMPARE(canvas.rootObject()->property("regexvalue").toRegExp(), QRegExp("abcd"));
- QVERIFY(!canvas.rootObject()->property("acceptableInput").toBool());
+ window.rootObject()->setProperty("regexvalue", QRegExp("abcd"));
+ QCOMPARE(window.rootObject()->property("regexvalue").toRegExp(), QRegExp("abcd"));
+ QVERIFY(!window.rootObject()->property("acceptableInput").toBool());
- canvas.rootObject()->setProperty("regexvalue", QRegExp("abc"));
- QCOMPARE(canvas.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
- QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+ window.rootObject()->setProperty("regexvalue", QRegExp("abc"));
+ QCOMPARE(window.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
+ QVERIFY(window.rootObject()->property("acceptableInput").toBool());
}
void tst_qquicktextinput::implicitSize_data()
if (insert_text) {
textInput->insert(0, input);
} else {
- QQuickCanvas canvas;
- textInput->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textInput->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textInput->hasActiveFocus());
- simulateKey(&canvas, Qt::Key_Home);
+ simulateKey(&window, Qt::Key_Home);
for (int i = 0; i < input.length(); i++)
- QTest::keyClick(&canvas, input.at(i).toLatin1());
+ QTest::keyClick(&window, input.at(i).toLatin1());
}
QEXPECT_FAIL( "keys blank=input", "To eat blanks or not? Known issue. Task 43172", Abort);
QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
QVERIFY(textInput != 0);
- QQuickCanvas canvas;
- textInput->setParentItem(canvas.rootItem());
- canvas.show();
- canvas.requestActivateWindow();
- QTest::qWaitForWindowActive(&canvas);
+ QQuickWindow window;
+ textInput->setParentItem(window.rootItem());
+ window.show();
+ window.requestActivateWindow();
+ QTest::qWaitForWindowActive(&window);
QVERIFY(textInput->hasActiveFocus());
- simulateKeys(&canvas, keys);
+ simulateKeys(&window, keys);
QCOMPARE(textInput->text(), expectedText);
QCOMPARE(textInput->displayText(), expectedDisplayText);
QWindow window;
window.setGeometry(0, 0, 400, 400);
- QQuickView *canvas = new QQuickView(&window);
- QVERIFY(canvas);
- canvas->setResizeMode(QQuickView::SizeRootObjectToView);
- QCOMPARE(QSize(0,0), canvas->initialSize());
- canvas->setSource(testFileUrl("resizemodeitem.qml"));
- QQuickItem* item = qobject_cast<QQuickItem*>(canvas->rootObject());
+ QQuickView *view = new QQuickView(&window);
+ QVERIFY(view);
+ view->setResizeMode(QQuickView::SizeRootObjectToView);
+ QCOMPARE(QSize(0,0), view->initialSize());
+ view->setSource(testFileUrl("resizemodeitem.qml"));
+ QQuickItem* item = qobject_cast<QQuickItem*>(view->rootObject());
QVERIFY(item);
window.show();
- canvas->show();
+ view->show();
// initial size from root object
QCOMPARE(item->width(), 200.0);
QCOMPARE(item->height(), 200.0);
- QCOMPARE(canvas->size(), QSize(200, 200));
- QCOMPARE(canvas->size(), canvas->sizeHint());
- QCOMPARE(canvas->size(), canvas->initialSize());
+ QCOMPARE(view->size(), QSize(200, 200));
+ QCOMPARE(view->size(), view->sizeHint());
+ QCOMPARE(view->size(), view->initialSize());
// size update from view
- canvas->resize(QSize(80,100));
+ view->resize(QSize(80,100));
QTRY_COMPARE(item->width(), 80.0);
QCOMPARE(item->height(), 100.0);
- QCOMPARE(canvas->size(), QSize(80, 100));
- QCOMPARE(canvas->size(), canvas->sizeHint());
+ QCOMPARE(view->size(), QSize(80, 100));
+ QCOMPARE(view->size(), view->sizeHint());
- canvas->setResizeMode(QQuickView::SizeViewToRootObject);
+ view->setResizeMode(QQuickView::SizeViewToRootObject);
// size update from view disabled
- canvas->resize(QSize(60,80));
+ view->resize(QSize(60,80));
QCOMPARE(item->width(), 80.0);
QCOMPARE(item->height(), 100.0);
QTest::qWait(50);
- QCOMPARE(canvas->size(), QSize(60, 80));
+ QCOMPARE(view->size(), QSize(60, 80));
// size update from root object
item->setWidth(250);
item->setHeight(350);
QCOMPARE(item->width(), 250.0);
QCOMPARE(item->height(), 350.0);
- QTRY_COMPARE(canvas->size(), QSize(250, 350));
- QCOMPARE(canvas->size(), QSize(250, 350));
- QCOMPARE(canvas->size(), canvas->sizeHint());
+ QTRY_COMPARE(view->size(), QSize(250, 350));
+ QCOMPARE(view->size(), QSize(250, 350));
+ QCOMPARE(view->size(), view->sizeHint());
- // reset canvas
+ // reset window
window.hide();
- delete canvas;
- canvas = new QQuickView(&window);
- QVERIFY(canvas);
- canvas->setResizeMode(QQuickView::SizeViewToRootObject);
- canvas->setSource(testFileUrl("resizemodeitem.qml"));
- item = qobject_cast<QQuickItem*>(canvas->rootObject());
+ delete view;
+ view = new QQuickView(&window);
+ QVERIFY(view);
+ view->setResizeMode(QQuickView::SizeViewToRootObject);
+ view->setSource(testFileUrl("resizemodeitem.qml"));
+ item = qobject_cast<QQuickItem*>(view->rootObject());
QVERIFY(item);
window.show();
- canvas->show();
+ view->show();
// initial size for root object
QCOMPARE(item->width(), 200.0);
QCOMPARE(item->height(), 200.0);
- QCOMPARE(canvas->size(), canvas->sizeHint());
- QCOMPARE(canvas->size(), canvas->initialSize());
+ QCOMPARE(view->size(), view->sizeHint());
+ QCOMPARE(view->size(), view->initialSize());
// size update from root object
item->setWidth(80);
item->setHeight(100);
QCOMPARE(item->width(), 80.0);
QCOMPARE(item->height(), 100.0);
- QTRY_COMPARE(canvas->size(), QSize(80, 100));
- QCOMPARE(canvas->size(), QSize(80, 100));
- QCOMPARE(canvas->size(), canvas->sizeHint());
+ QTRY_COMPARE(view->size(), QSize(80, 100));
+ QCOMPARE(view->size(), QSize(80, 100));
+ QCOMPARE(view->size(), view->sizeHint());
// size update from root object disabled
- canvas->setResizeMode(QQuickView::SizeRootObjectToView);
+ view->setResizeMode(QQuickView::SizeRootObjectToView);
item->setWidth(60);
item->setHeight(80);
- QCOMPARE(canvas->width(), 80);
- QCOMPARE(canvas->height(), 100);
- QCOMPARE(QSize(item->width(), item->height()), canvas->sizeHint());
+ QCOMPARE(view->width(), 80);
+ QCOMPARE(view->height(), 100);
+ QCOMPARE(QSize(item->width(), item->height()), view->sizeHint());
// size update from view
- canvas->resize(QSize(200,300));
+ view->resize(QSize(200,300));
QTest::qWait(50);
QCOMPARE(item->width(), 200.0);
QCOMPARE(item->height(), 300.0);
- QCOMPARE(canvas->size(), QSize(200, 300));
- QCOMPARE(canvas->size(), canvas->sizeHint());
+ QCOMPARE(view->size(), QSize(200, 300));
+ QCOMPARE(view->size(), view->sizeHint());
window.hide();
- delete canvas;
+ delete view;
// if we set a specific size for the view then it should keep that size
// for SizeRootObjectToView mode.
- canvas = new QQuickView(&window);
- canvas->resize(300, 300);
- canvas->setResizeMode(QQuickView::SizeRootObjectToView);
- QCOMPARE(QSize(0,0), canvas->initialSize());
- canvas->setSource(testFileUrl("resizemodeitem.qml"));
- canvas->resize(300, 300);
- item = qobject_cast<QQuickItem*>(canvas->rootObject());
+ view = new QQuickView(&window);
+ view->resize(300, 300);
+ view->setResizeMode(QQuickView::SizeRootObjectToView);
+ QCOMPARE(QSize(0,0), view->initialSize());
+ view->setSource(testFileUrl("resizemodeitem.qml"));
+ view->resize(300, 300);
+ item = qobject_cast<QQuickItem*>(view->rootObject());
QVERIFY(item);
window.show();
- canvas->show();
+ view->show();
QTest::qWait(50);
// initial size from root object
QCOMPARE(item->width(), 300.0);
QCOMPARE(item->height(), 300.0);
- QCOMPARE(canvas->size(), QSize(300, 300));
- QCOMPARE(canvas->size(), canvas->sizeHint());
- QCOMPARE(canvas->initialSize(), QSize(200, 200)); // initial object size
+ QCOMPARE(view->size(), QSize(300, 300));
+ QCOMPARE(view->size(), view->sizeHint());
+ QCOMPARE(view->initialSize(), QSize(200, 200)); // initial object size
- delete canvas;
+ delete view;
}
static void silentErrorsMsgHandler(QtMsgType, const char *)
void tst_QQuickView::errors()
{
- QQuickView *canvas = new QQuickView;
- QVERIFY(canvas);
+ QQuickView *view = new QQuickView;
+ QVERIFY(view);
QtMsgHandler old = qInstallMsgHandler(silentErrorsMsgHandler);
- canvas->setSource(testFileUrl("error1.qml"));
+ view->setSource(testFileUrl("error1.qml"));
qInstallMsgHandler(old);
- QVERIFY(canvas->status() == QQuickView::Error);
- QVERIFY(canvas->errors().count() == 1);
- delete canvas;
+ QVERIFY(view->status() == QQuickView::Error);
+ QVERIFY(view->errors().count() == 1);
+ delete view;
}
void tst_QQuickView::engine()
QQmlEngine *engine = new QQmlEngine;
QVERIFY(!engine->incubationController());
- QQuickView *canvas = new QQuickView(engine, 0);
- QVERIFY(canvas);
- QVERIFY(engine->incubationController() == canvas->incubationController());
+ QQuickView *view = new QQuickView(engine, 0);
+ QVERIFY(view);
+ QVERIFY(engine->incubationController() == view->incubationController());
- QQuickView *canvas2 = new QQuickView(engine, 0);
- QVERIFY(canvas);
- QVERIFY(engine->incubationController() == canvas->incubationController());
- delete canvas;
+ QQuickView *view2 = new QQuickView(engine, 0);
+ QVERIFY(view);
+ QVERIFY(engine->incubationController() == view->incubationController());
+ delete view;
QVERIFY(!engine->incubationController());
- engine->setIncubationController(canvas2->incubationController());
- QVERIFY(engine->incubationController() == canvas2->incubationController());
- delete canvas2;
+ engine->setIncubationController(view2->incubationController());
+ QVERIFY(engine->incubationController() == view2->incubationController());
+ delete view2;
QVERIFY(!engine->incubationController());
- QQuickView *canvas3 = new QQuickView;
- QQuickView *canvas4 = new QQuickView(canvas3->engine(), 0);
+ QQuickView *view3 = new QQuickView;
+ QQuickView *view4 = new QQuickView(view3->engine(), 0);
- QVERIFY(canvas3->engine());
- QVERIFY(canvas4->engine());
- QCOMPARE(canvas3->engine(), canvas4->engine());
- delete canvas3;
- QVERIFY(!canvas4->engine());
+ QVERIFY(view3->engine());
+ QVERIFY(view4->engine());
+ QCOMPARE(view3->engine(), view4->engine());
+ delete view3;
+ QVERIFY(!view4->engine());
QTest::ignoreMessage(QtWarningMsg, "QQuickView: invalid qml engine. ");
- canvas4->setSource(QUrl());
+ view4->setSource(QUrl());
- QCOMPARE(canvas4->status(), QQuickView::Error);
- QVERIFY(!canvas4->errors().isEmpty());
- QCOMPARE(canvas4->errors().back().description(), QLatin1String("QQuickView: invalid qml engine."));
- delete canvas4;
+ QCOMPARE(view4->status(), QQuickView::Error);
+ QVERIFY(!view4->errors().isEmpty());
+ QCOMPARE(view4->errors().back().description(), QLatin1String("QQuickView: invalid qml engine."));
+ delete view4;
}
QTEST_MAIN(tst_QQuickView)
QFETCH(QString, property);
QFETCH(QStringList, propertyData);
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.loadUrl(source);
QScopedPointer<QObject> object(component.create());
QQuickListView *listView = qobject_cast<QQuickListView *>(object.data());
QVERIFY(listView);
- listView->setParentItem(canvas.rootItem());
+ listView->setParentItem(window.rootItem());
QQuickItem *contentItem = listView->contentItem();
QVERIFY(contentItem);
QFETCH(QString, property);
QFETCH(QStringList, propertyData);
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.loadUrl(source);
QScopedPointer<QObject> object(component.create());
QQuickListView *listView = qobject_cast<QQuickListView *>(object.data());
QVERIFY(listView);
- listView->setParentItem(canvas.rootItem());
+ listView->setParentItem(window.rootItem());
QQuickItem *contentItem = listView->contentItem();
QVERIFY(contentItem);
QFETCH(QString, warning);
QFETCH(int, count);
- QQuickCanvas canvas;
+ QQuickWindow window;
QQmlComponent component(&engine);
component.loadUrl(source);
QScopedPointer<QObject> object(component.create());
QQuickListView *listView = qobject_cast<QQuickListView *>(object.data());
QVERIFY(listView);
- listView->setParentItem(canvas.rootItem());
+ listView->setParentItem(window.rootItem());
QQuickItem *contentItem = listView->contentItem();
QVERIFY(contentItem);
CONFIG += testcase
-TARGET = tst_qquickcanvas
-SOURCES += tst_qquickcanvas.cpp
+TARGET = tst_qquickwindow
+SOURCES += tst_qquickwindow.cpp
include (../../shared/util.pri)
#include <QDebug>
#include <QTouchEvent>
#include <QtQuick/QQuickItem>
-#include <QtQuick/QQuickCanvas>
+#include <QtQuick/QQuickWindow>
#include <QtQml/QQmlEngine>
#include <QtQml/QQmlComponent>
#include <QtQuick/private/qquickrectangle_p.h>
#include "../../shared/util.h"
#include <QSignalSpy>
-#include <private/qquickcanvas_p.h>
+#include <private/qquickwindow_p.h>
#include <private/qguiapplication_p.h>
struct TouchEventData {
tp.setLastPos(last);
tp.setScenePos(item->mapToScene(p));
tp.setLastScenePos(item->mapToScene(last));
- tp.setScreenPos(item->canvas()->mapToGlobal(tp.scenePos().toPoint()));
- tp.setLastScreenPos(item->canvas()->mapToGlobal(tp.lastScenePos().toPoint()));
+ tp.setScreenPos(item->window()->mapToGlobal(tp.scenePos().toPoint()));
+ tp.setLastScreenPos(item->window()->mapToGlobal(tp.lastScenePos().toPoint()));
return tp;
}
Q_INVOKABLE QQuickItem *rootItem()
{
if (!m_rootItem) {
- QQuickCanvasPrivate *c = QQuickCanvasPrivate::get(canvas());
+ QQuickWindowPrivate *c = QQuickWindowPrivate::get(window());
m_rootItem = c->rootItem;
QObject::connect(m_rootItem, SIGNAL(destroyed()), this, SLOT(rootItemDestroyed()));
}
setEnabled(true);
setVisible(true);
- lastEvent = makeTouchData(QEvent::None, canvas(), 0, QList<QTouchEvent::TouchPoint>());//CHECK_VALID
+ lastEvent = makeTouchData(QEvent::None, window(), 0, QList<QTouchEvent::TouchPoint>());//CHECK_VALID
lastVelocity = lastVelocityFromMouseMove = QVector2D();
lastMousePos = QPointF();
}
};
-class tst_qquickcanvas : public QQmlDataTest
+class tst_qquickwindow : public QQmlDataTest
{
Q_OBJECT
public:
void mouseFromTouch_basic();
- void clearCanvas();
+ void clearWindow();
void qmlCreation();
void clearColor();
};
//If the item calls update inside updatePaintNode, it should schedule another update
-void tst_qquickcanvas::constantUpdates()
+void tst_qquickwindow::constantUpdates()
{
- QQuickCanvas canvas;
- canvas.resize(250, 250);
- ConstantUpdateItem item(canvas.rootItem());
- canvas.show();
+ QQuickWindow window;
+ window.resize(250, 250);
+ ConstantUpdateItem item(window.rootItem());
+ window.show();
QTRY_VERIFY(item.iterations > 60);
}
-void tst_qquickcanvas::touchEvent_basic()
+void tst_qquickwindow::touchEvent_basic()
{
TestTouchItem::clearMousePressCounter();
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
- TestTouchItem *bottomItem = new TestTouchItem(canvas->rootItem());
+ TestTouchItem *bottomItem = new TestTouchItem(window->rootItem());
bottomItem->setObjectName("Bottom Item");
bottomItem->setSize(QSizeF(150, 150));
QPointF pos(10, 10);
// press single point
- QTest::touchEvent(canvas, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),canvas);
+ QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window);
QTest::qWait(50);
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
- // At one point this was failing with kwin (KDE window manager) because canvas->setPos(100, 100)
- // would put the decorated window at that position rather than the canvas itself.
- COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed, makeTouchPoint(topItem, pos)));
+ // At one point this was failing with kwin (KDE window manager) because window->setPos(100, 100)
+ // would put the decorated window at that position rather than the window itself.
+ COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(topItem, pos)));
topItem->reset();
// press multiple points
- QTest::touchEvent(canvas, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),canvas)
- .press(1, bottomItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window)
+ .press(1, bottomItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
- COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed, makeTouchPoint(topItem, pos)));
- COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed, makeTouchPoint(bottomItem, pos)));
+ 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)));
topItem->reset();
bottomItem->reset();
// touch point on top item moves to bottom item, but top item should still receive the event
- QTest::touchEvent(canvas, touchDevice).press(0, topItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
- QTest::touchEvent(canvas, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
- COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchUpdate, canvas, Qt::TouchPointMoved,
+ COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchUpdate, window, Qt::TouchPointMoved,
makeTouchPoint(topItem, topItem->mapFromItem(bottomItem, pos), pos)));
topItem->reset();
// touch point on bottom item moves to top item, but bottom item should still receive the event
- QTest::touchEvent(canvas, touchDevice).press(0, bottomItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).press(0, bottomItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
- QTest::touchEvent(canvas, touchDevice).move(0, topItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).move(0, topItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
- COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchUpdate, canvas, Qt::TouchPointMoved,
+ COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchUpdate, window, Qt::TouchPointMoved,
makeTouchPoint(bottomItem, bottomItem->mapFromItem(topItem, pos), pos)));
bottomItem->reset();
// a single stationary press on an item shouldn't cause an event
- QTest::touchEvent(canvas, touchDevice).press(0, topItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
- QTest::touchEvent(canvas, touchDevice).stationary(0)
- .press(1, bottomItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).stationary(0)
+ .press(1, bottomItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1); // received press only, not stationary
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
- COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed, makeTouchPoint(topItem, pos)));
- COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed, makeTouchPoint(bottomItem, pos)));
+ 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)));
topItem->reset();
bottomItem->reset();
// cleanup: what is pressed must be released
// Otherwise you will get an assertion failure:
- // ASSERT: "itemForTouchPointId.isEmpty()" in file items/qquickcanvas.cpp
- QTest::touchEvent(canvas, touchDevice).release(0, pos.toPoint(), canvas).release(1, pos.toPoint(), canvas);
+ // ASSERT: "itemForTouchPointId.isEmpty()" in file items/qquickwindow.cpp
+ QTest::touchEvent(window, touchDevice).release(0, pos.toPoint(), window).release(1, pos.toPoint(), window);
// move touch point from top item to bottom, and release
- QTest::touchEvent(canvas, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),canvas);
+ QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window);
QTest::qWait(50);
- QTest::touchEvent(canvas, touchDevice).release(0, bottomItem->mapToScene(pos).toPoint(),canvas);
+ QTest::touchEvent(window, touchDevice).release(0, bottomItem->mapToScene(pos).toPoint(),window);
QTest::qWait(50);
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
- COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchEnd, canvas, Qt::TouchPointReleased,
+ COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchEnd, window, Qt::TouchPointReleased,
makeTouchPoint(topItem, topItem->mapFromItem(bottomItem, pos), pos)));
topItem->reset();
// release while another point is pressed
- QTest::touchEvent(canvas, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),canvas)
- .press(1, bottomItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).press(0, topItem->mapToScene(pos).toPoint(),window)
+ .press(1, bottomItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
- QTest::touchEvent(canvas, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), canvas);
+ QTest::touchEvent(window, touchDevice).move(0, bottomItem->mapToScene(pos).toPoint(), window);
QTest::qWait(50);
- QTest::touchEvent(canvas, touchDevice).release(0, bottomItem->mapToScene(pos).toPoint(), canvas)
+ QTest::touchEvent(window, touchDevice).release(0, bottomItem->mapToScene(pos).toPoint(), window)
.stationary(1);
QTest::qWait(50);
QCOMPARE(topItem->lastEvent.touchPoints.count(), 1);
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 1);
- COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchEnd, canvas, Qt::TouchPointReleased,
+ COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchEnd, window, Qt::TouchPointReleased,
makeTouchPoint(topItem, topItem->mapFromItem(bottomItem, pos))));
- COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed, makeTouchPoint(bottomItem, pos)));
+ COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(bottomItem, pos)));
topItem->reset();
bottomItem->reset();
delete topItem;
delete middleItem;
delete bottomItem;
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::touchEvent_propagation()
+void tst_qquickwindow::touchEvent_propagation()
{
TestTouchItem::clearMousePressCounter();
QFETCH(bool, enableItem);
QFETCH(bool, showItem);
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
- TestTouchItem *bottomItem = new TestTouchItem(canvas->rootItem());
+ TestTouchItem *bottomItem = new TestTouchItem(window->rootItem());
bottomItem->setObjectName("Bottom Item");
bottomItem->setSize(QSizeF(150, 150));
topItem->setVisible(showItem);
// single touch to top item, should be received by middle item
- QTest::touchEvent(canvas, touchDevice).press(0, pointInTopItem, canvas);
+ QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window);
QTest::qWait(50);
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(middleItem->lastEvent.touchPoints.count(), 1);
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
- COMPARE_TOUCH_DATA(middleItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed,
+ COMPARE_TOUCH_DATA(middleItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
makeTouchPoint(middleItem, middleItem->mapFromItem(topItem, pos))));
// touch top and middle items, middle item should get both events
- QTest::touchEvent(canvas, touchDevice).press(0, pointInTopItem, canvas)
- .press(1, pointInMiddleItem, canvas);
+ QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window)
+ .press(1, pointInMiddleItem, window);
QTest::qWait(50);
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(middleItem->lastEvent.touchPoints.count(), 2);
QVERIFY(bottomItem->lastEvent.touchPoints.isEmpty());
- COMPARE_TOUCH_DATA(middleItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed,
+ COMPARE_TOUCH_DATA(middleItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
(QList<QTouchEvent::TouchPoint>() << makeTouchPoint(middleItem, middleItem->mapFromItem(topItem, pos))
<< makeTouchPoint(middleItem, pos) )));
middleItem->reset();
middleItem->setVisible(showItem);
// touch top and middle items, bottom item should get all events
- QTest::touchEvent(canvas, touchDevice).press(0, pointInTopItem, canvas)
- .press(1, pointInMiddleItem, canvas);
+ QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window)
+ .press(1, pointInMiddleItem, window);
QTest::qWait(50);
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
QCOMPARE(bottomItem->lastEvent.touchPoints.count(), 2);
- COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed,
+ COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
(QList<QTouchEvent::TouchPoint>() << makeTouchPoint(bottomItem, bottomItem->mapFromItem(topItem, pos))
<< makeTouchPoint(bottomItem, bottomItem->mapFromItem(middleItem, pos)) )));
bottomItem->reset();
bottomItem->setVisible(showItem);
// no events should be received
- QTest::touchEvent(canvas, touchDevice).press(0, pointInTopItem, canvas)
- .press(1, pointInMiddleItem, canvas)
- .press(2, pointInBottomItem, canvas);
+ QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window)
+ .press(1, pointInMiddleItem, window)
+ .press(2, pointInBottomItem, window);
QTest::qWait(50);
QVERIFY(topItem->lastEvent.touchPoints.isEmpty());
QVERIFY(middleItem->lastEvent.touchPoints.isEmpty());
middleItem->acceptTouchEvents = acceptTouchEvents;
middleItem->setEnabled(enableItem);
middleItem->setVisible(showItem);
- QTest::touchEvent(canvas, touchDevice).press(0, pointInTopItem, canvas);
+ QTest::touchEvent(window, touchDevice).press(0, pointInTopItem, window);
QTest::qWait(50);
if (!enableItem || !showItem) {
// 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);
- COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed,
+ COMPARE_TOUCH_DATA(bottomItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
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());
- COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed,
+ COMPARE_TOUCH_DATA(topItem->lastEvent, makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed,
makeTouchPoint(topItem, pos)));
}
delete topItem;
delete middleItem;
delete bottomItem;
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::touchEvent_propagation_data()
+void tst_qquickwindow::touchEvent_propagation_data()
{
QTest::addColumn<bool>("acceptTouchEvents");
QTest::addColumn<bool>("acceptMouseEvents");
QTest::newRow("hide item") << true << true << true << false;
}
-void tst_qquickcanvas::touchEvent_cancel()
+void tst_qquickwindow::touchEvent_cancel()
{
TestTouchItem::clearMousePressCounter();
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
- TestTouchItem *item = new TestTouchItem(canvas->rootItem());
+ TestTouchItem *item = new TestTouchItem(window->rootItem());
item->setPos(QPointF(50, 50));
item->setSize(QSizeF(150, 150));
QPointF pos(10, 10);
- QTest::touchEvent(canvas, touchDevice).press(0, item->mapToScene(pos).toPoint(),canvas);
+ QTest::touchEvent(window, touchDevice).press(0, item->mapToScene(pos).toPoint(),window);
QCoreApplication::processEvents();
QTRY_COMPARE(item->lastEvent.touchPoints.count(), 1);
- TouchEventData d = makeTouchData(QEvent::TouchBegin, canvas, Qt::TouchPointPressed, makeTouchPoint(item,pos));
+ TouchEventData d = makeTouchData(QEvent::TouchBegin, window, Qt::TouchPointPressed, makeTouchPoint(item,pos));
COMPARE_TOUCH_DATA(item->lastEvent, d);
item->reset();
QWindowSystemInterface::handleTouchCancelEvent(0, touchDevice);
QCoreApplication::processEvents();
- d = makeTouchData(QEvent::TouchCancel, canvas);
+ d = makeTouchData(QEvent::TouchCancel, window);
COMPARE_TOUCH_DATA(item->lastEvent, d);
delete item;
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::touchEvent_reentrant()
+void tst_qquickwindow::touchEvent_reentrant()
{
TestTouchItem::clearMousePressCounter();
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
- TestTouchItem *item = new TestTouchItem(canvas->rootItem());
+ TestTouchItem *item = new TestTouchItem(window->rootItem());
item->spinLoopWhenPressed = true; // will call processEvents() from the touch handler
QPointF pos(60, 60);
// None of these should commit from the dtor.
- QTest::QTouchEventSequence press = QTest::touchEvent(canvas, touchDevice, false).press(0, pos.toPoint(), canvas);
+ QTest::QTouchEventSequence press = QTest::touchEvent(window, touchDevice, false).press(0, pos.toPoint(), window);
pos += QPointF(2, 2);
- QTest::QTouchEventSequence move = QTest::touchEvent(canvas, touchDevice, false).move(0, pos.toPoint(), canvas);
- QTest::QTouchEventSequence release = QTest::touchEvent(canvas, touchDevice, false).release(0, pos.toPoint(), canvas);
+ 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);
// Now commit (i.e. call QWindowSystemInterface::handleTouchEvent), but do not process the events yet.
press.commit(false);
QTRY_COMPARE(item->touchEventCount, 3);
delete item;
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::touchEvent_velocity()
+void tst_qquickwindow::touchEvent_velocity()
{
TestTouchItem::clearMousePressCounter();
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
QTest::qWait(10);
- TestTouchItem *item = new TestTouchItem(canvas->rootItem());
+ TestTouchItem *item = new TestTouchItem(window->rootItem());
item->setPos(QPointF(50, 50));
item->setSize(QSizeF(150, 150));
QWindowSystemInterface::TouchPoint tp;
tp.id = 1;
tp.state = Qt::TouchPointPressed;
- QPoint pos = canvas->mapToGlobal(item->mapToScene(QPointF(10, 10)).toPoint());
+ QPoint pos = window->mapToGlobal(item->mapToScene(QPointF(10, 10)).toPoint());
tp.area = QRectF(pos, QSizeF(4, 4));
points << tp;
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
points[0].state = Qt::TouchPointMoved;
points[0].area.adjust(5, 5, 5, 5);
QVector2D velocity(1.5, 2.5);
points[0].velocity = velocity;
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
QCoreApplication::processEvents();
QCOMPARE(item->touchEventCount, 2);
QCOMPARE(item->lastEvent.touchPoints.count(), 1);
transformMatrix.rotate(-90, 0, 0, 1); // counterclockwise
QVector2D transformedVelocity = transformMatrix.mapVector(velocity).toVector2D();
points[0].area.adjust(5, 5, 5, 5);
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
QCoreApplication::processEvents();
QCOMPARE(item->lastVelocity, transformedVelocity);
- QPoint itemLocalPos = item->mapFromScene(canvas->mapFromGlobal(points[0].area.center().toPoint())).toPoint();
+ QPoint itemLocalPos = item->mapFromScene(window->mapFromGlobal(points[0].area.center().toPoint())).toPoint();
QPoint itemLocalPosFromEvent = item->lastEvent.touchPoints[0].pos().toPoint();
QCOMPARE(itemLocalPos, itemLocalPosFromEvent);
points[0].state = Qt::TouchPointReleased;
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
QCoreApplication::processEvents();
delete item;
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::mouseFromTouch_basic()
+void tst_qquickwindow::mouseFromTouch_basic()
{
// 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 *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
QTest::qWait(10);
- TestTouchItem *item = new TestTouchItem(canvas->rootItem());
+ TestTouchItem *item = new TestTouchItem(window->rootItem());
item->setPos(QPointF(50, 50));
item->setSize(QSizeF(150, 150));
item->acceptTouchEvents = false;
QWindowSystemInterface::TouchPoint tp;
tp.id = 1;
tp.state = Qt::TouchPointPressed;
- QPoint pos = canvas->mapToGlobal(item->mapToScene(QPointF(10, 10)).toPoint());
+ QPoint pos = window->mapToGlobal(item->mapToScene(QPointF(10, 10)).toPoint());
tp.area = QRectF(pos, QSizeF(4, 4));
points << tp;
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
points[0].state = Qt::TouchPointMoved;
points[0].area.adjust(5, 5, 5, 5);
QVector2D velocity(1.5, 2.5);
points[0].velocity = velocity;
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
points[0].state = Qt::TouchPointReleased;
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
QCoreApplication::processEvents();
// The item should have received a mouse press, move, and release.
QCOMPARE(item->mousePressNum, 1);
QCOMPARE(item->mouseMoveNum, 1);
QCOMPARE(item->mouseReleaseNum, 1);
- QCOMPARE(item->lastMousePos.toPoint(), item->mapFromScene(canvas->mapFromGlobal(points[0].area.center().toPoint())).toPoint());
+ QCOMPARE(item->lastMousePos.toPoint(), item->mapFromScene(window->mapFromGlobal(points[0].area.center().toPoint())).toPoint());
QCOMPARE(item->lastVelocityFromMouseMove, velocity);
QVERIFY((item->lastMouseCapabilityFlags & QTouchDevice::Velocity) != 0);
points[0].state = Qt::TouchPointPressed;
points[0].velocity = velocity;
points[0].area = QRectF(pos, QSizeF(4, 4));
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
points[0].state = Qt::TouchPointMoved;
points[0].area.adjust(5, 5, 5, 5);
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
QCoreApplication::processEvents();
- QCOMPARE(item->lastMousePos.toPoint(), item->mapFromScene(canvas->mapFromGlobal(points[0].area.center().toPoint())).toPoint());
+ QCOMPARE(item->lastMousePos.toPoint(), item->mapFromScene(window->mapFromGlobal(points[0].area.center().toPoint())).toPoint());
QCOMPARE(item->lastVelocityFromMouseMove, transformedVelocity);
points[0].state = Qt::TouchPointReleased;
- QWindowSystemInterface::handleTouchEvent(canvas, touchDeviceWithVelocity, points);
+ QWindowSystemInterface::handleTouchEvent(window, touchDeviceWithVelocity, points);
QCoreApplication::processEvents();
delete item;
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::clearCanvas()
+void tst_qquickwindow::clearWindow()
{
- QQuickCanvas *canvas = new QQuickCanvas;
+ QQuickWindow *window = new QQuickWindow;
QQuickItem *item = new QQuickItem;
- item->setParentItem(canvas->rootItem());
+ item->setParentItem(window->rootItem());
- QVERIFY(item->canvas() == canvas);
+ QVERIFY(item->window() == window);
- delete canvas;
+ delete window;
- QVERIFY(item->canvas() == 0);
+ QVERIFY(item->window() == 0);
delete item;
}
-void tst_qquickcanvas::mouseFiltering()
+void tst_qquickwindow::mouseFiltering()
{
TestTouchItem::clearMousePressCounter();
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
- TestTouchItem *bottomItem = new TestTouchItem(canvas->rootItem());
+ TestTouchItem *bottomItem = new TestTouchItem(window->rootItem());
bottomItem->setObjectName("Bottom Item");
bottomItem->setSize(QSizeF(150, 150));
QPoint pos(100, 100);
- QTest::mousePress(canvas, Qt::LeftButton, 0, pos);
+ QTest::mousePress(window, Qt::LeftButton, 0, pos);
// Mouse filtering propagates down the stack, so the
// correct order is
QTRY_COMPARE(bottomItem->mousePressId, 2);
QTRY_COMPARE(topItem->mousePressId, 3);
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::qmlCreation()
+void tst_qquickwindow::qmlCreation()
{
QQmlEngine engine;
QQmlComponent component(&engine);
QObject* created = component.create();
QVERIFY(created);
- QQuickCanvas* canvas = qobject_cast<QQuickCanvas*>(created);
- QVERIFY(canvas);
- QCOMPARE(canvas->clearColor(), QColor(Qt::green));
+ QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
+ QVERIFY(window);
+ QCOMPARE(window->color(), QColor(Qt::green));
- QQuickItem* item = canvas->findChild<QQuickItem*>("item");
+ QQuickItem* item = window->findChild<QQuickItem*>("item");
QVERIFY(item);
- QCOMPARE(item->canvas(), canvas);
+ QCOMPARE(item->window(), window);
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::clearColor()
+void tst_qquickwindow::clearColor()
{
- //### Can we examine rendering to make sure it is really blue?
- QQuickCanvas *canvas = new QQuickCanvas;
- canvas->resize(250, 250);
- canvas->setPos(100, 100);
- canvas->setClearColor(Qt::blue);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
- QCOMPARE(canvas->clearColor(), QColor(Qt::blue));
- delete canvas;
+ //::grab examines rendering to make sure it works visually
+ QQuickWindow *window = new QQuickWindow;
+ window->resize(250, 250);
+ window->setPos(100, 100);
+ window->setColor(Qt::blue);
+ window->show();
+ QTest::qWaitForWindowShown(window);
+ QCOMPARE(window->color(), QColor(Qt::blue));
+ delete window;
}
-void tst_qquickcanvas::grab()
+void tst_qquickwindow::grab()
{
- QQuickCanvas canvas;
- canvas.setClearColor(Qt::red);
+ QQuickWindow window;
+ window.setColor(Qt::red);
- canvas.resize(250, 250);
- canvas.show();
+ window.resize(250, 250);
+ window.show();
- QTest::qWaitForWindowShown(&canvas);
+ QTest::qWaitForWindowShown(&window);
- QImage content = canvas.grabFrameBuffer();
- QCOMPARE(content.width(), canvas.width());
- QCOMPARE(content.height(), canvas.height());
+ QImage content = window.grabWindow();
+ QCOMPARE(content.width(), window.width());
+ QCOMPARE(content.height(), window.height());
QCOMPARE((uint) content.convertToFormat(QImage::Format_RGB32).pixel(0, 0), (uint) 0xffff0000);
}
-void tst_qquickcanvas::multipleWindows()
+void tst_qquickwindow::multipleWindows()
{
- QList<QQuickCanvas *> windows;
+ QList<QQuickWindow *> windows;
for (int i=0; i<6; ++i) {
- QQuickCanvas *c = new QQuickCanvas();
- c->setClearColor(Qt::GlobalColor(Qt::red + i));
+ QQuickWindow *c = new QQuickWindow();
+ c->setColor(Qt::GlobalColor(Qt::red + i));
c->resize(300, 200);
c->setPos(100 + i * 30, 100 + i * 20);
c->show();
// move them
for (int i=0; i<windows.size(); ++i) {
- QQuickCanvas *c = windows.at(i);
+ QQuickWindow *c = windows.at(i);
c->setPos(c->x() - 10, c->y() - 10);
}
// resize them
for (int i=0; i<windows.size(); ++i) {
- QQuickCanvas *c = windows.at(i);
+ QQuickWindow *c = windows.at(i);
c->resize(200, 150);
}
qDeleteAll(windows);
}
-void tst_qquickcanvas::animationsWhileHidden()
+void tst_qquickwindow::animationsWhileHidden()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("AnimationsWhileHidden.qml"));
QObject* created = component.create();
- QQuickCanvas* canvas = qobject_cast<QQuickCanvas*>(created);
- QVERIFY(canvas);
- QVERIFY(canvas->isVisible());
+ QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
+ QVERIFY(window);
+ QVERIFY(window->isVisible());
// Now hide the window and verify that it went off screen
- canvas->hide();
+ window->hide();
QTest::qWait(10);
- QVERIFY(!canvas->isVisible());
+ QVERIFY(!window->isVisible());
// Running animaiton should cause it to become visible again shortly.
- QTRY_VERIFY(canvas->isVisible());
+ QTRY_VERIFY(window->isVisible());
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::headless()
+void tst_qquickwindow::headless()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("Headless.qml"));
QObject* created = component.create();
- QQuickCanvas* canvas = qobject_cast<QQuickCanvas*>(created);
- QVERIFY(canvas);
+ QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
+ QVERIFY(window);
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->isVisible());
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->isVisible());
- QSignalSpy initialized(canvas, SIGNAL(sceneGraphInitialized()));
- QSignalSpy invalidated(canvas, SIGNAL(sceneGraphInvalidated()));
+ QSignalSpy initialized(window, SIGNAL(sceneGraphInitialized()));
+ QSignalSpy invalidated(window, SIGNAL(sceneGraphInvalidated()));
- // Verify that the canvas is alive and kicking
- QVERIFY(canvas->openglContext() != 0);
+ // Verify that the window is alive and kicking
+ QVERIFY(window->openglContext() != 0);
// Store the visual result
- QImage originalContent = canvas->grabFrameBuffer();
+ QImage originalContent = window->grabWindow();
- // Hide the canvas and verify signal emittion and GL context deletion
- canvas->hide();
- canvas->releaseResources();
+ // Hide the window and verify signal emittion and GL context deletion
+ window->hide();
+ window->releaseResources();
QTRY_COMPARE(invalidated.size(), 1);
- QVERIFY(canvas->openglContext() == 0);
+ QVERIFY(window->openglContext() == 0);
// Destroy the native windowing system buffers
- canvas->destroy();
- QVERIFY(canvas->handle() == 0);
+ window->destroy();
+ QVERIFY(window->handle() == 0);
// Show and verify that we are back and running
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ window->show();
+ QTest::qWaitForWindowShown(window);
QTRY_COMPARE(initialized.size(), 1);
- QVERIFY(canvas->openglContext() != 0);
+ QVERIFY(window->openglContext() != 0);
// Verify that the visual output is the same
- QImage newContent = canvas->grabFrameBuffer();
+ QImage newContent = window->grabWindow();
QCOMPARE(originalContent, newContent);
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::focusObject()
+void tst_qquickwindow::focusObject()
{
QQmlEngine engine;
QQmlComponent component(&engine);
QObject *created = component.create();
QVERIFY(created);
- QQuickCanvas *canvas = qobject_cast<QQuickCanvas*>(created);
- QVERIFY(canvas);
+ QQuickWindow *window = qobject_cast<QQuickWindow*>(created);
+ QVERIFY(window);
- QQuickItem *item1 = canvas->findChild<QQuickItem*>("item1");
+ QQuickItem *item1 = window->findChild<QQuickItem*>("item1");
QVERIFY(item1);
item1->setFocus(true);
- QCOMPARE(item1, canvas->focusObject());
+ QCOMPARE(item1, window->focusObject());
- QQuickItem *item2 = canvas->findChild<QQuickItem*>("item2");
+ QQuickItem *item2 = window->findChild<QQuickItem*>("item2");
QVERIFY(item2);
item2->setFocus(true);
- QCOMPARE(item2, canvas->focusObject());
+ QCOMPARE(item2, window->focusObject());
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::ignoreUnhandledMouseEvents()
+void tst_qquickwindow::ignoreUnhandledMouseEvents()
{
- QQuickCanvas* canvas = new QQuickCanvas;
- canvas->resize(100, 100);
- canvas->show();
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow* window = new QQuickWindow;
+ window->resize(100, 100);
+ window->show();
+ QTest::qWaitForWindowShown(window);
QQuickItem* item = new QQuickItem;
item->setSize(QSizeF(100, 100));
- item->setParentItem(canvas->rootItem());
+ item->setParentItem(window->rootItem());
{
QMouseEvent me(QEvent::MouseButtonPress, QPointF(50, 50), Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier);
me.setAccepted(true);
- QVERIFY(QCoreApplication::sendEvent(canvas, &me));
+ QVERIFY(QCoreApplication::sendEvent(window, &me));
QVERIFY(!me.isAccepted());
}
QMouseEvent me(QEvent::MouseMove, QPointF(51, 51), Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier);
me.setAccepted(true);
- QVERIFY(QCoreApplication::sendEvent(canvas, &me));
+ QVERIFY(QCoreApplication::sendEvent(window, &me));
QVERIFY(!me.isAccepted());
}
QMouseEvent me(QEvent::MouseButtonRelease, QPointF(51, 51), Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier);
me.setAccepted(true);
- QVERIFY(QCoreApplication::sendEvent(canvas, &me));
+ QVERIFY(QCoreApplication::sendEvent(window, &me));
QVERIFY(!me.isAccepted());
}
- delete canvas;
+ delete window;
}
-void tst_qquickcanvas::ownershipRootItem()
+void tst_qquickwindow::ownershipRootItem()
{
qmlRegisterType<RootItemAccessor>("QtQuick", 2, 0, "RootItemAccessor");
component.loadUrl(testFileUrl("ownershipRootItem.qml"));
QObject* created = component.create();
- QQuickCanvas* canvas = qobject_cast<QQuickCanvas*>(created);
- QVERIFY(canvas);
- QTest::qWaitForWindowShown(canvas);
+ QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
+ QVERIFY(window);
+ QTest::qWaitForWindowShown(window);
- RootItemAccessor* accessor = canvas->findChild<RootItemAccessor*>("accessor");
+ RootItemAccessor* accessor = window->findChild<RootItemAccessor*>("accessor");
QVERIFY(accessor);
engine.collectGarbage();
QCoreApplication::processEvents();
QVERIFY(!accessor->isRootItemDestroyed());
}
-QTEST_MAIN(tst_qquickcanvas)
+QTEST_MAIN(tst_qquickwindow)
-#include "tst_qquickcanvas.moc"
+#include "tst_qquickwindow.moc"
qquickanimatedimage \
qquickanimatedsprite \
qquickborderimage \
- qquickcanvas \
+ qquickwindow \
qquickdrag \
qquickdroparea \
qquickflickable \
view.show();
QTest::qWaitForWindowShown(&view);
- return view.grabFrameBuffer();
+ return view.grabWindow();
}
private slots:
QQuickView *QQuickViewTestUtil::createView()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- return canvas;
+ return window;
}
-void QQuickViewTestUtil::flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration)
+void QQuickViewTestUtil::flick(QQuickView *window, const QPoint &from, const QPoint &to, int duration)
{
const int pointCount = 5;
QPoint diff = to - from;
// send press, five equally spaced moves, and release.
- QTest::mousePress(canvas, Qt::LeftButton, 0, from);
+ QTest::mousePress(window, Qt::LeftButton, 0, from);
for (int i = 0; i < pointCount; ++i)
- QTest::mouseMove(canvas, from + (i+1)*diff/pointCount, duration / pointCount);
+ QTest::mouseMove(window, from + (i+1)*diff/pointCount, duration / pointCount);
- QTest::mouseRelease(canvas, Qt::LeftButton, 0, to);
+ QTest::mouseRelease(window, Qt::LeftButton, 0, to);
QTest::qWait(50);
}
{
QQuickView *createView();
- void flick(QQuickView *canvas, const QPoint &from, const QPoint &to, int duration);
+ void flick(QQuickView *window, const QPoint &from, const QPoint &to, int duration);
QList<int> adjustIndexesForAddDisplaced(const QList<int> &indexes, int index, int count);
QList<int> adjustIndexesForMove(const QList<int> &indexes, int from, int to, int count);
#include <QtQuick/private/qquickpincharea_p.h>
#include <QtQuick/private/qquickflickable_p.h>
-#include <private/qquickcanvas_p.h>
+#include <private/qquickwindow_p.h>
#include <QtQml/qqmlengine.h>
#include <QtQml/qqmlproperty.h>
QQuickView *tst_TouchMouse::createView()
{
- QQuickView *canvas = new QQuickView(0);
- canvas->setGeometry(0,0,240,320);
+ QQuickView *window = new QQuickView(0);
+ window->setGeometry(0,0,240,320);
- return canvas;
+ return window;
}
void tst_TouchMouse::initTestCase()
void tst_TouchMouse::simpleTouchEvent()
{
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("singleitem.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QTest::qWaitForWindowShown(canvas);
- QVERIFY(canvas->rootObject() != 0);
+ window->setSource(testFileUrl("singleitem.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QTest::qWaitForWindowShown(window);
+ QVERIFY(window->rootObject() != 0);
- EventItem *eventItem1 = canvas->rootObject()->findChild<EventItem*>("eventItem1");
+ EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
QVERIFY(eventItem1);
// Do not accept touch or mouse
QPoint p1;
p1 = QPoint(20, 20);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 1);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
p1 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 1);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 1);
eventItem1->eventList.clear();
// Accept touch
eventItem1->acceptTouch = true;
p1 = QPoint(20, 20);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 1);
p1 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 3);
eventItem1->eventList.clear();
eventItem1->acceptMouse = true;
eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
p1 = QPoint(20, 20);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::MouseButtonPress);
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
- QCOMPARE(canvasPriv->mouseGrabberItem, eventItem1);
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(window);
+ QCOMPARE(windowPriv->mouseGrabberItem, eventItem1);
QPoint localPos = eventItem1->mapFromScene(p1).toPoint();
- QPoint globalPos = canvas->mapToGlobal(p1);
+ QPoint globalPos = window->mapToGlobal(p1);
QPoint scenePos = p1; // item is at 0,0
QCOMPARE(eventItem1->eventList.at(0).points.at(0).pos().toPoint(), localPos);
QCOMPARE(eventItem1->eventList.at(0).points.at(0).scenePos().toPoint(), scenePos);
QCOMPARE(eventItem1->eventList.at(1).mousePosGlobal, globalPos);
p1 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 4);
QCOMPARE(eventItem1->eventList.at(2).type, QEvent::TouchUpdate);
QCOMPARE(eventItem1->eventList.at(3).type, QEvent::MouseMove);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 6);
QCOMPARE(eventItem1->eventList.at(4).type, QEvent::TouchEnd);
QCOMPARE(eventItem1->eventList.at(5).type, QEvent::MouseButtonRelease);
eventItem1->acceptMouse = false;
eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
p1 = QPoint(20, 20);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::MouseButtonPress);
p1 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
eventItem1->eventList.clear();
eventItem1->acceptTouch = true;
eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
p1 = QPoint(20, 20);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 1);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
p1 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::TouchUpdate);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 3);
QCOMPARE(eventItem1->eventList.at(2).type, QEvent::TouchEnd);
eventItem1->eventList.clear();
- delete canvas;
+ delete window;
}
void tst_TouchMouse::eventFilter()
{
// // install event filter on item and see that it can grab events
-// QQuickView *canvas = createView();
+// QQuickView *window = createView();
-// canvas->setSource(testFileUrl("singleitem.qml"));
-// canvas->show();
-// canvas->requestActivateWindow();
-// QVERIFY(canvas->rootObject() != 0);
+// window->setSource(testFileUrl("singleitem.qml"));
+// window->show();
+// window->requestActivateWindow();
+// QVERIFY(window->rootObject() != 0);
-// EventItem *eventItem1 = canvas->rootObject()->findChild<EventItem*>("eventItem1");
+// EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
// QVERIFY(eventItem1);
// eventItem1->acceptTouch = true;
// eventItem1->installEventFilter(filter);
// QPoint p1 = QPoint(20, 20);
-// QTest::touchEvent(canvas, device).press(0, p1, canvas);
+// QTest::touchEvent(window, device).press(0, p1, window);
// // QEXPECT_FAIL("", "We do not implement event filters correctly", Abort);
// QCOMPARE(eventItem1->eventList.size(), 0);
// QCOMPARE(filter->eventList.size(), 1);
-// QTest::touchEvent(canvas, device).release(0, p1, canvas);
+// QTest::touchEvent(window, device).release(0, p1, window);
// QCOMPARE(eventItem1->eventList.size(), 0);
// QCOMPARE(filter->eventList.size(), 2);
// delete filter;
-// delete canvas;
+// delete window;
}
void tst_TouchMouse::mouse()
// - eventItem2
QTest::qWait(qApp->styleHints()->mouseDoubleClickInterval() + 10);
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("twoitems.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window->setSource(testFileUrl("twoitems.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- EventItem *eventItem1 = canvas->rootObject()->findChild<EventItem*>("eventItem1");
+ EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
QVERIFY(eventItem1);
- EventItem *eventItem2 = canvas->rootObject()->findChild<EventItem*>("eventItem2");
+ EventItem *eventItem2 = window->rootObject()->findChild<EventItem*>("eventItem2");
QVERIFY(eventItem2);
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
// bottom item likes mouse, top likes touch
eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
eventItem1->acceptMouse = true;
// item 2 doesn't accept anything, thus it sees a touch pass by
QPoint p1 = QPoint(30, 30);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::MouseButtonPress);
- delete canvas;
+ delete window;
}
void tst_TouchMouse::touchOverMouse()
// eventItem1
// - eventItem2
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("twoitems.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window->setSource(testFileUrl("twoitems.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- EventItem *eventItem1 = canvas->rootObject()->findChild<EventItem*>("eventItem1");
+ EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
QVERIFY(eventItem1);
- EventItem *eventItem2 = canvas->rootObject()->findChild<EventItem*>("eventItem2");
+ EventItem *eventItem2 = window->rootObject()->findChild<EventItem*>("eventItem2");
QVERIFY(eventItem2);
// bottom item likes mouse, top likes touch
eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
eventItem2->acceptTouch = true;
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
QCOMPARE(eventItem1->eventList.size(), 0);
QPoint p1 = QPoint(20, 20);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 0);
QCOMPARE(eventItem2->eventList.size(), 1);
QCOMPARE(eventItem2->eventList.at(0).type, QEvent::TouchBegin);
p1 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window);
QCOMPARE(eventItem2->eventList.size(), 2);
QCOMPARE(eventItem2->eventList.at(1).type, QEvent::TouchUpdate);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem2->eventList.size(), 3);
QCOMPARE(eventItem2->eventList.at(2).type, QEvent::TouchEnd);
eventItem2->eventList.clear();
- delete canvas;
+ delete window;
}
void tst_TouchMouse::mouseOverTouch()
// eventItem1
// - eventItem2
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("twoitems.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window->setSource(testFileUrl("twoitems.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- EventItem *eventItem1 = canvas->rootObject()->findChild<EventItem*>("eventItem1");
+ EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
QVERIFY(eventItem1);
- EventItem *eventItem2 = canvas->rootObject()->findChild<EventItem*>("eventItem2");
+ EventItem *eventItem2 = window->rootObject()->findChild<EventItem*>("eventItem2");
QVERIFY(eventItem2);
// bottom item likes mouse, top likes touch
eventItem2->setAcceptedMouseButtons(Qt::LeftButton);
eventItem2->acceptMouse = true;
- QTest::qWaitForWindowShown(canvas);
+ QTest::qWaitForWindowShown(window);
QPoint p1 = QPoint(20, 20);
QTest::qWait(qApp->styleHints()->mouseDoubleClickInterval() + 10);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 0);
QCOMPARE(eventItem2->eventList.size(), 2);
QCOMPARE(eventItem2->eventList.at(0).type, QEvent::TouchBegin);
// p1 += QPoint(10, 0);
-// QTest::touchEvent(canvas, device).move(0, p1, canvas);
+// QTest::touchEvent(window, device).move(0, p1, window);
// QCOMPARE(eventItem2->eventList.size(), 1);
-// QTest::touchEvent(canvas, device).release(0, p1, canvas);
+// QTest::touchEvent(window, device).release(0, p1, window);
// QCOMPARE(eventItem2->eventList.size(), 1);
// eventItem2->eventList.clear();
- delete canvas;
+ delete window;
}
void tst_TouchMouse::buttonOnFlickable()
// - eventItem1 y: 100, height 100
// - eventItem2 y: 300, height 100
- QQuickView *canvas = createView();
+ QQuickView *window = createView();
- canvas->setSource(testFileUrl("buttononflickable.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ window->setSource(testFileUrl("buttononflickable.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickFlickable *flickable = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
+ QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flickable);
// should a mouse area button be clickable on top of flickable? yes :)
- EventItem *eventItem1 = canvas->rootObject()->findChild<EventItem*>("eventItem1");
+ EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
QVERIFY(eventItem1);
eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
eventItem1->acceptMouse = true;
// should a touch button be touchable on top of flickable? yes :)
- EventItem *eventItem2 = canvas->rootObject()->findChild<EventItem*>("eventItem2");
+ EventItem *eventItem2 = window->rootObject()->findChild<EventItem*>("eventItem2");
QVERIFY(eventItem2);
QCOMPARE(eventItem2->eventList.size(), 0);
eventItem2->acceptTouch = true;
// mouse button
QCOMPARE(eventItem1->eventList.size(), 0);
QPoint p1 = QPoint(20, 130);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::MouseButtonPress);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 4);
QCOMPARE(eventItem1->eventList.at(2).type, QEvent::TouchEnd);
QCOMPARE(eventItem1->eventList.at(3).type, QEvent::MouseButtonRelease);
// touch button
p1 = QPoint(10, 310);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem2->eventList.size(), 1);
QCOMPARE(eventItem2->eventList.at(0).type, QEvent::TouchBegin);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem2->eventList.size(), 2);
QCOMPARE(eventItem2->eventList.at(1).type, QEvent::TouchEnd);
QCOMPARE(eventItem1->eventList.size(), 0);
// click above button, no events please
p1 = QPoint(10, 90);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 0);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 0);
eventItem1->eventList.clear();
// check that flickable moves - mouse button
QCOMPARE(eventItem1->eventList.size(), 0);
p1 = QPoint(10, 110);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 2);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::MouseButtonPress);
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
- QCOMPARE(canvasPriv->touchMouseId, 0);
- QCOMPARE(canvasPriv->itemForTouchPointId[0], eventItem1);
- QCOMPARE(canvasPriv->mouseGrabberItem, eventItem1);
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(window);
+ QCOMPARE(windowPriv->touchMouseId, 0);
+ QCOMPARE(windowPriv->itemForTouchPointId[0], eventItem1);
+ QCOMPARE(windowPriv->mouseGrabberItem, eventItem1);
p1 += QPoint(0, -10);
QPoint p2 = p1 + QPoint(0, -10);
QPoint p3 = p2 + QPoint(0, -10);
QTest::qWait(10);
- QTest::touchEvent(canvas, device).move(0, p1, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window);
QTest::qWait(10);
- QTest::touchEvent(canvas, device).move(0, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p2, window);
QTest::qWait(10);
- QTest::touchEvent(canvas, device).move(0, p3, canvas);
+ QTest::touchEvent(window, device).move(0, p3, window);
// we cannot really know when the events get grabbed away
QVERIFY(eventItem1->eventList.size() >= 4);
QCOMPARE(eventItem1->eventList.at(2).type, QEvent::TouchUpdate);
QCOMPARE(eventItem1->eventList.at(3).type, QEvent::MouseMove);
- QCOMPARE(canvasPriv->mouseGrabberItem, flickable);
+ QCOMPARE(windowPriv->mouseGrabberItem, flickable);
QVERIFY(flickable->isMovingVertically());
- QTest::touchEvent(canvas, device).release(0, p3, canvas);
- delete canvas;
+ QTest::touchEvent(window, device).release(0, p3, window);
+ delete window;
}
void tst_TouchMouse::buttonOnTouch()
// - eventItem1 y: 100, height 100
// - eventItem2 y: 300, height 100
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("buttonontouch.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("buttonontouch.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QVERIFY(pinchArea);
- QQuickItem *button1 = canvas->rootObject()->findChild<QQuickItem*>("button1");
+ QQuickItem *button1 = window->rootObject()->findChild<QQuickItem*>("button1");
QVERIFY(button1);
- EventItem *eventItem1 = canvas->rootObject()->findChild<EventItem*>("eventItem1");
+ EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
QVERIFY(eventItem1);
- EventItem *eventItem2 = canvas->rootObject()->findChild<EventItem*>("eventItem2");
+ EventItem *eventItem2 = window->rootObject()->findChild<EventItem*>("eventItem2");
QVERIFY(eventItem2);
- QQuickMultiPointTouchArea *touchArea = canvas->rootObject()->findChild<QQuickMultiPointTouchArea*>("toucharea");
+ QQuickMultiPointTouchArea *touchArea = window->rootObject()->findChild<QQuickMultiPointTouchArea*>("toucharea");
QVERIFY(touchArea);
- EventItem *eventItem3 = canvas->rootObject()->findChild<EventItem*>("eventItem3");
+ EventItem *eventItem3 = window->rootObject()->findChild<EventItem*>("eventItem3");
QVERIFY(eventItem3);
- EventItem *eventItem4 = canvas->rootObject()->findChild<EventItem*>("eventItem4");
+ EventItem *eventItem4 = window->rootObject()->findChild<EventItem*>("eventItem4");
QVERIFY(eventItem4);
// Normal touch click
QPoint p1 = QPoint(10, 110);
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
- QTest::touchEvent(canvas, device).release(0, p1, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
+ QTest::touchEvent(window, device).release(0, p1, window);
QCOMPARE(eventItem1->eventList.size(), 4);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::MouseButtonPress);
eventItem1->eventList.clear();
// Normal mouse click
- QTest::mouseClick(canvas, Qt::LeftButton, 0, p1);
+ QTest::mouseClick(window, Qt::LeftButton, 0, p1);
QCOMPARE(eventItem1->eventList.size(), 2);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::MouseButtonPress);
QCOMPARE(eventItem1->eventList.at(1).type, QEvent::MouseButtonRelease);
QPoint p2 = QPoint(60, 10);
// Start the events after each other
- QTest::touchEvent(canvas, device).press(0, p1, canvas);
- QTest::touchEvent(canvas, device).stationary(0).press(1, p2, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window);
+ QTest::touchEvent(window, device).stationary(0).press(1, p2, window);
QCOMPARE(button1->scale(), 1.0);
// This event seems to be discarded, let's ignore it for now until someone digs into pincharea
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas).move(1, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window).move(1, p2, window);
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas).move(1, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window).move(1, p2, window);
// QCOMPARE(button1->scale(), 1.5);
qDebug() << "Button scale: " << button1->scale();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas).move(1, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window).move(1, p2, window);
// QCOMPARE(button1->scale(), 2.0);
qDebug() << "Button scale: " << button1->scale();
- QTest::touchEvent(canvas, device).release(0, p1, canvas).release(1, p2, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window).release(1, p2, window);
// QVERIFY(eventItem1->eventList.isEmpty());
// QCOMPARE(button1->scale(), 2.0);
qDebug() << "Button scale: " << button1->scale();
button1->setScale(1.0);
p1 = QPoint(40, 110);
p2 = QPoint(60, 110);
- QTest::touchEvent(canvas, device).press(0, p1, canvas).press(1, p2, canvas);
+ QTest::touchEvent(window, device).press(0, p1, window).press(1, p2, window);
QCOMPARE(button1->scale(), 1.0);
QCOMPARE(eventItem1->eventList.count(), 2);
QCOMPARE(eventItem1->eventList.at(0).type, QEvent::TouchBegin);
// This event seems to be discarded, let's ignore it for now until someone digs into pincharea
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas).move(1, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window).move(1, p2, window);
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas).move(1, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window).move(1, p2, window);
//QCOMPARE(button1->scale(), 1.5);
qDebug() << button1->scale();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p1, canvas).move(1, p2, canvas);
+ QTest::touchEvent(window, device).move(0, p1, window).move(1, p2, window);
qDebug() << button1->scale();
//QCOMPARE(button1->scale(), 2.0);
- QTest::touchEvent(canvas, device).release(0, p1, canvas).release(1, p2, canvas);
+ QTest::touchEvent(window, device).release(0, p1, window).release(1, p2, window);
// QCOMPARE(eventItem1->eventList.size(), 99);
qDebug() << button1->scale();
//QCOMPARE(button1->scale(), 2.0);
- delete canvas;
+ delete window;
}
void tst_TouchMouse::pinchOnFlickable()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("pinchonflickable.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("pinchonflickable.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QVERIFY(pinchArea);
- QQuickFlickable *flickable = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
+ QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flickable);
- QQuickItem *rect = canvas->rootObject()->findChild<QQuickItem*>("rect");
+ QQuickItem *rect = window->rootObject()->findChild<QQuickItem*>("rect");
QVERIFY(rect);
// flickable - single touch point
QVERIFY(flickable->contentX() == 0.0);
QPoint p = QPoint(100, 100);
- QTest::touchEvent(canvas, device).press(0, p, canvas);
+ QTest::touchEvent(window, device).press(0, p, window);
QCOMPARE(rect->pos(), QPointF(200.0, 200.0));
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
QTest::qWait(10);
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
QTest::qWait(10);
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
- QTest::touchEvent(canvas, device).release(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
+ QTest::touchEvent(window, device).release(0, p, window);
QGuiApplication::processEvents();
QTest::qWait(10);
QPoint p1 = QPoint(40, 20);
QPoint p2 = QPoint(60, 20);
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
- pinchSequence.press(0, p1, canvas).commit();
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(window, device);
+ pinchSequence.press(0, p1, window).commit();
// In order for the stationary point to remember its previous position,
// we have to reuse the same pinchSequence object. Otherwise if we let it
// be destroyed and then start a new sequence, point 0 will default to being
// stationary at 0, 0, and PinchArea will filter out that touchpoint because
// it is outside its bounds.
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
QCOMPARE(rect->scale(), 1.0);
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
- pinchSequence.release(0, p1, canvas).release(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
+ pinchSequence.release(0, p1, window).release(1, p2, window).commit();
QVERIFY(rect->scale() > 1.0);
}
void tst_TouchMouse::flickableOnPinch()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("flickableonpinch.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("flickableonpinch.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QVERIFY(pinchArea);
- QQuickFlickable *flickable = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
+ QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flickable);
- QQuickItem *rect = canvas->rootObject()->findChild<QQuickItem*>("rect");
+ QQuickItem *rect = window->rootObject()->findChild<QQuickItem*>("rect");
QVERIFY(rect);
// flickable - single touch point
QVERIFY(flickable->contentX() == 0.0);
QPoint p = QPoint(100, 100);
- QTest::touchEvent(canvas, device).press(0, p, canvas);
+ QTest::touchEvent(window, device).press(0, p, window);
QCOMPARE(rect->pos(), QPointF(200.0, 200.0));
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
QTest::qWait(1000);
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
- QTest::touchEvent(canvas, device).release(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
+ QTest::touchEvent(window, device).release(0, p, window);
QTest::qWait(1000);
// pinch
QPoint p1 = QPoint(40, 20);
QPoint p2 = QPoint(60, 20);
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
- pinchSequence.press(0, p1, canvas).commit();
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(window, device);
+ pinchSequence.press(0, p1, window).commit();
// In order for the stationary point to remember its previous position,
// we have to reuse the same pinchSequence object. Otherwise if we let it
// be destroyed and then start a new sequence, point 0 will default to being
// stationary at 0, 0, and PinchArea will filter out that touchpoint because
// it is outside its bounds.
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
QCOMPARE(rect->scale(), 1.0);
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
- pinchSequence.release(0, p1, canvas).release(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
+ pinchSequence.release(0, p1, window).release(1, p2, window).commit();
QVERIFY(rect->scale() > 1.0);
}
void tst_TouchMouse::mouseOnFlickableOnPinch()
{
- QQuickView *canvas = createView();
- canvas->setSource(testFileUrl("mouseonflickableonpinch.qml"));
- canvas->show();
- canvas->requestActivateWindow();
- QVERIFY(canvas->rootObject() != 0);
+ QQuickView *window = createView();
+ window->setSource(testFileUrl("mouseonflickableonpinch.qml"));
+ window->show();
+ window->requestActivateWindow();
+ QVERIFY(window->rootObject() != 0);
- QQuickPinchArea *pinchArea = canvas->rootObject()->findChild<QQuickPinchArea*>("pincharea");
+ QQuickPinchArea *pinchArea = window->rootObject()->findChild<QQuickPinchArea*>("pincharea");
QVERIFY(pinchArea);
- QQuickFlickable *flickable = canvas->rootObject()->findChild<QQuickFlickable*>("flickable");
+ QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>("flickable");
QVERIFY(flickable);
- QQuickItem *rect = canvas->rootObject()->findChild<QQuickItem*>("rect");
+ QQuickItem *rect = window->rootObject()->findChild<QQuickItem*>("rect");
QVERIFY(rect);
// flickable - single touch point
QVERIFY(flickable->contentX() == 0.0);
QPoint p = QPoint(100, 100);
- QTest::touchEvent(canvas, device).press(0, p, canvas);
+ QTest::touchEvent(window, device).press(0, p, window);
QCOMPARE(rect->pos(), QPointF(200.0, 200.0));
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
QTest::qWait(1000);
p -= QPoint(10, 0);
- QTest::touchEvent(canvas, device).move(0, p, canvas);
- QTest::touchEvent(canvas, device).release(0, p, canvas);
+ QTest::touchEvent(window, device).move(0, p, window);
+ QTest::touchEvent(window, device).release(0, p, window);
QTest::qWait(1000);
// pinch
QPoint p1 = QPoint(40, 20);
QPoint p2 = QPoint(60, 20);
- QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(canvas, device);
- pinchSequence.press(0, p1, canvas).commit();
+ QTest::QTouchEventSequence pinchSequence = QTest::touchEvent(window, device);
+ pinchSequence.press(0, p1, window).commit();
// In order for the stationary point to remember its previous position,
// we have to reuse the same pinchSequence object. Otherwise if we let it
// be destroyed and then start a new sequence, point 0 will default to being
// stationary at 0, 0, and PinchArea will filter out that touchpoint because
// it is outside its bounds.
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
p1 -= QPoint(10,10);
p2 += QPoint(10,10);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
QCOMPARE(rect->scale(), 1.0);
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(10, 0);
p2 += QPoint(10, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
- pinchSequence.release(0, p1, canvas).release(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
+ pinchSequence.release(0, p1, window).release(1, p2, window).commit();
QVERIFY(rect->scale() > 1.0);
// PinchArea should steal the event after flicking started
rect->setScale(1.0);
flickable->setContentX(0.0);
p = QPoint(100, 100);
- pinchSequence.press(0, p, canvas).commit();
+ pinchSequence.press(0, p, window).commit();
QCOMPARE(rect->pos(), QPointF(200.0, 200.0));
p -= QPoint(10, 0);
- pinchSequence.move(0, p, canvas).commit();
+ pinchSequence.move(0, p, window).commit();
p -= QPoint(10, 0);
- pinchSequence.move(0, p, canvas).commit();
+ pinchSequence.move(0, p, window).commit();
QTest::qWait(1000);
p -= QPoint(10, 0);
- pinchSequence.move(0, p, canvas).commit();
+ pinchSequence.move(0, p, window).commit();
- QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
- QCOMPARE(canvasPriv->mouseGrabberItem, flickable);
- qDebug() << "Mouse Grabber: " << canvasPriv->mouseGrabberItem << " itemForTouchPointId: " << canvasPriv->itemForTouchPointId;
+ QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(window);
+ QCOMPARE(windowPriv->mouseGrabberItem, flickable);
+ qDebug() << "Mouse Grabber: " << windowPriv->mouseGrabberItem << " itemForTouchPointId: " << windowPriv->itemForTouchPointId;
// Add a second finger, this should lead to stealing
p1 = QPoint(40, 100);
p2 = QPoint(60, 100);
- pinchSequence.stationary(0).press(1, p2, canvas).commit();
+ pinchSequence.stationary(0).press(1, p2, window).commit();
QCOMPARE(rect->scale(), 1.0);
p1 -= QPoint(5, 0);
p2 += QPoint(5, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(5, 0);
p2 += QPoint(5, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
p1 -= QPoint(5, 0);
p2 += QPoint(5, 0);
- pinchSequence.move(0, p1, canvas).move(1, p2, canvas).commit();
- pinchSequence.release(0, p1, canvas).release(1, p2, canvas).commit();
+ pinchSequence.move(0, p1, window).move(1, p2, window).commit();
+ pinchSequence.release(0, p1, window).release(1, p2, window).commit();
QVERIFY(rect->scale() > 1.0);
- pinchSequence.release(0, p, canvas).commit();
+ pinchSequence.release(0, p, window).commit();
}
QTEST_MAIN(tst_TouchMouse)
surfaceFormat.setAlphaBufferSize(8);
qxView.setFormat(surfaceFormat);
qxView.setClearBeforeRendering(true);
- qxView.setClearColor(QColor(Qt::transparent));
+ qxView.setColor(QColor(Qt::transparent));
qxView.setWindowFlags(Qt::FramelessWindowHint);
}