Added \ingroup for the overview pages and \group page.

16 files changed, 229 insertions, 168 deletions

diff --git a/doc/src/declarative/anchor-layout.qdoc b/doc/src/declarative/anchor-layout.qdoc
index b77ce36..2435e4e 100644
--- a/doc/src/declarative/anchor-layout.qdoc
+++ b/doc/src/declarative/anchor-layout.qdoc
@@ -28,13 +28,16 @@
 /*!
 \page qml-anchor-layout.html
 \target anchor-layout
+\contentspage QML Features
+\previouspage Using QML Positioner and Repeater Items
+\nextpage Using QML Positioner and Repeater Items
 \title Anchor-based Layout in QML
 
 In addition to the more traditional \l Grid, \l Row, and \l Column,
 QML also provides a way to layout items using the concept of \e anchors.
 Each item can be thought of as having a set of 7 invisible "anchor lines":
 \l {Item::anchors.left}{left}, \l {Item::anchors.horizontalCenter}{horizontalCenter},
-\l {Item::anchors.right}{right}, \l {Item::anchors.top}{top}, 
+\l {Item::anchors.right}{right}, \l {Item::anchors.top}{top},
 \l {Item::anchors.verticalCenter}{verticalCenter}, \l {Item::anchors.baseline}{baseline},
 and \l {Item::anchors.bottom}{bottom}.
 
diff --git a/doc/src/declarative/animation.qdoc b/doc/src/declarative/animation.qdoc
index 208a1c4..708f412 100644
--- a/doc/src/declarative/animation.qdoc
+++ b/doc/src/declarative/animation.qdoc
@@ -27,6 +27,8 @@
 
 /*!
 \page qdeclarativeanimation.html
+\ingroup qml-features
+\contentspage QML Features
 \title QML Animation
 
 
@@ -80,7 +82,7 @@ States}{state changes}
 
 These methods are demonstrated below. Notice these examples use
 PropertyAnimation, which is one of several QML elements that can be used to
-create an animation. See the \l {Animation Elements} section further below for 
+create an animation. See the \l {Animation Elements} section further below for
 details.
 
 
@@ -92,7 +94,7 @@ source} using the \e Animation \bold on \e Property syntax. Here is a \l
 Rectangle whose movement is animated using this method:
 
 \snippet doc/src/snippets/declarative/animation-propertyvaluesource.qml 0
-	
+
 This applies a PropertyAnimation to the \l Rectangle's \c x and \c y properties
 to animate from their current values (i.e. zero) to 50, over 1000 milliseconds.
 The animation starts as soon as the \l Rectangle is loaded. To animate from
@@ -141,7 +143,7 @@ demonstration of behavioral animations.
 
 An animation can be created within a signal handler to be triggered when the
 signal is received. For example:
-    
+
 \snippet doc/src/snippets/declarative/animation-signalhandler.qml 0
 
 The PropertyAnimation is triggered when the MouseArea is clicked, animating the
@@ -156,8 +158,8 @@ The \l {PropertyAnimation::}{to} property is also required to specify the new
 \section2 Standalone Animations
 
 Animations can also be created as ordinary QML objects that are not bound to
-any particular objects and properties. Here is an example, using a 
-PropertyAnimation object. The animation is explicitly started when the 
+any particular objects and properties. Here is an example, using a
+PropertyAnimation object. The animation is explicitly started when the
 \l Rectangle is clicked:
 
 \snippet doc/src/snippets/declarative/animation-standalone.qml 0
@@ -187,10 +189,10 @@ object and add it to an item's \l {Item::}{transitions} property. An example:
 
 The PropertyChanges object in the \e moved state defines that when the
 \l Rectangle is in this state, its position should be changed
-to (50, 50). When the \l Rectangle changes to the \e moved state, the 
+to (50, 50). When the \l Rectangle changes to the \e moved state, the
 \l Transition will be triggered, and the transition's \l PropertyAnimation will
 animate the changes in the \c x and \c y properties to their new values.
-The animation will not be applied at any time other than during the state 
+The animation will not be applied at any time other than during the state
 change.
 
 Notice the example does not set any \l {PropertyAnimation::}{from} and \l
@@ -231,13 +233,13 @@ It can also define the number of \l {Animation::}{loops} for an animation.
 PropertyAnimation is the most basic animation element for animating a property.
 It can be used to animate \c real, \c int, \c color, \c rect, \c point, \c size, and
 \c vector3d properties. It is inherited by NumberAnimation, ColorAnimation,
-RotationAnimation and Vector3dAnimation: NumberAnimation provides a more 
-efficient implementation for animating \c real and \c int properties, and 
-Vector3dAnimation does the same for \c vector3d properties.  ColorAnimation 
-and RotationAnimation provide more specific attributes for animating color 
-and rotation changes. 
+RotationAnimation and Vector3dAnimation: NumberAnimation provides a more
+efficient implementation for animating \c real and \c int properties, and
+Vector3dAnimation does the same for \c vector3d properties.  ColorAnimation
+and RotationAnimation provide more specific attributes for animating color
+and rotation changes.
 
-A ColorAnimation allows color values for the \l {ColorAnimation::}{from} 
+A ColorAnimation allows color values for the \l {ColorAnimation::}{from}
 and \l {ColorAnimation::}{to} properties. The
 following animates the rectangle's \l {Rectangle::}{color} property:
 
@@ -251,10 +253,10 @@ animates the rectangle's \l {Item::rotation} property:
 In addition, the following specialized animation elements are available:
 
 \list
-\o SmoothedAnimation: a specialized NumberAnimation that provides smooth 
+\o SmoothedAnimation: a specialized NumberAnimation that provides smooth
 changes in animation when the target value changes
-\o SpringAnimation: provides a spring-like animation with specialized 
-attributes such as \l {SpringAnimation::}{mass}, 
+\o SpringAnimation: provides a spring-like animation with specialized
+attributes such as \l {SpringAnimation::}{mass},
 \l{SpringAnimation::}{damping} and \l{SpringAnimation::}{epsilon}
 \o ParentAnimation: used for animating a parent change (see ParentChange)
 \o AnchorAnimation: used for animating an anchor change (see AnchorChanges)
diff --git a/doc/src/declarative/basictypes.qdoc b/doc/src/declarative/basictypes.qdoc
index 034b7d1..0277ccb 100644
--- a/doc/src/declarative/basictypes.qdoc
+++ b/doc/src/declarative/basictypes.qdoc
@@ -27,12 +27,14 @@
 
 /*!
     \page qdeclarativebasictypes.html
+    \ingroup qml-features
+    \contentspage QML Features
     \title QML Basic Types
 
     QML has a set of primitive types, as listed below, that are used throughout
     the \l {QML Elements}.
 
-    Some of these types can also be used for defining 
+    Some of these types can also be used for defining
     \c property values in QML. See \l{Writing QML Components: Properties, Methods and Signals} for the
     list of types that can be used for \c property values.
 
@@ -43,7 +45,7 @@
     \qmlbasictype int
     \ingroup qmlbasictypes
 
-    \brief An integer is a whole number, e.g. 0, 10, or -20. 
+    \brief An integer is a whole number, e.g. 0, 10, or -20.
 
     An integer is a whole number, e.g. 0, 10, or -20. The possible \c
     int values range from around -2000000000 to around 2000000000,
@@ -117,7 +119,7 @@
     \qmlbasictype url
     \ingroup qmlbasictypes
 
-    \brief A URL is a resource locator, like a file name. 
+    \brief A URL is a resource locator, like a file name.
 
     A URL is a resource locator, like a file name. It can be either
     absolute, e.g. "http://qt.nokia.com", or relative, e.g.
@@ -198,7 +200,7 @@
 /*!
     \qmlbasictype size
     \ingroup qmlbasictypes
-    
+
     \brief A size type has width and height attributes
 
     A \c size type has \c width and \c height attributes.
@@ -237,7 +239,7 @@
 
     For example, to read the \l {Item::childrenRect.x}{Item::childrenRect} \c rect property:
     \qml
-    Rectangle { 
+    Rectangle {
         width: childrenRect.width
         height: childrenRect.height
 
@@ -273,7 +275,7 @@
     MyDatePicker { minDate: "2000-01-01"; maxDate: "2020-12-31" }
     \endqml
 
-    To read a date value returned from a C++ extension class, use 
+    To read a date value returned from a C++ extension class, use
     \l{QML:Qt::formatDate()}{Qt.formatDate()} and \l{QML:Qt::formatDateTime()}{Qt.formatDateTime()}.
 
     \sa {QML Basic Types}
@@ -292,7 +294,7 @@
     MyTimePicker { time: "14:22:15" }
     \endqml
 
-    To read a time value returned from a C++ extension class, use 
+    To read a time value returned from a C++ extension class, use
     \l{QML:Qt::formatTime()}{Qt.formatTime()} and \l{QML:Qt::formatDateTime()}{Qt.formatDateTime()}.
 
     \sa {QML Basic Types}
@@ -493,7 +495,7 @@
     \qml
     Text { horizontalAlignment: "AlignRight" }
     \endqml
-    
+
     or as \c {<Element>.<value>}:
     \qml
     Text { horizontalAlignment: Text.AlignRight }
diff --git a/doc/src/declarative/declarativeui.qdoc b/doc/src/declarative/declarativeui.qdoc
index 41b9952..b17d178 100644
--- a/doc/src/declarative/declarativeui.qdoc
+++ b/doc/src/declarative/declarativeui.qdoc
@@ -31,12 +31,12 @@
 \ingroup qt-gui-concepts
 
 \brief Qt Quick provides a declarative framework for building highly
-dynamic, custom user interfaces.
+dynamic user interfaces.
 
 \section1 Introduction
 
 Qt Quick is a collection of technologies that are designed to help
-developers create the kind of intuitive, modern-looking, fluid user
+developers create the kind of intuitive, modern, fluid user
 interfaces that are increasingly used on mobile phones, media players,
 set-top boxes and other portable devices.
 
@@ -45,7 +45,7 @@ language for describing user interfaces and a language runtime. A collection
 of C++ APIs is used to integrate these high level features with classic
 Qt applications.
 
-\section2 QML, Elements and the Qt Declarative Module
+\section2 QML
 
 User interfaces and their behavior are described using QML, an extension to
 \l{About JavaScript}{JavaScript} that lets developers and designers
@@ -55,64 +55,62 @@ graphical and behavioral building blocks that can be combined together in
 \l{QML Documents}{QML documents} to build components ranging in complexity
 from simple buttons and sliders, to complete Internet-enabled applications.
 
-QML improves the integration between JavaScript and Qt's existing
-QObject-based type system, adds support for automatic
-\l{Property Binding}{property bindings} and provides
-\l{Network Transparency}{network transparency} at the language level.
+\section2 Qt Declarative Module
 
-The Qt Declarative module implements the interface between the QML language
-and the elements available to it. It also provides a C++ API that can be
-used to load and interact with QML files from within Qt applications.
+The Qt Declarative module provides a C++ API that is for interacting with QML files from within Qt applications. The module allows the programmer to build applications' backend logic using Qt.
 
-Qt Quick builds on \l{QML for Qt programmers}{Qt's existing strengths}.
-QML can be be used to incrementally extend an existing application or
-to build completely new applications.  QML is fully
-\l{Extending QML in C++}{extensible from C++} through the Qt Declarative
-Module.
+QML and the Qt Declarative Module separate the frontend UI logic from the backend logic.
 
 \section1 Getting Started
 
 \list
-\o \l{What's new in Qt Quick}
-\o \l{Introduction to the QML language}
-\o \l{QML for Qt Programmers}
+\o \l{Intro to Qt Quick}{Introduction to Qt Quick}
+\o \l{Introduction to the QML language}{Introduction to the QML Language}
+\o \l{QML for Qt Programmers}{QML Programming for Qt Programmers}
 \o \l{Getting Started Programming with QML}
-\o \l{Intro to Qt Quick}
+\o \l{What's new in Qt Quick}{What's New in the Qt Quick Release}
 \endlist
 
-\list
-\o \l{QML Tutorial}{Tutorial: "Hello World"}
-\o \l{QML Advanced Tutorial}{Tutorial: "Same Game"}
-\o \l{QML Examples and Demos}
-\endlist
-
-\section1 QML Concepts
+\section1 QML Features
 
 \list
-\o \l{QML Documents}
 \o \l{Property Binding}
-\o \l{Anchor-based Layout in QML}
-\o \l{Writing QML Components: Properties, Methods and Signals}
-\o \l{QML Scope}
-\o \l{QML Modules}
+\o \l{Using QML Positioner and Repeater Items}{Component Layouts}
+\o \l{Anchor-based Layout in QML}{Anchor Layout}
+\o \l{Writing QML Components: Properties, Methods and Signals}{Reusable Components}
+\o \l{Text Handling}
+\o \l{Keyboard Focus in QML}{Keyboard Focus}
+\o \l{Mouse Events}
+\o \l{QML States} {States}
+\o \l{QML Animation}{Animation and Transitions}
+\o \l{QML Basic Types}{QML Basic Data Types}
+\o \l{QML Data Models}{Structuring Data with Models}
+\o \l{Presenting Data with QML}{Presenting Data with Views}
+\o \l{Affine Transformations}
+\o \l{Dynamic Object Management in QML}{Dynamic Object Management}
+\o \l{Network Transparency}{Resource Loading}
+\o \l{Extending QML in C++}{Extending QML Functionalities using C++}
+\o \l{Using QML in C++ Applications}
+\o \l{Integrating QML with existing Qt UI code}{Integrating QML Code with Existing Qt UI Code}
+\o \l{Signals and Slots Event System}
+\o \l{QML Internationalization}{Internationalization}
+\o \l{Graphical Effects}
 \endlist
 
-\section1 User Interaction
+\section1 QML Add-Ons
 
 \list
-\o \l{Keyboard Focus in QML}
-\o \l{QML States}
-\o \l{QML Animation}
+\o \l{Qt WebKit}
+\o \l{Mobility QML bindings}
 \endlist
 
-\section1 Handling Data
+\section1 Qt Quick Tools
 
 \list
-\o \l{QML Basic Types}{QML Basic Data Types}
-\o \l{Using QML Positioner and Repeater Items}
-\o \l{QML Data Models}
-\o \l{Presenting Data with QML}
-\o \l{Network Transparency}
+\o \l{Debugging QML}
+\o \l{QML Viewer}
+\o \l{QML Performance}
+\o \l{Developing Qt Quick Applications}{Developing with Qt Creator}
 \endlist
 
 \section1 Architecture
@@ -120,39 +118,45 @@ Module.
 \list
 \o \l{Qt Declarative UI Runtime}
 \o \l{Integrating JavaScript}
-\o \l{Dynamic Object Management in QML}
-\endlist
-
-\section1 Using QML with C++
-
-\list
-\o \l{Qt Declarative UI Runtime}
-\o \l{Using QML in C++ Applications}
-\o \l{Integrating QML with existing Qt UI code}
-\o \l{Tutorial: Writing QML extensions with C++}
-\o \l{Extending QML in C++}
+\o \l{QML Scope}
+\o \l{QML Modules}
+\o \l{QML Documents}
+\o \l{QML Global Object}
+\o \l{QML Security}
+\o \l{Qt Declarative Module}
 \endlist
 
 \section1 Reference
 
 \list
 \o \l{QML Elements}
-\o \l{QML Basic Types}
-\o \l{QML Global Object}
-\o \l{QML Internationalization}
-\o \l{QML Security}
 \o \l{Qt Declarative Module}
-\o \l{Debugging QML}
-\o \l{QML Viewer}
-\o \l{QML Performance}
+\o \l{QML Basic Types}{QML Data Types}
 \o \l{QML Coding Conventions}
+\o \l{Qt Creator Manual}
+\o \l{Programming with Qt}
+\o \l{http://doc.qt.nokia.com/qtmobility-1.1.0/index.html}{Qt Mobility Documentation}
 \endlist
 
-\section1 Online Examples
+\section1 Examples
 
 \list
+\o \l{QML Tutorial}{"Hello World" Tutorial}
+\o \l{Getting Started Programming with QML}
+\o \l{QML Advanced Tutorial}{Tutorial: "Same Game"}
+\o \l{Tutorial: Writing QML extensions with C++}
+\o \l{QML Examples and Demos}
+
 \o Forum Nokia:
 \l{http://wiki.forum.nokia.com/index.php/Qt_Quick_examples_for_porting}{Qt Quick
 examples for porting}
 \endlist
+
+\section1 Best Practices
+
+\list
+\o \l{QML Best Practices: Data Types}{Using Data Types in QML}
+\o \l{QML Best Practices: Coding Conventions}{Coding Tips}
+\o \l{Geir's screen size document}
+\endlist
 */
diff --git a/doc/src/declarative/dynamicobjects.qdoc b/doc/src/declarative/dynamicobjects.qdoc
index fcc9fd4..1e43166 100644
--- a/doc/src/declarative/dynamicobjects.qdoc
+++ b/doc/src/declarative/dynamicobjects.qdoc
@@ -27,11 +27,13 @@
 
 /*!
 \page qdeclarativedynamicobjects.html
+\ingroup qml-features
+\contentspage {QML Features}
 \title Dynamic Object Management in QML
 
-QML provides a number of ways to dynamically create and manage QML objects. 
+QML provides a number of ways to dynamically create and manage QML objects.
 The \l{Loader}, \l{Repeater}, \l{ListView}, \l{GridView} and \l{PathView} elements
-all support dynamic object management.  Objects can also be created and managed 
+all support dynamic object management.  Objects can also be created and managed
 from C++, and this is the preferred method for hybrid QML/C++ applications
 (see \l{Using QML in C++ Applications}).
 
@@ -45,20 +47,20 @@ of the concepts discussed on this page.
 
 \section1 Creating Objects Dynamically
 
-There are two ways to create objects dynamically from JavaScript. You can either call 
+There are two ways to create objects dynamically from JavaScript. You can either call
 \l {QML:Qt::createComponent()}{Qt.createComponent()} to dynamically create
 a \l Component object, or use \l{QML:Qt::createQmlObject()}{Qt.createQmlObject()}
 to create an item from a string of QML.
-Creating a component is better if you have an existing component defined in a \c .qml 
+Creating a component is better if you have an existing component defined in a \c .qml
 file, and you want to dynamically create instances of that component. Otherwise,
-creating an item from a string of QML is useful when the item QML itself is generated 
+creating an item from a string of QML is useful when the item QML itself is generated
 at runtime.
 
 
 \section2 Creating a Component dynamically
 
-To dynamically load a component defined in a QML file, call the 
-\l {QML:Qt::createComponent()}{Qt.createComponent()} function on the \l{QML Global Object}. 
+To dynamically load a component defined in a QML file, call the
+\l {QML:Qt::createComponent()}{Qt.createComponent()} function on the \l{QML Global Object}.
 This function takes the URL of the QML file as its only argument and creates
 a \l Component object from this URL.
 
@@ -88,14 +90,14 @@ in case the QML file is loaded over a network and thus is not ready immediately.
 \codeline
 \snippet doc/src/snippets/declarative/componentCreation.js finishCreation
 
-If you are certain the QML file to be loaded is a local file, you could omit the \c finishCreation() 
+If you are certain the QML file to be loaded is a local file, you could omit the \c finishCreation()
 function and call \l {Component::createObject()}{createObject()} immediately:
 
 \snippet doc/src/snippets/declarative/componentCreation.js func
 \snippet doc/src/snippets/declarative/componentCreation.js local
 \snippet doc/src/snippets/declarative/componentCreation.js func-end
 
-Notice in both instances, \l {Component::createObject()}{createObject()} is called with 
+Notice in both instances, \l {Component::createObject()}{createObject()} is called with
 \c appWindow passed as an argument so that the created object will become a child of the
 \c appWindow item in \c main.qml. Otherwise, the new item will not appear in the scene.
 
@@ -156,7 +158,7 @@ items that you did not dynamically create yourself.
 
 Items can be deleted using the \c destroy() method. This method has an optional
 argument (which defaults to 0) that specifies the approximate delay in milliseconds
-before the object is to be destroyed. 
+before the object is to be destroyed.
 
 Here is an example. The \c application.qml creates five instances of the \c SelfDestroyingRect.qml
 component. Each instance runs a NumberAnimation, and when the animation has finished, calls
@@ -188,7 +190,7 @@ Item {
 }
 \endqml
 
-This would result in an error, since items can only be dynamically 
+This would result in an error, since items can only be dynamically
 destroyed if they were dynamically created.
 
 Objects created with \l{QML:Qt::createQmlObject()}{Qt.createQmlObject()}
diff --git a/doc/src/declarative/extending.qdoc b/doc/src/declarative/extending.qdoc
index e23ca91..e61447a 100644
--- a/doc/src/declarative/extending.qdoc
+++ b/doc/src/declarative/extending.qdoc
@@ -27,6 +27,8 @@
 
 /*!
 \page qml-extending.html
+\ingroup qml-features
+\contentspage QML Features
 \title Extending QML in C++
 
 The QML syntax declaratively describes how to construct an in-memory object
@@ -360,28 +362,28 @@ pointers to invalid objects.  QML makes the following guarentees:
 
 \list
 \o An object assigned to a QObject (or QObject-derived) pointer property will be
-valid at the time of assignment.  
+valid at the time of assignment.
 
-Following assignment, it is the responsibility of the class to subsequently guard 
+Following assignment, it is the responsibility of the class to subsequently guard
 this pointer, either through a class specific method or the generic QPointer class.
 
-\o An object assigned to a QVariant will be valid at the time of assignment.  
+\o An object assigned to a QVariant will be valid at the time of assignment.
 
-When assigning an object to a QVariant property, QML will always use a QMetaType::QObjectStar 
-typed QVariant.  It is the responsibility of the class to guard the pointer.  A 
-general rule when writing a class that uses QVariant properties is to check the 
-type of the QVariant when it is set and if the type is not handled by your class, 
+When assigning an object to a QVariant property, QML will always use a QMetaType::QObjectStar
+typed QVariant.  It is the responsibility of the class to guard the pointer.  A
+general rule when writing a class that uses QVariant properties is to check the
+type of the QVariant when it is set and if the type is not handled by your class,
 reset it to an invalid variant.
 
-\o An object assigned to a QObject (or QObject-derived) list property will be 
-valid at the time of assignment.  
+\o An object assigned to a QObject (or QObject-derived) list property will be
+valid at the time of assignment.
 
-Following assignment, it is the responsibility of the class to subsequently guard 
+Following assignment, it is the responsibility of the class to subsequently guard
 this pointer, either through a class specific method or the generic QPointer class.
 \endlist
 
 Elements should assume that any QML assigned object can be deleted at any time, and
-respond accordingly.  If documented as such an element need not continue to work in 
+respond accordingly.  If documented as such an element need not continue to work in
 this situation, but it must not crash.
 
 \section1 Signal Support
@@ -637,6 +639,7 @@ public:
 
 /*!
 \page qml-extending-types.html
+\ingroup qml-features
 \title Writing QML Components: Properties, Methods and Signals
 
 One of the key concepts in QML is the ability to define your own QML components that suit
diff --git a/doc/src/declarative/focus.qdoc b/doc/src/declarative/focus.qdoc
index ae72c3c..3da60f1 100644
--- a/doc/src/declarative/focus.qdoc
+++ b/doc/src/declarative/focus.qdoc
@@ -28,6 +28,8 @@
 /*!
 \target qmlfocus
 \page qdeclarativefocus.html
+\ingroup qml-features
+\contentspage QML Features
 \title Keyboard Focus in QML
 
 When a key is pressed or released, a key event is generated and delivered to the
diff --git a/doc/src/declarative/integrating.qdoc b/doc/src/declarative/integrating.qdoc
index 7028585..23235d7 100644
--- a/doc/src/declarative/integrating.qdoc
+++ b/doc/src/declarative/integrating.qdoc
@@ -27,6 +27,7 @@
 
 /*!
 \page qml-integration.html
+\ingroup qml-features
 \title Integrating QML with existing Qt UI code
 
 There are a number of ways to integrate QML into QWidget-based UI applications,
@@ -37,8 +38,8 @@ depending on the characteristics of your existing UI code.
 
 If you have an existing QWidget-based UI, QML widgets can be integrated into
 it using QDeclarativeView. QDeclarativeView is a subclass of QWidget so you
-can add it to your user interface like any other QWidget. Use 
-QDeclarativeView::setSource() to load a QML file into the view, then add the 
+can add it to your user interface like any other QWidget. Use
+QDeclarativeView::setSource() to load a QML file into the view, then add the
 view to your UI:
 
 \code
@@ -52,7 +53,7 @@ layout->addWidget(qmlView);
 
 The one drawback to this approach is that QDeclarativeView is slower to initialize
 and uses more memory than a QWidget, and creating large numbers of QDeclarativeView
-objects may lead to performance degradation. If this is the case, it may be 
+objects may lead to performance degradation. If this is the case, it may be
 better to rewrite your widgets in QML, and load the widgets from a main QML widget
 instead of using QDeclarativeView.
 
@@ -70,7 +71,7 @@ of simple and dynamic elements.
 If you have an existing UI based on the \l{Graphics View Framework},
 you can integrate QML widgets directly into your QGraphicsScene. Use
 QDeclarativeComponent to create a QGraphicsObject from a QML file, and
-place the graphics object into your scene using \l{QGraphicsScene::addItem()}, or 
+place the graphics object into your scene using \l{QGraphicsScene::addItem()}, or
 reparent it to an item already in the \l{QGraphicsScene}.
 
 For example:
@@ -95,7 +96,7 @@ of QML UIs:
 
 \section2 Loading QGraphicsWidget objects in QML
 
-An alternative approach is to expose your existing QGraphicsWidget objects to 
+An alternative approach is to expose your existing QGraphicsWidget objects to
 QML and construct your scene in QML instead. See the \l {declarative-cppextensions-qgraphicslayouts.html}{graphics layouts example}
 which shows how to expose Qt's graphics layout classes to QML in order
 to use QGraphicsWidget with classes like QGraphicsLinearLayout and QGraphicsGridLayout.
diff --git a/doc/src/declarative/network.qdoc b/doc/src/declarative/network.qdoc
index a19ca6b..4354f9d 100644
--- a/doc/src/declarative/network.qdoc
+++ b/doc/src/declarative/network.qdoc
@@ -27,6 +27,7 @@
 
 /*!
 \page qdeclarativenetwork.html
+\ingroup qml-features
 \title Network Transparency
 
 QML supports network transparency by using URLs (rather than file names) for all
@@ -57,7 +58,7 @@ Network transparency is supported throughout QML, for example:
 Even QML types themselves can be on the network - if the \l {QML Viewer} is used to load
 \tt http://example.com/mystuff/Hello.qml and that content refers to a type "World", the engine
 will load \tt http://example.com/mystuff/qmldir and resolve the type just as it would for a local file.
-For example if the qmldir file contains the line "World World.qml", it will load 
+For example if the qmldir file contains the line "World World.qml", it will load
 \tt http://example.com/mystuff/World.qml
 Any other resources that \tt Hello.qml referred to, usually by a relative URL, would
 similarly be loaded from the network.
diff --git a/doc/src/declarative/positioners.qdoc b/doc/src/declarative/positioners.qdoc
index 9265732..7faac03 100644
--- a/doc/src/declarative/positioners.qdoc
+++ b/doc/src/declarative/positioners.qdoc
@@ -27,8 +27,13 @@
 
 /*!
 \page qml-positioners.html
+\ingroup qml-features
+\previouspage Property Binding
+\nextpage Anchor-based Layout in QML
+\contentspage QML Features
 \title Using QML Positioner and Repeater Items
 
+
 \section1 Introduction
 
 Positioner items are container items that manage the positions and sizes of
diff --git a/doc/src/declarative/propertybinding.qdoc b/doc/src/declarative/propertybinding.qdoc
index 3bf85de..92cf874 100644
--- a/doc/src/declarative/propertybinding.qdoc
+++ b/doc/src/declarative/propertybinding.qdoc
@@ -27,15 +27,21 @@
 
 /*!
 \page propertybinding.html
+\ingroup qml-features
+\contentspage QML Features
+\previouspage QML Features
+\nextpage Using QML Positioner and Repeater Items
 \title Property Binding
 
+
+\section1 Introduction
 Property binding is a declarative way of specifying the value of a property.  Binding allows
 a property's value to be expressed as an JavaScript expression that defines the value relative
-to other property values or data accessible in the application.  The property value is 
+to other property values or data accessible in the application.  The property value is
 automatically kept up to date if the other properties or data values change.
 
-Property bindings are created implicitly in QML whenever a property is assigned an JavaScript
-expression.  The following QML uses two property bindings to connect the size of the rectangle
+Property bindings are created implicitly in QML whenever a property is assigned a JavaScript
+expression.  The following QML  code uses two property bindings to connect the size of the rectangle
 to that of \c otherItem.
 
 \code
@@ -45,9 +51,9 @@ Rectangle {
 }
 \endcode
 
-QML extends a standards compliant JavaScript engine, so any valid JavaScript expression can be 
+QML extends a standards compliant JavaScript engine, so any valid JavaScript expression can be
 used as a property binding.  Bindings can access object properties, make function calls and even
-use builtin JavaScript objects like \e {Date} and \e {Math}.  Assigning a constant value to a 
+use built-in JavaScript objects like \c {Date} and \c {Math}.  Assigning a constant value to a
 property can even be thought of as a binding - after all, a constant is a valid JavaScript
 expression!  Here are some examples of more complex bindings:
 
@@ -71,10 +77,10 @@ function.
 
 \section1 Changing Bindings
 
-The \l PropertyChanges element can be used within a state change to modify the bindings on 
-properties.  
+The \l PropertyChanges element can be used within a state change to modify the bindings on
+properties.
 
-This example modifies the \l Rectangle's width property binding to be \c {otherItem.height} 
+This example modifies the \l Rectangle's width property binding to be \c {otherItem.height}
 when in the "square" state.  When it returns to its default state, width's original property
 binding will have been restored.
 
@@ -97,7 +103,7 @@ Rectangle {
 
 \section1 Effects of Property Assignment in JavaScript
 
-Assigning a property value from JavaScript does \e not create a property binding.
+Assigning a property value from JavaScript does \i not create a property binding.
 For example:
 
 \code
@@ -110,10 +116,10 @@ Rectangle {
 \endcode
 
 Instead of creating a property binding, this simply sets the \c width of the \l Rectangle
-to the value of \c other.width at the time the JavaScript code is invoked.  See 
+to the value of \c other.width at the time the JavaScript code is invoked.  See
 \l {Property Assignment vs Property Binding} for more details.
 
-Also note that assigning a value to a property that is currently bound will remove the binding.
+Also note that assigning a value to a property that is currently bound will remove the previous binding.
 A property can only have one value at a time, and if any code explicitly sets
 this value, the binding is removed.  The \l Rectangle in the example below will have
 a width of 13, regardless of the \c otherItem's width.
@@ -135,7 +141,7 @@ although it is possible to set up a \l Binding object (shown below).
 \section1 Binding Element
 
 The implicit binding syntax shown previously is easy to use and works perfectly for most uses
-of bindings.  In some advanced cases, it is necessary to create bindings explicitly using the 
+of bindings.  In some advanced cases, it is necessary to create bindings explicitly using the
 \l Binding element.
 
 For example, to bind a property exposed from C++ (\c system.brightness) to a value
diff --git a/doc/src/declarative/qdeclarativei18n.qdoc b/doc/src/declarative/qdeclarativei18n.qdoc
index 0d5fbcc..fac1e55 100644
--- a/doc/src/declarative/qdeclarativei18n.qdoc
+++ b/doc/src/declarative/qdeclarativei18n.qdoc
@@ -27,6 +27,7 @@
 
 /*!
 \page qdeclarativei18n.html
+\ingroup qml-features
 \title QML Internationalization
 
 \section1 Overview
diff --git a/doc/src/declarative/qdeclarativemodels.qdoc b/doc/src/declarative/qdeclarativemodels.qdoc
index e11cd56..fdae0bb 100644
--- a/doc/src/declarative/qdeclarativemodels.qdoc
+++ b/doc/src/declarative/qdeclarativemodels.qdoc
@@ -27,10 +27,12 @@
 
 /*!
 \page qdeclarativemodels.html
+\ingroup qml-features
+\contentspage QML Features
 \target qmlmodels
 \title QML Data Models
 
-QML items such as ListView, GridView and \l Repeater require Data Models 
+QML items such as ListView, GridView and \l Repeater require Data Models
 that provide the data to be displayed.
 These items typically require a \e delegate component that
 creates an instance for each item in the model.  Models may be static, or
@@ -38,7 +40,7 @@ have items modified, inserted, removed or moved dynamically.
 
 Data is provided to the delegate via named data roles which the
 delegate may bind to. Here is a ListModel with two roles, \e type and \e age,
-and a ListView with a delegate that binds to these roles to display their 
+and a ListView with a delegate that binds to these roles to display their
 values:
 
 \snippet doc/src/snippets/declarative/qml-data-models/listmodel-listview.qml document
@@ -48,7 +50,7 @@ properties, the roles can be accessed with the qualified \e model name instead.
 For example, if a \l Text element had \e type or \e age properties, the text in the
 above example would display those property values instead of the \e type and \e age values
 from the model item. In this case, the properties could have been referenced as
-\c model.type and \c model.age instead to ensure the delegate displays the 
+\c model.type and \c model.age instead to ensure the delegate displays the
 property values from the model item.
 
 A special \e index role containing the index of the item in the model
@@ -125,10 +127,10 @@ be used to display an RSS feed.
 
 \section2 VisualItemModel
 
-VisualItemModel allows QML items to be provided as a model.  
+VisualItemModel allows QML items to be provided as a model.
 
 This model contains both the data and delegate; the child items of a
-VisualItemModel provide the contents of the delegate. The model 
+VisualItemModel provide the contents of the delegate. The model
 does not provide any roles.
 
 \code
@@ -165,7 +167,7 @@ models.
 
 A model may be a simple QStringList, which provides the contents of the list via the \e modelData role.
 
-Here is a ListView with a delegate that references its model item's 
+Here is a ListView with a delegate that references its model item's
 value using the \c modelData role:
 
 \snippet examples/declarative/modelviews/stringlistmodel/view.qml 0
@@ -184,7 +186,7 @@ the model by calling QDeclarativeContext::setContextProperty() again.
 
 \section2 QList<QObject*>
 
-A list of QObject* values can also be used as a model. A QList<QObject*> provides 
+A list of QObject* values can also be used as a model. A QList<QObject*> provides
 the properties of the objects in the list as roles.
 
 The following application creates a \c DataObject class that with
@@ -205,7 +207,7 @@ the ListView delegate:
 
 \snippet examples/declarative/modelviews/objectlistmodel/view.qml 0
 
-Note the use of the fully qualified access to the \c color property.  
+Note the use of the fully qualified access to the \c color property.
 The properties of the object are not replicated in the \c model
 object, since they are easily available via the \c modelData
 object.
@@ -221,10 +223,10 @@ the model by calling QDeclarativeContext::setContextProperty() again.
 
 A model can be defined by subclassing QAbstractItemModel. This is the
 best approach if you have a more complex model that cannot be supported
-by the other approaches. A QAbstractItemModel can also automatically 
+by the other approaches. A QAbstractItemModel can also automatically
 notify a QML view when the model data has changed.
 
-The roles of a QAbstractItemModel subclass can be exposed to QML by calling 
+The roles of a QAbstractItemModel subclass can be exposed to QML by calling
 QAbstractItemModel::setRoleNames(). The default role names set by Qt are:
 
 \table
@@ -244,9 +246,9 @@ that has \e type and \e size roles. It calls QAbstractItemModel::setRoleNames()
 role names for accessing the properties via QML:
 
 \snippet examples/declarative/modelviews/abstractitemmodel/model.h 0
-\dots 
+\dots
 \snippet examples/declarative/modelviews/abstractitemmodel/model.h 1
-\dots 
+\dots
 \snippet examples/declarative/modelviews/abstractitemmodel/model.h 2
 \codeline
 \snippet examples/declarative/modelviews/abstractitemmodel/model.cpp 0
@@ -261,14 +263,14 @@ roles:
 
 QML views are automatically updated when the model changes. Remember the model
 must follow the standard rules for model changes and notify the view when
-the model has changed by using QAbstractItemModel::dataChanged(), 
+the model has changed by using QAbstractItemModel::dataChanged(),
 QAbstractItemModel::beginInsertRows(), etc. See the \l {Model subclassing reference} for
 more information.
 
 The complete example is available in Qt's \l {declarative/modelviews/abstractitemmodel}{examples/declarative/modelviews/abstractitemmodel} directory.
 
 QAbstractItemModel presents a hierarchy of tables, but the views currently provided by QML
-can only display list data.  
+can only display list data.
 In order to display child lists of a hierarchical model
 the VisualDataModel element provides several properties and functions for use
 with models of type QAbstractItemModel:
@@ -283,14 +285,14 @@ with models of type QAbstractItemModel:
 
 \section2 Exposing C++ data models to QML
 
-The above examples use QDeclarativeContext::setContextProperty() to set 
-model values directly in QML components. An alternative to this is to 
-register the C++ model class as a QML type from a QML C++ plugin using 
-QDeclarativeExtensionPlugin. This would allow the model classes to be 
+The above examples use QDeclarativeContext::setContextProperty() to set
+model values directly in QML components. An alternative to this is to
+register the C++ model class as a QML type from a QML C++ plugin using
+QDeclarativeExtensionPlugin. This would allow the model classes to be
 created directly as elements within QML:
 
 \table
-\row 
+\row
 
 \o
 \code
@@ -299,7 +301,7 @@ class MyModelPlugin : public QDeclarativeExtensionPlugin
 public:
     void registerTypes(const char *uri)
     {
-        qmlRegisterType<MyModel>(uri, 1, 0, 
+        qmlRegisterType<MyModel>(uri, 1, 0,
                 "MyModel");
     }
 }
@@ -466,6 +468,8 @@ updated, and that \e{value} holds the new value.
 
 /*!
 \page qml-presenting-data.html
+\ingroup qml-features
+\contentspage QML Features
 \title Presenting Data with QML
 
 \section1 Introduction
diff --git a/doc/src/declarative/qdeclarativestates.qdoc b/doc/src/declarative/qdeclarativestates.qdoc
index b663d43..f378ce6 100644
--- a/doc/src/declarative/qdeclarativestates.qdoc
+++ b/doc/src/declarative/qdeclarativestates.qdoc
@@ -27,6 +27,8 @@
 
 /*!
 \page qdeclarativestates.html
+\ingroup qml-features
+\contentspage QML Features
 \target qmlstates
 \title QML States
 
@@ -36,9 +38,9 @@ User interfaces are designed to present different interface configurations in
 different scenarios, or to modify their appearances in response to user
 interaction. Often, there are a set of changes that are made concurrently, such
 that the interface could be seen to be internally changing from one \e state to
-another. 
+another.
 
-This applies generally to interface elements regardless of their complexity. 
+This applies generally to interface elements regardless of their complexity.
 A photo viewer may initially present images in a grid, and when an image is
 clicked, change to a "detailed" state where the individual image is expanded
 and the interface is changed to present new options for image editing. On the
@@ -47,7 +49,7 @@ other end of the scale, when a simple button is pressed, it may change to a
 appearance.
 
 In QML, any object can change between different \e states to apply sets of
-changes that modify the properties of relevant items. Each \e state could 
+changes that modify the properties of relevant items. Each \e state could
 present a different configuration that could, for example:
 
 \list
@@ -83,10 +85,10 @@ within the MouseArea changes the state to the "moved" state, thus moving the \l
 Rectangle.
 
 \snippet doc/src/snippets/declarative/states.qml 0
- 
+
 The \l State item defines all the changes to be made in the new state. It
-could specify additional properties to be changed, or create additional 
-PropertyChanges for other objects. It can also modify the properties of other 
+could specify additional properties to be changed, or create additional
+PropertyChanges for other objects. It can also modify the properties of other
 objects, not just the object that owns the state. For example:
 
 \qml
@@ -96,13 +98,13 @@ Rectangle {
         State {
             name: "moved"
             PropertyChanges { target: myRect; x: 50; y: 50; color: "blue" }
-            PropertyChanges { target: someOtherItem; width: 1000 }            
+            PropertyChanges { target: someOtherItem; width: 1000 }
         }
     ]
 }
 \endqml
 
-As a convenience, if an item only has one state, its \l {Item::}{states} 
+As a convenience, if an item only has one state, its \l {Item::}{states}
 property can be defined as a single \l State, without the square-brace list
 syntax:
 
@@ -115,7 +117,7 @@ Item {
 }
 \endqml
 
-A \l State is not limited to performing modifications on property values. It 
+A \l State is not limited to performing modifications on property values. It
 can also:
 
 \list
@@ -125,8 +127,8 @@ can also:
 \o Modify anchor values using AnchorChanges
 \endlist
 
-The \l {declarative/animation/states}{States and Transitions example} 
-demonstrates how to declare a basic set of states and apply animated 
+The \l {declarative/animation/states}{States and Transitions example}
+demonstrates how to declare a basic set of states and apply animated
 transitions between them.
 
 
@@ -136,15 +138,15 @@ Of course, the \l Rectangle in the example above could have simply been moved
 by setting its position to (50, 50) in the mouse area's \c onClicked handler.
 However, aside from enabling batched property changes, one of the features of
 QML states is the ability of an item to revert to its \e {default state}.
-The default state contains all of an item's initial property values before 
+The default state contains all of an item's initial property values before
 they were modified in a state change.
 
 For example, suppose the \l Rectangle should move to (50,50) when the mouse is
-pressed, and then move back to its original position when the mouse is 
+pressed, and then move back to its original position when the mouse is
 released. This can be achieved by using the \l {State::}{when} property,
 like this:
 
-\qml 
+\qml
 Rectangle {
     ...
 
@@ -158,7 +160,7 @@ Rectangle {
         ...
     }
 }
-\endqml 
+\endqml
 
 The \l {State::}{when} property is set to an expression that evaluates to
 \c true when the item should be set to that state. When the mouse is pressed,
@@ -169,7 +171,7 @@ Alternatively, an item can be explicitly set to its default state by setting its
 \l {Item::}{state} property to an empty string (""). For example, instead of
 using the \l {State::}{when} property, the above code could be changed to:
 
-\qml 
+\qml
 Rectangle {
     ...
 
@@ -184,10 +186,10 @@ Rectangle {
         ...
     }
 }
-\endqml 
+\endqml
 
 Obviously it makes sense to use the \l {State::}{when} property when possible
-as it provides a simpler (and a better, more declarative) solution than 
+as it provides a simpler (and a better, more declarative) solution than
 assigning the state from signal handlers.
 
 
@@ -210,14 +212,14 @@ Rectangle {
     states: [
        ...
     ]
-     
+
     transitions: [
         Transition {
             NumberAnimation { properties: "x,y"; duration: 500 }
         }
     ]
  }
-\endqml  
+\endqml
 
 This \l Transition defines that if any \c x or \c y properties have changed
 during a state change within this item, their values should be animated over 500
diff --git a/doc/src/declarative/qtbinding.qdoc b/doc/src/declarative/qtbinding.qdoc
index 71f41bc..347fd94 100644
--- a/doc/src/declarative/qtbinding.qdoc
+++ b/doc/src/declarative/qtbinding.qdoc
@@ -27,6 +27,7 @@
 
 /*!
 \page qtbinding.html
+\ingroup qml-features
 \target qtbinding
 \title Using QML in C++ Applications
 
diff --git a/doc/src/overviews.qdoc b/doc/src/overviews.qdoc
index b9bd3b4..3bb7aec 100644
--- a/doc/src/overviews.qdoc
+++ b/doc/src/overviews.qdoc
@@ -43,7 +43,7 @@
     web-enabled applications for desktop, mobile, and embedded
     operating systems. This page contains links to articles and overviews
 	explaining key components and techniuqes used in Qt development.
-	
+
     \generatelist {related}
  */
 
@@ -112,7 +112,7 @@
   \ingroup technology-apis
   \ingroup best-practices
   \ingroup qt-basic-concepts
-  
+
 
   These pages document Qt's API's for using SQL database systems
   in Qt applications.
@@ -133,7 +133,7 @@
 
     \generatelist{related}
 */
-/*! 
+/*!
 
 	\group licensing
 	\title Qt Licenses and Credits
@@ -146,3 +146,25 @@
 	\generatelist {related}
 
 */
+
+/*!
+    \group qml-best-practices
+    \title QML Best Practices Guides
+
+    \brief QML Programming Best Practices Guides
+
+    These documents provide guidelines and best practices for using QML and Qt
+    to solve specific technical problems.
+
+    \generatelist {related}
+*/
+/*!
+    \group qml-features
+    \title QML Features
+
+    \brief Features of the QML Language
+
+    These are overviews of the many features of the QML Language.
+
+    \generatelist {related}
+*/