Avoid initializing QFlags with 0 or nullptr in further cases

Amends 744e77b841.

Change-Id: I16e37aaf503eb62f67fca0e48be4c92c4a72ae46
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

examples/quick/scenegraph/rendernode/softwarerenderer.cpp

@@ -95,7 +95,7 @@ void SoftwareRenderNode::render(const RenderState *renderState)
 
 QSGRenderNode::StateFlags SoftwareRenderNode::changedStates() const
 {
-    return nullptr;
+    return {};
 }
 
 QSGRenderNode::RenderingFlags SoftwareRenderNode::flags() const

src/imports/layouts/qquicklayout.cpp

@@ -117,8 +117,7 @@ QQuickLayoutAttached::QQuickLayoutAttached(QObject *parent)
       m_isLeftMarginSet(false),
       m_isTopMarginSet(false),
       m_isRightMarginSet(false),
-      m_isBottomMarginSet(false),
+      m_isBottomMarginSet(false)
-      m_alignment(nullptr)
 {
 
 }

src/plugins/qmltooling/qmldbg_preview/qqmlpreviewfileengine.cpp

@@ -195,7 +195,7 @@ QAbstractFileEngine::FileFlags QQmlPreviewFileEngine::fileFlags(
     if (m_fallback)
         return m_fallback->fileFlags(type);
 
-    QAbstractFileEngine::FileFlags ret = 0;
+    QAbstractFileEngine::FileFlags ret;
 
     if (type & PermsMask) {
         ret |= QAbstractFileEngine::FileFlags(

src/qml/qml/qqmlcomponent.cpp

@@ -376,7 +376,7 @@ bool QQmlComponentPrivate::setInitialProperty(QObject *component, const QString&
 {
     QQmlProperty prop = QQmlComponentPrivate::removePropertyFromRequired(component, name, requiredProperties());
     QQmlPropertyPrivate *privProp = QQmlPropertyPrivate::get(prop);
-    if (!prop.isValid() || !privProp->writeValueProperty(value, nullptr)) {
+    if (!prop.isValid() || !privProp->writeValueProperty(value, {})) {
         QQmlError error{};
         error.setUrl(url);
         error.setDescription(QLatin1String("Could not set property %1").arg(name));

src/qml/qml/qqmlvmemetaobject.cpp

@@ -840,7 +840,7 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                         int rv = QMetaObject::metacall(valueType, c, valueTypePropertyIndex, a);
 
                         if (c == QMetaObject::WriteProperty)
-                            valueType->write(target, coreIndex, nullptr);
+                            valueType->write(target, coreIndex, {});
 
                         return rv;
                     } else {

src/qmlmodels/qqmldelegatemodel.cpp

@@ -591,11 +591,11 @@ int QQmlDelegateModel::count() const
 QQmlDelegateModel::ReleaseFlags QQmlDelegateModelPrivate::release(QObject *object)
 {
     if (!object)
-        return QQmlDelegateModel::ReleaseFlags(0);
+        return QQmlDelegateModel::ReleaseFlags{};
 
     QQmlDelegateModelItem *cacheItem = QQmlDelegateModelItem::dataForObject(object);
     if (!cacheItem)
-        return QQmlDelegateModel::ReleaseFlags(0);
+        return QQmlDelegateModel::ReleaseFlags{};
 
     if (!cacheItem->releaseObject())
         return QQmlDelegateModel::Referenced;

src/qmlmodels/qqmlobjectmodel.cpp

@@ -270,7 +270,7 @@ QQmlInstanceModel::ReleaseFlags QQmlObjectModel::release(QObject *item)
         if (!d->children[idx].deref())
             return QQmlInstanceModel::Referenced;
     }
-    return nullptr;
+    return {};
 }
 
 QVariant QQmlObjectModel::variantValue(int index, const QString &role)

src/qmltest/quicktestevent.cpp

@@ -197,7 +197,7 @@ namespace QtQuickTest
                 me.setTimestamp(++lastMouseTimestamp);
                 break;
             case MouseRelease:
-                me = QMouseEvent(QEvent::MouseButtonRelease, pos, window->mapToGlobal(pos), button, nullptr, stateKey);
+                me = QMouseEvent(QEvent::MouseButtonRelease, pos, window->mapToGlobal(pos), button, {}, stateKey);
                 me.setTimestamp(++lastMouseTimestamp);
                 lastMouseTimestamp += 500; // avoid double clicks being generated
                 break;

src/quick/designer/qquickdesignercustomobjectdata.cpp

@@ -192,7 +192,7 @@ void QQuickDesignerCustomObjectData::doResetProperty(QQmlContext *context, const
 
     QQmlAbstractBinding *binding = QQmlPropertyPrivate::binding(property);
     if (binding && !(hasValidResetBinding(propertyName) && getResetBinding(propertyName) == binding)) {
-        binding->setEnabled(false, nullptr);
+        binding->setEnabled(false, {});
     }
 
 

src/quick/items/qquickflickable.cpp

@@ -316,7 +316,7 @@ void QQuickFlickablePrivate::itemGeometryChanged(QQuickItem *item, QQuickGeometr
 {
     Q_Q(QQuickFlickable);
     if (item == contentItem) {
-        Qt::Orientations orient = nullptr;
+        Qt::Orientations orient;
         if (change.xChange())
             orient |= Qt::Horizontal;
         if (change.yChange())

src/quick/items/qquickgenericshadereffect.cpp

@@ -310,7 +310,7 @@ QSGNode *QQuickGenericShaderEffect::handleUpdatePaintNode(QSGNode *oldNode, QQui
         m_dirty &= ~QSGShaderEffectNode::DirtyShaderGeometry;
     }
 
-    m_dirty = nullptr;
+    m_dirty = {};
     for (int i = 0; i < NShader; ++i) {
         m_dirtyConstants[i].clear();
         m_dirtyTextures[i].clear();

src/quick/items/qquickmousearea.cpp

@@ -62,7 +62,7 @@ Q_DECLARE_LOGGING_CATEGORY(DBG_HOVER_TRACE)
 QQuickMouseAreaPrivate::QQuickMouseAreaPrivate()
 : enabled(true), scrollGestureEnabled(true), hovered(false), longPress(false),
   moved(false), stealMouse(false), doubleClick(false), preventStealing(false),
-  propagateComposedEvents(false), overThreshold(false), pressed(nullptr),
+  propagateComposedEvents(false), overThreshold(false),
   pressAndHoldInterval(-1)
 #if QT_CONFIG(quick_draganddrop)
   , drag(nullptr)

src/quick/items/qquickpainteditem.cpp

@@ -133,7 +133,6 @@ QQuickPaintedItemPrivate::QQuickPaintedItemPrivate()
     , contentsScale(1.0)
     , fillColor(Qt::transparent)
     , renderTarget(QQuickPaintedItem::Image)
-    , performanceHints(nullptr)
     , opaquePainting(false)
     , antialiasing(false)
     , mipmap(false)

src/quick/items/qquickscreen.cpp

@@ -424,9 +424,6 @@ QScreen *QQuickScreenInfo::wrappedScreen() const
 
 QQuickScreenAttached::QQuickScreenAttached(QObject* attachee)
     : QQuickScreenInfo(attachee)
-    , m_window(nullptr)
-    , m_updateMask(nullptr)
-    , m_updateMaskSet(false)
 {
     m_attachee = qobject_cast<QQuickItem*>(attachee);
 

src/quick/items/qquickscreen_p.h

@@ -152,10 +152,10 @@ protected Q_SLOTS:
     void screenChanged(QScreen*);
 
 private:
-    QQuickWindow* m_window;
+    QQuickWindow* m_window = nullptr;
     QQuickItem* m_attachee;
     Qt::ScreenOrientations m_updateMask;
-    bool m_updateMaskSet;
+    bool m_updateMaskSet = false;
 };
 
 class Q_QUICK_PRIVATE_EXPORT QQuickScreen : public QObject

src/quick/items/qquickstateoperations.cpp

@@ -600,11 +600,6 @@ class QQuickAnchorSetPrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QQuickAnchorSet)
 public:
-    QQuickAnchorSetPrivate()
-      : usedAnchors(nullptr), resetAnchors(nullptr)
-    {
-    }
-
     QQuickAnchors::Anchors usedAnchors;
     QQuickAnchors::Anchors resetAnchors;
 

src/quick/items/qquickwindow.cpp

@@ -527,7 +527,7 @@ void QQuickWindowPrivate::renderSceneGraph(const QSize &size, const QSize &surfa
             renderer->setDeviceRect(rect);
             renderer->setViewportRect(rect);
             const bool flipY = rhi ? !rhi->isYUpInNDC() : false;
-            QSGAbstractRenderer::MatrixTransformFlags matrixFlags = 0;
+            QSGAbstractRenderer::MatrixTransformFlags matrixFlags;
             if (flipY)
                 matrixFlags |= QSGAbstractRenderer::MatrixTransformFlipY;
             renderer->setProjectionMatrixToRect(QRectF(QPoint(0, 0), logicalSize), matrixFlags);
@@ -4444,7 +4444,7 @@ bool QQuickWindow::clearBeforeRendering() const
 
 QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image) const
 {
-    return createTextureFromImage(image, nullptr);
+    return createTextureFromImage(image, {});
 }
 
 

src/quick/scenegraph/adaptations/software/qsgsoftwarecontext.cpp

@@ -206,12 +206,12 @@ QSGRendererInterface::ShaderType QSGSoftwareContext::shaderType() const
 
 QSGRendererInterface::ShaderCompilationTypes QSGSoftwareContext::shaderCompilationType() const
 {
-    return nullptr;
+    return {};
 }
 
 QSGRendererInterface::ShaderSourceTypes QSGSoftwareContext::shaderSourceType() const
 {
-    return nullptr;
+    return {};
 }
 
 void *QSGSoftwareContext::getResource(QQuickWindow *window, Resource resource) const

src/quick/scenegraph/adaptations/software/qsgsoftwareinternalimagenode.cpp

@@ -465,7 +465,7 @@ void QSGSoftwareInternalImageNode::paint(QPainter *painter)
                          m_targetRect.right() - m_innerTargetRect.right(), m_targetRect.bottom() - m_innerTargetRect.bottom());
         QSGSoftwareHelpers::QTileRules tilerules(getTileRule(m_subSourceRect.width()), getTileRule(m_subSourceRect.height()));
         QSGSoftwareHelpers::qDrawBorderPixmap(painter, m_targetRect.toRect(), margins, pm, QRect(0, 0, pm.width(), pm.height()),
-                                              margins, tilerules, QSGSoftwareHelpers::QDrawBorderPixmap::DrawingHints(nullptr));
+                                              margins, tilerules, QSGSoftwareHelpers::QDrawBorderPixmap::DrawingHints{});
         return;
     }
 

src/quick/scenegraph/adaptations/software/qsgsoftwarepublicnodes.cpp

@@ -205,7 +205,7 @@ void QSGSoftwareNinePatchNode::paint(QPainter *painter)
         painter->drawPixmap(m_bounds, m_pixmap, QRectF(0, 0, m_pixmap.width(), m_pixmap.height()));
     else
         QSGSoftwareHelpers::qDrawBorderPixmap(painter, m_bounds.toRect(), m_margins, m_pixmap, QRect(0, 0, m_pixmap.width(), m_pixmap.height()),
-                                              m_margins, Qt::StretchTile, QSGSoftwareHelpers::QDrawBorderPixmap::DrawingHints(nullptr));
+                                              m_margins, Qt::StretchTile, QSGSoftwareHelpers::QDrawBorderPixmap::DrawingHints{});
 }
 
 QRectF QSGSoftwareNinePatchNode::bounds() const

src/quick/scenegraph/compressedtexture/qsgcompressedtexture.cpp

@@ -296,7 +296,7 @@ void QSGCompressedTexturePrivate::updateRhiTexture(QRhi *rhi, QRhiResourceUpdate
         return;
     }
 
-    QRhiTexture::Flags texFlags = 0;
+    QRhiTexture::Flags texFlags;
     if (fmt.second)
         texFlags |= QRhiTexture::sRGB;
 

src/quick/scenegraph/coreapi/qsgbatchrenderer.cpp

@@ -546,7 +546,7 @@ void Updater::visitNode(Node *n)
 
     m_added = count;
     m_force_update = force;
-    n->dirtyState = nullptr;
+    n->dirtyState = {};
 }
 
 void Updater::visitClipNode(Node *n)
@@ -2627,7 +2627,7 @@ QRhiGraphicsPipeline *Renderer::buildStencilPipeline(const Batch *batch, bool fi
     QRhiGraphicsPipeline *ps = m_rhi->newGraphicsPipeline();
     ps->setFlags(QRhiGraphicsPipeline::UsesStencilRef);
     QRhiGraphicsPipeline::TargetBlend blend;
-    blend.colorWrite = 0;
+    blend.colorWrite = {};
     ps->setTargetBlends({ blend });
     ps->setSampleCount(renderTarget()->sampleCount());
     ps->setStencilTest(true);

src/quick/scenegraph/coreapi/qsgopenglvisualizer.cpp

@@ -202,7 +202,7 @@ void OpenGLVisualizer::visualizeChanges(Node *n)
         // This is because many changes don't propegate their dirty state to the
         // parent so the node updater will not unset these states. They are
         // not used for anything so, unsetting it should have no side effects.
-        n->dirtyState = nullptr;
+        n->dirtyState = {};
     }
 
     SHADOWNODE_TRAVERSE(n) {

src/quick/scenegraph/coreapi/qsgrendernode.cpp

@@ -131,7 +131,7 @@ QSGRenderNodePrivate::QSGRenderNodePrivate()
   */
 QSGRenderNode::StateFlags QSGRenderNode::changedStates() const
 {
-    return nullptr;
+    return {};
 }
 
 /*!
@@ -311,7 +311,7 @@ void QSGRenderNode::releaseResources()
  */
 QSGRenderNode::RenderingFlags QSGRenderNode::flags() const
 {
-    return nullptr;
+    return {};
 }
 
 /*!

src/quickshapes/qquickshape_p_p.h

@@ -89,7 +89,7 @@ public:
     virtual void beginSync(int totalCount) = 0;
     virtual void endSync(bool async) = 0;
     virtual void setAsyncCallback(void (*)(void *), void *) { }
-    virtual Flags flags() const { return 0; }
+    virtual Flags flags() const { return {}; }
     virtual void setPath(int index, const QQuickPath *path) = 0;
     virtual void setStrokeColor(int index, const QColor &color) = 0;
     virtual void setStrokeWidth(int index, qreal w) = 0;

src/quickshapes/qquickshapegenericrenderer.cpp

@@ -470,14 +470,14 @@ void QQuickShapeGenericRenderer::triangulateStroke(const QPainterPath &path,
     stroker.setInvScale(inverseScale);
 
     if (pen.style() == Qt::SolidLine) {
-        stroker.process(vp, pen, clip, nullptr);
+        stroker.process(vp, pen, clip, {});
     } else {
         QDashedStrokeProcessor dashStroker;
         dashStroker.setInvScale(inverseScale);
-        dashStroker.process(vp, pen, clip, nullptr);
+        dashStroker.process(vp, pen, clip, {});
         QVectorPath dashStroke(dashStroker.points(), dashStroker.elementCount(),
                                dashStroker.elementTypes(), 0);
-        stroker.process(dashStroke, pen, clip, nullptr);
+        stroker.process(dashStroke, pen, clip, {});
     }
 
     if (!stroker.vertexCount()) {

src/quickshapes/qquickshapesoftwarerenderer.cpp

@@ -266,7 +266,7 @@ void QQuickShapeSoftwareRenderNode::render(const RenderState *state)
 
 QSGRenderNode::StateFlags QQuickShapeSoftwareRenderNode::changedStates() const
 {
-    return nullptr;
+    return {};
 }
 
 QSGRenderNode::RenderingFlags QQuickShapeSoftwareRenderNode::flags() const

src/quickwidgets/qquickwidget.cpp

@@ -525,7 +525,7 @@ QImage QQuickWidgetPrivate::grabFramebuffer()
 
 */
 QQuickWidget::QQuickWidget(QWidget *parent)
-: QWidget(*(new QQuickWidgetPrivate), parent, nullptr)
+    : QWidget(*(new QQuickWidgetPrivate), parent, {})
 {
     setMouseTracking(true);
     setFocusPolicy(Qt::StrongFocus);
@@ -553,7 +553,7 @@ QQuickWidget::QQuickWidget(const QUrl &source, QWidget *parent)
   \sa Status, status(), errors()
 */
 QQuickWidget::QQuickWidget(QQmlEngine* engine, QWidget *parent)
-    : QWidget(*(new QQuickWidgetPrivate), parent, nullptr)
+    : QWidget(*(new QQuickWidgetPrivate), parent, {})
 {
     setMouseTracking(true);
     setFocusPolicy(Qt::StrongFocus);

tests/auto/quick/nodes/tst_nodestest.cpp

@@ -121,9 +121,6 @@ class DummyRenderer : public QSGBatchRenderer::Renderer
 public:
     DummyRenderer(QSGRootNode *root, QSGDefaultRenderContext *renderContext)
         : QSGBatchRenderer::Renderer(renderContext)
-        , changedNode(nullptr)
-        , changedState(nullptr)
-        , renderCount(0)
     {
         setRootNode(root);
     }
@@ -139,11 +136,11 @@ public:
         QSGBatchRenderer::Renderer::nodeChanged(node, state);
     }
 
-    QSGNode *changedNode;
+    QSGNode *changedNode = nullptr;
     QSGNode::DirtyState changedState;
 
-    int renderCount;
+    int renderCount = 0;
-    int renderingOrder;
+    int renderingOrder = 0;
     static int globalRendereringOrder;
 };
 

tests/auto/quick/pointerhandlers/multipointtoucharea_interop/tst_multipointtoucharea_interop.cpp

@@ -295,10 +295,10 @@ void tst_MptaInterop::unloadHandlerWithPassiveGrab()
     QVERIFY(mpta);
 
     QPoint point(90, 90);
-    QTest::mousePress(window, Qt::LeftButton, 0, point);
+    QTest::mousePress(window, Qt::LeftButton, {}, point);
     QCOMPARE(window->mouseGrabberItem(), mpta);
     QTRY_VERIFY(handler.isNull()); // it got unloaded
-    QTest::mouseRelease(window, Qt::LeftButton, 0, point); // QTBUG-73819: don't crash
+    QTest::mouseRelease(window, Qt::LeftButton, {}, point); // QTBUG-73819: don't crash
 }
 
 void tst_MptaInterop::dragHandlerInParentStealingGrabFromItem() // QTBUG-75025

tests/auto/quick/qquickmousearea/tst_qquickmousearea.cpp

@@ -717,7 +717,7 @@ void tst_QQuickMouseArea::updateMouseAreaPosOnClick()
     QCOMPARE(mouseRegion->mouseX(), rect->x());
     QCOMPARE(mouseRegion->mouseY(), rect->y());
 
-    QMouseEvent event(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+    QMouseEvent event(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
     QGuiApplication::sendEvent(&window, &event);
 
     QCOMPARE(mouseRegion->mouseX(), 100.0);
@@ -745,7 +745,7 @@ void tst_QQuickMouseArea::updateMouseAreaPosOnResize()
     QCOMPARE(mouseRegion->mouseX(), 0.0);
     QCOMPARE(mouseRegion->mouseY(), 0.0);
 
-    QMouseEvent event(QEvent::MouseButtonPress, rect->position().toPoint(), Qt::LeftButton, Qt::LeftButton, nullptr);
+    QMouseEvent event(QEvent::MouseButtonPress, rect->position().toPoint(), Qt::LeftButton, Qt::LeftButton, {});
     QGuiApplication::sendEvent(&window, &event);
 
     QVERIFY(!mouseRegion->property("emitPositionChanged").toBool());
@@ -774,7 +774,7 @@ void tst_QQuickMouseArea::noOnClickedWithPressAndHold()
         QQuickMouseArea *mouseArea = qobject_cast<QQuickMouseArea*>(window.rootObject()->children().first());
         QVERIFY(mouseArea);
 
-        QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+        QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
         QGuiApplication::sendEvent(&window, &pressEvent);
 
         QCOMPARE(mouseArea->pressedButtons(), Qt::LeftButton);
@@ -788,7 +788,7 @@ void tst_QQuickMouseArea::noOnClickedWithPressAndHold()
         QVERIFY(!window.rootObject()->property("clicked").toBool());
         QVERIFY(window.rootObject()->property("held").toBool());
 
-        QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+        QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
         QGuiApplication::sendEvent(&window, &releaseEvent);
 
         QTRY_VERIFY(window.rootObject()->property("held").toBool());
@@ -804,14 +804,14 @@ void tst_QQuickMouseArea::noOnClickedWithPressAndHold()
         QVERIFY(QTest::qWaitForWindowExposed(&window));
         QVERIFY(window.rootObject() != nullptr);
 
-        QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+        QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
         QGuiApplication::sendEvent(&window, &pressEvent);
 
         QVERIFY(!window.rootObject()->property("clicked").toBool());
 
         QTest::qWait(1000);
 
-        QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+        QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
         QGuiApplication::sendEvent(&window, &releaseEvent);
 
         QVERIFY(window.rootObject()->property("clicked").toBool());
@@ -835,7 +835,7 @@ void tst_QQuickMouseArea::onMousePressRejected()
     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, nullptr);
+    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
 
     QVERIFY(window.rootObject()->property("mr1_pressed").toBool());
@@ -847,7 +847,7 @@ void tst_QQuickMouseArea::onMousePressRejected()
 
     QTest::qWait(200);
 
-    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
     QVERIFY(window.rootObject()->property("mr1_released").toBool());
@@ -882,8 +882,8 @@ void tst_QQuickMouseArea::pressedCanceledOnWindowDeactivate()
     QCOMPARE(window.rootObject()->property("clicked").toInt(), expectedClicks);
 
 
-    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
-    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
 
     QGuiApplication::sendEvent(&window, &pressEvent);
 
@@ -900,7 +900,7 @@ void tst_QQuickMouseArea::pressedCanceledOnWindowDeactivate()
         QCOMPARE(window.rootObject()->property("clicked").toInt(), ++expectedClicks);
 
         QGuiApplication::sendEvent(&window, &pressEvent);
-        QMouseEvent pressEvent2(QEvent::MouseButtonDblClick, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+        QMouseEvent pressEvent2(QEvent::MouseButtonDblClick, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
         QGuiApplication::sendEvent(&window, &pressEvent2);
 
         QTRY_VERIFY(window.rootObject()->property("pressed").toBool());
@@ -953,16 +953,16 @@ void tst_QQuickMouseArea::doubleClick()
 
     // The sequence for a double click is:
     // press, release, (click), press, double click, release
-    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, nullptr);
+    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
 
-    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, nullptr);
+    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
     QCOMPARE(window.rootObject()->property("released").toInt(), 1);
 
     QGuiApplication::sendEvent(&window, &pressEvent);
-    pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, nullptr);
+    pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
@@ -988,10 +988,10 @@ void tst_QQuickMouseArea::clickTwice()
     QVERIFY(mouseArea);
     mouseArea->setAcceptedButtons(acceptedButtons);
 
-    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, nullptr);
+    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
 
-    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, nullptr);
+    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
     QCOMPARE(window.rootObject()->property("pressed").toInt(), 1);
@@ -999,7 +999,7 @@ void tst_QQuickMouseArea::clickTwice()
     QCOMPARE(window.rootObject()->property("clicked").toInt(), 1);
 
     QGuiApplication::sendEvent(&window, &pressEvent);
-    pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, nullptr);
+    pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
@@ -1026,16 +1026,16 @@ void tst_QQuickMouseArea::invalidClick()
 
     // The sequence for a double click is:
     // press, release, (click), press, double click, release
-    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, nullptr);
+    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
 
-    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, nullptr);
+    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
     QCOMPARE(window.rootObject()->property("released").toInt(), 0);
 
     QGuiApplication::sendEvent(&window, &pressEvent);
-    pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, nullptr);
+    pressEvent = QMouseEvent(QEvent::MouseButtonDblClick, QPoint(100, 100), button, button, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
@@ -1055,12 +1055,12 @@ void tst_QQuickMouseArea::pressedOrdering()
 
     QCOMPARE(window.rootObject()->property("value").toString(), QLatin1String("base"));
 
-    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+    QMouseEvent pressEvent(QEvent::MouseButtonPress, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
     QGuiApplication::sendEvent(&window, &pressEvent);
 
     QCOMPARE(window.rootObject()->property("value").toString(), QLatin1String("pressed"));
 
-    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, nullptr);
+    QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPoint(100, 100), Qt::LeftButton, Qt::LeftButton, {});
     QGuiApplication::sendEvent(&window, &releaseEvent);
 
     QCOMPARE(window.rootObject()->property("value").toString(), QLatin1String("toggled"));
@@ -1319,13 +1319,13 @@ void tst_QQuickMouseArea::hoverPropagation()
     QCOMPARE(root->property("point1").toBool(), false);
     QCOMPARE(root->property("point2").toBool(), false);
 
-    QMouseEvent moveEvent(QEvent::MouseMove, QPoint(32, 32), Qt::NoButton, Qt::NoButton, nullptr);
+    QMouseEvent moveEvent(QEvent::MouseMove, QPoint(32, 32), Qt::NoButton, Qt::NoButton, {});
     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, nullptr);
+    QMouseEvent moveEvent2(QEvent::MouseMove, QPoint(232, 32), Qt::NoButton, Qt::NoButton, {});
     QGuiApplication::sendEvent(&window, &moveEvent2);
     QCOMPARE(root->property("point1").toBool(), false);
     QCOMPARE(root->property("point2").toBool(), true);

tests/auto/quick/qquickpixmapcache/tst_qquickpixmapcache.cpp

@@ -431,7 +431,7 @@ void tst_qquickpixmapcache::uncached()
     QUrl url("image://mypixmaps/mypix");
     {
         QQuickPixmap p;
-        p.load(&engine, url, nullptr);
+        p.load(&engine, url, QQuickPixmap::Options{});
         QImage img = p.image();
         QCOMPARE(img.pixel(0,0), qRgb(255, 0, 0));
     }
@@ -440,7 +440,7 @@ void tst_qquickpixmapcache::uncached()
     MyPixmapProvider::fillColor = qRgb(0, 255, 0);
     {
         QQuickPixmap p;
-        p.load(&engine, url, nullptr);
+        p.load(&engine, url, QQuickPixmap::Options{});
         QImage img = p.image();
         QCOMPARE(img.pixel(0,0), qRgb(0, 255, 0));
     }
@@ -458,7 +458,7 @@ void tst_qquickpixmapcache::uncached()
     MyPixmapProvider::fillColor = qRgb(255, 0, 255);
     {
         QQuickPixmap p;
-        p.load(&engine, url, nullptr);
+        p.load(&engine, url, QQuickPixmap::Options{});
         QImage img = p.image();
         QCOMPARE(img.pixel(0,0), qRgb(255, 0, 255));
     }

tests/auto/quick/qquicktextedit/tst_qquicktextedit.cpp

@@ -226,7 +226,7 @@ private:
     void simulateKeys(QWindow *window, const QKeySequence &sequence);
 #endif
 
-    void simulateKey(QWindow *, int key, Qt::KeyboardModifiers modifiers = nullptr);
+    void simulateKey(QWindow *, int key, Qt::KeyboardModifiers modifiers = {});
 
     QStringList standard;
     QStringList richText;
@@ -1389,7 +1389,7 @@ void tst_qquicktextedit::focusOnPress()
     QCOMPARE(textEditObject->hasActiveFocus(), false);
 
     QPoint centerPoint(window.width()/2, window.height()/2);
-    Qt::KeyboardModifiers noModifiers = nullptr;
+    Qt::KeyboardModifiers noModifiers;
     QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
     QGuiApplication::processEvents();
     QCOMPARE(textEditObject->hasFocus(), true);

tests/auto/quick/qquickwindow/tst_qquickwindow.cpp

@@ -73,7 +73,7 @@ static QTouchEvent::TouchPoint makeTouchPoint(QQuickItem *item, const QPointF &p
     return tp;
 }
 
-static TouchEventData makeTouchData(QEvent::Type type, QWindow *w, Qt::TouchPointStates states = nullptr,
+static TouchEventData makeTouchData(QEvent::Type type, QWindow *w, Qt::TouchPointStates states = {},
                                     const QList<QTouchEvent::TouchPoint>& touchPoints = QList<QTouchEvent::TouchPoint>())
 {
     TouchEventData d = { type, nullptr, w, states, touchPoints };
@@ -157,7 +157,7 @@ public:
         setEnabled(true);
         setVisible(true);
 
-        lastEvent = makeTouchData(QEvent::None, window(), nullptr, QList<QTouchEvent::TouchPoint>());//CHECK_VALID
+        lastEvent = makeTouchData(QEvent::None, window(), {}, QList<QTouchEvent::TouchPoint>());//CHECK_VALID
 
         lastVelocity = lastVelocityFromMouseMove = QVector2D();
         lastMousePos = QPointF();
@@ -2082,7 +2082,7 @@ void tst_qquickwindow::requestActivate()
         QString warning = QString::fromLatin1("Mouse event MousePress not accepted by receiving window");
         QWARN(warning.toLatin1().data());
     }
-    me = QMouseEvent(QEvent::MouseButtonPress, pos, window1->mapToGlobal(pos), Qt::LeftButton, nullptr, Qt::NoModifier);
+    me = QMouseEvent(QEvent::MouseButtonPress, pos, window1->mapToGlobal(pos), Qt::LeftButton, {}, Qt::NoModifier);
     QSpontaneKeyEvent::setSpontaneous(&me);
     if (!qApp->notify(window1.data(), &me)) {
         QString warning = QString::fromLatin1("Mouse event MouseRelease not accepted by receiving window");

tests/auto/quick/shared/viewtestutil.cpp

@@ -73,13 +73,13 @@ void QQuickViewTestUtil::moveMouseAway(QQuickView *window)
 void QQuickViewTestUtil::moveAndRelease(QQuickView *window, const QPoint &position)
 {
     QTest::mouseMove(window, position);
-    QTest::mouseRelease(window, Qt::LeftButton, 0, position);
+    QTest::mouseRelease(window, Qt::LeftButton, {}, position);
 }
 
 void QQuickViewTestUtil::moveAndPress(QQuickView *window, const QPoint &position)
 {
     QTest::mouseMove(window, position);
-    QTest::mousePress(window, Qt::LeftButton, 0, position);
+    QTest::mousePress(window, Qt::LeftButton, {}, position);
 }
 
 void QQuickViewTestUtil::flick(QQuickView *window, const QPoint &from, const QPoint &to, int duration)