Merge remote-tracking branch 'origin/5.15' into dev

 Conflicts:
	tests/auto/quick/qquickmousearea/BLACKLIST

Change-Id: I3de2c6377d57f5f9204d2cfc688d50a7a0b4150c

8 files changed, 75 insertions, 74 deletions

diff --git a/src/qml/doc/src/cppintegration/definetypes.qdoc b/src/qml/doc/src/cppintegration/definetypes.qdoc
index f66dc44383..cbbbd9ba58 100644
--- a/src/qml/doc/src/cppintegration/definetypes.qdoc
+++ b/src/qml/doc/src/cppintegration/definetypes.qdoc
@@ -307,7 +307,7 @@ merged with the original target class when used from within QML. For example:
 The \c leftMargin property is a new property added to an existing C++ type, \l
 QLineEdit, without modifying its source code.
 
-The \l {QML_EXTENDED(extended)} macro is for registering extended types. The
+The QML_EXTENDED(extended) macro is for registering extended types. The
 argument is the name of another class to be used as extension.
 
 An extension class is a regular QObject, with a constructor that takes a QObject
diff --git a/src/qml/doc/src/cppintegration/extending-tutorial.qdoc b/src/qml/doc/src/cppintegration/extending-tutorial.qdoc
index d587173e5a..458768bf18 100644
--- a/src/qml/doc/src/cppintegration/extending-tutorial.qdoc
+++ b/src/qml/doc/src/cppintegration/extending-tutorial.qdoc
@@ -103,11 +103,22 @@ functionality of an existing QObject-based class, it could inherit from that cla
 Alternatively, if we want to create a visual item that doesn't need to perform drawing
 operations with the QPainter API, we can just subclass QQuickItem.
 
-The \c PieChart class defines the two properties, \c name and \c color, with the Q_PROPERTY macro,
-and overrides QQuickPaintedItem::paint(). The class implementation in \c piechart.cpp
-simply sets and returns the \c m_name and \c m_color values as appropriate, and
-implements \c paint() to draw a simple pie chart. It also turns off the
-QGraphicsItem::ItemHasNoContents flag to enable painting:
+The \c PieChart class defines the two properties, \c name and \c color, with the
+Q_PROPERTY macro, and overrides QQuickPaintedItem::paint(). The \c PieChart
+class is registered using the QML_ELEMENT macro, to allow it to be used from
+QML. If you don't register the class, \c app.qml won't be able to create a
+\c PieChart.
+
+For the registration to take effect, the \c qmltypes option is added to
+\c CONFIG in the project file and a \c QML_IMPORT_NAME and
+\c QML_IMPORT_MAJOR_VERSION are given:
+
+\snippet tutorials/extending-qml/chapter1-basics/chapter1-basics.pro 0
+
+The class implementation in \c piechart.cpp simply sets and returns the
+\c m_name and \c m_color values as appropriate, and implements \c paint() to
+draw a simple pie chart. It also turns off the QGraphicsItem::ItemHasNoContents
+flag to enable painting:
 
 \snippet tutorials/extending-qml/chapter1-basics/piechart.cpp 0
 \dots 0
@@ -125,9 +136,7 @@ provided for various other \l {QML Basic Types}{basic types}; for example, a str
 like "640x480" can be automatically converted to a QSize value.
 
 We'll also create a C++ application that uses a QQuickView to run and
-display \c app.qml. The application must register the \c PieChart type
-using the qmlRegisterType() function, to allow it to be used from QML. If
-you don't register the type, \c app.qml won't be able to create a \c PieChart.
+display \c app.qml.
 
 Here is the application \c main.cpp:
 
@@ -143,7 +152,7 @@ Now we can build and run the application:
 
 \image extending-tutorial-chapter1.png
 
-\note You may see a warning \e {Expression ... depends on non-NOTIFYable properties:
+\note You may see a warning \e {Expression ... depends on non-NOTIFYable properties:
       PieChart::name}. This happens because we add a binding to the writable \c name
       property, but haven't yet defined a notify signal for it. The QML engine therefore
       cannot update the binding if the \c name value changes. This is addressed in
@@ -450,7 +459,7 @@ In this tutorial, we've shown the basic steps for creating a QML extension:
 
 \list
 \li Define new QML types by subclassing QObject and registering them with
-    qmlRegisterType()
+    QML_ELEMENT or QML_NAMED_ELEMENT()
 \li Add callable methods using \l Q_INVOKABLE or Qt slots, and connect to Qt signals
     with an \c onSignal syntax
 \li Add property bindings by defining \l{Qt's Property System}{NOTIFY} signals
diff --git a/src/qml/doc/src/qmlfunctions.qdoc b/src/qml/doc/src/qmlfunctions.qdoc
index 63c28d7aa7..04d907f168 100644
--- a/src/qml/doc/src/qmlfunctions.qdoc
+++ b/src/qml/doc/src/qmlfunctions.qdoc
@@ -27,7 +27,7 @@
 
 /*!
   \macro QML_ELEMENT
-  \related QQmlEngine
+  \relates QQmlEngine
 
   Declares the enclosing type or namespace to be available in QML, using its
   class or namespace name as the QML element name.
@@ -45,10 +45,10 @@
   \endcode
 
   You can use the build system to register the type in the type namespace
-  "com.mycompany.qmlcomponents" with major version \c 1 by specifying the
+  \e {com.mycompany.qmlcomponents} with major version \c 1 by specifying the
   following in your project file:
 
-  \code
+  \badcode
   CONFIG += qmltypes
   QML_IMPORT_NAME = com.mycompany.qmlcomponents
   QML_IMPORT_MAJOR_VERSION = 1
@@ -74,7 +74,7 @@
 
 /*!
   \macro QML_NAMED_ELEMENT(name)
-  \related QQmlEngine
+  \relates QQmlEngine
 
   Declares the enclosing type or namespace to be available in QML, using \a name
   as the element name. Otherwise behaves the same as QML_ELEMENT.
@@ -209,7 +209,7 @@
   {attached property} to other types. This takes effect if the type
   is exposed to QML using a \l QML_ELEMENT or \l QML_NAMED_ELEMENT() macro.
 
-  \sa QML_ELEMENT, QML_NAMED_ELEMENT(), qmlAtachedPropertiesObject(),
+  \sa QML_ELEMENT, QML_NAMED_ELEMENT(), qmlAttachedPropertiesObject(),
       {Providing Attached Properties}
 */
 
@@ -234,7 +234,7 @@
   \l QML_ATTACHED(), or \l QML_EXTENDED() macros in the enclosing C++ type do
   not apply to the enclosing type but instead to \a FOREIGN_TYPE. The enclosing
   type still needs to be registered with the
-  \l {The Meta-Object System}{meta object system} using a \l G_GADGET or
+  \l {The Meta-Object System}{meta object system} using a \l Q_GADGET or
   \l Q_OBJECT macro.
 
   This is useful for registering types that cannot be amended to add the macros,
@@ -278,13 +278,14 @@
 
   This will cause any QML which attempts to use the "Game" type to produce an
   error message:
-  \code
+
+  \badcode
   fun.qml: Get back to work, slacker!
      Game {
      ^
   \endcode
 
-  Using this technique, you only need a \l G_GADGET struct to customize the error
+  Using this technique, you only need a \l Q_GADGET struct to customize the error
   message, not a full-blown \l QObject. Without \l QML_UNCREATABLE(),
   \l QML_UNAVAILABLE still results in a more specific error message than the usual
   "is not a type" for completely unknown types.
@@ -905,7 +906,7 @@
 */
 
 /*!
-   \fn int qmlRegisterSingletonInstance(const char *uri, int versionMajor, int versionMinor, const char *typeName, QObject* cppObject)
+   \fn template<typename T> auto qmlRegisterSingletonInstance(const char *uri, int versionMajor, int versionMinor, const char *typeName, T *cppObject)
    \relates QQmlEngine
    \since 5.14
 
diff --git a/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc b/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc
index 2eaedf8f9b..a4119ff793 100644
--- a/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc
+++ b/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc
@@ -125,10 +125,11 @@ component <component name> : BaseType {
 Inside the file which declares the inline component, the type can be referenced
 simply by its name.
 
-\snippet src/qml/doc/snippets/qml/qml-documents/Images.qml document
+\snippet qml/qml-documents/Images.qml document
 
 In other files, it has to be prefixed with the name of its containing component.
-\snippet src/qml/doc/snippets/qml/qml-documents/LabeledImageBox.qml document
+
+\snippet qml/qml-documents/LabeledImageBox.qml document
 
 \note Inline components don't share their scope with the component they are
 declared in. In the following example, when \c A.MyInlineComponent in file
@@ -137,8 +138,8 @@ an id in B.qml.
 It is therefore advisable not to reference objects in an inline component
 which are not part of it.
 
-\snippet src/qml/doc/snippets/qml/qml-documents/A.qml document
-\snippet src/qml/doc/snippets/qml/qml-documents/B.qml document
+\snippet qml/qml-documents/A.qml document
+\snippet qml/qml-documents/B.qml document
 
 \note Inline components cannot be nested.
 
diff --git a/src/qml/doc/src/qmllanguageref/modules/qmldir.qdoc b/src/qml/doc/src/qmllanguageref/modules/qmldir.qdoc
index f7d71030b5..99c7fa5621 100644
--- a/src/qml/doc/src/qmllanguageref/modules/qmldir.qdoc
+++ b/src/qml/doc/src/qmllanguageref/modules/qmldir.qdoc
@@ -422,7 +422,7 @@ import QtQuick.tooling 1.1
 // Component objects.
 Module {
     // A Component object directly corresponds to a type exported
-    // in a plugin with a call to qmlRegisterType.
+    // using the QML_ELEMENT or QML_NAMED_ELEMENT macros.
     Component {
 
         // The name is a unique identifier used to refer to this type.
@@ -440,25 +440,34 @@ Module {
         attachedType: "QQuickAnimationAttached"
 
         // The list of exports determines how a type can be imported.
-        // Each string has the format "URI/Name version" and matches the
-        // arguments to qmlRegisterType. Usually types are only exported
-        // once, if at all.
-        // If the "URI/" part of the string is missing that means the
-        // type should be put into the package defined by the URI the
-        // module was imported with.
-        // For example if this module was imported with 'import Foo 4.8'
-        // the Animation object would be found in the package Foo and
-        // QtQuick.
+        // Each string has the format "URI/Name version". The URI is
+        // the import name given via the build system, for example as
+        // QML_IMPORT_NAME in qmake. The name is either the C++ class
+        // name or, in case of QML_NAMED_ELEMENT(), an explicitly given
+        // name. The version is constructed from the major version
+        // given via the build system, as QML_IMPORT_MAJOR_VERSION in
+        // qmake, and any revisions given in the class or its base
+        // classes by Q_REVISION(), the REVISION argument to Q_PROPERTY,
+        // or QML_ADDED_IN_MINOR_VERSION(). Usually types are only
+        // exported once, if at all. The following tells us that there
+        // are two variants of Animation, and that 'import QtQuick 2.0'
+        // will expose a different revision than imports of later
+        // versions.
         exports: [
-            "Animation 4.7",
-            "QtQuick/Animation 1.0"
+            "QtQuick/Animation 2.0",
+            "QtQuick/Animation 2.1"
         ]
 
         // The meta object revisions for the exports specified in 'exports'.
-        // Describes with revisioned properties will be visible in an export.
-        // The list must have exactly the same length as the 'exports' list.
-        // For example the 'animations' propery described below will only be
-        // available through the QtQuick/Animation 1.0 export.
+        // Each meta object revision may add additional properties or methods,
+        // relative to the previous one. Those will only be visible when the
+        // module is imported with at least the corresponding version as
+        // specified in the 'exports' list.
+        // The exportMetaObjectRevisions list must have exactly the same
+        // length as the 'exports' list. For example, the 'animations' property
+        // described below will only be available through the QtQuick/Animation
+        // 2.1 export. Usually the revisions will match the versions in the
+        // 'exports' list.
         exportMetaObjectRevisions: [0, 1]
 
         Property {
@@ -486,7 +495,7 @@ Module {
         // declarations also support the isReadonly, isPointer and isList
         // attributes which mean the same as for Property
         Method { name: "restart" }
-        Signal { name: "started"; revision: 2 }
+        Signal { name: "started"; revision: 1 }
         Signal {
             name: "runningChanged"
             Parameter { type: "bool" }
diff --git a/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc b/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
index 32106d5bb8..fdba452271 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
@@ -127,15 +127,15 @@ Rectangle {
 
 In this case, the engine will emit an error and refuse to load the file.
 
-\section4 Non-module Namespace Imports
+\section4 C++ Module Imports
 
-Types can also be registered into namespaces directly via the various
-registration functions in C++ (such as qmlRegisterType()).  The types which
-have been registered into a namespace in this way may be imported by importing
-the namespace, as if the namespace was a module identifier.
+Usually, C++ types are declared using the QML_ELEMENT and QML_NAMED_ELEMENT()
+macros and registered via the build system using QML_IMPORT_NAME and
+QML_IMPORT_MAJOR_VERSION. The import name and version given this way form a
+module that can be imported to access the types.
 
 This is most common in client applications which define their own QML object
-types in C++ and register them with the QML type system manually.
+types in C++.
 
 \section4 Importing into a Qualified Local Namespace
 
diff --git a/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc b/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc
index 832d9a9e26..ecfef2e04f 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc
@@ -684,7 +684,7 @@ Required properties play a special role in model-view-delegate code:
 If the delegate of a view has required properties whose names match with
 the role names of the view's model, then those properties will be initialized
 with the model's corresponding values.
-For more information, visit the \l{Models and Views in QtQuick} page.
+For more information, visit the \l{Models and Views in Qt Quick} page.
 
 \sa {QQmlComponent::createWithInitialProperties}, {QQmlApplicationEngine::setInitialProperties}
 and {QQuickView::setInitialProperties} for ways to initialize required properties from C++.
diff --git a/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc b/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc
index 5144fe219e..53984a440d 100644
--- a/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc
+++ b/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc
@@ -582,34 +582,15 @@ property is only invoked when the property is reassigned to a different object v
     QML objects (and certainly not JavaScript object either) and the key-value
     pairs in \c attributes are \e not QML properties. Rather, the \c items
     property holds an array of values, and \c attributes holds a set of key-value
-    pairs. Since they are stored as a set of values, instead of as an object,
-    their contents \e cannot be modified individually:
-
-    \qml
-    Item {
-        property variant items: [1, 2, 3, "four", "five"]
-        property variant attributes: { 'color': 'red', 'width': 100 }
-
-        Component.onCompleted: {
-            items[0] = 10
-            console.log(items[0])     // This will still be '1'!
-            attributes.color = 'blue'
-            console.log(attributes.color)     // This will still be 'red'!
-        }
-    }
-    \endqml
-
-    Since it is not possible to individually add or remove items from a list or
-    object stored in a \c variant, the only way to modify its contents is to
-    reassign a new value. However, this is not efficient, as it causes the value
-    to be serialized and deserialized.
+    pairs.
 
     Additionally, since \c items and \c attributes are not QML objects, changing
-    their individual values do not trigger property change notifications. If
-    the above example had \c onNumberChanged or \c onAnimalChanged signal
-    handlers, they would not have been called.  If, however, the \c items or
-    \c attributes properties themselves were reassigned to different values, then
-    such handlers would be called.
+    the values they contain does not trigger property change notifications. If
+    the above example had \c onItemsChanged or \c onAttributesChanged signal
+    handlers, they would not be called when assigning individual entries in
+    either property.  If, however, the \c items or \c attributes properties
+    themselves were reassigned to different values, then such handlers would be
+    called.
 
     JavaScript programmers should also note that when a JavaScript object is
     copied to an array or map property, the \e contents of the object (that is,