Doc: Qt Quick: Fix module name format (Pt 1/2)

Follow the conventions at
http://qt-project.org/wiki/Spelling_Module_Names_in_Qt_Documentation

Attempt to differentiate between the whole module ("Qt Quick") and the
QML import ("QtQuick") by encoding the latter with monospace font. There
are places in the text where both representations are valid.

Change-Id: Id6e157a4191aaa4e23a9cd5c76abfe902fe43d33
Reviewed-by: Jerome Pasion <jerome.pasion@digia.com>

11 files changed, 25 insertions, 25 deletions

diff --git a/src/qml/doc/src/cppintegration/data.qdoc b/src/qml/doc/src/cppintegration/data.qdoc
index ba8ad47bab..dc1b4cae9c 100644
--- a/src/qml/doc/src/cppintegration/data.qdoc
+++ b/src/qml/doc/src/cppintegration/data.qdoc
@@ -119,9 +119,9 @@ when passed from C++ to QML and vice-versa:
         \li \l enumeration
 \endtable
 
-(Note that classes provided by the QtGui module, such as QColor, QFont,
-QQuaternion and QMatrix4x4, are only available from QML when the \l QtQuick
-module is imported.)
+\note Classes provided by the \l {Qt GUI} module, such as QColor, QFont,
+QQuaternion and QMatrix4x4, are only available from QML when the \l {Qt Quick}
+module is included.
 
 As a convenience, many of these types can be specified in QML by string values,
 or by a related method provided by the \l {QML:Qt} object. For example, the \l
diff --git a/src/qml/doc/src/cppintegration/definetypes.qdoc b/src/qml/doc/src/cppintegration/definetypes.qdoc
index b8879ebb04..af7aed251d 100644
--- a/src/qml/doc/src/cppintegration/definetypes.qdoc
+++ b/src/qml/doc/src/cppintegration/definetypes.qdoc
@@ -291,7 +291,7 @@ qmlRegisterRevision<BaseType,1>("MyTypes", 1, 1);
 \endcode
 
 This is useful when deriving from base classes provided by other authors,
-e.g. when extending classes from the QtQuick library.
+e.g. when extending classes from the Qt Quick module.
 
 
 \section1 Defining QML-Specific Types and Attributes
@@ -677,11 +677,11 @@ to be declared for an item without explicitly assigning them to the
 
 \section2 Defining Visual Items with the QtQuick Module
 
-When building user interfaces with the QtQuick module, all QML objects that are
+When building user interfaces with the \l {Qt Quick} module, all QML objects that are
 to be visually rendered must derive from the \l Item type, as it is the base
-type for all visual objects in the QtQuick module. This \l Item type is
+type for all visual objects in \l {Qt Quick}. This \l Item type is
 implemented by the QQuickItem C++ class, which is provided as part of the
-QtQuick C++ module. Therefore, this class should be subclassed when it is
+\l {Qt Quick} C++ module. Therefore, this class should be subclassed when it is
 necessary to implement a visual type in C++ that can be integrated into a
 QML-based user interface.
 
diff --git a/src/qml/doc/src/cppintegration/topic.qdoc b/src/qml/doc/src/cppintegration/topic.qdoc
index 41645e2379..b6df231b3f 100644
--- a/src/qml/doc/src/cppintegration/topic.qdoc
+++ b/src/qml/doc/src/cppintegration/topic.qdoc
@@ -43,7 +43,7 @@ with QML and JavaScript within \l{qtqml-documents-topic.html}{QML documents}, an
 C++
 \li Use and invoke some C++ functionality from QML (for example, to invoke your application logic,
 use a data model implemented in C++, or call some functions in a third-party C++ library)
-\li Access functionality in the \l {Qt QML} or QtQuick C++ API (for example, to dynamically generate
+\li Access functionality in the \l {Qt QML} or \l {Qt Quick} C++ API (for example, to dynamically generate
 images using QQuickImageProvider)
 \li Implement your own \l{qtqml-typesystem-objecttypes.html}{QML object types} from C++
 \unicode{0x2014} whether for use within your own specific application, or for distribution to others
diff --git a/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc b/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc
index 09faa61672..27fcc7b39b 100644
--- a/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc
+++ b/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc
@@ -66,7 +66,7 @@ can take one or two arguments:
 \li The first is the parent for the new object.  The parent can be a graphical
     object (i.e. of the \l Item type) or non-graphical object (i.e. of the
     \l QtObject or C++ QObject type). Only graphical objects with graphical
-    parent objects will be rendered to the QtQuick visual canvas.  If you wish
+    parent objects will be rendered to the \l {Qt Quick} visual canvas.  If you wish
     to set the parent later you can safely pass \c null to this function.
 \li The second is optional and is a map of property-value pairs that define
     initial any property values for the object.  Property values specified by
diff --git a/src/qml/doc/src/javascript/imports.qdoc b/src/qml/doc/src/javascript/imports.qdoc
index 800091689c..f4d7f7dc08 100644
--- a/src/qml/doc/src/javascript/imports.qdoc
+++ b/src/qml/doc/src/javascript/imports.qdoc
@@ -71,13 +71,13 @@ parameters and return values when calling such functions from QML.
 
 \section1 Imports Within JavaScript Resources
 
-In QtQuick 2.0, support has been added to allow JavaScript resources to import
+In \c {QtQuick 2.0}, support has been added to allow JavaScript resources to import
 other JavaScript resources and also QML type namespaces using a variation of
 the standard QML import syntax (where all of the previously described rules and
 qualifications apply).
 
 Due to the ability of a JavaScript resource to import another script or QML
-module in this fashion in QtQuick 2.0, some extra semantics are defined:
+module in this fashion in \c {QtQuick 2.0}, some extra semantics are defined:
 \list
 \li a script with imports will not inherit imports from the QML document which imported it (so accessing Component.errorString will fail, for example)
 \li a script without imports will inherit imports from the QML document which imported it (so accessing Component.errorString will succeed, for example)
diff --git a/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc b/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc
index b9df6a4381..4e1d4a2c86 100644
--- a/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc
+++ b/src/qml/doc/src/qmllanguageref/documents/definetypes.qdoc
@@ -29,7 +29,7 @@
 \title Defining Object Types through QML Documents
 \brief Description of how a QML document is a reusable type definition
 
-One of the core features of QML is that it enables QML object types to be easily defined in a lightweight manner through QML documents to suit the needs of individual QML applications. The standard QtQuick module provides various types like \l Rectangle, \l Text and \l Image for building a QML application; beyond these, you can easily define your own QML types to be reused within your application. This ability to create your own types forms the building blocks of any QML application.
+One of the core features of QML is that it enables QML object types to be easily defined in a lightweight manner through QML documents to suit the needs of individual QML applications. The standard \l {Qt Quick} module provides various types like \l Rectangle, \l Text and \l Image for building a QML application; beyond these, you can easily define your own QML types to be reused within your application. This ability to create your own types forms the building blocks of any QML application.
 
 
 \section1 Defining an Object Type with a QML File
diff --git a/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc b/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc
index d20f66d80a..cdfab3cd3f 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc
@@ -89,9 +89,9 @@ Rectangle {
 }
 \endqml
 
-This declares an object of type \l Rectangle, followed by a set of curly braces that encompasses the attributes defined for that object. The \l Rectangle type is a type made available by the \l QtQuick module, and the attributes defined in this case are the values of the rectangle's \c width, \c height and \c color properties. (These are properties made available by the \l Rectangle type, as described in the \l Rectangle documentation.)
+This declares an object of type \l Rectangle, followed by a set of curly braces that encompasses the attributes defined for that object. The \l Rectangle type is a type made available by the \c QtQuick module, and the attributes defined in this case are the values of the rectangle's \c width, \c height and \c color properties. (These are properties made available by the \l Rectangle type, as described in the \l Rectangle documentation.)
 
-The above object can be loaded by the engine if it is part of a \l{qtqml-documents-topic.html}{QML document}. That is, if the source code is complemented with \e import statement that imports the QtQuick module (to make the \l Rectangle type available), as below:
+The above object can be loaded by the engine if it is part of a \l{qtqml-documents-topic.html}{QML document}. That is, if the source code is complemented with \e import statement that imports the \c QtQuick module (to make the \l Rectangle type available), as below:
 
 \qml
 import QtQuick 2.0
@@ -103,7 +103,7 @@ Rectangle {
 }
 \endqml
 
-When placed into a \c .qml file and loaded by the QML engine, the above code creates a \l Rectangle object using the \l Rectangle type supplied by the QtQuick module:
+When placed into a \c .qml file and loaded by the QML engine, the above code creates a \l Rectangle object using the \l Rectangle type supplied by the \c QtQuick module:
 
 \image qtqml-syntax-basics-object-declaration.png
 
@@ -140,7 +140,7 @@ Rectangle {
 When this code is loaded by the engine, it creates an object tree with a \l Rectangle object at the root; this object has a \l Gradient child object, which in turn has two \l GradientStop children.
 
 Note, however, that this is a parent-child relationship in the context of the QML object tree, not
-in the context of the visual scene. The concept of a parent-child relationship in a visual scene is provided by the \l Item type from the \l QtQuick module, which is the base type for most QML types, as most QML objects are intended to be visually rendered. For example, \l Rectangle and \l Text are both \l {Item}-based types, and below, a \l Text object has been declared as a visual child of a \l Rectangle object:
+in the context of the visual scene. The concept of a parent-child relationship in a visual scene is provided by the \l Item type from the \c QtQuick module, which is the base type for most QML types, as most QML objects are intended to be visually rendered. For example, \l Rectangle and \l Text are both \l {Item}-based types, and below, a \l Text object has been declared as a visual child of a \l Rectangle object:
 
 \qml
 import QtQuick 2.0
diff --git a/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc b/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
index eda7dbf006..1496a1e5c9 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/imports.qdoc
@@ -144,7 +144,7 @@ the types should be imported into a particular document-local namespace. If a
 namespace is specified, then any references to the types made available by the
 import must be prefixed by the local namespace qualifier.
 
-Below, the QtQuick module is imported into the namespace "CoreItems". Now, any
+Below, the \c QtQuick module is imported into the namespace "CoreItems". Now, any
 references to types from the \c QtQuick module must be prefixed with the
 \c CoreItems name:
 
@@ -178,7 +178,7 @@ CoreItems.Rectangle {
     width: 100; height: 100
 
     MyModule.Text { text: "Hello from my custom text item!" }
-    CoreItems.Text { text: "Hello from QtQuick!" }
+    CoreItems.Text { text: "Hello from Qt Quick!" }
 }
 \endqml
 
diff --git a/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc b/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc
index 6c90ddcf0a..fba072d2e4 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/signals.qdoc
@@ -115,7 +115,7 @@ Even though the \l MouseArea documentation does not document a signal handler na
 
 \section2 Using the Connections Type
 
-In some cases it may be desirable to access a signal outside of the object that emits it. For these purposes, the QtQuick module provides the \l Connections type for connecting to signals of arbitrary objects. A \l Connections object can receive any signal from its specified \l {Connections::target}{target}.
+In some cases it may be desirable to access a signal outside of the object that emits it. For these purposes, the \c QtQuick module provides the \l Connections type for connecting to signals of arbitrary objects. A \l Connections object can receive any signal from its specified \l {Connections::target}{target}.
 
 For example, the \c onClicked handler in the earlier example could have been received by the root \l Rectangle instead, by placing the \c onClicked handler in a \l Connections object that has its \l {Connections::target}{target} set to the \l MouseArea:
 
diff --git a/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc b/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc
index 6f468d42bc..c195c8724f 100644
--- a/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc
+++ b/src/qml/doc/src/qmllanguageref/typesystem/basictypes.qdoc
@@ -67,7 +67,7 @@ The basic types supported natively in the QML language are listed below:
 \section2 Basic Types Provided By QML Modules
 
 QML modules may extend the QML language with more basic types.
-For example, the basic types provided by the QtQuick module are listed below:
+For example, the basic types provided by the \c QtQuick module are listed below:
 \annotatedlist qtquickbasictypes
 
 Currently only QML modules which are provided by Qt may provide their
diff --git a/src/qml/doc/src/whatsnew.qdoc b/src/qml/doc/src/whatsnew.qdoc
index b73b6436f1..e561ec5215 100644
--- a/src/qml/doc/src/whatsnew.qdoc
+++ b/src/qml/doc/src/whatsnew.qdoc
@@ -34,8 +34,8 @@
 The \l{Qt QML} module is new in Qt 5.0. It provides the QML engine and
 implements the QML language supporting infrastructure.
 
-(Prior to Qt 5, this functionality was provided by the QtDeclarative module, which
-has now been replaced by the new \l {Qt QML} and QtQuick C++ modules. See the
+(Prior to Qt 5, this functionality was provided by the \c QtDeclarative module, which
+has now been replaced by the new \l {Qt QML} and \l {Qt Quick} C++ modules. See the
 \l {Porting QML Applications to Qt 5} for more information.)
 
 \section2 QML Engine
@@ -72,11 +72,11 @@ has now been replaced by the new \l {Qt QML} and QtQuick C++ modules. See the
     \list
     \li QML now supports defining properties of value type basic types within QML documents.  Supported types include
         QSizeF, QPointF and QRectF as \c size, \c point and \c rect respectively.
-    \li QColor is now a value type provided by the QtQuick module.  The red, green, blue and alpha channels
+    \li QColor is now a value type provided by the \c QtQuick module.  The red, green, blue and alpha channels
         of a \l color property can be accessed via \c r, \c g, \c b and \c a properties.
     \li Factory functions for various value types have been added to the \c Qt object exposed to QML.
-        Some of those functions require the QtQuick module to be imported in order to return valid values.
-        See the QtQuick 2.0 release notes for more information about these functions.
+        Some of those functions require the \c QtQuick module to be imported in order to return valid values.
+        See the \l {Qt Quick Release Notes} for more information about these functions.
     \endlist
 \li Support for sequence types QList<int>, QList<qreal>, QList<bool>, QList<QUrl>,
     QList<QString> and QStringList has been improved. QObjects can define Q_PROPERTYs of