Make title capitalization more consistent in QML documentation.

Change-Id: Iec8168135676e0e9e130bd2245ef33fd780829d5
Reviewed-by: Alan Alpert <alan.alpert@nokia.com>

23 files changed, 81 insertions, 81 deletions

diff --git a/src/qml/doc/src/cppclasses/topic.qdoc b/src/qml/doc/src/cppclasses/topic.qdoc
index 93d7bb3190..b552a9c50a 100644
--- a/src/qml/doc/src/cppclasses/topic.qdoc
+++ b/src/qml/doc/src/cppclasses/topic.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 /*!
 \page qtqml-cppclasses-topic.html
-\title C++ Classes Provided By The Qt QML Module
+\title C++ Classes Provided by the Qt QML Module
 \brief Overview of the C++ classes provided by the Qt QML module
 
 The Qt QML module provides C++ classes which implement the QML framework.
diff --git a/src/qml/doc/src/cppintegration/data.qdoc b/src/qml/doc/src/cppintegration/data.qdoc
index ef388a1ed5..7429a1d2bf 100644
--- a/src/qml/doc/src/cppintegration/data.qdoc
+++ b/src/qml/doc/src/cppintegration/data.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 /*!
 \page qtqml-cppintegration-data.html
-\title Exposing Data From C++ To QML
+\title Exposing Data from C++ to QML
 \brief Description of how to expose data from C++ to QML
 
 
@@ -87,7 +87,7 @@ on using Qt properties with QML.
 
 
 
-\section1 Supported data types
+\section1 Supported Data Types
 
 Any C++ data that is used from QML - whether as custom properties, or parameters for signals or
 functions - must be of a type that is recognizable by QML.
@@ -263,7 +263,7 @@ a QColor-type property or to call a C++ function that requires a QColor paramete
 
 
 
-\section1 Data Returned From Instance Method Invocation
+\section1 Data Returned from Instance Method Invocation
 
 A registered C++ type may have functions flagged with the
 Q_INVOKABLE flag defined.  Those functions of an instance of
diff --git a/src/qml/doc/src/cppintegration/functions.qdoc b/src/qml/doc/src/cppintegration/functions.qdoc
index d32dd7722f..19dff3cd10 100644
--- a/src/qml/doc/src/cppintegration/functions.qdoc
+++ b/src/qml/doc/src/cppintegration/functions.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 /*!
 \page qtqml-cppintegration-functions.html
-\title Exposing C++ Functionality To QML
+\title Exposing C++ Functionality to QML
 \brief Description of how to expose functionality defined in C++ to QML
 
 
@@ -36,7 +36,7 @@
 
 
 
-\section1 Properties Of Types Defined In C++
+\section1 Properties of Types Defined in C++
 
 Any \l {The Property System}{Qt properties} - that is, those declared with the Q_PROPERTY()
 macro - are accessible from QML. Here is a modified version of the \l {Embedding C++ objects into
@@ -55,7 +55,7 @@ the property cannot be used for \l{Property Binding}, as the QML engine would no
 notified when the value changes. If you are using custom types in QML, make sure their
 properties have NOTIFY signals so that they can be used in property bindings.
 
-\section1 Signals And Slots
+\section1 Signals and Slots
 
 QML integrates with the normal Qt C++ signals and slots system.
 Signal handlers may be defined in a QML object, to handle signals
diff --git a/src/qml/doc/src/cppintegration/reverse.qdoc b/src/qml/doc/src/cppintegration/reverse.qdoc
index e9948ee112..a4b4c8c543 100644
--- a/src/qml/doc/src/cppintegration/reverse.qdoc
+++ b/src/qml/doc/src/cppintegration/reverse.qdoc
@@ -26,16 +26,16 @@
 ****************************************************************************/
 /*!
 \page qtqml-cppintegration-reverse.html
-\title Interacting With QML Objects From C++
+\title Interacting with QML Objects from C++
 \brief Description of how to interact with QML objects from C++
 
-\section1 QML Objects, QObject And QMetaObject
+\section1 QML Objects, QObject and QMetaObject
 
 QML object types are, internally, QObject-derived types.  Each type has an
 associated QMetaObject, and all functions, properties and signals of an
 instance of a QML object type can be accessed through the QMetaObject.
 
-\section1 Accessing QML Objects From C++
+\section1 Accessing QML Objects from C++
 
 Once you have a pointer to a QML object in C++, you can access its properties,
 invoke its functions, and connect to its signals.  To get such a pointer, a
@@ -89,7 +89,7 @@ below for further details.
 
 
 
-\section2 Object Name And findChild
+\section2 Object Name and findChild
 
 NOTE: this is only applicable to QML object types provided by the Qt Quick
 module.
@@ -121,7 +121,7 @@ to, for example, swap a QML view component for another view, if the new componen
 required \c objectName. It is better for the C++ implementation to know as little as possible about
 the QML user interface implementation and the composition of the QML object tree.
 
-\section2 Passed As Arguments
+\section2 Passed as Arguments
 
 Any QML object may be passed as an argument to a Q_INVOKABLE C++ function
 if that function has a pointer to a QObject as a parameter.  The object
@@ -192,7 +192,7 @@ QML supports the calling of overloaded C++ functions. If there are multiple C++
 same name but different arguments, the correct function will be called according to the number and
 the types of arguments that are provided.
 
-\section1 Signals And Slots
+\section1 Signals and Slots
 
 All QML signals are automatically available to C++, and can be connected to using QObject::connect()
 like any ordinary Qt C++ signal. In return, any C++ signal can be received by a QML object using
diff --git a/src/qml/doc/src/cppintegration/topic.qdoc b/src/qml/doc/src/cppintegration/topic.qdoc
index 1fd0cd7df4..3b88c50099 100644
--- a/src/qml/doc/src/cppintegration/topic.qdoc
+++ b/src/qml/doc/src/cppintegration/topic.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 /*!
 \page qtqml-cppintegration-topic.html
-\title Integrating QML And C++
+\title Integrating QML and C++
 \brief Description of how to integrate QML and C++ code
 
 QML was designed to allow tight integration with C++ code.  This allows hybrid
@@ -62,13 +62,13 @@ QML code
 \endlist
 
 
-\section1 Exposing C++ Types To QML
+\section1 Exposing C++ Types to QML
 
 QML types may be implemented in C++ and then exposed to the QML type system via
 plugins or type registration.  This is covered in more detail elsewhere in the
 documentation; see the documentation regarding
 \l{qtqml-cppintegration-registercpptypes.html}
-{Registering C++ Types With The QML Type System} for more information on that
+{Registering C++ Types with the QML Type System} for more information on that
 topic.
 
 For more information on the specifics of how to define C++ types for use in QML
@@ -76,23 +76,23 @@ For more information on the specifics of how to define C++ types for use in QML
 about defining \l{qtqml-modules-cppplugins.html#creating-a-plugin}
 {C++ types for use in QML}.
 
-\section1 Exposing C++ Data To QML
+\section1 Exposing C++ Data to QML
 
 Data from C++ may be exposed to QML via context properties, instance
 properties, or by returning data from Q_INVOKABLE methods.  For more
 information about each of these approaches, and the ownership semantics
 applicable to each, see the documentation on \l{qtqml-cppintegration-data.html}
-{Exposing C++ Data To QML}.
+{Exposing C++ Data to QML}.
 
-\section1 Exposing C++ Functions To QML
+\section1 Exposing C++ Functions to QML
 
 Functions from C++ may be exposed to QML via signals and slots, by tagging a
 function declaration with the Q_INVOKABLE macro, or by registering the C++ type
 as a module API and installing that module API into a particular namespace.
 For more information about these approaches, see the documentation on
-\l{qtqml-cppintegration-functions.html}{Exposing C++ Functionality To QML}.
+\l{qtqml-cppintegration-functions.html}{Exposing C++ Functionality to QML}.
 
-\section1 Interacting With Objects Defined In QML From C++
+\section1 Interacting with Objects Defined in QML from C++
 
 Most properties of an object defined in QML may be accessed via
 QQmlProperty::read() or QObject::property().  If the property is a list
@@ -104,6 +104,6 @@ handlers.
 
 For more information about accessing QML objects from C++, see the
 documentation on \l{qtqml-cppintegration-reverse.html}
-{Interacting With Objects Defined In QML From C++}.
+{Interacting with Objects Defined in QML from C++}.
 
 */
diff --git a/src/qml/doc/src/documents/definetypes.qdoc b/src/qml/doc/src/documents/definetypes.qdoc
index 80222de6db..ec1750e840 100644
--- a/src/qml/doc/src/documents/definetypes.qdoc
+++ b/src/qml/doc/src/documents/definetypes.qdoc
@@ -70,7 +70,7 @@ The \c SquareButton type encapsulates the tree of QML objects declared in \c Squ
 
 \note the letter case of the file name is significant on some (notably UNIX) filesystems. It is recommended the file name case matches the case of the desired QML type name exactly - for example, \c Box.qml and not \c BoX.qml - regardless of the platform to which the QML type will be deployed.
 
-\section2 Importing types defined outside the current directory
+\section2 Importing Types Defined Outside the Current Directory
 
 If \c SquareButton.qml was not in the same directory as \c myapplication.qml,
 the \c SquareButton type would need to be specifically made available through an \e import statement in \c myapplication.qml. It could be imported from a relative path on the file system, or as an installed module; see \l {QML Modules}{module} for more details.
diff --git a/src/qml/doc/src/documents/topic.qdoc b/src/qml/doc/src/documents/topic.qdoc
index ddb4fc4949..3752460500 100644
--- a/src/qml/doc/src/documents/topic.qdoc
+++ b/src/qml/doc/src/documents/topic.qdoc
@@ -42,7 +42,7 @@ The ability to define re-usable QML object types in documents is an important
 enabler to allow clients to write modular, highly readable and maintainable
 code.
 
-\section1 Structure Of A QML Document
+\section1 Structure of a QML Document
 
 A QML document consists of two sections: the imports section, and the object
 declaration section.  The imports section in a document contains import
diff --git a/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc b/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc
index bd8e50cd53..78ce09d0ad 100644
--- a/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc
+++ b/src/qml/doc/src/javascript/dynamicobjectcreation.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \page qtqml-javascript-dynamicobjectcreation.html
-\title Dynamic QML object creation from JavaScript
+\title Dynamic QML Object Creation from JavaScript
 \brief instantiating and managing QML objects from JavaScript
 
 QML supports the dynamic creation of objects from within JavaScript.  This is
diff --git a/src/qml/doc/src/javascript/expressions.qdoc b/src/qml/doc/src/javascript/expressions.qdoc
index 33007943f0..130be84b0b 100644
--- a/src/qml/doc/src/javascript/expressions.qdoc
+++ b/src/qml/doc/src/javascript/expressions.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 /*!
 \page qtqml-javascript-expressions.html
-\title JavaScript Expressions In QML Documents
+\title JavaScript Expressions in QML Documents
 \brief Description of where JavaScript expressions are valid in QML documents
 
 
@@ -71,7 +71,7 @@ logic.  There are four ways that JavaScript can be used in a QML document:
   \li \l{QML Object Attributes#custom-methods}{custom methods} can be defined
       in QML files as JavaScript functions
   \li JavaScript files providing functions and variables can be
-      \l{Importing JavaScript Files In QML Documents}{imported} in a QML
+      \l{Importing JavaScript Files in QML Documents}{imported} in a QML
       document
 \endlist
 
@@ -507,7 +507,7 @@ required, during evaluation of a JavaScript expression.
 
 \snippet qml/integrating-javascript/scarceresources/avatarExample.cpp 4
 
-\section2 Example Five: Explicit Destruction And JavaScript References
+\section2 Example Five: Explicit Destruction and JavaScript References
 
 One thing to be aware of when using "var" type properties is that they
 hold references to JavaScript objects.  As such, if multiple references
diff --git a/src/qml/doc/src/javascript/imports.qdoc b/src/qml/doc/src/javascript/imports.qdoc
index 9e71368f81..df8141dec5 100644
--- a/src/qml/doc/src/javascript/imports.qdoc
+++ b/src/qml/doc/src/javascript/imports.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 /*!
 \page qtqml-javascript-imports.html
-\title Importing JavaScript Files In QML Documents
+\title Importing JavaScript Files in QML Documents
 \brief Description of how to import and use JavaScript files in QML documents
 
 Both relative and absolute JavaScript URLs can be imported in QML documents.
@@ -47,7 +47,7 @@ The functions defined in an imported JavaScript file are available to objects
 defined in the importing QML document, via the \c{"Qualifier.functionName()"}
 syntax.
 
-\section1 Importing One JavaScript File From Another
+\section1 Importing a JavaScript File from Another
 
 In QtQuick 2.0, support has been added to allow JavaScript files to import
 other JavaScript files and also QML type namespaces using a variation of the
@@ -155,7 +155,7 @@ As they are shared, .pragma library files cannot access QML component instance
 objects or properties directly, although QML values can be passed as function
 parameters.
 
-\section1 Including One JavaScript File From Another
+\section1 Including a JavaScript File from Another
 
 When a JavaScript file is imported, it must be imported with a qualifier.  The
 functions in that file are then accessible from the importing script via the
diff --git a/src/qml/doc/src/javascript/topic.qdoc b/src/qml/doc/src/javascript/topic.qdoc
index 015a769af4..c7d7d2b9ff 100644
--- a/src/qml/doc/src/javascript/topic.qdoc
+++ b/src/qml/doc/src/javascript/topic.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 /*!
 \page qtqml-javascript-topic.html
-\title Integrating QML And JavaScript
+\title Integrating QML and JavaScript
 \brief Description of how to use JavaScript in QML applications
 
 The QML language uses a JSON-like syntax and allows various expressions and
@@ -48,7 +48,7 @@ can include properties from other objects. These
 are JavaScript expressions.
 
 See the documentation page titled
-\l{qtqml-javascript-expressions.html}{JavaScript Expressions In QML Documents}
+\l{qtqml-javascript-expressions.html}{JavaScript Expressions in QML Documents}
 for more information about using JavaScript expressions in QML.
 
 \section1 JavaScript Imports
@@ -56,7 +56,7 @@ for more information about using JavaScript expressions in QML.
 A QML document may import JavaScript files.  This allows an application
 developer to provide application logic in modular, self-contained files.
 See the documentation page titled
-\l{qtqml-javascript-imports.html}{Importing JavaScript Files In QML Documents}
+\l{qtqml-javascript-imports.html}{Importing JavaScript Files in QML Documents}
 for more information on how to import JavaScript files and how to use the
 functionality they provide.
 
diff --git a/src/qml/doc/src/modules/cppplugins.qdoc b/src/qml/doc/src/modules/cppplugins.qdoc
index d8729d6c97..4887e426aa 100644
--- a/src/qml/doc/src/modules/cppplugins.qdoc
+++ b/src/qml/doc/src/modules/cppplugins.qdoc
@@ -27,10 +27,10 @@
 
 /*!
 \page qtqml-modules-cppplugins.html
-\title Creating C++ Plugins For QML
+\title Creating C++ Plugins for QML
 \brief Description of how to write C++ plugins for QML
 
-\section1 Creating A Plugin
+\section1 Creating a Plugin
 
     The \l{QQmlEngine}{QML engine} load C++ plugins for QML.
     Such plugins are usually provided in a QML extension module, and can
diff --git a/src/qml/doc/src/modules/qmldir.qdoc b/src/qml/doc/src/modules/qmldir.qdoc
index 354dfb0573..5c9a4ef506 100644
--- a/src/qml/doc/src/modules/qmldir.qdoc
+++ b/src/qml/doc/src/modules/qmldir.qdoc
@@ -41,7 +41,7 @@ directory within the module according to the named identifier for the module; se
 Modules} documentation for more information.
 
 
-\section1 Writing a qmldir file
+\section1 Writing a qmldir File
 
 A \c qmldir file contains one or more lines of the following commands:
 
@@ -98,7 +98,7 @@ internal MyPrivateType MyPrivateType.qml
 MyScript 1.0 MyScript.js
             \endcode
 
-            See \l{qtqml-javascript-imports.html}{Importing JavaScript Files In QML Documents} for
+            See \l{qtqml-javascript-imports.html}{Importing JavaScript Files in QML Documents} for
             more information.
 
     \row
@@ -206,7 +206,7 @@ See \l{Located Modules} and \l{Installed Modules} for more example \c qmldir fil
 \l{examples/qml/cppextensions/plugins} for an example that uses C++ plugins.
 
 
-\section1 Writing a qmltypes file
+\section1 Writing a qmltypes File
 
 QML modules may refer to one or more type information files in their
 \c qmldir file. These usually have the \c .qmltypes
diff --git a/src/qml/doc/src/modules/topic.qdoc b/src/qml/doc/src/modules/topic.qdoc
index 9a72d68a1f..dd3e4de661 100644
--- a/src/qml/doc/src/modules/topic.qdoc
+++ b/src/qml/doc/src/modules/topic.qdoc
@@ -82,7 +82,7 @@ necessary for exporting JavaScript files and object types defined in C++.
 
 See \l{qtqml-modules-qmldir.html}{Adding Module Metadata with a qmldir File} for more information.
 
-\section1 Providing Types And Functionality In A C++ Plugin
+\section1 Providing Types and Functionality in a C++ Plugin
 
 An application which has a lot of logic implemented in C++, or which defines
 types in C++ and exposes them to QML, may wish to implement a QML plugin.  A
diff --git a/src/qml/doc/src/syntax/basics.qdoc b/src/qml/doc/src/syntax/basics.qdoc
index 5d8b60378c..abf7969fbc 100644
--- a/src/qml/doc/src/syntax/basics.qdoc
+++ b/src/qml/doc/src/syntax/basics.qdoc
@@ -36,7 +36,7 @@ QML source code is generally loaded by the engine through QML \e documents, whic
 standalone documents of QML code. These can be used to define \l {QML Object Types}{QML object types} that can then be reused throughout an application.
 
 
-\section1 Import statements
+\section1 Import Statements
 
 A QML document may have one or more imports at the top of the file.
 An import can be any one of:
@@ -71,7 +71,7 @@ Please see the \l{qtqml-syntax-imports.html}{QML Syntax - Import Statements}
 documentation for in-depth information about QML imports.
 
 
-\section1 Object declarations
+\section1 Object Declarations
 
 Syntactically, a block of QML code defines a tree of QML objects to be created. Objects are
 defined using \e {object declarations} that describe the type of object to be created as well
@@ -117,7 +117,7 @@ Rectangle { width: 200; height: 200; color: "red" }
 Obviously, the \l Rectangle object declared in this example is very simple indeed, as it defines nothing more than a few property values. To create more useful objects, an object declaration may define many other types of attributes: these are discussed in the \l{qtqml-syntax-object-declaration.html}{Object Declarations} documentation. Additionally, an object declaration may define child objects, as discussed below.
 
 
-\section2 Child objects
+\section2 Child Objects
 
 Any object declaration can define child objects through nested object declarations. In this way, \b {any object declaration implicitly declares an object tree that may contain any number of child objects}.
 
diff --git a/src/qml/doc/src/syntax/imports.qdoc b/src/qml/doc/src/syntax/imports.qdoc
index 89eab8979c..b68c29d99e 100644
--- a/src/qml/doc/src/syntax/imports.qdoc
+++ b/src/qml/doc/src/syntax/imports.qdoc
@@ -29,7 +29,7 @@
 \title Import Statements
 \brief Description of import statements in QML
 
-\section1 Syntax Of An Import Statement
+\section1 Syntax of an Import Statement
 
 
 The \c import statement is used to provide the QML engine with access to the modules that define the types that are referred to from within the QML file.
diff --git a/src/qml/doc/src/syntax/objectattributes.qdoc b/src/qml/doc/src/syntax/objectattributes.qdoc
index fed3401436..22b9eef389 100644
--- a/src/qml/doc/src/syntax/objectattributes.qdoc
+++ b/src/qml/doc/src/syntax/objectattributes.qdoc
@@ -35,7 +35,7 @@ object type is created with the set of attributes that have been defined for
 that object type.  There are several different kinds of attributes which
 can be specified, which are described below.
 
-\section1 Attributes in object declarations
+\section1 Attributes in Object Declarations
 
 An \l{qtqml-syntax-basics.html#object-declarations}{object declaration} in a
 QML document defines a new type.  It also declares an object hierarchy that
@@ -54,7 +54,7 @@ The set of QML object-type attribute types is as follows:
 
 These attributes are discussed in detail below.
 
-\section2 The \e id attribute
+\section2 The \e id Attribute
 
 Every QML object type has exactly one \e id attribute. This attribute is
 provided by the language itself, and cannot be redefined or overridden by any
@@ -96,14 +96,14 @@ to it; for example, it is not possible to access \c myTextInput.id in the above
 example.
 
 
-\section2 Property attributes
+\section2 Property Attributes
 
 A property is an attribute of an object that can be assigned a static value
 or bound to a dynamic expression. A property's value can be read by other
 objects. Generally it can also be modified by another object, unless a
 particular QML type has explicitly disallowed this for a specific property.
 
-\section3 Defining property attributes
+\section3 Defining Property Attributes
 
 A property may be defined for a type in C++ by registering a
 Q_PROPERTY of a class which is then registered with the QML type system.
@@ -122,7 +122,7 @@ Property names must begin with a lower case letter and can only contain
 letters, numbers and underscores. \l {JavaScript Reserved Words}
 {JavaScript reserved words} are not valid property names.  The \c default
 keyword is optional, and modifies the semantics of the property being declared.
-See the upcoming section on \l {Default properties}{default properties} for
+See the upcoming section on \l {Default Properties}{default properties} for
 more information about the \c default property modifier.
 
 Declaring a custom property implicitly creates a value-change
@@ -144,7 +144,7 @@ Rectangle {
 }
 \endqml
 
-\section4 Valid types in custom property definitions
+\section4 Valid Types in Custom Property Definitions
 
 The following types can be used as custom property types:
 
@@ -203,7 +203,7 @@ which was then imported by the client), then a property of type
 \c ColorfulButton would also be valid.
 
 
-\section3 Values of property attributes
+\section3 Values of Property Attributes
 
 The value of a property of an object instance may specified in an
 object declaration in two separate ways:
@@ -214,7 +214,7 @@ object declaration in two separate ways:
 
 The value in either case may be either a binding expression or a static value.
 
-\section4 Value assignment on initialization
+\section4 Value Assignment on Initialization
 
 The syntax for assigning a value to a property on initialization is:
 
@@ -241,7 +241,7 @@ Rectangle {
 }
 \endqml
 
-\section4 Imperative value assignment
+\section4 Imperative Value Assignment
 
 An imperative value assignment is where a property value (either static value
 or binding expression) is assigned to a property from imperative JavaScript
@@ -265,7 +265,7 @@ Rectangle {
 }
 \endqml
 
-\section4 Valid property values
+\section4 Valid Property Values
 
 As previously noted, there are two kinds of values which may be assigned to a
 property: static values, and binding expression values.
@@ -323,7 +323,7 @@ about \l{qtqml-syntax-propertybinding.html}{property binding} for more
 information on the topic.
 
 
-\section3 Type safety
+\section3 Type Safety
 
 Properties are type safe. A property can only be assigned a value that matches
 the property type.
@@ -349,9 +349,9 @@ See \l {QML Basic Types} for a list of the types of properties that are
 supported by default.  Additionally, any available \l {QML Object Types}
 {QML object type} may also be used as a property type.
 
-\section3 Special property types
+\section3 Special Property Types
 
-\section4 Object list property attributes
+\section4 Object List Property Attributes
 
 A \l list type property can be assigned a list of QML object-type values.
 The syntax for defining an object list value is a comma-separated list
@@ -452,7 +452,7 @@ the Qt Quick module is imported.  See the documentation about
 \l{QML Basic Types} for more information.
 
 
-\section3 Property aliases
+\section3 Property Aliases
 
 Property aliases are properties which hold a reference to another property.
 Unlike an ordinary property definition, which allocates a new, unique storage
@@ -507,7 +507,7 @@ the displayed text at all, as property bindings are not bi-directional: the
 the other way around.
 
 
-\section4 Considerations for property aliases
+\section4 Considerations for Property Aliases
 
 Aliases are only activated once a component has been fully initialized. An
 error is generated when an uninitialized alias is referenced. Likewise,
@@ -532,7 +532,7 @@ Internally, however, the red can correctly set its \c color
 property and refer to the actual defined property rather than the alias.
 
 
-\section3 Default properties
+\section3 Default Properties
 
 An object definition can have a single \e default property. A default property
 is the property to which a value is assigned if an object is declared within
@@ -587,7 +587,7 @@ default property to automatically reassign children of the TabWidget as
 children of an inner ListView.
 
 
-\section2 Signal attributes
+\section2 Signal Attributes
 
 A signal is a notification from an object that some event has occurred: for
 example, a property has changed, an animation has started or stopped, or
@@ -622,7 +622,7 @@ Item {
 }
 \endqml
 
-\section3 Defining signal attributes
+\section3 Defining Signal Attributes
 
 A signal may be defined for a type in C++ by registering a Q_SIGNAL of a class
 which is then registered with the QML type system.  Alternatively, a custom
@@ -660,7 +660,7 @@ To emit a signal, invoke it as a method. Any relevant
 is emitted, and handlers can use the defined signal argument names to access
 the respective arguments.
 
-\section3 Property change signals
+\section3 Property Change Signals
 
 QML types also provide built-in \e {property change signals} that are emitted
 whenever a property value changes, as previously described in the section on
@@ -669,7 +669,7 @@ whenever a property value changes, as previously described in the section on
 information about why these signals are useful, and how to use them.
 
 
-\section2 Signal handler attributes
+\section2 Signal Handler Attributes
 
 Signal handlers are a special sort of \l{Method attributes}{method attribute},
 where the method implementation is invoked by the QML engine whenever the
@@ -715,7 +715,7 @@ SquareButton {
 See the \l {Signal and Handler Event System} for more details on use of
 signals.
 
-\section3 Property change signal handlers
+\section3 Property Change Signal Handlers
 
 Signal handlers for property change signal take the syntax form
 \e on<Property>Changed where \e <Property> is the name of the property,
@@ -736,14 +736,14 @@ TextInput {
 \endqml
 
 
-\section2 Method attributes
+\section2 Method Attributes
 
 A method of an object type is a function which may be called to perform some
 processing or trigger further events.  A method can be connected to a signal so
 that it is automatically invoked whenever the signal is emitted.  See
 \l {Signal and Handler Event System} for more details.
 
-\section3 Defining method attributes
+\section3 Defining Method Attributes
 
 A method may be defined for a type in C++ by tagging a function of a class
 which is then registered with the QML type system with Q_INVOKABLE or by
@@ -813,7 +813,7 @@ Item {
 \endqml
 
 
-\section2 Attached properties and attached signal handlers
+\section2 Attached Properties and Attached Signal Handlers
 
 \e {Attached properties} and \e {attached signal handlers} are mechanisms that
 enable objects to be annotated with extra properties or signal handlers that
@@ -878,7 +878,7 @@ Since the name of the \e {attaching type} is \c Component and that type has a
 \c Component.isCompleted.
 
 
-\section3 A note about accessing attached properties and signal handlers
+\section3 A Note About Accessing Attached Properties and Signal Handlers
 
 A common error is to assume that attached properties and signal handlers are
 directly accessible from the children of the object to which these attributes
diff --git a/src/qml/doc/src/syntax/propertybinding.qdoc b/src/qml/doc/src/syntax/propertybinding.qdoc
index 1f529b3f2d..75efc358dd 100644
--- a/src/qml/doc/src/syntax/propertybinding.qdoc
+++ b/src/qml/doc/src/syntax/propertybinding.qdoc
@@ -111,7 +111,7 @@ While syntactically bindings can be of arbitrary complexity, if a binding starts
 
 
 \keyword qml-javascript-assignment
-\section1 Creating property bindings from JavaScript
+\section1 Creating Property Bindings from JavaScript
 
 Once a property has been bound to an expression, the property is set to be automatically updated as necessary. However, be aware that if the property is later assigned a static value from a JavaScript statement, this will remove the binding.
 
@@ -150,7 +150,7 @@ Rectangle {
 Now when the space key is pressed, a new binding of \c width*3 is assigned, instead of simply removing the initial binding.
 
 
-\section2 Using \c this with property binding
+\section2 Using \c this with Property Binding
 
 When creating a property binding from JavaScript, QML allows the use of the \c
 this keyword to refer to the object to which the property binding will be
diff --git a/src/qml/doc/src/syntax/signals.qdoc b/src/qml/doc/src/syntax/signals.qdoc
index 8d3df556a3..6cc68d30bf 100644
--- a/src/qml/doc/src/syntax/signals.qdoc
+++ b/src/qml/doc/src/syntax/signals.qdoc
@@ -44,7 +44,7 @@ is emitted, the corresponding signal handler is invoked. Placing logic such as s
 operations in the handler allows the component to respond to the event.
 
 \keyword qml-signals-and-handlers
-\section1 Receiving signals with signal handlers
+\section1 Receiving Signals with Signal Handlers
 
 To receive a notification when a particular signal is emitted for a particular object, the object definition should declare a signal handler named \e on<Signal> where \e <Signal> is the name of the signal, with the first letter capitalized. The signal handler should contain the JavaScript code to be executed when the signal handler is invoked.
 
@@ -88,7 +88,7 @@ Rectangle {
 \endqml
 
 
-\section2 Property change signal handlers
+\section2 Property Change Signal Handlers
 
 A signal is automatically emitted when the value of a QML property changes. This type of signal is a \e {property change signal} and signal handlers for these signals are written in the form \e on<Property>Changed where \e <Property> is the name of the property, with the first letter capitalized.
 
@@ -113,7 +113,7 @@ Rectangle {
 Even though the \l MouseArea documentation does not document a signal handler named \c onPressedChanged, the signal is implicitly provided by the fact that the \c pressed property exists.
 
 
-\section2 Using the Connections type
+\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 {Connection::target}{target}.
 
@@ -141,7 +141,7 @@ Rectangle {
 \endqml
 
 
-\section2 Attached signal handlers
+\section2 Attached Signal Handlers
 
 An \l {attached signal handler} is a signal handler that receives a signal from an \e {attaching type} rather than the object within which the handler is declared.
 
@@ -167,7 +167,7 @@ Attached signal handlers allow objects to be notified of particular signals that
 See \l {Attached properties and attached signal handlers} for more information on attached signal handlers.
 
 
-\section1 Adding signals to custom QML types
+\section1 Adding Signals to Custom QML Types
 
 Signals can be added to custom QML types through the \c signal keyword.
 
diff --git a/src/qml/doc/src/typesystem/basictypes.qdoc b/src/qml/doc/src/typesystem/basictypes.qdoc
index f2348734d3..a6c5a8bc5c 100644
--- a/src/qml/doc/src/typesystem/basictypes.qdoc
+++ b/src/qml/doc/src/typesystem/basictypes.qdoc
@@ -239,7 +239,7 @@ property is only invoked when the property is reassigned to a different object v
     converted into a \c url value, and vice-versa.
 
 
-    \section1 Using the url type
+    \section1 Using the url Type
 
     When a relative URL is written to a \c url type property, it is converted
     into a URL object, so \bold {matching the URL value against the input string
@@ -619,7 +619,7 @@ property is only invoked when the property is reassigned to a different object v
     converted into a \c list value, and vice-versa.
 
 
-    \section1 Using the list type
+    \section1 Using the list Type
 
     For example, the \l Item type has a \l {Item::}{states} list-type property that
     can be assigned to and used as follows:
diff --git a/src/qml/doc/src/typesystem/objecttypes.qdoc b/src/qml/doc/src/typesystem/objecttypes.qdoc
index 7b223f0632..f2715b30cc 100644
--- a/src/qml/doc/src/typesystem/objecttypes.qdoc
+++ b/src/qml/doc/src/typesystem/objecttypes.qdoc
@@ -44,7 +44,7 @@ Custom QML object types can be defined by creating a .qml file that defines the
 type, as discussed in \l {qtqml-documents-definetypes.html}
 {Documents as QML object type definitions}, or by defining a QML type from C++
 and registering the type with the QML engine, as discussed in
-\l{qtqml-registercpptypes.html}{Registering C++ Types With The QML Type System}.
+\l{qtqml-registercpptypes.html}{Registering C++ Types with the QML Type System}.
 
 
 \section1 Creating Object Types from QML
diff --git a/src/qml/doc/src/typesystem/topic.qdoc b/src/qml/doc/src/typesystem/topic.qdoc
index e12873547e..5e32ccb027 100644
--- a/src/qml/doc/src/typesystem/topic.qdoc
+++ b/src/qml/doc/src/typesystem/topic.qdoc
@@ -59,7 +59,7 @@ more information about basic types, or the \l{qtqml-documents-properties.html}
 other available property types.
 
 
-\section1 JavaScript types
+\section1 JavaScript Types
 
 JavaScript objects and arrays are supported by the QML engine. Any standard
 JavaScript type can be created and stored using the generic \l var type.
diff --git a/src/qml/doc/src/whatsnew.qdoc b/src/qml/doc/src/whatsnew.qdoc
index 89051d6d7f..d66d78d5ec 100644
--- a/src/qml/doc/src/whatsnew.qdoc
+++ b/src/qml/doc/src/whatsnew.qdoc
@@ -47,7 +47,7 @@ has now been replaced by the new QtQml and QtQuick C++ modules. See the
 \li New QQmlEngine::trimComponentCache() method safely discards unused data in the engine's component cache to free memory.
 \endlist
 
-\section2 Component and Object creation
+\section2 Component and Object Creation
 
 \list
 \li QML objects can now be created asynchronously to improve application performance.