Create new documentation structure

The documentation currently has no clear separation between Qt QML
and Qt Quick.  With recent commits like:
6c8378eaf1edbbefe6aaa3672b0127816a004fd7
and
ab1e510121c8a679fdaca12ccd30e0f7ac12a26b
the separation between the language definition and implementation,
provided by Qt QML, and the standard library for the QML language,
provided by Qt Quick, is clear.

This commit creates a new documentation structure that is more
navigable and separates concepts into logical categories, with
clear separation between QtQML and QtQuick.  It also provides a more
generic QML Application Developer Resources page which contains links
to information for QML application developers.

Change-Id: Ia807ccfbfd24ffa0e1c7f0a51ed9d2ed3aa6a733
Reviewed-by: Martin Jones <martin.jones@nokia.com>

115 files changed, 4088 insertions, 1214 deletions

diff --git a/src/quick/doc/snippets/qml/codingconventions/dotproperties.qml b/src/quick/doc/snippets/qml/codingconventions/dotproperties.qml
new file mode 100644
index 0000000000..75f4629b3e
--- /dev/null
+++ b/src/quick/doc/snippets/qml/codingconventions/dotproperties.qml
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+Item {
+
+//! [0]
+Rectangle {
+    anchors.left: parent.left; anchors.top: parent.top; anchors.right: parent.right; anchors.leftMargin: 20
+}
+
+Text {
+    text: "hello"
+    font.bold: true; font.italic: true; font.pixelSize: 20; font.capitalization: Font.AllUppercase
+}
+
+//! [0]
+
+//! [1]
+Rectangle {
+    anchors { left: parent.left; top: parent.top; right: parent.right; leftMargin: 20 }
+}
+
+Text {
+    text: "hello"
+    font { bold: true; italic: true; pixelSize: 20; capitalization: Font.AllUppercase }
+}
+//! [1]
+
+}
diff --git a/src/quick/doc/snippets/qml/codingconventions/javascript-imports.qml b/src/quick/doc/snippets/qml/codingconventions/javascript-imports.qml
new file mode 100644
index 0000000000..5ea66a9b1f
--- /dev/null
+++ b/src/quick/doc/snippets/qml/codingconventions/javascript-imports.qml
@@ -0,0 +1,47 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+//![0]
+import "myscript.js" as Script
+
+Rectangle { color: "blue"; width: Script.calculateWidth(parent) }
+//![0]
diff --git a/src/quick/doc/snippets/qml/codingconventions/javascript.qml b/src/quick/doc/snippets/qml/codingconventions/javascript.qml
new file mode 100644
index 0000000000..de3cc21493
--- /dev/null
+++ b/src/quick/doc/snippets/qml/codingconventions/javascript.qml
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+Rectangle {
+
+//![0]
+Rectangle { color: "blue"; width: parent.width / 3 }
+//![0]
+
+//![1]
+Rectangle {
+    color: "blue"
+    width: {
+        var w = parent.width / 3
+        console.debug(w)
+        return w
+    }
+}
+//![1]
+
+//![2]
+function calculateWidth(object)
+{
+    var w = object.width / 3
+    // ...
+    // more javascript code
+    // ...
+    console.debug(w)
+    return w
+}
+
+Rectangle { color: "blue"; width: calculateWidth(parent) }
+//![2]
+}
diff --git a/src/quick/doc/snippets/qml/codingconventions/lists.qml b/src/quick/doc/snippets/qml/codingconventions/lists.qml
new file mode 100644
index 0000000000..f99c92b08e
--- /dev/null
+++ b/src/quick/doc/snippets/qml/codingconventions/lists.qml
@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+Item {
+    Item {
+//! [0]
+states: [
+    State {
+        name: "open"
+        PropertyChanges { target: container; width: 200 }
+    }
+]
+//! [0]
+    }
+    Item {
+//! [1]
+states: State {
+    name: "open"
+    PropertyChanges { target: container; width: 200 }
+}
+//! [1]
+    }
+}
diff --git a/src/quick/doc/snippets/qml/codingconventions/myscript.js b/src/quick/doc/snippets/qml/codingconventions/myscript.js
new file mode 100644
index 0000000000..cfa646250b
--- /dev/null
+++ b/src/quick/doc/snippets/qml/codingconventions/myscript.js
@@ -0,0 +1,9 @@
+function calculateWidth(parent)
+{
+    var w = parent.width / 3
+    // ...
+    // more javascript code
+    // ...
+    console.debug(w)
+    return w
+}
diff --git a/src/quick/doc/snippets/qml/codingconventions/photo.qml b/src/quick/doc/snippets/qml/codingconventions/photo.qml
new file mode 100644
index 0000000000..1bd2811e9f
--- /dev/null
+++ b/src/quick/doc/snippets/qml/codingconventions/photo.qml
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+//! [0]
+Rectangle {
+    id: photo                                               // id on the first line makes it easy to find an object
+
+    property bool thumbnail: false                          // property declarations
+    property alias image: photoImage.source
+
+    signal clicked                                          // signal declarations
+
+    function doSomething(x)                                 // javascript functions
+    {                               
+        return x + photoImage.width
+    }
+
+    color: "gray"                                           // object properties
+    x: 20; y: 20; height: 150                               // try to group related properties together
+    width: {                                                // large bindings
+        if(photoImage.width > 200){
+	    photoImage.width;
+	}else{
+	    200;
+	}
+    }
+
+    Rectangle {                                             // child objects
+        id: border
+        anchors.centerIn: parent; color: "white"
+
+        Image { id: photoImage; anchors.centerIn: parent }
+    }
+
+    states: State {                                         // states
+        name: "selected"
+        PropertyChanges { target: border; color: "red" }
+    }
+
+    transitions: Transition {                               // transitions
+        from: ""; to: "selected"
+        ColorAnimation { target: border; duration: 200 }
+    }
+}
+//! [0]
+
diff --git a/src/quick/doc/snippets/qml/codingconventions/private.qml b/src/quick/doc/snippets/qml/codingconventions/private.qml
new file mode 100644
index 0000000000..9aba1d0377
--- /dev/null
+++ b/src/quick/doc/snippets/qml/codingconventions/private.qml
@@ -0,0 +1,49 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+//! [0]
+Item {
+    id: component
+    width: 40; height: 50
+    property real __area: width * height * 0.5    //not meant for outside use
+}
+//! [0]
diff --git a/src/quick/doc/src/models.qdoc b/src/quick/doc/src/apireference.qdoc
index 6d4e69b4c9..c6c255aaa4 100644
--- a/src/quick/doc/src/models.qdoc
+++ b/src/quick/doc/src/apireference.qdoc
@@ -26,10 +26,7 @@
 ****************************************************************************/
 
 /*!
-\group qtquick-models
-\title Qt Quick Models
-\brief Structuring data for display.
-
-\section1 Related Types
-\generatelist{related}
+\page qtquick-apireference.html
+\title Qt Quick Module API Reference
+\brief Description of the C++ API provided by the Qt Quick module
 */
diff --git a/src/quick/doc/src/appdevguide/applicationdevelopers.qdoc b/src/quick/doc/src/appdevguide/applicationdevelopers.qdoc
new file mode 100644
index 0000000000..2b172ef2d6
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/applicationdevelopers.qdoc
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+/*!
+\page qtquick-applicationdevelopers.html
+\title QML Application Developer Resources
+\brief Essential documentation for QML application developers
+
+\section1 Overview Of QML and Qt Quick
+
+\section2 What Is QML?
+
+QML is a user-interface specification and programming language.
+It allows highly performant, fluidly animated, visually appealing applications
+to be rapidly developed by either developers or designers.  QML offers a
+highly-readable, declarative, JSON-like syntax with support for imperative
+JavaScript expressions combined with dynamic property bindings.
+
+\section2 What Is Qt Quick?
+
+Qt Quick is the standard library of types and functionality for QML.  It
+includes visual elements, interactive elements, animations, models and views,
+particle effects and shader effects.  A QML application developer can get
+access to all of that functionality with a single import statement.
+
+\section1 Quick Start
+
+\list
+\li \l{qtquick-quickstart-basics.html}{QML Basics}
+    \list
+    \li \l{qtquick-quickstart-basics.html#creating-a-qml-document}{Creating A QML Document}
+    \li \l{qtquick-quickstart-basics.html#importing-and-using-the-qtquick-module}{Importing And Using The QtQuick Module}
+    \li \l{qtquick-quickstart-basics.html#loading-and-displaying-the-qml-document}{Loading And Displaying The QML Document}
+    \endlist
+\li \l{qtquick-quickstart-essentials.html}{QML Essentials}
+    \list
+    \li \l{qtquick-quickstart-essentials.html#bindings-and-signals}{Bindings And Signals}
+    \li \l{qtquick-quickstart-essentials.html#handling-user-input}{Handling User Input}
+    \li \l{qtquick-quickstart-essentials.html#defining-custom-qml-types-for-re-use}{Defining Custom QML Types For Re-use}
+    \endlist
+\endlist
+
+\section1 Features And Use-Case Solutions
+
+\list
+\li \l{qtquick-usecase-visual.html}{Placing Visual Content And Images In The Window}
+\li \l{qtquick-usecase-userinput.html}{Responding To User Input}
+\li \l{qtquick-usecase-animations.html}{Animating UI Elements}
+\li \l{qtquick-usecase-text.html}{Formatting And Displaying Text}
+\li \l{qtquick-usecase-layouts.html}{Complex Layouts}
+\li \l{qtquick-usecase-styling.html}{Style And Theme: Look And Feel}
+\li \l{qtquick-usecase-integratingjs.html}{Integrating With JavaScript}
+\li \l{qtquick-usecase-integratingcpp.html}{Integrating With C++}
+\li \l{qtquick-usecase-modules.html}{Creating Modules For QML}
+\li \l{qtquick-usecase-multimedia.html}{Playing Sounds And Video In QML}
+\endlist
+
+\section1 Important Application Development Topics
+
+\list
+\li \l{qml-intro.html}{Introduction To QML Application Development}
+\li \l{qtquick-performance.html}{Performance Considerations And Suggestions}
+\li \l{qtquick-internationalization.html}{Internationalization And Localization}
+\li \l{qtquick-glossary.html}{Glossary Of Terms}
+\endlist
+
+
+\section1 Testing and Debugging
+\list
+\li \l{qtquick-qmlscene.html}{Prototyping with qmlscene}
+\li \l{qtquick-debugging.html}{Debugging QML Applications}
+\li \l{qtquick-qtquicktest.html}{QtQuickTest: QML Unit Testing Framework}
+\endlist
+
+\section1 Further Information About The QML Language
+
+Please see the documentation for the \l{qtqml-main.html}{Qt QML Module} for
+in-depth information about QML documents and the QML language.
+
+\section1 Further Information About Qt Quick
+
+Please see the documentation for the \l{qtquick-main.html}{Qt Quick Module}
+for in-depth information about the various QML types and other functionality
+provided by Qt Quick.
+
+*/
+
diff --git a/src/quick/doc/src/appdevguide/codingconventions.qdoc b/src/quick/doc/src/appdevguide/codingconventions.qdoc
new file mode 100644
index 0000000000..89a1bd8cb3
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/codingconventions.qdoc
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qml-coding-conventions.html
+\title QML Coding Conventions
+\brief code style convention
+
+This document contains the QML coding conventions that we follow in our documentation and examples and recommend that others follow.
+
+\section1 QML Objects
+
+Through our documentation and examples, QML objects are always structured in the following order:
+
+\list
+\li id
+\li property declarations
+\li signal declarations
+\li JavaScript functions
+\li object properties
+\li child objects
+\li states
+\li transitions
+\endlist
+
+For better readability, we separate these different parts with an empty line.
+
+
+For example, a hypothetical \e photo QML object would look like this:
+
+\snippet qml/codingconventions/photo.qml 0
+
+
+\section1 Grouped Properties
+
+If using multiple properties from a group of properties,
+we use the \e {group notation} rather than the \e {dot notation} to improve readability.
+
+For example, this:
+
+\snippet qml/codingconventions/dotproperties.qml 0
+
+can be written like this:
+
+\snippet qml/codingconventions/dotproperties.qml 1
+
+
+\section1 Private Properties
+
+QML and JavaScript do not enforce private properties like C++. There is a need
+to hide these private properties, for example, when the properties are part of
+the implementation. As a convention, private properties begin with two
+\e underscore characters. For example, \c __area, is a property that is
+accessible but is not meant for public use. Note that QML and JavaScript will
+grant the user access to these properties.
+
+\snippet qml/codingconventions/private.qml 0
+
+
+\section1 Lists
+
+If a list contains only one element, we generally omit the square brackets.
+
+For example, it is very common for a component to only have one state.
+
+In this case, instead of:
+
+\snippet qml/codingconventions/lists.qml 0
+
+we will write this:
+
+\snippet qml/codingconventions/lists.qml 1
+
+
+\section1 JavaScript Code
+
+If the script is a single expression, we recommend writing it inline:
+
+\snippet qml/codingconventions/javascript.qml 0
+
+If the script is only a couple of lines long, we generally use a block:
+
+\snippet qml/codingconventions/javascript.qml 1
+
+If the script is more than a couple of lines long or can be used by different objects, we recommend creating a function and calling it like this:
+
+\snippet qml/codingconventions/javascript.qml 2
+
+For long scripts, we will put the functions in their own JavaScript file and import it like this:
+
+\snippet qml/codingconventions/javascript-imports.qml 0
+
+*/
+
+
+
+
+
+
+
+
+
diff --git a/src/quick/doc/src/appdevguide/debugging.qdoc b/src/quick/doc/src/appdevguide/debugging.qdoc
new file mode 100644
index 0000000000..d0b239427b
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/debugging.qdoc
@@ -0,0 +1,166 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-debugging.html
+\ingroup qtquick-tools
+\title Debugging QML Applications
+\brief debugging tools in QML
+
+\section1 Console API
+
+\section2 Log
+
+\c console.log, console.debug, console.info, console.warn and console.error can be used to print
+debugging information to the console. For example:
+
+\code
+function f(a, b) {
+  console.log("a is ", a, "b is ", b);
+}
+\endcode
+
+The output is generated using the qDebug, qWarning, qCritical methods in C++
+(see also http://doc.qt.nokia.com/latest/debug.html#warning-and-debugging-messages).
+
+Setting the environment variable QML_CONSOLE_EXTENDED also prints the source
+code location of the call.
+
+\section2 Assert
+
+\c console.assert tests that an expression is true. If not, it will write an optional message
+to the console and print the stack trace.
+
+\code
+function f() {
+  var x = 12
+  console.assert(x == 12, "This will pass");
+  console.assert(x > 12, "This will fail");
+}
+\endcode
+
+\section2 Timer
+
+\c console.time and console.timeEnd log the time (in milliseconds) that was spent between
+the calls. Both take a string argument that identifies the measurement. For example:
+
+\code
+function f() {
+    console.time("wholeFunction");
+    console.time("firstPart");
+    // first part
+    console.timeEnd("firstPart");
+    // second part
+    console.timeEnd("wholeFunction");
+}
+\endcode
+
+\section2 Trace
+
+\c console.trace prints the stack trace of JavaScript execution at the point where
+it was called. The stack trace info contains function name, file name, line number
+and column number. The stack trace is limited to last 10 stack frames.
+
+\section2 Count
+
+\c console.count prints the current number of times a particular piece of code has been executed,
+along with a message. That is,
+
+\code
+function f() {
+  console.count("f called");
+}
+\endcode
+
+will print \c{f called: 1}, \c{f called: 2} ... whenever \c{f()} is executed.
+
+\section2 Profile
+
+\c console.profile turns on the QML and JavaScript profilers. Nested calls are not
+supported and a warning will be printed to the console.
+
+\c console.profileEnd turns off the QML and JavaScript profilers. Calling this function
+without a previous call to console.profile will print a warning to the console. A
+profiling client should have been attached before this call to receive and store the
+profiling data. For example:
+
+\code
+function f() {
+    console.profile();
+    //Call some function that needs to be profiled.
+    //Ensure that a client is attached before ending
+    //the profiling session.
+    console.profileEnd();
+}
+\endcode
+
+\section2 Exception
+
+\c console.exception prints an error message together with the stack trace of JavaScript
+execution at the point where it is called.
+
+\section1 Debugging Transitions
+
+When a transition doesn't look quite right, it can be helpful to view it in slow
+motion to see what is happening more clearly. This functionality is supported
+in the \l{qtquick-qmlscene.html}{QML Scene} tool: to enable this,
+click on the "Debugging" menu, then "Slow Down Animations".
+
+
+\section1 Debugging module imports
+
+The \c QML_IMPORT_TRACE environment variable can be set to enable debug output
+from QML's import loading mechanisms.
+
+For example, for a simple QML file like this:
+
+\qml
+import QtQuick 2.0
+
+Rectangle { width: 100; height: 100 }
+\endqml
+
+If you set \c {QML_IMPORT_TRACE=1} before running the \l{qtquick-qmlscene.html}
+{QML Scene} (or your QML C++ application), you will see output similar to this:
+
+\code
+QQmlImportDatabase::addImportPath "/qt-sdk/imports"
+QQmlImportDatabase::addImportPath "/qt-sdk/bin/QMLViewer.app/Contents/MacOS"
+QQmlImportDatabase::addToImport 0x106237370 "." -1.-1 File as ""
+QQmlImportDatabase::addToImport 0x106237370 "Qt" 4.7 Library as ""
+QQmlImportDatabase::resolveType "Rectangle" = "QDeclarativeRectangle"
+\endcode
+
+
+\section1 Debugging with Qt Creator
+
+\l{http://qt.nokia.com/products/developer-tools}{Qt Creator} provides built-in
+support for QML debugging. QML projects and standalone C++ applications that
+utilize QML can be debugged on desktops as well as on remote devices.
+For more information, see the Qt Creator Manual.
+
+*/
diff --git a/src/quick/doc/src/appdevguide/deployment.qdoc b/src/quick/doc/src/appdevguide/deployment.qdoc
new file mode 100644
index 0000000000..2104bb6552
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/deployment.qdoc
@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-deployment.html
+\title Deploying QML Applications
+\brief process of deploying QML applications
+
+
+
+QML documents are loaded and executed by the QML runtime. This includes the
+Declarative UI engine along with the built-in QML elements and plugin modules,
+and it also provides access to third-party QML elements and modules.
+
+Applications that use QML need to invoke the QML runtime in order to
+execute QML documents. This can be done by creating a QQuickView
+or a QQmlEngine, as described below. In addition, the Declarative UI
+package includes the qmlscene tool, which loads \c .qml files. This tool is
+useful for developing and testing QML code without the need to write
+a C++ application to load the QML runtime.
+
+
+
+\section1 Deploying QML-based applications
+
+To deploy an application that uses QML, the QML runtime must be invoked by
+the application. This is done by writing a Qt C++ application that loads the
+QQmlEngine by either:
+
+\list
+\li Loading the QML file through a QQuickView instance, or
+\li Creating a QQmlEngine instance and loading QML files with QQmlComponent
+\endlist
+
+
+\section2 Deploying with QQuickView
+
+QQuickView is a QWidget-based class that is able to load QML files.
+For example, if there is a QML file, \c application.qml, like this:
+
+\qml
+    import QtQuick 2.0
+
+    Rectangle { width: 100; height: 100; color: "red" }
+\endqml
+
+It can be loaded in a Qt application's \c main.cpp file like this:
+
+\code
+    #include <QApplication>
+    #include <QQuickView>
+
+    int main(int argc, char *argv[])
+    {
+        QApplication app(argc, argv);
+
+        QQuickView view;
+        view.setSource(QUrl::fromLocalFile("application.qml"));
+        view.show();
+
+        return app.exec();
+    }
+\endcode
+
+This creates a QWidget-based view that displays the contents of
+\c application.qml.
+
+The application's \c .pro \l{qmake Project Files}{project file} must specify
+the \c declarative module for the \c QT variable. For example:
+
+\code
+    TEMPLATE += app
+    QT += gui declarative
+    SOURCES += main.cpp
+\endcode
+
+
+\section2 Creating a QQmlEngine directly
+
+If \c application.qml does not have any graphical components, or if it is
+preferred to avoid QQuickView for other reasons, the QQmlEngine
+can be constructed directly instead. In this case, \c application.qml is
+loaded as a QQmlComponent instance rather than placed into a view:
+
+\code
+    #include <QApplication>
+    #include <QQmlEngine>
+    #include <QQmlContext>
+    #include <QQmlComponent>
+
+    int main(int argc, char *argv[])
+    {
+        QApplication app(argc, argv);
+
+        QQmlEngine engine;
+        QQmlContext *objectContext = new QQmlContext(engine.rootContext());
+
+        QQmlComponent component(&engine, "application.qml");
+        QObject *object = component.create(objectContext);
+
+        // ... delete object and objectContext when necessary
+
+        return app.exec();
+    }
+\endcode
+
+See \l{qtqml-cppintegration-data.html}{Exposing C++ Data to QML} for more information about using
+QQmlEngine, QQmlContext and QQmlComponent, as well
+as details on including QML files through \l{The Qt Resource System}{Qt's Resource system}.
+
+
+
+\section1 Developing and Prototyping with QML Scene
+
+The Declarative UI package includes a QML runtime tool,
+\l{qtquick-qmlscene.html}{qmlscene}, which loads and displays QML documents.
+This is useful during the application development phase for prototyping
+QML-based applications without writing your own C++ applications to invoke
+the QML runtime.
+
+
+
+\section1 Managing resource files with the Qt resource system
+
+The \l {The Qt Resource System}{Qt resource system} allows resource files to be stored as
+binary files in an application executable. This can be useful when building a mixed
+QML/C++ application as it enables QML files (as well as other resources such as images
+and sound files) to be referred to through the resource system URI scheme rather than
+relative or absolute paths to filesystem resources. Note, however, that if you use the resource
+system, the application executable must be re-compiled whenever a QML source file is changed
+in order to update the resources in the package.
+
+To use the resource system in a mixed QML/C++ application:
+
+\list
+\li Create a \c .qrc \l {The Qt Resource System}{resource collection file} that lists resource
+   files in XML format
+\li From C++, load the main QML file as a resource using the \c :/ prefix or as a URL with the
+   \c qrc scheme
+\endlist
+
+Once this is done, all files specified by relative paths in QML will be loaded from
+the resource system instead. Use of the resource system is completely transparent to
+the QML layer; this means all QML code should refer to resource files using relative
+paths and should \e not use the \c qrc scheme. This scheme should only be used from
+C++ code for referring to resource files.
+
+Here is a application packaged using the \l {The Qt Resource System}{Qt resource system}.
+The directory structure looks like this:
+
+\code
+project
+    |- example.qrc
+    |- main.qml
+    |- images
+        |- background.png
+    |- main.cpp
+    |- project.pro
+\endcode
+
+The \c main.qml and \c background.png files will be packaged as resource files. This is
+done in the \c example.qrc resource collection file:
+
+\quotefile qml/qtbinding/resources/example.qrc
+
+Since \c background.png is a resource file, \c main.qml can refer to it using the relative
+path specified in \c example.qrc:
+
+\snippet qml/qtbinding/resources/main.qml 0
+
+To allow QML to locate resource files correctly, the \c main.cpp loads the main QML
+file, \c main.qml, as a resource file using the \c qrc scheme:
+
+\snippet qml/qtbinding/resources/main.cpp 0
+
+Finally \c project.pro uses the RESOURCES variable to indicate that \c example.qrc should
+be used to build the application resources:
+
+\quotefile qml/qtbinding/resources/resources.pro
+
+See \l {The Qt Resource System} for more information.
+
+
diff --git a/src/quick/doc/src/appdevguide/glossary.qdoc b/src/quick/doc/src/appdevguide/glossary.qdoc
new file mode 100644
index 0000000000..6e20d2fed9
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/glossary.qdoc
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-glossary.html
+\title Glossary Of Terms
+\brief Glossary of terms used in the documentation for QML and QtQuick
+
+\section1 Common Terms
+
+\table
+    \header
+        \li Term
+        \li Definition
+
+    \row
+        \li QML
+        \li The language provided by the Qt QML module in which QML
+            applications are written
+
+    \row
+        \li Qt Quick
+        \li The standard-library of types and functionality for the
+            QML language, which is provided by the Qt Quick module,
+            and may be accessed with "import QtQuick 2.0"
+
+    \row
+        \li Type
+        \li A type is either a property type, or a QML object type.
+            All QML object types may also be a property type (for
+            example, you can have a property of type Button) but not
+            all property types are also QML object types (for example,
+            an integer is not an object).  Types are either built-in
+            to the QML language (\l{qtqml-basictypes.html}{basic types}),
+            or they are provided by the QtQuick import
+            (\l{qtquick-qmltypereference.html}{Qt Quick types}), or they
+            are provided in extensions to QML (\l{qtqml-modules-topic.html}
+            {Modules}) or by the application developer as QML documents.
+
+    \row
+        \li Component
+        \li A Component is a special type which may be used to instantiate
+            other QML object types.
+
+    \row
+        \li Object
+        \li An object is an instance of a type.
+
+    \row
+        \li Property
+        \li An object can have one or more properties.  Some properties
+            are associated with the canvas (e.g., x, y, width, height,
+            and opacity) while others may be data specific to that type
+            (e.g., the "text" property of the Text type).
+
+    \row
+        \li Binding
+        \li A binding is a JavaScript expression which is "bound" to a
+            property.  The value of the property at any point in time
+            will be the value returned by evaluating that expression.
+
+    \row
+        \li Signal
+        \li A signal is a notification of a condition occurring, and may be
+            either "emitted" or "handled".  Most properties of QML objects
+            have a change signal, and also an associated change signal handler
+            which may be defined by clients to implement functionality.  For
+            example, the "onClicked()" handler of an instance of the MouseArea
+            type might be defined in an application to cause a sound to be
+            played.
+
+    \row
+        \li Signal Handler
+        \li A signal handler is the expression (or function) which is triggered
+            by a signal.  It is also known as a "slot" in C++.
+
+    \row
+        \li Lazy Instantiation
+        \li Object instances can be instantiated "lazily" at run-time,
+            to avoid performing unnecessary work until needed.  Qt Quick
+            provides the Loader element to make lazy instantiation more
+            convenient.
+\endtable
+
+\section1 Indexed Alphabetically
+
+*/
diff --git a/src/quick/doc/src/appdevguide/internationalization.qdoc b/src/quick/doc/src/appdevguide/internationalization.qdoc
new file mode 100644
index 0000000000..ee2ac5df20
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/internationalization.qdoc
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-internationalization.html
+\ingroup qml-features
+\title Localization And Internationalization Support In Qt Quick
+\brief Description of how a QML developer can internationalize their application
+
+\section1 Translation
+
+Strings in QML can be marked for translation using the qsTr(), qsTranslate(), qsTrId(),
+QT_TR_NOOP(), QT_TRANSLATE_NOOP(), and QT_TRID_NOOP() functions.
+
+For example:
+\qml
+Text { text: qsTr("Pictures") }
+\endqml
+
+These functions are standard QtScript functions; for more details see
+QScriptEngine::installTranslatorFunctions().
+
+QML relies on the core internationalization capabilities provided by Qt. These
+capabilities are described more fully in:
+\list
+\li \l {Internationalization with Qt}
+\li \l {Qt Linguist Manual}
+\endlist
+
+You can test a translation with the \l{qtquick-qmlscene.html}{QML Scene} using the -translation option.
+
+\section2 Example
+
+First we create a simple QML file with text to be translated. The string
+that needs to be translated is enclosed in a call to \c qsTr().
+
+hello.qml:
+\qml
+import QtQuick 2.0
+
+Rectangle {
+    width: 200; height: 200
+    Text { text: qsTr("Hello"); anchors.centerIn: parent }
+}
+\endqml
+
+Next we create a translation source file using lupdate:
+\code
+lupdate hello.qml -ts hello.ts
+\endcode
+
+Then we open \c hello.ts in \l{Qt Linguist Manual} {Linguist}, provide
+a translation and create the release file \c hello.qm.
+
+Finally, we can test the translation:
+\code
+qmlviewer -translation hello.qm hello.qml
+\endcode
+
+You can see a complete example and source code in the \l{declarative/i18n}{QML Internationalization example}.
+
+\section1 Localization
+
+Localization is the process of adapting to local conventions,
+for example presenting dates and times using the locally preferred formats.
+
+Qt Quick supports localization via the \l {QtQuick2::Locale}{Locale} object and extensions to the
+\l{ECMA-262}{ECMAScript} \l {QtQuick2::Date}{Date} and \l {QtQuick2::Number}{Number} types.
+
+
+*/
+
diff --git a/src/quick/doc/src/appdevguide/performance.qdoc b/src/quick/doc/src/appdevguide/performance.qdoc
new file mode 100644
index 0000000000..f2918139dc
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/performance.qdoc
@@ -0,0 +1,1120 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-performance.html
+\title Performance Considerations And Suggestions
+\brief Discussion of performance-related tradeoffs and best-practices
+
+\section1 Timing Considerations
+
+As an application developer, you must strive to allow the rendering engine
+to achieve a consistent 60 frames-per-second refresh rate.  60 FPS means
+that there is approximately 16 milliseconds between each frame in which
+processing can be done, which includes the processing required to upload
+the draw primitives to the graphics hardware.
+
+In practice, this means that the application developer should use asynchronous,
+event driven programming wherever possible, should use worker threads to do
+significant processing, should never manually spin the event loop, and should
+never spend more than a couple of milliseconds per frame within blocking functions.
+Failure to do so will result in skipped frames, which has a drastic effect on the
+user experience.
+
+\note A pattern which is tempting, but should \e never be used, is creating your
+own QEventLoop or calling QCoreApplication::processEvents() in order to avoid
+blocking within a C++ code block invoked from QML. This is dangerous because
+when an event loop is entered in a signal handler or binding, the QML engine
+continues to run other bindings, animations, transitions, etc. Those bindings
+can then cause side effects which, for example, destroy the hierarchy containing
+your event loop.
+
+\section1 Profiling
+
+The most important tip is: use the QML profiler included with Qt Creator.  Knowing
+where time is spent in an application will allow you to focus on problem areas which
+actually exist, rather than problem areas which potentially exist.  See the Qt Creator
+manual for more information on how to use the QML profiling tool.
+
+Determining which bindings are being run the most often, or which functions your
+application is spending the most time in, will allow you to decide whether you need
+to optimize the problem areas, or redesign some implementation details of your
+application so that the performance is improved.  Attempting to optimize code without
+profiling is likely to result in very minor rather than significant performance
+improvements.
+
+\section1 JavaScript
+
+Most QML applications will have a large amount of JavaScript code in them, in the
+form of dynamic functions, signal handlers, and property binding expressions.
+This is not generally a problem (in fact, due to some optimizations in the QML engine
+(bindings compiler, etc) it can for some use-cases be faster than calling a C++ function)
+however care must be taken to ensure that unnecessary processing isn't triggered
+accidentally.
+
+\section2 Bindings
+
+There are two types of bindings in QML: optimized and non-optimized bindings.
+It is a good idea to keep binding expressions as simple as possible, since the
+QML engine makes use of an optimized binding expression evaluator which can
+evaluate simple binding expressions without needing to switch into a full
+JavaScript execution environment.  These optimized bindings are evaluated far
+more efficiently than more complex (non-optimized) bindings.
+
+Things to avoid in binding expressions to maximize optimizability:
+\list
+  \li declaring intermediate JavaScript variables
+  \li calling JavaScript functions
+  \li constructing closures or defining functions within the binding expression
+  \li accessing properties outside of the immediate context (generally, this means outside the component)
+  \li writing to other properties as side effects
+\endlist
+
+The QML_COMPILER_STATS environment variable may be set when running a QML application
+to print statistics about how many bindings were able to be optimized.
+
+Bindings are quickest when they know the type of objects and properties they are working
+with.  This means that non-final property lookup in a binding expression can be slower
+in some cases, where it is possible that the type of the property being looked up has
+been changed (for example, by a derived type).
+
+Note that if a binding cannot be optimized by the QML engine's optimized binding
+expression evaluator, and thus must be evaluated by the full JavaScript environment,
+some of the tips listed above will no longer apply.  For example, it can sometimes be
+beneficial to cache the result of property resolution in an intermediate JavaScript
+variable, in a very complex binding.  Upcoming sections have more information on these
+sorts of optimizations.
+
+\section2 Type-Conversion
+
+One major cost of using JavaScript is that in most cases when a property from a QML
+element is accessed, a JavaScript object with an external resource containing the
+underlying C++ data (or a reference to it) is created.  In most cases, this is fairly
+inexpensive, but in others it can be quite expensive.  One example of where it is
+expensive is assigning a C++ QVariantMap Q_PROPERTY to a QML "variant" property.
+Lists can also be expensive, although sequences of specific types (QList of int,
+qreal, bool, QString, and QUrl) should be inexpensive; other list types involve an
+expensive conversion cost (creating a new JavaScript Array, and adding new elements
+one by one, with per-element conversion from C++ type instance to JavaScript value).
+
+Converting between some basic property types (such as "string" and "url" properties)
+can also be expensive.  Using the closest matching property type will avoid unnecessary
+conversion.
+
+If you must expose a QVariantMap to QML, use a "var" property rather than a "variant"
+property.  In general, "property var" should be considered to be superior to
+"property variant" for every use-case in QtQuick 2.0 (note that "property variant"
+is marked as obsolete in the QtQuick 2.0 documentation), as it allows a true JavaScript
+reference to be stored (which can reduce the number of conversions required in certain
+expressions).
+
+\section2 Resolving Properties
+
+Property resolution takes time.  While in some cases the result of a lookup can be
+cached and reused, it is always best to avoid doing unnecessary work altogether, if
+possible.
+
+In the following example, we have a block of code which is run often (in this case, it
+is the contents of an explicit loop; but it could be a commonly-evaluated binding expression,
+for example) and in it, we resolve the element with the "rect" id and its "color" property
+multiple times:
+
+\qml
+// bad.qml
+import QtQuick 2.0
+
+Item {
+    width: 400
+    height: 200
+    Rectangle {
+        id: rect
+        anchors.fill: parent
+        color: "blue"
+    }
+
+    function printValue(which, value) {
+        console.log(which + " = " + value);
+    }
+
+    Component.onCompleted: {
+        var t0 = new Date();
+        for (var i = 0; i < 1000; ++i) {
+            printValue("red", rect.color.r);
+            printValue("green", rect.color.g);
+            printValue("blue", rect.color.b);
+            printValue("alpha", rect.color.a);
+        }
+        var t1 = new Date();
+        console.log("Took: " + (t1.valueOf() - t0.valueOf()) + " milliseconds for 1000 iterations");
+    }
+}
+\endqml
+
+We could instead resolve the common base just once in the block:
+
+\qml
+// good.qml
+import QtQuick 2.0
+
+Item {
+    width: 400
+    height: 200
+    Rectangle {
+        id: rect
+        anchors.fill: parent
+        color: "blue"
+    }
+
+    function printValue(which, value) {
+        console.log(which + " = " + value);
+    }
+
+    Component.onCompleted: {
+        var t0 = new Date();
+        for (var i = 0; i < 1000; ++i) {
+            var rectColor = rect.color; // resolve the common base.
+            printValue("red", rectColor.r);
+            printValue("green", rectColor.g);
+            printValue("blue", rectColor.b);
+            printValue("alpha", rectColor.a);
+        }
+        var t1 = new Date();
+        console.log("Took: " + (t1.valueOf() - t0.valueOf()) + " milliseconds for 1000 iterations");
+    }
+}
+\endqml
+
+Just this simple change results in a significant performance improvement.
+Note that the code above can be improved even further (since the property
+being looked up never changes during the loop processing), by hoisting the
+property resolution out of the loop, as follows:
+
+\qml
+// better.qml
+import QtQuick 2.0
+
+Item {
+    width: 400
+    height: 200
+    Rectangle {
+        id: rect
+        anchors.fill: parent
+        color: "blue"
+    }
+
+    function printValue(which, value) {
+        console.log(which + " = " + value);
+    }
+
+    Component.onCompleted: {
+        var t0 = new Date();
+        var rectColor = rect.color; // resolve the common base outside the tight loop.
+        for (var i = 0; i < 1000; ++i) {
+            printValue("red", rectColor.r);
+            printValue("green", rectColor.g);
+            printValue("blue", rectColor.b);
+            printValue("alpha", rectColor.a);
+        }
+        var t1 = new Date();
+        console.log("Took: " + (t1.valueOf() - t0.valueOf()) + " milliseconds for 1000 iterations");
+    }
+}
+\endqml
+
+\section2 Property Bindings
+
+A property binding expression will be re-evaluated if any of the properties
+it references are changed.  As such, binding expressions should be kept as
+simple as possible.
+
+If you have a loop where you do some processing, but only the final result
+of the processing is important, it is often better to update a temporary
+accumulator which you afterwards assign to the property you need to update,
+rather than incrementally updating the property itself, in order to avoid
+triggering re-evaluation of binding expressions during the intermediate
+stages of accumulation.
+
+The following contrived example illustrates this point:
+
+\qml
+// bad.qml
+import QtQuick 2.0
+
+Item {
+    id: root
+    width: 200
+    height: 200
+    property int accumulatedValue: 0
+
+    Text {
+        anchors.fill: parent
+        text: root.accumulatedValue.toString()
+        onTextChanged: console.log("text binding re-evaluated")
+    }
+
+    Component.onCompleted: {
+        var someData = [ 1, 2, 3, 4, 5, 20 ];
+        for (var i = 0; i < someData.length; ++i) {
+            accumulatedValue = accumulatedValue + someData[i];
+        }
+    }
+}
+\endqml
+
+The loop in the onCompleted handler causes the "text" property binding to
+be re-evaluated six times (which then results in any other property bindings
+which rely on the text value, as well as the onTextChanged signal handler,
+to be re-evaluated each time, and lays out the text for display each time).
+This is clearly unnecessary in this case, since we really only care about
+the final value of the accumulation.
+
+It could be rewritten as follows:
+
+\qml
+// good.qml
+import QtQuick 2.0
+
+Item {
+    id: root
+    width: 200
+    height: 200
+    property int accumulatedValue: 0
+
+    Text {
+        anchors.fill: parent
+        text: root.accumulatedValue.toString()
+        onTextChanged: console.log("text binding re-evaluated")
+    }
+
+    Component.onCompleted: {
+        var someData = [ 1, 2, 3, 4, 5, 20 ];
+        var temp = accumulatedValue;
+        for (var i = 0; i < someData.length; ++i) {
+            temp = temp + someData[i];
+        }
+        accumulatedValue = temp;
+    }
+}
+\endqml
+
+\section2 Sequence tips
+
+As mentioned earlier, some sequence types are fast (eg, QList<int>, QList<qreal>,
+QList<bool>, QList<QString>, QStringList and QList<QUrl>) while others will be
+much slower.  Aside from using these types wherever possible instead of slower types,
+there are some other performance-related semantics you need to be aware of to achieve
+the best performance.
+
+Firstly, there are two different implementations for sequence types: one for where
+the sequence is a Q_PROPERTY of a QObject (we'll call this a reference sequence),
+and another for where the sequence is returned from a Q_INVOKABLE function of a
+QObject (we'll call this a copy sequence).
+
+A reference sequence is read and written via QMetaObject::property() and thus is read
+and written as a QVariant.  This means that changing the value of any element in the
+sequence from JavaScript will result in three steps occurring: the complete sequence
+will be read from the QObject (as a QVariant, but then cast to a sequence of the correct
+type); the element at the specified index will be changed in that sequence; and the
+complete sequence will be written back to the QObject (as a QVariant).
+
+A copy sequence is far simpler as the actual sequence is stored in the JavaScript
+object's resource data, so no read/modify/write cycle occurs (instead, the resource
+data is modified directly).
+
+Therefore, writes to elements of a reference sequence will be much slower than writes
+to elements of a copy sequence.  In fact, writing to a single element of an N-element
+reference sequence is equivalent in cost to assigning a N-element copy sequence to that
+reference sequence, so you're usually better off modifying a temporary copy sequence
+and then assigning the result to a reference sequence, during computation.
+
+Assume the existence (and prior registration into the "Qt.example 1.0" namespace) of the
+following C++ type:
+
+\code
+class SequenceTypeExample : public QQuickItem
+{
+    Q_OBJECT
+    Q_PROPERTY (QList<qreal> qrealListProperty READ qrealListProperty WRITE setQrealListProperty NOTIFY qrealListPropertyChanged)
+
+public:
+    SequenceTypeExample() : QQuickItem() { m_list << 1.1 << 2.2 << 3.3; }
+    ~SequenceTypeExample() {}
+
+    QList<qreal> qrealListProperty() const { return m_list; }
+    void setQrealListProperty(const QList<qreal> &list) { m_list = list; emit qrealListPropertyChanged(); }
+
+signals:
+    void qrealListPropertyChanged();
+
+private:
+    QList<qreal> m_list;
+};
+\endcode
+
+The following example writes to elements of a reference sequence in a
+tight loop, resulting in bad performance:
+
+\qml
+// bad.qml
+import QtQuick 2.0
+import Qt.example 1.0
+
+SequenceTypeExample {
+    id: root
+    width: 200
+    height: 200
+
+    Component.onCompleted: {
+        var t0 = new Date();
+        qrealListProperty.length = 100;
+        for (var i = 0; i < 500; ++i) {
+            for (var j = 0; j < 100; ++j) {
+                qrealListProperty[j] = j;
+            }
+        }
+        var t1 = new Date();
+        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
+    }
+}
+\endqml
+
+The QObject property read and write in the inner loop caused by the
+\c{"qrealListProperty[j] = j"} expression makes this code very suboptimal.  Instead,
+something functionally equivalent but much faster would be:
+
+\qml
+// good.qml
+import QtQuick 2.0
+import Qt.example 1.0
+
+SequenceTypeExample {
+    id: root
+    width: 200
+    height: 200
+
+    Component.onCompleted: {
+        var t0 = new Date();
+        var someData = [1.1, 2.2, 3.3]
+        someData.length = 100;
+        for (var i = 0; i < 500; ++i) {
+            for (var j = 0; j < 100; ++j) {
+                someData[j] = j;
+            }
+            qrealListProperty = someData;
+        }
+        var t1 = new Date();
+        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
+    }
+}
+\endqml
+
+Secondly, a change signal for the property is emitted if any element in it changes.
+If you have many bindings to a particular element in a sequence property, it is better
+to create a dynamic property which is bound to that element, and use that dynamic
+property as the symbol in the binding expressions instead of the sequence element,
+as it will only cause re-evaluation of bindings if its value changes.
+
+This is an unusual use-case which most clients should never hit, but is worth being
+aware of, in case you find yourself doing something like this:
+
+\qml
+// bad.qml
+import QtQuick 2.0
+import Qt.example 1.0
+
+SequenceTypeExample {
+    id: root
+
+    property int firstBinding: qrealListProperty[1] + 10;
+    property int secondBinding: qrealListProperty[1] + 20;
+    property int thirdBinding: qrealListProperty[1] + 30;
+
+    Component.onCompleted: {
+        var t0 = new Date();
+        for (var i = 0; i < 1000; ++i) {
+            qrealListProperty[2] = i;
+        }
+        var t1 = new Date();
+        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
+    }
+}
+\endqml
+
+Note that even though only the element at index 2 is modified in the loop, the three
+bindings will all be re-evaluated since the granularity of the change signal is that
+the entire property has changed.  As such, adding an intermediate binding can
+sometimes be beneficial:
+
+\qml
+// good.qml
+import QtQuick 2.0
+import Qt.example 1.0
+
+SequenceTypeExample {
+    id: root
+
+    property int intermediateBinding: qrealListProperty[1]
+    property int firstBinding: intermediateBinding + 10;
+    property int secondBinding: intermediateBinding + 20;
+    property int thirdBinding: intermediateBinding + 30;
+
+    Component.onCompleted: {
+        var t0 = new Date();
+        for (var i = 0; i < 1000; ++i) {
+            qrealListProperty[2] = i;
+        }
+        var t1 = new Date();
+        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
+    }
+}
+\endqml
+
+In the above example, only the intermediate binding will be re-evaluated each time,
+resulting in a significant performance increase.
+
+\section2 Value-Type tips
+
+Value-type properties (font, color, vector3d, etc) have similar QObject property
+and change notification semantics to sequence type properties.  As such, the tips
+given above for sequences are also applicable for value-type properties.  While
+they are usually less of a problem with value-types (since the number of
+sub-properties of a value-type is usually far less than the number of elements
+in a sequence), any increase in the number of bindings being re-evaluated needlessly
+will have a negative impact on performance.
+
+\section2 Other JavaScript Objects
+
+Different JavaScript engines provide different optimizations.  The JavaScript engine
+which QtQuick 2 uses is optimized for object instantiation and property lookup, but
+the optimizations which it provides relies on certain criteria.  If your application
+does not meet the criteria, the JavaScript engine falls back to a "slow-path" mode
+with much worse performance.  As such, always try to ensure you meet the following
+criteria:
+
+\list
+\li Avoid using eval() if at all possible
+\li Do not delete properties of objects
+\endlist
+
+\section1 Common Interface Elements
+
+\section2 Text Elements
+
+Calculating text layouts can be a slow operation.  Consider using the \c PlainText
+format instead of \c StyledText wherever possible, as this reduces the amount of work
+required of the layout engine.  If you cannot use \c PlainText (as you need to embed
+images, or use tags to specify ranges of characters to have certain formatting (bold,
+italic, etc) as opposed to the entire text) then you should use \c StyledText.
+
+You should only use \c AutoText if the text might be (but probably isn't)
+\c StyledText as this mode will incur a parsing cost.  The \c RichText mode should
+not be used, as \c StyledText provides almost all of its features at a fraction of
+its cost.
+
+\section2 Images
+
+Images are a vital part of any user interface.  Unfortunately, they are also a big
+source of problems due to the time it takes to load them, the amount of memory they
+consume, and the way in which they are used.
+
+\section3 Asynchronous Loading
+
+Images are often quite large, and so it is wise to ensure that loading an image doesn't
+block the UI thread.  Set the "asynchronous" property of the QML Image element to
+\c true to enable asynchronous loading of images from the local file system (remote
+images are always loaded asynchronously) where this would not result in a negative impact
+upon the aesthetics of the user interface.
+
+Image elements with the "asynchronous" property set to \c true will load images in
+a low-priority worker thread.
+
+\section3 Explicit Source Size
+
+If your application loads a large image but displays it in a small-sized element, set
+the "sourceSize" property to the size of the element being rendered to ensure that the
+smaller-scaled version of the image is kept in memory, rather than the large one.
+
+Beware that changing the sourceSize will cause the image to be reloaded.
+
+\section3 Avoid Run-time Composition
+
+Also remember that you can avoid doing composition work at run-time by providing the
+pre-composed image resource with your application (e.g., providing elements with shadow
+effects).
+
+\section2 Position Elements With Anchors
+
+It is more efficient to use anchors rather than bindings to position items
+relative to each other.  Consider this use of bindings to position rect2
+relative to rect1:
+
+\code
+Rectangle {
+    id: rect1
+    x: 20
+    width: 200; height: 200
+}
+Rectangle {
+    id: rect2
+    x: rect1.x
+    y: rect1.y + rect1.height
+    width: rect1.width - 20
+    height: 200
+}
+\endcode
+
+This is achieved more efficiently using anchors:
+
+\code
+Rectangle {
+    id: rect1
+    x: 20
+    width: 200; height: 200
+}
+Rectangle {
+    id: rect2
+    height: 200
+    anchors.left: rect1.left
+    anchors.top: rect1.bottom
+    anchors.right: rect1.right
+    anchors.rightMargin: 20
+}
+\endcode
+
+Note that this is still not as efficient as specifying a static size, so you should still specify static sizes via
+the x, y, width and height properties.
+
+Item coordinates are always relative to their parent, so if you wanted to be a fixed offset from your parent's
+0,0 coordinate you should not use anchors. For example the following items are in the same place, but the anchors
+code is not as resource efficient as fixed positioning.
+
+\code
+Rectangle {
+    width: 60
+    height: 60
+    Rectangle {
+        x: 20
+        y: 20
+        width: 20
+        height: 20
+    }
+    Rectangle {
+        anchors.fill: parent
+        anchors.margins: 20
+    }
+}
+\endcode
+
+\section1 Models and Views
+
+Most applications will have at least one model feeding data to a view.  There are
+some semantics which application developers need to be aware of, in order to achieve
+maximal performance.
+
+\section2 Custom C++ Models
+
+It is often desirable to write your own custom model in C++ for use with a view in
+QML.  While the optimal implementation of any such model will depend heavily on the
+use-case it must fulfil, some general guidelines are as follows:
+
+\list
+\li Be as asynchronous as possible
+\li Do all processing in a (low priority) worker thread
+\li Batch up backend operations so that (potentially slow) I/O and IPC is minimized
+\li Use a sliding slice window to cache results, whose parameters are determined with the help of profiling
+\endlist
+
+It is important to note that using a low-priority worker thread is recommended to
+minimise the risk of starving the GUI thread (which could result in worse perceived
+performance).  Also, remember that synchronization and locking mechanisms can be a
+significant cause of slow performance, and so care should be taken to avoid
+unnecessary locking.
+
+\section2 ListModel
+
+QML provides a ListModel element which can be used to feed data to a ListView.
+It should suffice for most use-cases and be relatively performant so long as
+it is used correctly.
+
+\section3 Populate Within A Worker Thread
+
+ListModel elements can be populated in a (low priority) worker thread in JavaScript.  The
+developer must explicitly call "sync()" on the ListModel from within the WorkerScript to
+have the changes synchronized to the main thread.  See the WorkerScript documentation
+for more information.
+
+Please note that using a WorkerScript element will result in a separate JavaScript engine
+being created (as the JavaScript engine is per-thread).  This will result in increased
+memory usage.  Multiple WorkerScript elements will all use the same worker thread, however,
+so the memory impact of using a second or third WorkerScript element is negligible once
+an application already uses one.
+
+\section3 Don't Use Dynamic Roles
+
+The ListModel element in QtQuick 2.0 is much more performant than in QtQuick 1.0.  The
+performance improvements mainly come from assumptions about the type of roles within each
+element in a given model - if the type doesn't change, the caching performance improves
+dramatically.  If the type can change dynamically from element to element, this optimization
+becomes impossible, and the performance of the model will be an order of magnitude worse.
+
+Therefore, dynamic typing is disabled by default; the developer must specifically set
+the boolean "dynamicRoles" property of the model to enable dynamic typing (and suffer
+the attendant performance degradation).  We recommend that you do not use dynamic typing
+if it is possible to redesign your application to avoid it.
+
+\section2 Views
+
+View delegates should be kept as simple as possible.  Have just enough QML in the delegate
+to display the necessary information.  Any additional functionality which is not immediately
+required (e.g., if it displays more information when clicked) should not be created until
+needed (see the upcoming section on lazy initialization).
+
+The following list is a good summary of things to keep in mind when designing a delegate:
+\list
+\li The fewer elements that are in a delegate, the faster they can be created, and thus
+   the faster the view can be scrolled.
+\li Keep the number of bindings in a delegate to a minimum; in particular, use anchors
+   rather than bindings for relative positioning within a delegate.
+\li Avoid using ShaderEffect elements within delegates.
+\li Never enable clipping on a delegate.
+\endlist
+
+You may set the \c cacheBuffer property of a view to allow asynchronous creation and
+buffering of delegates outside of the visible area.  Utilizing a \c cacheBuffer is
+recommended for view delegates that are non-trivial and unlikely to be created within a
+single frame.
+
+Be mindful that a \c cacheBuffer keeps additional delegates in-memory and therefore the
+value derived from utilizing the \c cacheBuffer must be balanced against additional memory
+usage.  Developers should use benchmarking to find the best value for their use-case, since
+the increased memory pressure caused by utilizing a \c cacheBuffer can, in some rare cases,
+cause reduced frame rate when scrolling.
+
+\section1 Visual Effects
+
+QtQuick 2 includes several features which allow developers and designers to create
+exceptionally appealing user interfaces.  Fluidity and dynamic transitions as well
+as visual effects can be used to great effect in an application, but some care must
+be taken when using some of the features in QML as they can have performance implications.
+
+\section2 Animations
+
+In general, animating a property will cause any bindings which reference that property
+to be re-evaluated.  Usually, this is what is desired but in other cases it may be better
+to disable the binding prior to performing the animation, and then reassign the binding
+once the animation has completed.
+
+Avoid running JavaScript during animation.  For example, running a complex JavaScript
+expression for each frame of an x property animation should be avoided.
+
+Developers should be especially careful using script animations, as these are run in the main
+thread (and therefore can cause frames to be skipped if they take too long to complete).
+
+\section2 Particles
+
+The QtQuick 2.0 Particles module allows beautiful particle effects to be integrated
+seamlessly into user interfaces.  However every platform has different graphics hardware
+capabilities, and the Particles module is unable to limit parameters to what your hardware
+can gracefully support.  The more particles you attempt to render (and the larger they are),
+the faster your graphics hardware will need to be in order to render at 60 FPS.  Affecting
+more particles requires a faster CPU.  It is therefore important to test all
+particle effects on your target platform carefully, to calibrate the number and size of
+particles you can render at 60 FPS.
+
+It should be noted that a particle system can be disabled when not in use
+(e.g., on a non-visible element) to avoid doing unnecessary simulation.
+
+See the \l{Particle System Performance Guide} for more in-depth information.
+
+\section2 Shaders
+
+Shaders written in GLSL allow for complex transformations and visual effects to be written,
+however they should be used with care.  Using a ShaderEffectSource causes a scene to
+prerendered into an FBO before it can be drawn.  This extra overhead is quite expensive.
+
+A ShaderEffect element can imply a ShaderEffectSource (and the indirect rendering costs
+associated with that) and also involves uploading a vertex and fragment shader program
+(which is then compiled into a GLSL shader).  Each fragment shader runs once for every
+pixel of the scene, and so these should be kept as simple as possible.
+
+\section1 Controlling Element Lifetime
+
+By partitioning an application into simple, modular components, each contained in a single
+QML file, you can achieve faster application startup time and better control over memory
+usage, and reduce the number of active-but-invisible elements in your application.
+
+\section2 Lazy Initialization
+
+The QML engine does some tricky things to try to ensure that loading and initialization of
+components doesn't cause frames to be skipped, however there is no better way to reduce
+startup time than to avoid doing work you don't need to do, and delaying the work until
+it is necessary.  This may be achieved by using either \l Loader or creating components
+\l {qtqml-javascript-dynamicobjects.html}{dynamically}.
+
+\section3 Using Loader
+
+The Loader is an element which allows dynamic loading and unloading of components.
+
+\list
+\li Using the "active" property of a Loader, initialization can be delayed until required.
+\li Using the overloaded version of the "setSource()" function, initial property values can
+   be supplied.
+\li Setting the Loader \l {Loader::asynchronous}{asynchronous} property to true may also
+   improve fluidity while a component is instantiated.
+\endlist
+
+\section3 Using Dynamic Creation
+
+Developers can use the Qt.createComponent() function to create a component dynamically at
+runtime from within JavaScript, and then call createObject() to instantiate it.  Depending
+on the ownership semantics specified in the call, the developer may have to delete the
+created object manually.  See \l{qtqml-javascript-dynamicobjects.html}
+{Dynamic Object Management in QML} for more information.
+
+\section2 Destroy Unused Elements
+
+Elements which are invisible because they are a child of a non-visible element (e.g., the
+second tab in a tab-widget, while the first tab is shown) should be initialized lazily in
+most cases, and deleted when no longer in use, to avoid the ongoing cost of leaving them
+active (e.g., rendering, animations, property binding evaluation, etc).
+
+An item loaded with a Loader element may be released by resetting the "source" or
+"sourceComponent" property of the Loader, while other items may be explicitly
+released by calling destroy() on them.  In some cases, it may be necessary to
+leave the item active, in which case it should be made invisible at the very least.
+
+See the upcoming section on Rendering for more information on active but invisible elements.
+
+\section1 Rendering
+
+The scene graph used for rendering in QtQuick 2.0 allows highly dynamic, animated user
+interfaces to be rendered fluidly at 60 FPS.  There are some things which can
+dramatically decrease rendering performance, however, and developers should be careful
+to avoid these pitfalls wherever possible.
+
+\section2 Clipping
+
+Clipping is disabled by default, and should only be enabled when required.
+
+Clipping is a visual effect, NOT an optimization.  It increases (rather than reduces)
+complexity for the renderer.  If clipping is enabled, an item will clip its own painting,
+as well as the painting of its children, to its bounding rectangle.  This stops the renderer
+from being able to reorder the drawing order of elements freely, resulting in a sub-optimal
+best-case scene graph traversal.
+
+Clipping inside a delegate is especially bad and should be avoided at all costs.
+
+\section2 Over-drawing and Invisible Elements
+
+If you have elements which are totally covered by other (opaque) elements, it is best to
+set their "visible" property to \c false or they will be needlessly drawn.
+
+Similarly, elements which are invisible (e.g., the second tab in a tab widget, while the
+first tab is shown) but need to be initialized at startup time (e.g., if the cost of
+instantiating the second tab takes too long to be able to do it only when the tab is
+activated), should have their "visible" property set to \c false, in order to avoid the
+cost of drawing them (although as previously explained, they will still incur the cost of
+any animations or bindings evaluation since they are still active).
+
+\section2 Manual Layouts
+
+The scene graph renderer is able to batch up certain operations to minimise the number of
+OpenGL state changes required.  However, this optimization is only possible for the
+built-in layout elements provided by QtQuick 2.0, and cannot be applied to manual layouts.
+
+Therefore, application developers should use the Row, Column, Grid, GridView and ListView
+elements instead of manual layouts wherever possible.
+
+\section1 Memory Allocation And Collection
+
+The amount of memory which will be allocated by an application and the way in which that
+memory will be allocated are very important considerations.  Aside from the obvious
+concerns about out-of-memory conditions on memory-constrained devices, allocating memory
+on the heap is a fairly computationally expensive operation, and certain allocation
+strategies can result in increased fragmentation of data across pages.  JavaScript uses
+a managed memory heap which is automatically garbage collected, and this provides some
+advantages but also has some important implications.
+
+An application written in QML uses memory from both the C++ heap and an automatically
+managed JavaScript heap.  The application developer needs to be aware of the subtleties
+of each in order to maximise performance.
+
+\section2 Tips For QML Application Developers
+
+The tips and suggestions contained in this section are guidelines only, and may not be
+applicable in all circumstances.  Be sure to benchmark and analyse your application
+carefully using empirical metrics, in order to make the best decisions possible.
+
+\section3 Instantiate and initialize components lazily
+
+If your application consists of multiple views (for example, multiple tabs) but only
+one is required at any one time, you can use lazy instantiation to minimize the
+amount of memory you need to have allocated at any given time.  See the prior section
+on \l{Lazy Initialization} for more information.
+
+\section3 Destroy unused objects
+
+If you lazily instantiate components, or dynamically create objects during a JavaScript
+expression, it is often better to manually \c{destroy()} them rather than waiting for
+automatic garbage collection to do so.  See the prior section on
+\l{Controlling Element Lifetime} for more information.
+
+\section3 Don't manually invoke the garbage collector
+
+In most cases, it is not wise to manually invoke the garbage collector, as it will block
+the GUI thread for a substantial period of time.  This can result in skipped frames and
+jerky animations, which should be avoided at all costs.
+
+There are some cases where manually invoking the garbage collector is acceptable (and
+this is explained in greater detail in an upcoming section), but in most cases, invoking
+the garbage collector is unnecessary and counter-productive.
+
+\section3 Avoid complex bindings
+
+Aside from the reduced performance of complex bindings (for example, due to having to
+enter the JavaScript execution context to perform evaluation), they also take up more
+memory both on the C++ heap and the JavaScript heap than bindings which can be
+evaluated by QML's optimized binding expression evaluator.
+
+\section3 Avoid defining multiple identical implicit types
+
+If a QML element has a custom property defined in QML, it becomes its own implicit type.
+This is explained in greater detail in an upcoming section.  If multiple identical
+implicit types are defined inline in a component, some memory will be wasted.  In that
+situation it is usually better to explicitly define a new component which can then be
+reused.
+
+Defining a custom property can often be a beneficial performance optimization (for
+example, to reduce the number of bindings which are required or re-evaluated), or it
+can improve the modularity and maintainability of a component.  In those cases, using
+custom properties is encouraged; however, the new type should, if it is used more than
+once, be split into its own component (.qml file) in order to conserve memory.
+
+\section3 Re-use existing components
+
+If you are considering defining a new component, it's worth double checking that such a
+component doesn't already exist in the component set for your platform.  Otherwise, you
+will be forcing the QML engine to generate and store type-data for a type which is
+essentially a duplicate of another pre-existing and potentially already loaded component.
+
+\section3 Use module APIs instead of pragma library scripts
+
+If you are using a pragma library script to store application-wide instance data,
+consider using a QObject module API instead.  This should result in better performance,
+and will result in less JavaScript heap memory being used.
+
+\section2 Memory Allocation in a QML Application
+
+The memory usage of a QML application may be split into two parts: its C++ heap usage,
+and its JavaScript heap usage.  Some of the memory allocated in each will be unavoidable,
+as it is allocated by the QML engine or the JavaScript engine, while the rest is
+dependent upon decisions made by the application developer.
+
+The C++ heap will contain:
+\list
+  \li the fixed and unavoidable overhead of the QML engine (implementation data
+  structures, context information, and so on)
+  \li per-component compiled data and type information, including per-type property
+  metadata, which is generated by the QML engine depending on which modules are
+  imported by the application and which components the application loads
+  \li per-object C++ data (including property values) plus a per-element metaobject
+  hierarchy, depending on which components the application instantiates
+  \li any data which is allocated specifically by QML imports (libraries)
+\endlist
+
+The JavaScript heap will contain:
+\list
+  \li the fixed and unavoidable overhead of the JavaScript engine itself (including
+  built-in JavaScript types)
+  \li the fixed and unavoidable overhead of our JavaScript integration (constructor
+  functions for loaded types, function templates, and so on)
+  \li per-type layout information and other internal type-data generated by the JavaScript
+  engine at runtime, for each type (see note below, regarding types)
+  \li per-object JavaScript data ("var" properties, JavaScript functions and signal
+  handlers, and non-optimized binding expressions)
+  \li variables allocated during expression evaluation
+\endlist
+
+Furthermore, there will be one JavaScript heap allocated for use in the main thread, and
+optionally one other JavaScript heap allocated for use in the WorkerScript thread.  If an
+application does not use a WorkerScript element, that overhead will not be incurred.  The
+JavaScript heap can be several megabytes in size, and so applications written for
+memory-constrained devices may be best served to avoid using the WorkerScript element
+despite its usefulness in populating list models asynchronously.
+
+Note that both the QML engine and the JavaScript engine will automatically generate their
+own caches of type-data about observed types.  Every component loaded by an application
+is a distinct (explicit) type, and every element (component instance) which defines its
+own custom properties in QML is an implicit type.  Any element (instance of a component)
+which does not define any custom properties is considered by the JavaScript and QML engines
+to be of the type explicitly defined by the component, rather than its own implicit type.
+
+Consider the following example:
+\qml
+import QtQuick 2.0
+
+Item {
+    id: root
+
+    Rectangle {
+        id: r0
+        color: "red"
+    }
+
+    Rectangle {
+        id: r1
+        color: "blue"
+        width: 50
+    }
+
+    Rectangle {
+        id: r2
+        property int customProperty: 5
+    }
+
+    Rectangle {
+        id: r3
+        property string customProperty: "hello"
+    }
+
+    Rectangle {
+        id: r4
+        property string customProperty: "hello"
+    }
+}
+\endqml
+
+In the previous example, the rectangles \c r0 and \c r1 do not have any custom properties,
+and thus the JavaScript and QML engines consider them both to be of the same type.  That
+is, \c r0 and \c r1 are both considered to be of the explicitly defined \c Rectangle type.
+The rectangles \c r2, \c r3 and \c r4 each have custom properties and are each considered
+to be different (implicit) types.  Note that \c r3 and \c r4 are each considered to be of
+different types, even though they have identical property information, simply because the
+custom property was not declared in the component which they are instances of.
+
+If \c r3 and \c r4 were both instances of a \c RectangleWithString component, and that
+component definition included the declaration of a string property named \c customProperty,
+then \c r3 and \c r4 would be considered to be the same type (that is, they would be
+instances of the \c RectangleWithString type, rather than defining their own implicit type).
+
+\section2 In-Depth Memory Allocation Considerations
+
+Whenever making decisions regarding memory allocation or performance trade-offs, it is
+important to keep in mind the impact of CPU-cache performance, operating system paging,
+and JavaScript engine garbage collection.  Potential solutions should be benchmarked
+carefully in order to ensure that the best one is selected.
+
+No set of general guidelines can replace a solid understanding of the underlying
+principles of computer science combined with a practical knowledge of the implementation
+details of the platform for which the application developer is developing.  Furthermore,
+no amount of theoretical calculation can replace a good set of benchmarks and analysis
+tools when making trade-off decisions.
+
+\section3 Fragmentation
+
+Fragmentation is a C++ development issue.  If the application developer is not defining
+any C++ types or plugins, they may safely ignore this section.
+
+Over time, an application will allocate large portions of memory, write data to that
+memory, and subsequently free some portions of that memory once it has finished using
+some of the data.  This can result in "free" memory being located in non-contiguous
+chunks, which cannot be returned to the operating system for other applications to use.
+It also has an impact on the caching and access characteristics of the application, as
+the "living" data may be spread across many different pages of physical memory.  This
+in turn could force the operating system to swap which can cause filesystem I/O - which
+is, comparatively speaking, an extremely slow operation.
+
+Fragmentation can be avoided by utilizing pool allocators (and other contiguous memory
+allocators), by reducing the amount of memory which is allocated at any one time by
+carefully managing object lifetimes, by periodically cleansing and rebuilding caches,
+or by utilizing a memory-managed runtime with garbage collection (such as JavaScript).
+
+\section3 Garbage Collection
+
+JavaScript provides garbage collection.  Memory which is allocated on the JavaScript
+heap (as opposed to the C++ heap) is owned by the JavaScript engine.  The engine will
+periodically collect all unreferenced data on the JavaScript heap, and if fragmentation
+becomes an issue, it will compact its heap by moving all "living" data into a contiguous
+region of memory (allowing the freed memory to be returned to the operating system).
+
+\section4 Implications of Garbage Collection
+
+Garbage collection has advantages and disadvantages.  It ensures that fragmentation is
+less of an issue, and it means that manually managing object lifetime is less important.
+However, it also means that a potentially long-lasting operation may be initiated by the
+JavaScript engine at a time which is out of the application developer's control.  Unless
+JavaScript heap usage is considered carefully by the application developer, the frequency
+and duration of garbage collection may have a negative impact upon the application
+experience.
+
+\section4 Manually Invoking the Garbage Collector
+
+An application written in QML will (most likely) require garbage collection to be
+performed at some stage.  While garbage collection will be automatically triggered by
+the JavaScript engine when the amount of available free memory is low, it is occasionally
+better if the application developer makes decisions about when to invoke the garbage
+collector manually (although usually this is not the case).
+
+The application developer is likely to have the best understanding of when an application
+is going to be idle for substantial periods of time.  If a QML application uses a lot
+of JavaScript heap memory, causing regular and disruptive garbage collection cycles
+during particularly performance-sensitive tasks (for example, list scrolling, animations,
+and so forth), the application developer may be well served to manually invoke the
+garbage collector during periods of zero activity.  Idle periods are ideal for performing
+garbage collection since the user will not notice any degradation of user experience
+(skipped frames, jerky animations, and so on) which would result from invoking the garbage
+collector while activity is occurring.
+
+The garbage collector may be invoked manually by calling \c{gc()} within JavaScript.
+This will cause a comprehensive collection and compaction cycle to be performed, which
+may take from between a few hundred to more than a thousand milliseconds to complete, and
+so should be avoided if at all possible.
+
+\section3 Memory vs Performance Trade-offs
+
+In some situations, it is possible to trade-off increased memory usage for decreased
+processing time.  For example, caching the result of a symbol lookup used in a tight loop
+to a temporary variable in a JavaScript expression will result in a significant performance
+improvement when evaluating that expression, but it involves allocating a temporary variable.
+In some cases, these trade-offs are sensible (such as the case above, which is almost always
+sensible), but in other cases it may be better to allow processing to take slightly longer
+in order to avoid increasing the memory pressure on the system.
+
+In some cases, the impact of increased memory pressure can be extreme.  In some situations,
+trading off memory usage for an assumed performance gain can result in increased page-thrash
+or cache-thrash, causing a huge reduction in performance. It is always necessary to benchmark
+the impact of trade-offs carefully in order to determine which solution is best in a given
+situation.
+
+For in-depth information on cache performance and memory-time trade-offs, please see
+Ulrich Drepper's excellent article "What Every Programmer Should Know About Memory"
+(available at http://ftp.linux.org.ua/pub/docs/developer/general/cpumemory.pdf as at 18th
+April 2012), and for information on C++-specific optimizations, please see Agner Fog's
+excellent manuals on optimizing C++ applications (available at
+http://www.agner.org/optimize/ as at 18th April 2012).
+
+*/
diff --git a/src/quick/doc/src/qmlintro.qdoc b/src/quick/doc/src/appdevguide/qml-intro.qdoc
index 8a01e6464a..e96fafb6cb 100644
--- a/src/quick/doc/src/qmlintro.qdoc
+++ b/src/quick/doc/src/appdevguide/qml-intro.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \page qml-intro.html tutorial
-\title Introduction to the QML Language
+\title Introduction to QML Application Development
 \brief Introduction to the concepts and features behind QML.
 
 QML is a declarative language designed to describe the user interface of a
@@ -36,13 +36,16 @@ interface is specified as a tree of objects with properties.
 
 This introduction is meant for those with little or no programming
 experience. JavaScript is used as a scripting language in QML, so you may want
-to learn a bit more about it (see the online \l{Javascript Guide}) before
-diving deeper into QML. It is also helpful to have a basic understanding of
-other Web technologies like HTML and JSON, but it is not required.
+to learn a bit more about it (see the \l{qtqml-javascript-topic.html}
+{Javascript integration in QML} documentation) before diving deeper into QML.
+It is also helpful to have a basic understanding of other Web technologies like
+HTML and JSON, but it is not required.
 
 The examples shown in this guide are located in the
 \c{examples/quick/tutorials/qmlintro} directory within the Qt source
-package. You can run then with the \l{QML Viewer} tool.
+package. You can run then with the \l{qtquick-qmlscene.html}{qmlscene} tool.  They make
+use of the Qt Quick module (which provides the standard library of
+QML types and functionality for the QML language).
 
 \section1 \l{QML Concepts and Syntax}
 \tableofcontents{1 QML Concepts and Syntax}{section4}
@@ -52,13 +55,16 @@ package. You can run then with the \l{QML Viewer} tool.
 
 \section1 \l{User Interaction with QML}
 \tableofcontents{1 User Interaction with QML}{section4}
+
+\section1 \l{QML Application Development Tools}
+\tableofcontents{1 QML Application Development Tools}{section4}
 */
 
 /*!
-\page qml-basic-syntax.html
+\page qml-intro-basic-syntax.html
 \brief The basic syntax and concepts of the QML language.
-\contentspage Introduction to the QML Language
-\previouspage Introduction to the QML Language
+\contentspage Introduction to QML Application Development
+\previouspage Introduction to QML Application Development
 \nextpage Composing User Interfaces with QML
 \title QML Concepts and Syntax
 
@@ -72,7 +78,7 @@ the terminology used in the reference documentation.
 \inlineimage declarative-qmlintro-basic-syntax.png
 \enddiv
 The following example shows the basic syntax of QML. When opened in
-the \l{QML Viewer}{\QQV tool}, the output displayed should match the
+the \l{qtquick-qmlscene.html}{qmlscene} tool, the output displayed should match the
 image shown on the right: a light blue rectangle.
 
 \snippet examples/quick/tutorials/qmlintro/basic-syntax.qml document
@@ -84,19 +90,20 @@ this simple example.
 
 \section1 Importing Modules
 
-The \c import statement imports the \c QtQuick \l{QML Modules}{module},
-which contains all of the standard \l{QML Elements}. Without this import
-statement, the \l Rectangle and other elements would not be available.
+The \c import statement imports the \l{qtquick-main.html}{QtQuick}
+\l{qtqml-modules-topic.html}{module}, which contains all of the standard
+QML types. Without this import statement, the \l Rectangle and
+other visual object types would not be available.
 
 A specific version of a module is imported. This guarantees that the
-elements imported when the application is run by the user match those
+QML types imported when the application is run by the user match those
 used by the developer when the application was written, ensuring that
 they have the expected behavior.
 
-\section1 Elements
+\section1 Object Declarations
 
 The rectangle in the above example is specified by the \l Rectangle
-element. When we declare objects like this, we write the element's type
+object definition. When we declare objects like this, we write the object's type
 followed by a pair of braces in between which additional data can be
 defined for the object, such as its property values and any child objects.
 
@@ -105,49 +112,42 @@ defined for the object, such as its property values and any child objects.
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/elements1.qml document
 
-Here, we create two elements: a rectangle with an image inside it. We say that
-the rectangle is the parent element and the image is its child. Since the
-rectangle does not have a parent element, it is a top level element.
+Here, we create two visual items: a rectangle with an image inside it. We say that
+the rectangle is the parent visual item and the image is its child. Since the
+rectangle does not have a parent, it is a top level visual item.
 
-The position of each element in the user interface is defined relative
-to the position of its parent, except for the top level element whose
+The position of each visual item in the user interface is defined relative
+to the position of its parent, except for the top level visual item whose
 position is always the top-left corner of the screen.
 
-QML files can contain multiple elements, but \e{only one} can be a top level
-element.
+QML files can contain multiple object declarations, but \e{only one} can be a top level
+visual item.
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-elements2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/elements2.qml document
 
-In this example, we can define as many elements inside the rectangle
-as we like, but we cannot define other top level elements. All the
-additional elements are defined inside the light blue rectangle.
-
-\note In the QML documentation, we refer to \e elements, \e items and
-\e components, often interchangeably.
+In this example, we can define as many objects inside the rectangle
+as we like, but we cannot define other top level visual items. All the
+additional objects are defined inside the light blue rectangle.
 
 \list
-\li When we talk about an \e element, we usually mean the syntactic structure,
+\li When we talk about an \e{object definition}, we mean the syntactic structure,
    including the name, the opening and closing braces, and its contents.
-\li An \e item is an element that has a visual appearance. All items are
-   elements that inherit \l Item either directly or indirectly. For example,
-   a \l Rectangle is an item, but a \l State is an element because it does
+\li A \e{visual item} is a declaration of an object that has a visual appearance. All visual items are
+   objects that inherit \l Item either directly or indirectly. For example,
+   a \l Rectangle is a visual item, but a \l State is a (non-visual) object because it does
    not have an intrinsic appearance.
-\li A \e component is an element that is defined to be reused. In many cases,
-   components are often items, too.
 \endlist
 
-For now, we will refer to elements and items. Components are discussed in
-detail later in this guide.
-
-A list of the most common elements is described on the \l{QML Basic Elements}
-page. A full list can be found on the \l{QML Elements} page.
+Note that all object definitions in QML are QML object types.  The QML type system
+provides basic types and object types.  A full list of object types provided by
+Qt Quick is described on the \l{qtquick-qmltypereference.html}{Qt Quick QML Type Reference} page.
 
 \section1 Properties
 
-A QML element usually has various \e properties that help define the element.
+A QML object usually has various \e properties that help define the object.
 For example, all items have the \l{Item::}{x} and \l{Item::}{y} properties
 that define the position of the item relative to its parent item (or the
 screen's origin) and \l{Item::}{width} and \l{Item::}{height} properties
@@ -181,7 +181,8 @@ must be separated by a semicolon.
 
 \section2 Basic Property Types
 
-QML supports properties of many types (see \l{QML Basic Types}). The basic types
+QML supports properties of many types (see the documentation about the
+\l{qtqml-typesystem-topic.html}{QML type system}). The basic types
 include \c int, \c real, \c bool, \c string and \c color.
 
 \qml
@@ -211,7 +212,7 @@ them together and react to changes.
 \section2 Grouped Properties
 \target dot properties
 
-Some elements contain a set of related properties that form a logical group;
+Some objects contain a set of related properties that form a logical group;
 these use a "dot" or grouped notation to show this. The \l Text item is one
 such item that uses groups of properties to describe the font used to
 display text.
@@ -224,11 +225,11 @@ or like this:
 
 \snippet examples/quick/tutorials/qmlintro/grouped-properties2.qml text with grouped properties
 
-In the element documentation, grouped properties are shown using the "dot" notation.
+In the object documentation, grouped properties are shown using the "dot" notation.
 
 \section2 List Properties
 
-Some properties contain lists of elements, such as \l State, \l Item or
+Some properties have a value which is a list of other objects, such as \l State, \l Item or
 \l Transition. For example, the \l{Item::}{states} property is used like
 this:
 
@@ -242,7 +243,7 @@ Item {
 \endqml
 
 The list is enclosed in square brackets, with a comma separating the list
-elements. In cases where you are only assigning a single element to a list,
+objects. In cases where you are only assigning a single object to a list,
 you can omit the square brackets:
 
 \qml
@@ -251,7 +252,7 @@ Item {
 }
 \endqml
 
-Elements in the list can be accessed by index. See the \l{list}{list type}
+Objects in the list can be accessed by index. See the \l{list}{list type}
 documentation for more details about list properties and their available
 operations.
 
@@ -267,13 +268,13 @@ Item {
 \endqml
 
 These expressions can include references to other objects and properties, in
-which case a \l{Property Binding in QML}{binding} is established: when the value of
+which case a \l{qtqml-syntax-propertybinding.html}{binding} is established: when the value of
 the expression changes, the property to which the expression is assigned is
 automatically updated to the new value. For example:
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-property-binding1.png
-\br
+
 \inlineimage declarative-qmlintro-property-binding2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/property-binding.qml elements
@@ -284,12 +285,12 @@ the \l Rectangle is automatically updated. This uses the special \c parent
 property to refer to a parent item, which we explore in the
 \l{Object Identifiers}{next section}.
 
-This is useful for relating the size of one element to another, so that
-changes to the sizes of elements in the design, or at run-time, will be
+This is useful for relating the size of one visual object to another, so that
+changes to the sizes of a visual object in the design, or at run-time, will be
 taken into account.
 
 Property binding works with all types of properties, not just those related
-to the size of an element.
+to the size of a visual object.
 
 \section1 Object Identifiers
 
@@ -298,8 +299,8 @@ be identified and referred to by other objects. An \c id must begin with
 a lower-case letter or an underscore, and cannot contain characters other
 than letters, numbers and underscores.
 
-For example, below we define a \l Text element and a \l Rectangle element
-as children of a \l Column element. The \l Text object has an \c id value
+For example, below we define a \l Text object and a \l Rectangle object
+as children of a \l Column object. The \l Text object has an \c id value
 of \c{textElement}. The Rectangle object defines its \c width property
 to be the same as that of the Text object by referring to
 \c{textElement.width}:
@@ -311,9 +312,9 @@ to be the same as that of the Text object by referring to
 \snippet examples/quick/tutorials/qmlintro/object-identifiers.qml document
 
 An object can be referred to by its \c id from anywhere within the
-\l{QML Documents}{component} in which it is declared. Therefore, an
+\l{qtqml-documents-topic.html}{component} in which it is declared. Therefore, an
 \c id value must always be unique within a single component.
-This means that a single QML file should only contain one place where
+This means that a single QML document should only contain one place where
 a particular \c id value is defined.
 
 The \c id value is a special value for a QML object and should not be
@@ -321,9 +322,9 @@ thought of as an ordinary object property; for example, it is not possible
 to access \c{textElement.id} in the above example. Once an object is
 created, its \c id cannot be changed.
 
-\note The \c parent value is a special identity that each element can use
+\note The \c parent value is a special identity that each object can use
 to refer to its parent item. For most simple user interfaces containing
-a few display items, the parent of an item will be the enclosing element
+a few display items, the parent of an item will be the enclosing object
 in the QML file that contains it. However, when we look at more complex
 ways to arrange and display items, we will find that this is not always
 the case.
@@ -344,7 +345,7 @@ your QML files.
 
 Comments can also be used to prevent the execution of code, which is
 sometimes useful for tracking down problems. In the above example, the
-\l Text element will have normal opacity, since the line containing the
+\l Text object will have normal opacity, since the line containing the
 opacity property has been turned into a comment.
 
 \section1 Responding to Changes
@@ -359,7 +360,7 @@ themselves; this is the main way to create items that respond to the user.
 \section2 Signal Handlers
 
 Signal handlers allow JavaScript code to be executed in response to a signal.
-For example, the \l MouseArea element has an \l{MouseArea::}{onClicked} handler
+For example, the \l MouseArea object has an \l{MouseArea::}{onClicked} handler
 that can be used to respond to a mouse click. Below, we use this handler to
 print a message whenever the mouse is clicked:
 
@@ -379,7 +380,7 @@ referred to in the JavaScript code, as below:
 When a property changes value, it can send a signal to notify others of this change.
 
 To receive these signals, simply create a \e{signal handler} named with an
-\e on<Property>Changed syntax. For example, the \l TextInput element has a
+\e on<Property>Changed syntax. For example, the \l TextInput type has a
 \l{TextInput::}{text} property. When this property changes, the \c textChanged
 signal is emitted. We can monitor this property for changes with the
 \c onTextChanged handler.
@@ -393,7 +394,7 @@ The following code shows this in practice:
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-property-change1.png
-\br
+
 \inlineimage declarative-qmlintro-property-change2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/property-change.qml property change
@@ -402,8 +403,8 @@ When the user modifies the text, the expression assigned to the \c textChanged
 handler will be evaluated. In this example, the text changes color when this
 happens.
 
-Similarly, the \l Rectangle element has \l{Item::}{width} and
-\l{Rectangle::}{color} properties. Below, we have a \l Rectangle element
+Similarly, the \l Rectangle type has \l{Item::}{width} and
+\l{Rectangle::}{color} properties. Below, we have a \l Rectangle object
 that has defined two signal handlers, \c onWidthChanged and \c onColorChanged,
 which will automatically be called whenever these properties are modified:
 
@@ -422,14 +423,14 @@ which can be useful for debugging purposes.
 \section2 Attached Properties
 \target attached-properties
 
-Some elements attach properties to other elements. This is used in cases
-where one element needs to access features of another, but does not
+Some objects attach properties to other objects. This is used in cases
+where one object needs to access features of another, but does not
 inherit properties to access those features.
 
 Attached Properties are of the form \e {<Type>.<property>} where \e <Type>
-is the type of the element that attaches \e <property>.
+is the type of the object that attaches \e <property>.
 
-An example of attached properties in use involves the \l Keys element which
+An example of attached properties in use involves the \l Keys type which
 attaches properties for handling key presses to any item. For example:
 
 \div {class="float-right"}
@@ -437,11 +438,11 @@ attaches properties for handling key presses to any item. For example:
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/attached-properties.qml attached properties
 
-The \l Keys properties are not defined by the \l Item element. They are
+The \l Keys properties are not defined by the \l Item type. They are
 defined separately and attached to the item.
 
 Attached properties are also used by delegates to reference information about
-the view they are used in. For example, the \l ListView element attaches
+the view they are used in. For example, the \l ListView type attaches
 the \e ListView.isCurrentItem property to each delegate it creates:
 
 \div {class="float-right"}
@@ -486,8 +487,8 @@ because \c changes is the default property of the \c State type.
 */
 
 /*!
-\page qml-composing-uis.html
-\contentspage Introduction to the QML Language
+\page qml-intro-composing-uis.html
+\contentspage Introduction to QML Application Development
 \previouspage QML Concepts and Syntax
 \nextpage User Interaction with QML
 \title Composing User Interfaces with QML
@@ -495,7 +496,7 @@ because \c changes is the default property of the \c State type.
 
 \tableofcontents
 
-In the \l{Introduction to the QML Language}{previous chapter}, we looked at
+In the \l{Introduction to QML Application Development}{previous chapter}, we looked at
 the syntax of QML and the basic building blocks that are used to create
 user interfaces. For example, at a low level, we have seen that an item's
 \c x and \c y properties are used to position it within its parent item.
@@ -572,7 +573,7 @@ the same width.
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-anchors-expanding1.png
-\br
+
 \inlineimage declarative-qmlintro-anchors-expanding2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/anchors-expanding.qml anchored items
@@ -582,8 +583,8 @@ to those of the text input item. Since the text can be modified by the user,
 the width of the item can change. The use of anchors causes the width of the
 rectangle to change as well.
 
-The \l{Anchor-Based Layout in QML} document covers the use of anchors in
-more detail.
+The \l{qtquick-concepts-positioning-anchors.html}{Anchor-Based Layout in QML}
+document covers the use of anchors in more detail.
 
 \section2 Margins
 
@@ -594,7 +595,7 @@ between them.
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-anchors-margins.png
-\br
+
 \inlineimage declarative-qmlintro-anchors-baseline-margins.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/anchors-margins.qml anchored items
@@ -621,7 +622,7 @@ siblings, care must be taken when referencing items in complex or deeply-nested
 user interfaces. Where there are lots of items to be arranged, it can be more
 productive to use \l{#Positioners}{positioners} and
 \l{Generating Items with Repeaters}{repeaters}, or
-\l{Models and Views}{models and views}.
+\l{qtquick-concepts-data-modelview.html}{models and views}.
 
 Connections between anchors cannot be deleted and will override explicit
 declarations of positions and sizes using the \l{Item::}{x}, \l{Item::}{y},
@@ -640,7 +641,7 @@ parent item and its child.
 
 In order to reference an item with an anchor, it needs a way to be identified.
 Children of the item can refer to it as \c parent, but otherwise it needs to
-define an \l{Introduction to the QML Language#Object Identifiers}{identifier}.
+define an \l{QML Concepts and Syntax#Object Identifiers}{identifier}.
 It is good practice to define identifiers for all the items that need to be
 positioned or referenced in some way unless those items can be referenced
 using the \c parent identifier.
@@ -711,7 +712,7 @@ try and individually position them.
 \section2 Standard Positioners
 
 A set of standard positioners are provided in the basic set of Qt Quick items.
-Since these are all based on the \l Item element, they contain properties that
+Since these are all based on the \l Item type, they contain properties that
 define their positions and sizes, but they do not have any visual appearance
 of their own; they simply arrange their child items in the space allocated to
 them. Any background color, if desired, must be added to a parent Rectangle.
@@ -732,8 +733,8 @@ they describe how space is added to different kinds of layout.
 
 The \c add and \c move properties describe what should happen when items
 are added to a positioner item or moved within it. These actions are
-described with \l{QML Animation and Transitions}{transitions}, and will
-be covered later.
+described with \l{qtquick-concepts-statesanimations-animations.html}
+{transitions}, and will be covered later.
 
 \section3 Row
 
@@ -858,7 +859,7 @@ screenshots.
 
 \div {class="float-right"}
 \inlineimage qml-flow-text1.png
-\br
+
 \inlineimage qml-flow-text2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/flow.qml document
@@ -907,8 +908,8 @@ and \l Flow positioners should have fixed widths and heights.
 */
 
 /*!
-\page qml-user-interaction.html
-\contentspage Introduction to the QML Language
+\page qml-intro-user-interaction.html
+\contentspage Introduction to QML Application Development
 \previouspage Composing User Interfaces with QML
 \nextpage Generating Items with Repeaters
 \title User Interaction with QML
@@ -917,7 +918,7 @@ and \l Flow positioners should have fixed widths and heights.
 \tableofcontents
 
 So far, we have shown how to declare items and arrange them to create a user
-interface. If we play a QML file using the \l{QML Viewer}, we can resize the
+interface. If we play a QML file using \l{qtquick-qmlscene.html}{qmlscene}, we can resize the
 display window and see the items adapt to the change, but the items
 themselves do not respond to user input from the keyboard or mouse.
 
@@ -962,7 +963,7 @@ area, and defines two signal handlers to response to mouse button input.
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-mouse-pressed1.png
-\br
+
 \inlineimage declarative-qmlintro-mouse-pressed2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/mouse-pressed-signals.qml text item
@@ -1048,7 +1049,7 @@ press a mouse button over the area.
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-mouse-hover-containsmouse1.png
-\br
+
 \inlineimage declarative-qmlintro-mouse-hover-containsmouse2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/mouse-hover-containsmouse.qml items
@@ -1115,7 +1116,7 @@ presses, as well as higher level features for navigation using keys.
 
 Unlike mouse input, which uses the \l MouseArea item, key input uses two
 attached properties to handle keyboard input: \l Keys and \l KeyNavigation.
-These look like ordinary elements, but can be applied to any item in order
+These look like ordinary object properties, but can be applied to any item in order
 to enable keyboard input support.
 
 \section2 Key Navigation
@@ -1132,7 +1133,7 @@ positioner. These are defined with identifiers, \c{leftRect} and
 
 \div {class="float-right"}
 \inlineimage declarative-qmlintro-key-navigation1.png
-\br
+
 \inlineimage declarative-qmlintro-key-navigation2.png
 \enddiv
 \snippet examples/quick/tutorials/qmlintro/key-navigation.qml items
@@ -1154,10 +1155,10 @@ because as defined by the \l KeyNavigation attached property for
 */
 
 /*!
-\page qml-positioning-items.html
-\contentspage Introduction to the QML Language
-\previouspage Composing User Interfaces with QML
-\nextpage QML Tutorial
+\page qml-intro-positioning-items.html
+\contentspage Introduction to QML Application Development
+\previouspage User Interaction with QML
+\nextpage QML Application Development Tools
 \title Generating Items with Repeaters
 \brief How to generate and position items dynamically.
 
@@ -1174,7 +1175,7 @@ from a model. Combining repeaters and positioners is an easy way to lay out
 lots of items. A \l Repeater item is placed inside a positioner, and generates
 items that the enclosing positioner arranges.
 
-Each Repeater creates a number of items by combining each element of data
+Each Repeater creates a number of items by combining each row of data
 from a model, specified using the \l{Repeater::model}{model} property, with
 the template item, defined as a child item within the Repeater.
 The total number of items is determined by the amount of data in the model.
@@ -1218,3 +1219,73 @@ positioned relative to other items with \l{anchor-layout}{anchors}, or used
 with \l{QML Data Models} such as
 \l{QML Data Models#VisualItemModel}{VisualItemModel}.
 */
+
+/*!
+\page qml-intro-tools.html
+\contentspage Introduction to QML Application Development
+\previouspage Generating Items with Repeaters
+\nextpage Introduction to QML Application Development
+\title QML Application Development Tools
+\brief Tools provided to enable rapid QML application development
+
+\tableofcontents
+
+\section1 Qt Creator Tools
+
+Qt Creator is a complete integrated development environment (IDE) for creating
+applications with Qt Quick and the Qt application framework.
+
+\image qmldesigner-visual-editor.png
+
+The main goal for Qt Creator is meeting the development needs of Qt Quick
+developers who are looking for simplicity, usability, productivity,
+extendibility and openness, while aiming to lower the barrier of entry for
+newcomers to Qt Quick and Qt. The key features of Qt Creator allow UI designers
+and developers to accomplish the following tasks:
+\list
+\li Get started with Qt Quick application development quickly and easily with
+examples, tutorials, and project wizards.
+\li Design application user interface with the integrated editor, Qt Quick
+Designer, or use graphics software to design the user interface and use scripts
+to export the design to Qt Quick Designer.
+\li Develop applications with the advanced code editor that provides new powerful
+features for completing code snippets, refactoring code, and viewing the object
+hierarchy of QML files.
+\li Build and deploy Qt Quick applications that target multiple desktop and
+mobile platforms, such as Microsoft Windows, Mac OS X, Linux, and Maemo.
+\li Debug JavaScript functions and execute JavaScript expressions in the current
+context, and inspect QML at runtime to explore the object structure, debug
+animations, and inspect colors.
+\li Deploy applications to mobile devices and create application installation
+packages for Maemo devices that can be published in the Ovi Store
+and other channels.
+\li Easily access information with the integrated context-sensitive Qt Help
+system.
+\endlist
+
+\image qtcreator-target-selector.png
+
+\section1 Where to Go from Here
+
+The \l{qtquick-applicationdevelopers.html}{QML Application Developer Resources}
+page contains the most important information for QML application developers.
+
+\l{external: Developing Qt Quick Applications with Creator}
+{Developing Qt Quick Applications with Creator} provides an overview
+of user interface development using the visual \e{Qt Quick Designer} tool.
+
+The \l{qtqml-main.html}{Qt QML module} documentation contains in-depth
+information about the QML language and the concepts behind QML.
+
+The \l{qtquick-main.html}{Qt Quick module} documentation contains in-depth
+information about the QML types and functionality provided by Qt Quick,
+which forms the basis for user-interfaces developed in QML.
+
+The \l{qtquick-codesamples.html}{Qt Quick Code Samples} page has a gallery of QML applications.
+
+\section1 License Information
+\list
+\li \l{qtquicklicense.html}{Qt Quick Licensing Information}
+\endlist
+
+*/
diff --git a/src/quick/doc/src/appdevguide/qmlscene.qdoc b/src/quick/doc/src/appdevguide/qmlscene.qdoc
new file mode 100644
index 0000000000..7ca404585d
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/qmlscene.qdoc
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-qmlscene.html
+\ingroup qtquick-tools
+\title Protoyping with qmlscene
+\ingroup qttools
+\brief a tool for testing and loading QML files
+
+The Qt SDK includes \c qmlscene, a tool for loading QML documents that
+makes it easy to quickly develop and debug QML applications. It provides a simple
+way of loading QML documents and also includes additional features useful for
+the development of QML applications.
+
+The \c qmlscene tool should only be used for testing and developing QML applications. It is
+\e not intended for use in a production environment and should not be used for the
+deployment of QML applications. In those cases, a custom C++ application should be
+written instead, or the QML file should be bundled in a module. See
+\l {Deploying QML applications} for more information.
+
+The \c qmlscene tool is located at \c QTDIR/bin/qmlscene. To load a \c .qml file,
+run the tool and select the file to be opened, or provide the
+file path on the command line:
+
+\code
+    qmlscene myqmlfile.qml
+\endcode
+
+To see the configuration options, run \c qmlscene with the \c -help argument.
+
+
+\section1 Adding module import paths
+
+Additional module import paths can be provided using the \c -I flag.
+For example, the \l{declarative/cppextensions/plugins}{QML plugins example} creates
+a C++ plugin identified as \c com.nokia.TimeExample. Since this has a namespaced
+identifier, \c qmlscene has to be run with the \c -I flag from the example's
+base directory:
+
+\code
+qmlscene -I . plugins.qml
+\endcode
+
+This adds the current directory to the import path so that \c qmlscene will
+find the plugin in the \c com/nokia/TimeExample directory.
+
+Note by default, the current directory is included in the import search path,
+but namespaced modules like \c com.nokia.TimeExample are not found unless
+the path is explicitly added.
+
+
+\section1 Loading placeholder data
+
+Often, QML applications are prototyped with fake data that is later replaced
+by real data sources from C++ plugins. The \c qmlscene tool assists in this aspect by
+loading fake data into the application context: it looks for a directory named
+"dummydata" in the same directory as the target QML file, and any \c .qml
+files in that directory are loaded as QML objects and bound to the root context
+as properties named after the files.
+
+For example, this QML document refers to a \c lottoNumbers property which does
+not actually exist within the document:
+
+\qml
+import QtQuick 2.0
+
+ListView {
+    width: 200; height: 300
+    model: lottoNumbers
+    delegate: Text { text: number }
+}
+\endqml
+
+If within the document's directory, there is a "dummydata" directory which
+contains a \c lottoNumbers.qml file like this:
+
+\qml
+import QtQuick 2.0
+
+ListModel {
+    ListElement { number: 23 }
+    ListElement { number: 44 }
+    ListElement { number: 78 }
+}
+\endqml
+
+Then this model would be automatically loaded into the ListView in the previous document.
+
+Child properties are included when loaded from dummy data. The following document
+refers to a \c clock.time property:
+
+\qml
+import QtQuick 2.0
+Text { text: clock.time }
+\endqml
+
+The text value could be filled by a \c dummydata/clock.qml file with a \c time
+property in the root context:
+
+\qml
+import QtQuick 2.0
+QtObject { property int time: 54321 }
+\endqml
+
+To replace this with real data, you can simply bind the real data object to
+the root context in C++ using QQmlContext::setContextProperty(). This
+is detailed in \l{qtqml-cppintegration-topic.html}{Integrating QML and C++}.
+
+*/
+
diff --git a/src/quick/doc/src/appdevguide/qtquicktest.qdoc b/src/quick/doc/src/appdevguide/qtquicktest.qdoc
new file mode 100644
index 0000000000..50ce424464
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/qtquicktest.qdoc
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page qtquick-qtquicktest.html
+\inqmlmodule QtQuick 2
+    \title QtQuickTest Reference Documentation
+    \keyword QtQuickTest Reference Documentation
+    \brief unit testing framework for QML
+
+    \section1 Introduction
+
+    QtQuickTest is a unit test framework for QML applications.
+    Test cases are written as JavaScript functions within a TestCase
+    element:
+
+    \code
+    import QtQuick 2.0
+    import QtTest 1.0
+
+    TestCase {
+        name: "MathTests"
+
+        function test_math() {
+            compare(2 + 2, 4, "2 + 2 = 4")
+        }
+
+        function test_fail() {
+            compare(2 + 2, 5, "2 + 2 = 5")
+        }
+    }
+    \endcode
+
+    Functions whose names start with \c{test_} are treated as test cases
+    to be executed.  See the documentation for the \l TestCase and
+    \l SignalSpy elements for more information on writing test cases.
+
+    \section1 Running tests
+
+    Test cases are launched by a C++ harness that consists of
+    the following code:
+
+    \code
+    #include <QtQuickTest/quicktest.h>
+    QUICK_TEST_MAIN(example)
+    \endcode
+
+    Where "example" is an identifier to use to uniquely identify
+    this set of tests.  You should add \c{CONFIG += qmltestcase}.
+    for example:
+
+    \code
+    TEMPLATE = app
+    TARGET = tst_example
+    CONFIG += warn_on qmltestcase
+    SOURCES += tst_example.cpp
+    \endcode
+
+    The test harness scans the specified source directory recursively
+    for "tst_*.qml" files.  If \c{QUICK_TEST_SOURCE_DIR} is not defined,
+    then the current directory will be scanned when the harness is run.
+    Other *.qml files may appear for auxillary QML components that are
+    used by the test.
+
+    The \c{-input} command-line option can be set at runtime to run
+    test cases from a different directory.  This may be needed to run
+    tests on a target device where the compiled-in directory name refers
+    to a host.  For example:
+
+    \code
+    tst_example -input /mnt/SDCard/qmltests
+    \endcode
+
+    See \c{tests/qmlauto} in the source tree for an example of creating a
+    test harness that uses the \c{QUICK_TEST_SOURCE_DIR} macro.
+
+    If your test case needs QML imports, then you can add them as
+    \c{-import} options to the the test program command-line by adding
+    the following line to your .pro file:
+
+    \code
+    IMPORTPATH += $$PWD/../imports/my_module1 $$PWD/../imports/my_module2
+    \endcode
+*/
diff --git a/src/quick/doc/src/appdevguide/quickstart/basics.qdoc b/src/quick/doc/src/appdevguide/quickstart/basics.qdoc
new file mode 100644
index 0000000000..48942a5c88
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/quickstart/basics.qdoc
@@ -0,0 +1,38 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+/*!
+\page qtquick-quickstart-basics.html
+\title Quick Start Guide - QML Basics
+\brief Basic QML application development examples
+
+\section1 Creating A QML Document
+
+\section1 Importing And Using The QtQuick Module
+
+\section1 Loading And Displaying The QML Document
+
+*/
diff --git a/src/quick/doc/src/appdevguide/quickstart/essentials.qdoc b/src/quick/doc/src/appdevguide/quickstart/essentials.qdoc
new file mode 100644
index 0000000000..cace64f06e
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/quickstart/essentials.qdoc
@@ -0,0 +1,38 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+/*!
+\page qtquick-quickstart-essentials.html
+\title Quick Start Guide - QML Essentials
+\brief Essential QML application development examples
+
+\section1 Bindings And Signals
+
+\section1 Handling User Input
+
+\section1 Defining Custom QML Types For Re-use
+
+*/
diff --git a/src/quick/doc/src/views.qdoc b/src/quick/doc/src/appdevguide/usecases/animations.qdoc
index a27625ec62..1ae5ac7816 100644
--- a/src/quick/doc/src/views.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/animations.qdoc
@@ -24,12 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-views
-\title Qt Quick Views
-\brief Presenting data in a view
-
-\section1 Related Types
-\generatelist{related}
+\page qtquick-usecase-animations.html
+\title Usecase - Animations In QML
+\brief Example of how to include animations in QML applications
 */
diff --git a/src/quick/doc/src/interaction.qdoc b/src/quick/doc/src/appdevguide/usecases/integratingcpp.qdoc
index aafad3ab5c..27bb40c131 100644
--- a/src/quick/doc/src/interaction.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/integratingcpp.qdoc
@@ -24,12 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-interaction
-\title Qt Quick Keys and Focus
-\brief Handling mouse input and interaction
-
-\section1 Related Types
-\generatelist{related}
+\page qtquick-usecase-integratingcpp.html
+\title Use Case - Integrating C++ In QML Applications
+\brief Example of how to integrate C++ within a QML application
 */
diff --git a/src/quick/doc/src/itemgraphics.qdoc b/src/quick/doc/src/appdevguide/usecases/integratingjs.qdoc
index 3924b34eaa..3a261a16d5 100644
--- a/src/quick/doc/src/itemgraphics.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/integratingjs.qdoc
@@ -24,12 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-item-graphics
-\title Qt Quick Item Graphics
-\brief Graphics applied onto visual types
-
-\section1 Related Types
-\generatelist{related}
+\page qtquick-usecase-integratingjs.html
+\title Use Case - Integrating JavaScript In QML
+\brief Example of how to integrate JavaScript code in QML applications
 */
diff --git a/src/quick/doc/src/particles/particletypes.qdoc b/src/quick/doc/src/appdevguide/usecases/layouts.qdoc
index 740fc0079d..a32b8b527f 100644
--- a/src/quick/doc/src/particles/particletypes.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/layouts.qdoc
@@ -24,12 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-particles
-\title Qt Quick Particle Types
-\brief Types for creating particle effects
-
-\section1 Related Types
-\generatelist{related}
+\page qtquick-usecase-layouts.html
+\title Use Case - Layouts In QML
+\brief Example of how to create layouts for visual elements in a QML application
 */
diff --git a/src/quick/doc/src/containers.qdoc b/src/quick/doc/src/appdevguide/usecases/modules.qdoc
index 73e39790f5..f453de1924 100644
--- a/src/quick/doc/src/containers.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/modules.qdoc
@@ -24,11 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-containers
-\title Qt Quick Containers
-\brief Specialized views for handling input and animations
-
-\generatelist{related}
+\page qtquick-usecase-modules.html
+\title Use Case - Extending QML With Modules
+\brief Example of how to create a loadable QML extension module
 */
diff --git a/src/quick/doc/src/appdevguide/usecases/multimedia.qdoc b/src/quick/doc/src/appdevguide/usecases/multimedia.qdoc
new file mode 100644
index 0000000000..8af6987f4c
--- /dev/null
+++ b/src/quick/doc/src/appdevguide/usecases/multimedia.qdoc
@@ -0,0 +1,31 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+/*!
+\page qtquick-usecase-multimedia.html
+\title Use Case - Playing Sound And Video In QML
+\brief Example of how to play multimedia in a QML application
+*/
diff --git a/src/quick/doc/src/utility.qdoc b/src/quick/doc/src/appdevguide/usecases/styling.qdoc
index c43c303994..4564e1cffd 100644
--- a/src/quick/doc/src/utility.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/styling.qdoc
@@ -24,12 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-utility
-\title Qt Quick Object Utilities
-\brief Types for managing objects
-
-\section1 Related Types
-\generatelist{related}
+\page qtquick-usecase-styling.html
+\title Use Case - Style And Theme Support
+\brief Example of how to style user-interface elements in QML
 */
diff --git a/src/quick/doc/src/animation-define.qdoc b/src/quick/doc/src/appdevguide/usecases/text.qdoc
index f3f3cec1e9..40b32d577d 100644
--- a/src/quick/doc/src/animation-define.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/text.qdoc
@@ -24,6 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-animation-define
+\page qtquick-usecase-text.html
+\title Use Case - Displaying Text In QML
+\brief Example of how to display text in QML
+*/
diff --git a/src/quick/doc/src/images.qdoc b/src/quick/doc/src/appdevguide/usecases/userinput.qdoc
index 842b56bcd3..212eff257d 100644
--- a/src/quick/doc/src/images.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/userinput.qdoc
@@ -24,16 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-images
-\ingroup qml-features
-\title Qt Quick Images
-\brief Displaying images in a QML scene
-
-\section1 Related Types
-
-\generatelist{related}
-
-
+\page qtquick-usecase-userinput.html
+\title Use Case - Responding To User-Input In QML
+\brief Example of how to accept user-input and respond to it in a QML application
 */
diff --git a/src/quick/doc/src/paths.qdoc b/src/quick/doc/src/appdevguide/usecases/visual.qdoc
index 4e963487a2..66244381e6 100644
--- a/src/quick/doc/src/paths.qdoc
+++ b/src/quick/doc/src/appdevguide/usecases/visual.qdoc
@@ -24,12 +24,8 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-paths
-\title Qt Quick Paths
-\brief Drawing and setting paths
-
-\section1 Related Types
-\generatelist{related}
+\page qtquick-usecase-visual.html
+\title Use Case - Visual Elements In QML
+\brief Example of how to display visual item types in a QML application
 */
diff --git a/src/quick/doc/src/basicelements.qdoc b/src/quick/doc/src/basicelements.qdoc
deleted file mode 100644
index b1112e643e..0000000000
--- a/src/quick/doc/src/basicelements.qdoc
+++ /dev/null
@@ -1,131 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-\page qtquick-basicelements.html
-\ingroup qml-features
-\title Basic Elements
-\brief introduction to the Qt Quick Elements
-
-Qt Quick includes \e elements for placing components. These can be combined
-to form other components.
-
-\code
-import QtQuick 2.0
-\endcode
-\section1 Basic Elements
-This is a list of some of the elements readily available for users.
-\list
-\li \l {Item}
-\li \l {Rectangle}
-\li \l {Image}
-\li \l {Text}
-\li \l {TextInput}
-\li \l {TextEdit}
-\li \l {FocusScope}
-\li \l {Component}
-\li \l {MouseArea}
-\endlist
-
-For a complete list of QML elements, please visit the \l {QML Elements} page.
-
-\section1 Item Element
-
-Many QML elements inherit \l Item properties. \c Item possesses important properties
-such as \c focus, \c children, and dimension properties such as \c width and
-\c height. Although \c Item has physical properties, it is not a visual element.
-Using \c Item as the top-level QML element (as the screen) will not produce a
-visual result, use the \l {Rectangle} element instead. Use the \c Item to create
-opacity effects, such as when creating an invisible container to hold other
-components.
-
-\section1 Rectangle Element
-
-The \l Rectangle element is the basic visual element, for displaying different
-types of items onto the screen. The \c Rectangle is customizable and utilizes
-other elements such as \l Gradient and \l BorderImage for displaying advanced
-customized graphics.
-
-\section1 Image Element
-
-To insert an image into a QML scene, merely declare an \l Image element. The
-\c Image element can load images in formats supported by Qt.
-
-\section1 Text Elements
-
-The \l Text and \l TextEdit elements display formatted text onto the screen.
-\c TextEdit features multi-line editing while the \l TextInput element is for
-single line text input.
-
-\keyword qml-top-level-component
-\section1 Using Elements as the Top-Level Component
-
-For creating components, there are different
-elements that could be used as the top-level component. To display a simple scene,
-a \l Rectangle as the top-level component may suffice. \l Rectangle,
-\l FocusScope, \l Component, \l {QML:QtObject} {QtObject}, \l Item, are some of
-the commonly used elements as the top-level component.
-
-When importing components, the top-level component is important because the
-top-level component's properties are the only properties exposed to the parent.
-
-For example, a \c Button component may be implemented using different elements as
-its top-level component. When this component is loaded into another QML scene,
-the component will retain the top-level component's properties. If a non-visual
-component is the top-level component, the visual properties should be aliased to
-the top-level to display the component properly.
-
-For more information on how to build upon QML elements, see the
-\l{QML Components} document.
-
-\section1 Additional Elements
-
-The \l{Local Storage}{SQL Local Storage API} provides a JavaScript interface to an SQL relational
-database. The import statement needs a namespace
-
-\code
-import QtQuick.LocalStorage 2.0 as SQL
-\endcode
-
-The \l{QML Module QtQuick.Particles 2}{QtQuick.Particles} module provides a
-particle system for additional graphics. The
-\l{qml-particlesystem.html}{Using the Qt Quick Particle System} article outlines
-the system features.
-\code
-import QtQuick.Particles 2.0
-\endcode
-
-\section1 Extending and Importing Elements
-
-Components may use the basic elements to create new components or to add
-functionality to existing components. In addition, external component sets
-may exist to perform logic or provide plugins.
-
-To extend existing elements or to create a custom component, the articles
-\l{Creating QML Types} and \l{The QML Engine} contain information about
-registering new types into the QML engine.
-*/
diff --git a/src/quick/doc/src/writingcomponents.qdoc b/src/quick/doc/src/concepts/components.qdoc
index c664b7799f..5050e535bb 100644
--- a/src/quick/doc/src/writingcomponents.qdoc
+++ b/src/quick/doc/src/concepts/components.qdoc
@@ -24,19 +24,17 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-/*!
-\page qtquick-writecomponents.html
-\title Writing QML Components
-\brief creating and initializing QML components
 
-\code
-NOTE: This article is a work in progress.
-\endcode
+/*!
+\page qtquick-concepts-components.html
+\title Concepts - Reusable Components
+\brief Description of the concept and implementation of reusable UI components in Qt Quick
 
 One of the key concepts in QML is the ability to define your own QML components that suit
-the purposes of your application. The standard \l {QML Elements} provide the essential components
-for creating a QML application; beyond these, you can write your own custom components that can
-be created and reused, without the use of C++.
+the purposes of your application. The standard \l{qtquick-qmltypereference.html}
+{Qt Quick QML types} provide the essential components for creating a QML application;
+beyond these, you can write your own custom components that can be created and reused,
+without the use of C++.
 
 Components are the building blocks of a QML project. When writing a QML application, whether
 large or small, it is best to separate QML code into smaller components that perform specific
@@ -73,7 +71,7 @@ customize the \c width, \c height, \c radius and \c color properties of \c Butto
 
 
 If \c Button.qml was not in the same directory, \c application.qml would need to load it as a
-\l {Modules}{module} from a specific filesystem path or \l{QQmlExtensionPlugin}{plugin}.
+\l{qtqml-modules-topic.html}{QML module} from a specific filesystem path or \l{QQmlExtensionPlugin}{plugin}.
 Also, note the letter case of the component file name is significant on some (notably UNIX)
 filesystems. It is recommended the file name case matches the case of the QML component name
 exactly - for example, \c Box.qml and not \c BoX.qml - regardless of the platform to which the
@@ -127,12 +125,16 @@ It is optional for a property to have a default value. The default value is a co
 behaviorally identical to doing it in two steps, like this:
 
 \qml
-// Use default value
-property int myProperty: 10
+import QtQuick 2.0
 
-// Longer, but behaviorally identical
-property int myProperty
-myProperty: 10
+Item {
+    // Use default value
+    property int myProperty: 10
+
+    // Longer, but behaviorally identical
+    property int myProperty
+    myProperty: 10
+}
 \endqml
 
 
@@ -159,13 +161,18 @@ with their default values and the corresponding C++ type:
 \endtable
 
 QML object types can also be used as property types. This includes
-\l {Defining new QML elements}{custom QML types} implemented in C++. Such properties are
-defined like this:
+\l{qtqml-cppintegration-registercpptypes.html}{custom QML types defined in C++},
+as well as \l{qtqml-documents-definetypes.html}{custom QML types defined in QML}.
+Such properties are defined like this:
 
 \qml
-property Item itemProperty
-property QtObject objectProperty
-property MyCustomType customProperty
+import QtQuick 2.0
+
+Item {
+    property Item itemProperty
+    property QtObject objectProperty
+    property MyCustomType customProperty
+}
 \endqml
 
 Such object-type properties default to an \c undefined value.
@@ -178,7 +185,11 @@ see the \l {variant}{variant type documentation} for details.
 list:
 
 \qml
-property list<Item> listOfItems
+import QtQuick 2.0
+
+Item {
+    property list<Item> listOfItems
+}
 \endqml
 
 Note that list properties cannot be modified like ordinary JavaScript
@@ -188,7 +199,8 @@ arrays. See the \l {list}{list type documentation} for details.
 \section2 Property change signals
 
 Adding a \c property to an item automatically adds a \e {value changed}
-signal handler to the item. To connect to this signal, use a \l {Signal Handlers}{signal handler}
+signal handler to the item. To connect to this signal, use a
+\l{qtqml-syntax-objectattributes.html#signal-handlers}{signal handler}
 named with the \c on<Property>Changed syntax, using upper case for the first letter of the
 property name.
 
@@ -219,7 +231,7 @@ If the \l{Item::children}{children} property was not the default property for
 \qml
 Item {
     children: [
-        Rectangle {}
+        Rectangle {},
         Rectangle {}
     ]
 }
@@ -371,7 +383,8 @@ Here is an example of a component with a \c say() method that accepts a single \
 A method can be connected to a signal so that it is automatically invoked whenever the signal
 is emitted. See \l {Connecting signals to methods and other signals} below.
 
-Also see \l {Integrating JavaScript} for more information on using JavaScript with QML.
+Also see \l{qtqml-javascript-topic.html}{Integrating QML and JavaScript} for more information
+on using JavaScript with QML.
 
 
 \section1 Adding Signals
@@ -406,7 +419,8 @@ parameter types must be declared, as for the \c string and \c variant arguments
 performAction signal above; the allowed parameter types are the same as those listed in the \l
 {Adding Properties} section on this page.
 
-Adding a signal to an item automatically adds a \l {Signal Handlers}{signal handler} as well.
+Adding a signal to an item automatically adds a
+\l{qtqml-syntax-objectattributes.html#signal-handlers}{signal handler} as well.
 The signal hander is named \c on<SignalName>, with the first letter of the signal being upper
 cased. The above example item would now have the following signal handlers:
 
@@ -442,7 +456,8 @@ Signal objects have a \c connect() method that can be used to a connect a signal
 another signal. When a signal is connected to a method, the method is automatically invoked
 whenever the signal is emitted. (In Qt terminology, the method is a \e slot that is connected
 to the \e signal; all methods defined in QML are created as Qt slots.) This enables a signal
-to be received by a method instead of a \l {Signal Handlers}{signal handler}.
+to be received by a method instead of a \l{qtqml-syntax-objectattributes.html#signal-handlers}
+{signal handler}.
 
 For example, the \c application.qml above could be rewritten as:
 
@@ -452,16 +467,17 @@ The \c myMethod() method will be called whenever the \c buttonClicked signal is
 
 In many cases it is sufficient to receive signals through signal handlers rather than using
 the \c connect() function; the above example does not provide any improvements over using a
-simple \c onButtonClicked handler. However, if you are \l{Dynamic Object Management in QML}{creating objects dynamically},
-or \l {Integrating JavaScript}{integrating JavaScript code}, then you will find the
-\c connect() method useful. For example, the component below creates three \c Button
-objects dynamically, and connects the \c buttonClicked signal of each object to the
-\c myMethod() function:
+simple \c onButtonClicked handler. However, if you are \l{qtqml-javascript-dynamicobjects.html}
+{creating objects dynamically}, or \l{qtqml-javascript-topic.html}{integrating JavaScript code},
+then you will find the \c connect() method useful. For example, the component below creates
+three \c Button objects dynamically, and connects the \c buttonClicked signal of each object to
+the \c myMethod() function:
 
 \snippet qml/qml-extending-types/signals/connectdynamic.qml 0
 
 In the same way, you could connect a signal to methods defined in a dynamically
-created object, or \l {Receiving QML Signals in JavaScript}{connect a signal to a JavaScript method}.
+created object, or \l{qtqml-cppintegration-reverse.html#signals-and-slots}
+{connect a signal to a JavaScript method}.
 
 There is also a corresponding \c disconnect() method for removing connected signals. The following
 code removes the connection created in \c application.qml above:
@@ -469,7 +485,7 @@ code removes the connection created in \c application.qml above:
 \qml
 // application.qml
 Item {
-    ...
+    // ...
 
     function removeSignal() {
         button.clicked.disconnect(item.myMethod)
diff --git a/src/quick/doc/src/localstorage/localstorage.qdoc b/src/quick/doc/src/concepts/data-localstorage.qdoc
index e9d2a46b53..2de521a2a6 100644
--- a/src/quick/doc/src/localstorage/localstorage.qdoc
+++ b/src/quick/doc/src/concepts/data-localstorage.qdoc
@@ -24,14 +24,16 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
+
 /*!
-\page qml-localstorage.html
+\page qtquick-concepts-data-localstorage.html
 \title Local Storage
-\brief SQL storage for QML
+\brief SQL storage for Qt Quick
 
-The local storage API provides a JavaScript interface to an SQL relational
-database. The QtQuick.LocalStorage module contains the API and it may be given
-a namespace.
+Qt Quick includes a simple API to allow saving data to an SQL database.  The
+QtQuick.LocalStorage module provides a JavaScript interface to SQL which may be
+accessed from QML documents.  When imported, the module may be namespaced for
+developer convenience.
 
 Import QtQuick.LocalStorage module from QML:
 \code
diff --git a/src/quick/doc/src/modelview.qdoc b/src/quick/doc/src/concepts/data-modelview.qdoc
index 137703b822..49522b93bf 100644
--- a/src/quick/doc/src/modelview.qdoc
+++ b/src/quick/doc/src/concepts/data-modelview.qdoc
@@ -24,12 +24,13 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
+
 /*!
-\page qtquick-modelview.html
-\title Models and Views
-\brief how to display and form data in QML
+\page qtquick-concepts-data-modelview.html
+\title Models and Views in Qt Quick
+\brief how to display and form data in Qt Quick
 
-Simply put, applications need to form data and display the data. QML has the
+Simply put, applications need to form data and display the data. Qt Quick has the
 notion of \e models, \e views, and \e delegates to display data. They modularize
 the visualization of data in order to give the developer or designer control
 over the different aspects of the data. A developer can swap a list view with a
@@ -40,7 +41,7 @@ handle the data.
 \image modelview-overview.png
 \list
 \li \b Model - contains the data and its structure. There are several QML
-elements for creating models.
+types for creating models.
 \li \b View - a container that displays the data. The view might
 display the data in a list or a grid.
 \li \b Delegate - dictates how the data should appear in the view.
@@ -113,12 +114,13 @@ To visualize data, bind the view's \c model property to a model and the
     \snippet qml/listview-sections.qml model
     \snippet qml/listview-sections.qml delegate
 
-    The ListView element has the \c section \l{Property Binding in QML#Attached
-    Properties}{attached property} that can combine adjacent and related
-    elements into a section. The section's \c property property is for selecting
-    which list element property to use as sections. The \c criteria can dictate
-    how the section names are displayed and the \c delegate is similar to the
-    views' \l {qml-view-delegate}{delegate} property.
+    The ListView element has the \c section
+    \l{qtqml-syntax-objectattributes.html#Attached-properties-and-attached-signal-handlers}
+    {attached property} that can combine adjacent and related elements into a
+    section.  The section's \c property property is for selecting which list
+    element property to use as sections. The \c criteria can dictate how the
+    section names are displayed and the \c delegate is similar to the views'
+    \l {qml-view-delegate}{delegate} property.
     \snippet qml/listview-sections.qml section
     \image listview-section.png
 
@@ -185,9 +187,11 @@ To visualize data, bind the view's \c model property to a model and the
 
     QML provides several types of data models among the built-in set of QML
     elements. In addition, models can be created with Qt C++ and then made
-    available to the \l{The QML Engine}{QML engine} for use by
+    available to the \l{qtqml-cppclasses-engine.html}{QML engine} for use by
     QML components. For information about creating these models, visit the
-    \l{Exposing C++ Models} and \l{Creating QML Types} articles.
+    \l{qtqml-cppintegration-data.html#data-provided-in-a-custom-c++-model}
+    {exposing C++ models} and \l{qtqml-typesystem-topic.html#qml-object-types}
+    {creating QML types} articles.
 
     The use of positioner items to arrange items from a model is covered in
     \l{Generating Items with Repeaters}.
@@ -324,7 +328,9 @@ To visualize data, bind the view's \c model property to a model and the
     is useful for exposing existing C++ data models or otherwise complex
     datasets to QML.
 
-    For information, visit the \l{Exposing C++ Models} article.
+    For information, visit the
+    \l{qtqml-cppintegration-data.html#data-provided-in-a-custom-c++-model}
+    {exposing C++ models} article.
 
 
 \section1 Repeaters
@@ -343,7 +349,7 @@ from a model, specified using the \l{Repeater::model}{model} property, with
 the template item, defined as a child item within the Repeater.
 The total number of items is determined by the amount of data in the model.
 
-The following example shows a repeater used with a \l{#Grid}{Grid} item to
+The following example shows a repeater used with a Grid item to
 arrange a set of Rectangle items. The Repeater item creates a series of 24
 rectangles for the Grid item to position in a 5 by 5 arrangement.
 
diff --git a/src/quick/doc/src/particles/particles.qdoc b/src/quick/doc/src/concepts/effects-particles.qdoc
index 2f5432b39a..8d77c26d37 100644
--- a/src/quick/doc/src/particles/particles.qdoc
+++ b/src/quick/doc/src/concepts/effects-particles.qdoc
@@ -26,8 +26,8 @@
 ****************************************************************************/
 
 /*!
-  \qmlmodule QtQuick.Particles 2
-  \title QML Module QtQuick.Particles 2
+  \qmlmodule QtQuick.Particles 2.0
+  \title QML Module QtQuick.Particles 2.0
 
   \brief Contains types for particle effects
 
@@ -38,13 +38,13 @@
 
   For a simple overview of how the system can be used, see \l{Using the Qt Quick Particle System}.
 
-  For details on the performance characteristics see \l{qml-particlesystem-performance.html}{Qt Quick Particle System Performance}.
+  For details on the performance characteristics see \l{qtquick-concepts-particles-performance.html}{Qt Quick Particle System Performance}.
 
 */
 
 /*!
-    \page qml-particlesystem.html
-\inqmlmodule QtQuick.Particles 2
+    \page qtquick-concepts-effects-particles.html
+    \inqmlmodule QtQuick.Particles 2.0
     \title Using the Qt Quick Particle System
 
 
@@ -130,8 +130,8 @@
 */
 
 /*!
-    \page qml-particlesystem-performance.html
-\inqmlmodule QtQuick 2
+    \page qtquick-concepts-particles-performance.html
+    \inqmlmodule QtQuick 2.0
     \title Particle System Performance Guide
 
     The performance of the particle system scales with the number of particles it is maintaining. After prototyping the desired
diff --git a/src/quick/doc/src/shaders.qdoc b/src/quick/doc/src/concepts/effects-shaders.qdoc
index 51b3abb19b..8355b2758b 100644
--- a/src/quick/doc/src/shaders.qdoc
+++ b/src/quick/doc/src/concepts/effects-shaders.qdoc
@@ -24,8 +24,10 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
+
 /*!
 \group qtquick-shaders
+\page qtquick-concepts-effects-shaders.html
 \title Qt Quick Shader Effects
 \brief For applying OpenGL vertex and fragment shaders to rectangles
 
diff --git a/src/quick/doc/src/sprites.qdoc b/src/quick/doc/src/concepts/effects-sprites.qdoc
index 377abe86c0..50b380ebee 100644
--- a/src/quick/doc/src/sprites.qdoc
+++ b/src/quick/doc/src/concepts/effects-sprites.qdoc
@@ -28,6 +28,7 @@
 /*!
 \group qtquick-images-sprites
 \ingroup qml-features
+\page qtquick-concepts-effects-sprites.html
 \title Sprite Animations
 \brief Sprite-based animations with flexible transitioning
 
diff --git a/src/quick/doc/src/transformations.qdoc b/src/quick/doc/src/concepts/effects-transformations.qdoc
index 5bd4d832c0..b2ff5955fb 100644
--- a/src/quick/doc/src/transformations.qdoc
+++ b/src/quick/doc/src/concepts/effects-transformations.qdoc
@@ -27,6 +27,7 @@
 
 /*!
 \group qtquick-transformations
+\page qtquick-concepts-effects-transformations.html
 \title Qt Quick Transformation Types
 \brief Types for applying transformations to visual types
 
diff --git a/src/quick/doc/src/focus.qdoc b/src/quick/doc/src/concepts/input-focus.qdoc
index 69617c9773..d18407972c 100644
--- a/src/quick/doc/src/focus.qdoc
+++ b/src/quick/doc/src/concepts/input-focus.qdoc
@@ -26,14 +26,14 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-keyboardfocus.html
+\page qtquick-concepts-input-focus.html
 \ingroup qml-features
-\title Keyboard Focus in QML
+\title Keyboard Focus in Qt Quick
 \brief handling keyboard focus
 
 When a key is pressed or released, a key event is generated and delivered to the
-focused QML \l Item. To facilitate the construction of reusable components
-and to address some of the cases unique to fluid user interfaces, the QML items add aged
+focused Qt Quick \l Item. To facilitate the construction of reusable components
+and to address some of the cases unique to fluid user interfaces, the Qt Quick items add aged
 \e scope based extension to Qt's traditional keyboard focus model.
 
 \tableofcontents
@@ -78,9 +78,9 @@ element whose text is determined by whether or not it has active focus.
 An \l Item requests focus by setting the \c focus property to \c true.
 
 For very simple cases simply setting the \c focus property is sometimes
-sufficient. If we run the following example with the \l {QML Viewer}, we see that
-the \c {keyHandler} element has active focus and pressing the \c A, \c B,
-or \c C keys modifies the text appropriately.
+sufficient. If we run the following example with \l{qtquick-qmlscene.html}
+{qmlscene}, we see that the \c {keyHandler} element has active focus and
+pressing the \c A, \c B, or \c C keys modifies the text appropriately.
 
 \snippet qml/focus/basicwidget.qml focus true
 
diff --git a/src/quick/doc/src/mouseevents.qdoc b/src/quick/doc/src/concepts/input-mouse.qdoc
index aa4f3501e0..4890f2e20d 100644
--- a/src/quick/doc/src/mouseevents.qdoc
+++ b/src/quick/doc/src/concepts/input-mouse.qdoc
@@ -26,10 +26,10 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-mouseevents.html
+\page qtquick-concepts-input-mouseevents.html
 \ingroup QML Features
 \title Mouse Events
-\brief handling mouse events in QML
+\brief handling mouse events in Qt Quick
 
 \tableofcontents
 
@@ -42,10 +42,10 @@
 
 \section1 Mouse Event Handling
 
-QML uses \l{QML Signal and Handler Event System}{signals and handlers} to
-deliver mouse interactions. Specifically, the \l MouseArea and \l MouseEvent
-elements provide QML components with signal handlers to accept mouse events
-within a defined area.
+QML uses \l{qtqml-syntax-signals.html}{signals and handlers} to
+deliver mouse interactions. Specifically, Qt Quick provides the \l MouseArea
+and \l MouseEvent types which allow developers to define signal handlers which
+accept mouse events within a defined area.
 
 \section1 Defining a Mouse Area
 
@@ -60,7 +60,7 @@ definable.
 \section1 Receiving Events
 
 The MouseArea element provides
-\l{QML Signal and Handler Event System}{signals and handlers} to detect different
+\l{qtqml-syntax-signals.html}{signals and handlers} to detect different
 mouse events. The \l MouseArea element documentation describes these
 gestures in greater detail:
 
@@ -114,5 +114,7 @@ Many of the signals are sent multiple times to reflect various mouse events
 such as double clicking. To facilitate the classification of mouse clicks, the
 MouseEvent object has an \c accepted property to disable the event propagation.
 
-To learn more about QML's event system, please read the \l {QML Signal and Handler Event System} document.
+To learn more about QML's event system, please read the
+\l{qtqml-syntax-signals.html}{signals and handlers, and event system} document.
+
 */
diff --git a/src/quick/doc/src/texthandling.qdoc b/src/quick/doc/src/concepts/input-text.qdoc
index 2628776ca3..6387221670 100644
--- a/src/quick/doc/src/texthandling.qdoc
+++ b/src/quick/doc/src/concepts/input-text.qdoc
@@ -27,8 +27,9 @@
 
 /*!
 \group qtquick-text
-\title Qt Quick Text Handling and Validators
-\brief Text display, input, and validation
+\page qtquick-concepts-input-text.html
+\title Qt Quick Text Input Handling and Validators
+\brief Text input and validation
 
 \section1 Text Visual Types
 
@@ -66,6 +67,7 @@ Note that QML parses JavaScript regular expressions, while Qt's
 \title Qt Quick Text Validators
 \brief Types that validate text input
 
-The \l{Qt Quick Text Handling and Validators} page has information about
+The \l{qtquick-concepts-input-text.html}
+{Qt Quick Text Input Handling and Validators} page has information about
 validating user text input.
 */
diff --git a/src/quick/doc/src/concepts/interceptors.qdoc b/src/quick/doc/src/concepts/interceptors.qdoc
new file mode 100644
index 0000000000..0b53e2bc8b
--- /dev/null
+++ b/src/quick/doc/src/concepts/interceptors.qdoc
@@ -0,0 +1,41 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-concepts-interceptors.html
+\title Concepts - Event Interceptors
+\brief Description of the concept of property interception in Qt Quick
+
+\section1 Animating Property Assignments
+
+\section1 Dynamic Bindings
+
+\section1 Dynamic Signal Connections
+
+\section1 Timer-Based Events
+
+*/
diff --git a/src/quick/doc/src/anchor-layout.qdoc b/src/quick/doc/src/concepts/positioning-anchors.qdoc
index fb2d8b7d83..62b99948ce 100644
--- a/src/quick/doc/src/anchor-layout.qdoc
+++ b/src/quick/doc/src/concepts/positioning-anchors.qdoc
@@ -26,14 +26,13 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-anchorlayout.html
-\contentspage QML Features
-\title Layouts with Anchors
+\page qtquick-concepts-positioning-anchors.html
+\title Positioning with Anchors
 \brief placing items with anchor properties
 
 \target anchor-layout
 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.
+Qt Quick 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},
@@ -45,7 +44,7 @@ and \l {Item::anchors.bottom}{bottom}.
 The baseline (not pictured above) corresponds to the imaginary line on which
 text would sit. For items with no text it is the same as \e top.
 
-The QML anchoring system allows you to define relationships between the anchor lines of different items. For example, you can write:
+The Qt Quick anchoring system allows you to define relationships between the anchor lines of different items. For example, you can write:
 
 \code
 Rectangle { id: rect1; ... }
diff --git a/src/quick/doc/src/positioners.qdoc b/src/quick/doc/src/concepts/positioning-layouts.qdoc
index f423216e15..2cf4066525 100644
--- a/src/quick/doc/src/positioners.qdoc
+++ b/src/quick/doc/src/concepts/positioning-layouts.qdoc
@@ -27,6 +27,7 @@
 
 /*!
 \group qtquick-positioners
+\page qtquick-concepts-positioning-layouts.html
 \ingroup qml-features
 \title Item Layouts
 
diff --git a/src/quick/doc/src/righttoleft.qdoc b/src/quick/doc/src/concepts/positioning-righttoleft.qdoc
index d24d18d0c2..09488a064c 100644
--- a/src/quick/doc/src/righttoleft.qdoc
+++ b/src/quick/doc/src/concepts/positioning-righttoleft.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-righttoleft.html
+\page qtquick-concepts-positioning-righttoleft.html
 \ingroup qml-features
 \title Right-to-left User Interfaces
 \brief switching text flow and layout
@@ -91,7 +91,7 @@ views that takes the mirroring into account can be read from the \c effectiveLay
 The attached property \l LayoutMirroring is provided as a convenience for easily implementing right-to-left
 support for existing left-to-right Qt Quick applications. It mirrors the behavior of \l {anchor-layout}
 {Item anchors}, the layout direction of \l{Composing User Interfaces with QML#Positioners}{positioners} and
-\l{Models and Views}{model views}, and the explicit text alignment of QML text elements.
+\l{qtquick-concepts-data-modelview.html}{model views}, and the explicit text alignment of QML text elements.
 
 You can enable layout mirroring for a particular \l Item:
 
diff --git a/src/quick/doc/src/concepts/positioning.qdoc b/src/quick/doc/src/concepts/positioning.qdoc
new file mode 100644
index 0000000000..a02ef5574d
--- /dev/null
+++ b/src/quick/doc/src/concepts/positioning.qdoc
@@ -0,0 +1,142 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-concepts-positioning.html
+\title Concepts - Positioning
+\brief Description of the concept of visual object positioning in Qt Quick
+
+This page describes the concept of positioning visual user-interface elements
+and the various elements which Qt Quick provides to support precise
+positioning, and the ways in which positioning in Qt Quick can be automated.
+
+\section1 Manual Positioning
+
+In any user-interface, the visual elements exist at a particular location in
+the screen coordinates at any instant in time.  While fluidly animated and
+dynamic user-interfaces are a major focus of Qt Quick, statically-positioned
+user interfaces are still a viable option.  What's more, if the position of
+those elements does not change, it can often be more performant to specify
+the position manually than to use the more dynamic positioning methods
+documented in proceeding sections.
+
+In Qt Quick, every visual object is positioned within the
+\l{qtquick-concepts-visual-coordinates.html}{coordinate system}
+provided by the Qt Quick visual canvas.  As described in that document, the
+x and y coordinates of a visual object are relative to those of its visual
+parent, with the top-left corner have the value [0, 0].
+
+Thus, the following example will display three rectangles positioned manually:
+
+\table
+    \header
+    \li Example Code
+    \li Resultant Layout
+
+    \row
+    \li
+        \qml
+        import QtQuick 2.0
+
+        Rectangle {
+            id: r1
+            x: 0
+            y: 0
+            width: 200
+            height: 200
+
+            Rectangle {
+                id: r2
+                x: 0
+                y: 100
+                width: 100
+                height: 100
+            }
+
+            Rectangle {
+                id: r3
+                x: 100
+                y: 100
+                width: 50
+                height: 100
+            }
+        }
+        \endqml
+    \li
+        \image manual-layout.png
+\endtable
+
+\section1 Positioning With Bindings
+
+The position and dimensions of a visual object can also be set through property
+bindings.  This has the advantage that the values will automatically be updated
+as the dependencies of the bindings change.  For example, the width of one
+Rectangle might depend on the width of the Rectangle next to it.
+
+While bindings provide a very flexible and intuitive way of creating dynamic
+layouts, it should be noted that there is some performance cost associated with
+them, and where possible, pristine Anchor layouts should be preferred.
+
+\section1 Anchors
+
+A visual object can be thought of as having various anchor-points (or more
+correctly, anchor-lines).  Other items can be anchored to those points, which
+means that as any object changes, the other objects which are anchored to it
+will adjust automatically to maintain the anchoring.
+
+Qt Quick provides anchors as a top-level concept.  See the documentation about
+\l{qtquick-concepts-positioning-anchors.html}{positioning with anchors}
+for in-depth information on the topic.
+
+It is important to note that anchor-based layouts are generally far more
+performant than binding-based layouts, if pristine.  A "pristine" anchor layout
+is one which uses only anchors (with object nesting) to determine the
+positioning, whereas a "contaminated" anchor layout is one which uses both
+anchoring and bindings (either on position-related [x,y] properties or on
+dimension-related [width,height] properties) to determine the position.
+
+\section1 Pre-defined Layouts
+
+There are many well-known layouts which work well in user-interfaces, such as
+grids and lists, rows and columns.  Qt Quick supports these sort of pre-defined
+layouts, which can often be more performant to draw than anchor or
+binding-based layouts.  See the documentation on
+\l{qtquick-concepts-positioning-layouts.html}{layout elements} for more
+information about utilizing pre-defined layouts.
+
+\section1 Right-To-Left Support
+
+The directionality of the written form of a language often has a great impact
+on how the visual elements of a user-interface should be positioned.  Qt Quick
+supports right-to-left positioning of elements through the predefined-layouts
+as well as right-to-left text layouts.
+
+Please see the documentation about
+\l{qtquick-concepts-positioning-righttoleft.html}
+{right-to-left support in Qt Quick} for in-depth information on the topic.
+
+*/
diff --git a/src/quick/doc/src/animation.qdoc b/src/quick/doc/src/concepts/statesanimations-animations.qdoc
index f406948040..37975f5bae 100644
--- a/src/quick/doc/src/animation.qdoc
+++ b/src/quick/doc/src/concepts/statesanimations-animations.qdoc
@@ -26,8 +26,9 @@
 ****************************************************************************/
 
 /*!
-\group qtquick-animation-define
-\title Animation and Transitions
+\group qtquick-transitions-animations
+\page qtquick-concepts-statesanimations-animations.html
+\title Animation and Transitions In Qt Quick
 \brief the animation system in Qt Quick
 
 \section1 Animation and Transitions Elements
@@ -45,8 +46,7 @@
 \endlist
 
 Elements that animate properties based on data types
-\annotatedlist qtquick-property-animation
-
+\annotatedlist qtquick-animation-properties
 \list
 \li \l {PropertyAnimation} - Animates property changes
 \li \l {NumberAnimation} - Animates properties of type qreal
@@ -94,7 +94,7 @@ information about the different animation properties.
 \keyword qml-transition-animations
 \section2 Transitions during State Changes
 
-\l{States}{States} are property configurations where a property may have different values to reflect different states. State changes introduce
+\l{State}{States} are property configurations where a property may have different values to reflect different states. State changes introduce
 abrupt property changes; animations smooth transitions to produce visually
 appealing state changes.
 
@@ -173,7 +173,7 @@ demonstration of creating and combining multiple animations in QML.
 There are different methods to control animations.
 
 \section2 Animation Playback
-All \l{qml-animation-elements}{animation elements} inherit from the \l Animation element. It is not
+All animation types inherit from the \l Animation element. It is not
 possible to create \l Animation objects; instead, this element provides the
 essential properties and methods for animation elements. Animation elements have
 \c{start()}, \c{stop()}, \c{resume()}, \c{pause()}, \c {restart()}, and
diff --git a/src/quick/doc/src/behaviors-and-states.qdoc b/src/quick/doc/src/concepts/statesanimations-behaviors.qdoc
index ab2e1f7460..a41b50f015 100644
--- a/src/quick/doc/src/behaviors-and-states.qdoc
+++ b/src/quick/doc/src/concepts/statesanimations-behaviors.qdoc
@@ -26,8 +26,8 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-behaviors-states.html tutorial
-\title Using QML Behaviors with States
+\page qtquick-qmltypereference-behaviors.html
+\title Using Qt Quick Behaviors with States
 \brief animating property changes with behaviors
 
 \section1 Using Behaviors with States
diff --git a/src/quick/doc/src/states.qdoc b/src/quick/doc/src/concepts/statesanimations-states.qdoc
index ac7c45bb3b..d20e7cc3f2 100644
--- a/src/quick/doc/src/states.qdoc
+++ b/src/quick/doc/src/concepts/statesanimations-states.qdoc
@@ -26,7 +26,8 @@
 ****************************************************************************/
 
 /*!
-\group qtquick-states
+\group qtquick--states
+\page qtquick-concepts-statesanimations-states.html
 \title Qt Quick States
 \brief Creating and setting states
 
@@ -73,7 +74,8 @@ model the states using the \c State element and the color and flag
 configurations with the \c PropertyChanges element.
 \snippet qml/states.qml signal states
 The \l PropertyChanges element will change the values of object properties.
-Objects are referenced through their \l {qml-id}{id}. Objects outside
+Objects are referenced through their
+\l{qtqml-syntax-objectattributes.html#the-id-assignment}{id}. Objects outside
 the component are also referenced using the \c id property, exemplified by the
 property change to the external \c flag object.
 
@@ -115,15 +117,16 @@ The \c bell component will change to the \c RINGING state whenever the
 State changes induce abrupt value changes. The \l Transition element allow
 smoother changes during state changes. In transitions, animations and
 interpolation behaviors are definable. The
-\l {QML Animation and Transitions}{Animation and Transitions} article has more
-information about creating state animations.
+\l{qtquick-concepts-statesanimations-animations.html}
+{Animation and Transitions} article has more information about creating state
+animations.
 
 The \l {declarative/animation/states}{States and Transitions example}
 demonstrates how to declare a basic set of states and apply animated
 transitions between them.
 
-\l{Using QML Behaviors with States} explains a common problem when using Behaviors
-to animate state changes.
+\l{qtquick-qmltypereference-behaviors.html}{Using QML Behaviors with States}
+explains a common problem when using Behaviors to animate state changes.
 
 \section1 State Fast Forwarding
 
diff --git a/src/quick/doc/src/concepts/statesanimations.qdoc b/src/quick/doc/src/concepts/statesanimations.qdoc
new file mode 100644
index 0000000000..090b9ac816
--- /dev/null
+++ b/src/quick/doc/src/concepts/statesanimations.qdoc
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-concepts-statesanimations.html
+\title Concepts - States And Animations
+\brief Description of the concepts of states, transitions and animations in Qt Quick
+
+This page describes the concept of states, state transitions, and property
+animations.  It details which concepts are important and why, and how those
+concepts interrelate.  It also provides links to in-depth detail about the QML
+types that Qt Quick provides to implement those concepts.
+
+\section1 States
+
+The state of a particular visual item is the set of information which describes
+how and where the individual component parts of the visual item are displayed
+within it, and all the data associated with that state.  Most visual items in a
+user-interface will have a limited number of states, each with well-defined
+properties.
+
+For example, an element in a list may be either selected or not, and if
+selected, it may either be the currently active single selection or it may be
+part of a selection group.
+
+Each of those states may have certain associated visual appearance (neutral,
+highlighted, expanded, and so forth).
+
+Qt Quick provides a \c{State} element with properties which define its semantics
+and can be used to trigger behavior or animations.  See the documentation about
+\l{qtquick-concepts-statesanimations-states.html}{Qt Quick States} for more
+information.
+
+\section1 Transitions
+
+When a visual item transitions from one state to another, the appearance of
+that item will change.  A transition is an "edge" between two states.  It may
+trigger other events to occur, as other parts of the application may have
+behavior which is triggered when a certain state is entered or left.
+
+Qt Quick provides the \c{Transition} element which has properties which define
+what will occur when the application changes from one state to another.  See
+the documentation on
+\l{qtquick-concepts-statesanimations-animations.html#transitions-during-state-changes}
+{Transitions during State Changes} for more information about transitions.
+
+\section1 Animations
+
+When transitioning between states, a fluid animation can be used to aid the
+user during the transition.  Abrupt and unexpected changes to the visual
+canvas result in a suboptimal user-experience and should be avoided.
+
+If an element in a list becomes selected, the color change (from neutral to
+highlighted) can be animated.  If the position of the element in the list is
+changed, it can be moved in an fluidly animated fashion so that the eye of the
+user can track the change.
+
+These types of animations are supported in Qt Quick through various animation
+and transition elements.  See the documentation on
+\l{qtquick-concepts-statesanimations-animations.html}
+{Animations and Transitions In Qt Quick} for information about these elements
+and how to use them.
+
+Animations are not only related to states and transitions between states; for
+example, an animation might be triggered by other events, which are not
+associated with a distinct state.  It is often beneficial to always animate
+changes to certain properties of visual items, regardless of the cause of the
+change (for example, opacity effects).
+
+This type of animation is supported in Qt Quick with the \c{Behavior} element
+through the \tt{"Behavior on <Property>"} syntax.  Please see the documentation
+about
+\l{qtquick-concepts-statesanimations-animations.html#default-animation-as-behaviors}
+{default property animation behaviors} for more information about the Behavior
+element and how to use it.
+
+It is important to note, however, that using default property animations
+(using Behavior elements) as well as state-transition animations can sometimes
+results in undefined behavior occurring.  Please see the documentation about
+\l{qtquick-qmltypereference-behaviors.html}
+{using Qt Quick Behaviors with States} for more information about this topic.
+
+\section1 Animated Sprites
+
+The concept of animated sprites is separate to the concept of animations as
+used elsewhere on this page.  If you want to create or use an animated image
+or sprite, please see the documentation about
+\l{qtquick-concepts-effects-sprites.html}{sprite animations}.
+
+*/
diff --git a/src/quick/doc/src/concepts/topic.qdoc b/src/quick/doc/src/concepts/topic.qdoc
new file mode 100644
index 0000000000..9fd960850c
--- /dev/null
+++ b/src/quick/doc/src/concepts/topic.qdoc
@@ -0,0 +1,347 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-concepts-topic.html
+\title Important Concepts In Qt Quick
+\brief Overview of important concepts in Qt Quick
+
+Qt Quick provides everything needed to create a rich application with a fluid
+and dynamic user interface.  It is based around behavior declaration rather
+than imperative programming, and defines a visual canvas with its own
+coordinate system and drawing implementation.  There are many ways to position
+user-interface elements on the screen, and animation and transition effects are
+a first-class concept in Qt Quick.
+
+\section1 The Visual Canvas
+
+The visual canvas provided by the Qt Quick is a two dimensional canvas with
+z-ordering.
+
+\section2 Coordinate System
+
+The top-left pixel in the Qt Quick coordinate system is the [0, 0] pixel.
+The coordinate system of a child item is relative to its visual parent item.
+See the documentation on the
+\l{qtquick-concepts-visual-coordinates.html}{Coordinate System} for
+in-depth information about the coordinate system utilized by Qt Quick.
+
+\section2 Visual Parent
+
+There are two separate kinds of parenting in a QML application which uses
+Qt Quick.  The first kind is the ownership-parent (also known as the QObject
+parent) which determines object lifetime semantics.  The second kind is the
+visual-parent which determines where on the canvas an item is drawn, and also
+certain properties (for example, opacity applies to visual children).
+
+In almost all cases, the visual-parent is identical to the ownership-parent.
+See the documentation about the \l{qtquick-concepts-visual-parent.html}
+{Visual Parent}for more in-depth information on the topic.
+
+\section2 Scene Graph
+
+Modern computer systems and devices use OpenGL to draw graphics.  Qt Quick
+requires OpenGL and it is used to display applications developed with
+Qt Quick in QML.  In particular, Qt Quick defines a scene graph which is then
+rendered.  See the documentation about the
+\l{qtquick-concepts-visual-scenegraph.html}{Scene Graph} for in-depth
+information about the concept of a scene graph and why it is beneficial, and
+about the scene graph implementation provided by Qt Quick.
+
+\section1 Positioning
+
+Visual items in QML can be positioned in a variety of ways.  The most important
+positioning-related concept is that of anchoring, a form of relative
+positioning where items can be anchored (or attached) to each other at certain
+boundaries.  Other positioning concepts include absolute positioning,
+positioning with coordinate bindings, and layouts.
+
+\section1 Visual Objects
+
+Most user-interfaces include some visual aspect.  While multimodal interfaces
+are extremely interesting and can be very engaging and interactive (using,
+for example, haptic feedback and sounds to notify the user of changes in the
+state of an application), visual objects in a user-interface are able to convey
+a huge amount of information to the user at a glance.
+
+See the \l{qtquick-qmltypereference.html}{Qt Quick QML type reference} for the
+complete list of visual object types provided by Qt Quick.
+
+\section2 Manual Positioning
+
+Items can be positioned manually.  If the user-interface is going to be
+static, manual positioning provides the most efficient form of positioning.
+See the documentation about
+\l{qtquick-concepts-positioning.html#manual-positioning}
+{Absolute Positioning} for in-depth information about this form of positioning.
+
+\section2 Positioning With Bindings
+
+Items may also be positioned by assigning binding expressions to the properties
+associated with their location in the visual canvas.  This type of positioning
+is the most highly dynamic, however some performance cost is associated with
+positioning items in this manner.  See the documentation on
+\l{qtquick-concepts-positioning.html#positioning-with-bindings}
+{positioning with bindings} for in-depth information about this form of
+positioning.
+
+\section2 Anchors
+
+Anchors allows an item to be placed either adjacent to or inside of another,
+by attaching one or more of the item's anchor-points (boundaries) to an
+anchor-point of the other.  These anchors will remain even if the dimensions
+or location of one of the items changes, allowing for highly dynamic
+user-interfaces.  For in-depth information about anchoring, see the
+documentation about \l{qtquick-concepts-positioning-anchors.html}
+{positioning with anchors}
+
+\section2 Layouts
+
+Qt Quick also provides some built-in layout items.  For many use cases, the
+best layout to use is a simple grid, row, or column, and Qt Quick provides
+items which will layout children in these formations in the most efficient
+manner possible.  See the documentation about
+\l{qtquick-concepts-positioning-layouts.html}{layout} for in-depth information
+on the topic.
+
+\section2 Right-To-Left Support
+
+The directionality of the written form of a language often has a great impact
+on how the visual elements of a user-interface should be positioned.  Qt Quick
+supports right-to-left positioning of elements through the predefined-layouts
+as well as right-to-left text layouts.
+
+Please see the documentation about
+\l{qtquick-concepts-positioning-righttoleft.html}
+{right-to-left support in Qt Quick} for in-depth information on the topic.
+
+\section1 User Input
+
+Being able to respond to user-input is a fundamental part of user-interface
+design.  Depending on the use-case that an application solves, and the
+form-factor of the device that the application runs on, the best way
+to receive user-input may be different.
+
+\section2 Touch
+
+Allowing users to physically touch a screen to interact with an application is
+a popular user-interface paradigm on portable devices like smartphones and
+tablets.
+
+Qt Quick was designed specifically with touch-driven user-interfaces in mind,
+and thus touch events are supported in various visual object types, from
+\l{Flickable} lists to the generic \l{MultiPointTouchArea} type, as well as
+in the \l{MouseArea} type (which will be documented thoroughly in a proceeding
+section).
+
+\section2 Motion Gestures
+
+Detecting gestures with an accelerometer, or through camera-based gesture
+recognition, can allow users to interact with an application without requiring
+their full and undevided attention.  It can also provide a more interactive
+and engaging experience.
+
+Qt Quick itself does not offer first-class support for motion gestures, however
+another QML add-on module which provides support for gestures, which uses
+Qt Quick and integrates with Qt Quick's visual canvas does exist.  See the
+Qt Sensors module documentation for more information on the topic.
+
+\section2 Keyboard
+
+Supporting input from a keyboard is a vital component of the user-interface of
+many applications.
+
+XXX TODO: generic keypress event handling documentation?
+
+Qt Quick also provides visual object types which automatically receive keyboard
+events and key-presses, and displays the appropriate text.  Please see the
+documentation about \l{qtquick-concepts-input-text.html}{text input} for
+in-depth information on the topic.
+
+\section2 Mouse
+
+The computer mouse is still a very important vector for user-input.  Detecting
+and reacting to clicks and presses according to their position is a fundamental
+concept in user-interface design.
+
+Qt Quick provides the MouseArea visual object type which automatically receives
+mouse events (including clicks and wheel events) which allows developers to
+create custom user-interface objects to handle mouse input.  Please see the
+documentation about \l{qtquick-concepts-input-mouseevents.html}
+{mouse events in Qt Quick} for more information on the topic.
+
+\section2 Focus
+
+Most user-interfaces have multiple visual objects, but usually only one object
+has focus (that is, receives key-press events) at any time.  Qt Quick has
+support for complex focus specification.  See the documentation about
+\l{qtquick-concepts-input-focus.html}{keyboard focus in Qt Quick} for more
+information on this topic.
+
+\section1 Event Interceptors
+
+In a highly dynamic user-interface, the application developer will often wish
+to intercept some events (such as property assignments) so that the change can
+be animated.  Interceptors are a first-class concept in Qt Quick, and
+application developers can dynamically intercept property assignments and
+signal emissions, and define dynamic bindings.
+
+\section2 Animating Property Assignments
+
+When the location of a visual item changes, it is often suboptimal to simply
+change the location instantaneously.  It may be better to animate the update
+to allow the user's eye to follow the change, thus providing a seamless
+user-experience.  See the documentation on
+\l{qtquick-concepts-interceptors.html#animating-property-assignments}
+{Animating Property Assignments} for more information about property assignment
+interception.
+
+\section2 Dynamic Bindings
+
+Assigning binding expressions to properties is a fundamental concept of QML,
+and Qt Quick extends upon the idea with dynamic bindings where the target of
+the binding can be defined outside of the binding expression itself.  See the
+\l{qtquick-concepts-interceptors.html#dynamic-bindings}{Dynamic Bindings} page
+for more information about this concept.
+
+\section2 Dynamic Signal Connections
+
+Just as bindings can be retargeted dynamically in Qt Quick, so too can signal
+connections.  This allows highly dynamic dispatch to be implemented in a user
+interface where different visual items need to handle different events,
+depending on the situation, at run-time.  See the documentation about
+\l{qtquick-concepts-interceptors.html#dynamic-signal-connections}
+{Dynamic Signal Connections} for in-depth information.
+
+\section1 States, Transitions And Animations
+
+In any modern user-interface, transitioning between states and animating
+the user-interface is highly beneficial.  These are first-class concepts in
+Qt Quick, and are discussed in more detail in the
+\l{qtquick-concepts-statesanimations.html}{States, Transitions And Animations}
+documentation.
+
+\section1 Data - Models, Views and Data Storage
+
+Most applications will have data that needs to be displayed to the user.  That
+data might come from a variety of sources: network sources, local files, and
+databases are all common sources of data.
+
+\section2 Models and Views
+
+It is often advantageous to show similar data in a similar manner, within an
+application, and this gives rise to the idea of having a model which contains
+data, and a view which displays the data.  The view will display a delegate
+for every datum in the model.
+
+For information about how the Model/View paradigm is implemented in Qt Quick,
+see the page titled \l{qtquick-concepts-data-modelview.html}
+{Models and Views in Qt Quick}.
+
+\section2 Data Storage and Access
+
+Databases are commonly used to store information in applications.  Qt Quick
+provides simplified access to relational databases via the
+\l{qtquick-concepts-data-localstorage.html}{Qt Quick local storage module}.
+
+\section1 Graphical Effects and Particles
+
+Visually appealing user-interfaces are more engaging than lacklustre ones.
+That said, the designer must bear in mind that visual effects simply provide
+a useful way to subtlely communicate to the user (for example, which visual
+item is active, or how focus is being transferred).  Over-use of visual
+effects can actually detract from the user-experience.
+
+\section2 Visual Transformation
+
+Visual objects can be transformed.  For example, they can be scaled or rotated.
+These sort of transformations can provide hints about focus or selection, and
+can provide intuitive hints about what events are occurring in an application.
+
+For information about visual transformations to visual objects, see the
+page titled \l{qtquick-concepts-effects-transformations.html}
+{Qt Quick Transformation Types}.
+
+\section2 Shader Effects
+
+Shader effects allow the full, raw power of a graphics processing unit to be
+utilized directly via vertex and pixel shaders.  Using too many shader effects
+can result in increased power usage and sometimes slow performance, but if
+used sparingly and carefully, a shader can allow complex and visually appealing
+effects to be applied to a visual object (for example, ripples in water).
+
+For information about shader programs and shader effects, see the page
+titled \l{qtquick-concepts-effects-shaders.html}
+{Qt Quick Shader Effects}.
+
+\section2 Particles
+
+A particle system allows explosions, fireworks, smoke, fog and wind effects to
+be simulated and displayed to the user.  Qt Quick provides a particle system
+which allows these sort of complex, 2D simulations to be performed, including
+support for environmental effects like gravity and turbulence.
+Particles are most commonly used to add subtle and visually appealing effects
+to currently selected items in lists or in activity notifiers, and in games.
+
+For information about particles, see the documentation about the
+\l{qtquick-concepts-effects-particles.html}{Qt Quick Particle System}.
+
+\section2 Sprites
+
+A sprite is an animated image made up of frames.  Sprites are commonly found
+in games.  Qt Quick provides a visual type to display sprites, as well as a
+complex, stochastic, frame-transition controller for more complex applications
+which use sprites extensively (such as games).
+
+For information about sprite animations, see the page titled
+\l{qtquick-concepts-effects-sprites.html}{Sprite Animations}.
+
+\section1 Defining And Using Modular Components
+
+One of the aims of QML is to allow developers to write modular user-interface
+types which may be reused to build complex, interactive applications which
+are highly maintainable.  Reusable components and dynamic object instantiation
+are fundamental building blocks which allow this paradigm to be realised in
+Qt Quick.
+
+\section2 Defining Reusable Components
+
+Being able to define reusable components is a fundamental feature of the QML
+language.  Qt Quick extends on this, by providing some types which make the
+dynamic construction of reusable components simpler and more efficient.  Please
+see the documentation on \l{qtquick-concepts-components.html}
+{Defining Reusable Components} for more information on the topic.
+
+\section2 Dynamic Instantiation and Lazy Initialization
+
+Qt Quick also provides the Loader type which may be used in conjuction with a
+Component or a QML document to instantiate objects lazily and on-demand.
+Please see the \l{qtquick-performance.html}{performance guide} for more
+information on using dynamic instantiation and lazy initialization to improve
+application performance.
+
+*/
diff --git a/src/quick/doc/src/concepts/visual-coordinates.qdoc b/src/quick/doc/src/concepts/visual-coordinates.qdoc
new file mode 100644
index 0000000000..aff25980d4
--- /dev/null
+++ b/src/quick/doc/src/concepts/visual-coordinates.qdoc
@@ -0,0 +1,35 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-concepts-visual-coordinates.html
+\title Concepts - Visual Coordinates in Qt Quick
+\brief Description of the concept of visual coordinates in Qt Quick
+
+XXX TODO - Fill with content.
+
+*/
diff --git a/src/quick/doc/src/concepts/visual-parent.qdoc b/src/quick/doc/src/concepts/visual-parent.qdoc
new file mode 100644
index 0000000000..30f1d18b92
--- /dev/null
+++ b/src/quick/doc/src/concepts/visual-parent.qdoc
@@ -0,0 +1,35 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-concepts-visual-parent.html
+\title Concepts - Visual Parent in Qt Quick
+\brief Description of the concept of visual parent in Qt Quick
+
+XXX TODO - Fill with content.
+
+*/
diff --git a/src/quick/doc/src/qmlscenegraph.qdoc b/src/quick/doc/src/concepts/visual-scenegraph.qdoc
index 0b87c3a947..e244917a4f 100644
--- a/src/quick/doc/src/qmlscenegraph.qdoc
+++ b/src/quick/doc/src/concepts/visual-scenegraph.qdoc
@@ -26,8 +26,20 @@
 ****************************************************************************/
 
 /*!
-\title QML Scene Graph
-\page qmlscenegraph.html
+\title Qt Quick Scene Graph
+\page qtquick-concepts-visual-scenegraph.html
+
+\section1 What is a Scene Graph?
+
+When drawing visual objects of a user-interface, it can be beneficial to group
+drawing operations which are similar.  For example, if a user-interface
+includes many similar text boxes, each with a light-blue background, then all
+of those text boxes could be painted at the same time, prior to painting any
+of the text in each box, as this might be more performant than painting one of
+the text boxes, and then painting its text, and then painting the next text
+box, and then its text, and so on.
+
+\section1 The Scene Graph in Qt Quick
 
 Qt Quick 2 makes use of a dedicated scene graph based on OpenGL ES 2.0
 or OpenGL 2.0 for its rendering. Using a scene graph for graphics
diff --git a/src/quick/doc/src/cppextensionpoints.qdoc b/src/quick/doc/src/cppextensionpoints.qdoc
new file mode 100644
index 0000000000..953d804b60
--- /dev/null
+++ b/src/quick/doc/src/cppextensionpoints.qdoc
@@ -0,0 +1,52 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms
+** and conditions contained in a signed written agreement between you
+** and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtquick-cppextensionpoints.html
+\title C++ Extension Points Provided By Qt Quick
+\brief Description of the C++ extension points provided by the Qt Quick module
+
+// XXX TODO: should this be a topic page?  Are each of the sections below big enough to require their own page?
+
+Qt Quick provides several extension and integration points for C++ developers.
+In particular, it allows C++ developers to create and register custom
+QQuickItem-derived types which can be rendered by Qt Quick.  It also provides
+several scene graph-related classes which allow developers to define their own
+rendering primitives.
+
+\section1 User-Defined QQuickItem-Derived Types
+
+While the Qt Quick module already provides a rich library of visual item types
+for use in a QML application, some developers may wish to define their own
+item-derived types in C++ and expose them to the QML type system.
+
+\section1 Scene Graph-Related Classes
+
+As an OpenGL-based scene graph, the scene graph in Qt Quick uses nodes which
+may be geometries or textures.
+
+*/
diff --git a/src/quick/doc/src/qmltexthandling.qdoc b/src/quick/doc/src/qmltexthandling.qdoc
deleted file mode 100644
index 63f2c40145..0000000000
--- a/src/quick/doc/src/qmltexthandling.qdoc
+++ /dev/null
@@ -1,73 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-\page qtquick-texthandling.html
-\title Text Handling and Validators
-\brief elements that accept and handle text input
-
-\tableofcontents
-
-\section1 Text Elements
-
-\list
-\li \l{Text}
-\li \l{TextInput}
-\li \l{TextEdit}
-\endlist
-
-\section1 Validators
-\list
-\li \l{IntValidator}
-\li \l{DoubleValidator}
-\li \l{RegExpValidator}
-\endlist
-
-\section1 Displaying Text in QML
-QML provides several elements to display text onto the screen. The \l Text
-element will display formatted text onto the screen, the \l TextEdit element
-will place a multiline line edit onto the screen, and the \l TextInput will
-place a single editable line field onto the screen.
-
-To learn more about their specific features and properties, visit their
-respective element documentation.
-
-\section1 Validating Input Text
-The \l {Validators}{validator} elements enforce the type and format of
-\l TextInput objects.
-
-\snippet qml/texthandling.qml int validator
-The validator elements bind to \c {TextInput}'s \c validator property.
-
-\snippet qml/texthandling.qml regexp validator
-The regular expression in the snippet will only allow the inputted text to be
-\c {fruit basket}.
-
-Note that QML parses JavaScript regular expressions, while Qt's
-\l {QRegExp} class' regular expressions are based on Perl regular expressions.
-
-*/
diff --git a/src/quick/doc/src/elements.qdoc b/src/quick/doc/src/qmltypereference.qdoc
index 40533867df..a2cb4df1e1 100644
--- a/src/quick/doc/src/elements.qdoc
+++ b/src/quick/doc/src/qmltypereference.qdoc
@@ -26,78 +26,95 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-elements.html
-\title Qt Quick Elements
-\brief a listing of standard elements in Qt Quick
+\page qtquick-qmltypereference.html
+\title QML Types Provided By Qt Quick
+\brief Description of the QML types provided by the Qt Quick module
 
+This page contains links to documentation for every QML type provided by the
+Qt Quick module, organized according to category and purpose.  All of the types
+are based on the basic QML language object types: \l{QML::QtObject} and
+\l{QML::Component}.  Both of those basic types are available from the QtQuick
+import.
 
-\target elements
+\section1 Visual Types
 
-These are the functionally grouped lists of Qt Quick elements as part of
-\l{Qt Quick}. You can also browse the module pages for \l{QtQuick 2} and \l{QtQuick.Particles 2}
-
-Elements are declared with the their name and two curly braces. Elements may
-be nested in elements, thereby creating a parent-child relationship between the
-two elements.
-
-\section1 Basic Elements
-\list
-\li \l {Item} - Basic item element inherited by visual elements
-\endlist
-
-\section1 Graphics
 \list
-\li \l {Rectangle} - A rectangle element
+\li \l {Item} - Basic visual object type inherited by visual object types (visual items)
+\li \l {Rectangle} - A rectangle type
 \li \l {Image} - For incorporating bitmaps into a scene
 \li \l {BorderImage} - Allows the use of images as borders
-\li \l {AnimatedSprite} - For playing animations stored as a series of frames
 \li \l {AnimatedImage} - For playing animations stored as an animated GIF
+\li \l {AnimatedSprite} - For playing animations stored as a series of frames
+\li \l {Text} - For inserting formatted text into a scene
+\li \l {TextInput} - Captures user key input
+\li \l {TextEdit} - Displays multiple lines of editable formatted text
+\li \l {Canvas} - Provides a 2D canvas type similar to the HTML5 canvas
+\li \l {Window} - Provides a top-level window
+\endlist
+
+Visual object utility types
+\list
+\li \l {Accessible} - Attached property to make components accessible
 \li \l {Gradient} - For defining a color gradient
 \li \l {GradientStop} - Used to define a color within a \l {Gradient}
 \li \l {SystemPalette} - Provides access to the Qt palettes
-\li \l {Canvas} - Provides a 2D canvas element
+\li \l {Screen} - Provides information about the screen on which an \l {Item} is displayed
+\li \l {Sprite} - Specifies sprite animations
 \li \l {SpriteSequence} - For playing and transitioning between multiple animations stored as a series of frames
+\li \l {SpriteGoal} - For changing the state of a Sprite
 \endlist
 
-\section1 Text Handling
+\section1 User Input Types
+
 \list
-\li \l {Text} - For inserting formatted text into a scene
+\li \l {MouseArea} - Sets up an area for mouse interaction
+\li \l {Keys} - Provides components with attached properties to handle key input.
+\li \l {KeyNavigation} - Supports key navigation by arrow keys
+\li \l {FocusScope} - Element that mediate keyboard focus changes
+\li \l {Flickable} - Provides a surface that can be "flicked"
+\li \l {Flipable} - Provides a surface that produces "flipping" effects
+\li \l {PinchArea} - Enables simple pinch gesture handling
+\li \l {MultiPointTouchArea} - Enables handling of multiple touch points
+\li \l {Drag} - For specifying drag and drop events for visual items
+\li \l {DropArea} - For specifying drag and drop event handling in an area
 \li \l {TextInput} - Captures user key input
 \li \l {TextEdit} - Displays multiple lines of editable formatted text
+\endlist
+
+Text input utility types
+\list
 \li \l {IntValidator} - Validates values as integers
 \li \l {DoubleValidator} - Validates real values
 \li \l {RegExpValidator} - Validator for string regular expressions
 \li \l {FontLoader} - Loads fonts by name or URL
 \endlist
 
-\section1 Mouse and Interaction Area
+User input events
 \list
-\li \l {MouseArea} - Sets up an area for mouse interaction
-\li \l {Keys} - Provides components with attached properties to handle key input.
-\li \l {FocusScope} - Element that mediate keyboard focus changes
-\li \l {Flickable} - Provides a surface that can be "flicked"
-\li \l {Flipable} - Provides a surface that produces "flipping" effects
-\li \l {PinchArea} - Enables simple pinch gesture handling
-\li \l {MultiPointTouchArea} - Enables handling of multiple touch points
+\li \l {TouchPoint} - Describes a touch point in a MultiPointTouchArea
+\li \l {PinchEvent} - Specifies information about a pinch event
+\li \l {WheelEvent} - Provides information about a mouse wheel event
+\li \l {MouseEvent} - Provides information about a mouse click event
+\li \l {KeyEvent} - Provides information about a key press event
+\li \l {DragEvent} -Provides information about a drag event
 \endlist
 
-\section1 Positioners and Repeater
+\section1 Positioning
+
 \list
+\li \l {Positioner} - Provides information about where an Item exists within a layout
 \li \l {Column} - Arranges its children vertically
 \li \l {Row} - Arranges its children horizontally
 \li \l {Grid} - Positions its children in a grid
 \li \l {Flow} - Positions its children with wrapping support
 \li \l {Repeater} - Uses a model to create multiple components
+\li \l {qtquick-concepts-positioning-anchors.html}{Anchor} - Allows visual items to be anchored together
+\li \l {LayoutMirroring} - Attached property used to mirror layout behavior
 \endlist
 
-\section1 Transformations
-\list
-\li \l {Scale} - Assigns item scaling behaviors
-\li \l {Rotation} - Assigns item rotation behaviors
-\li \l {Translate} - Assigns item translation behaviors
-\endlist
+\section1 States, Transitions And Animations
 
-\section1 States
+States
 \list
 \li \l {State} - Defines sets of configurations of objects and properties
 \li \l {PropertyChanges} - Describes property changes within a state
@@ -105,11 +122,12 @@ two elements.
 \li \l {StateChangeScript} - Allows script binding in a state
 \li \l {ParentChange} - Re-parent an Item in a state change
 \li \l {AnchorChanges} - Change the anchors of an item in a state
-\endlist
 
-\section1 Animation and Transitions
+Transitions and Animations
+\endlist
 \list
 \li \l {Transition} - Animates transitions during state changes
+\li \l {ViewTransition} - Specifies items under transition in a view
 \li \l {SequentialAnimation} - Runs animations sequentially
 \li \l {ParallelAnimation} - Runs animations in parallel
 \li \l {Behavior} - Specifies a default animation for property changes
@@ -138,56 +156,95 @@ Elements that provide lower-level animation control
 \li \l {AnimationController} - Allows manual control of animation progress
 \endlist
 
-\section1 Models and Data Handling
+Animation paths
+\list
+\li \l {Path} - Defines a path used by \l {PathView}
+\li \l {PathLine} - Defines a line in \l {Path}
+\li \l {PathQuad} - Defines a quadratic Bezier curve in a \l {Path}
+\li \l {PathCubic} - Defines a cubic Bezier curve in a \l {Path}
+\li \l {PathArc} - Defines an arc in a \l {Path}
+\li \l {PathCurve} - Defines a point on a Catmull-Rom curve in a \l {Path}
+\li \l {PathSvg} - Defines a sub-path specified as a SVG path data string in a \l {Path}
+\li \l {PathAttribute} - Allows the setting of attributes along a \l {Path}
+\li \l {PathPercent} - Modifies the item distribution along a \l {Path}
+\endlist
+
+Visual object transformations
+\list
+\li \l {Transform} - Allows specification of advanced transformations on Items
+\li \l {Scale} - Assigns item scaling behaviors
+\li \l {Rotation} - Assigns item rotation behaviors
+\li \l {Translate} - Assigns item translation behaviors
+\endlist
+
+\section1 Interceptors
+
+\list
+\li \l {Connections} - Explicitly connects signals and signal handlers
+\li \l {Binding} - Binds any value to any property
+\li \l {Timer} - Provides timed triggers
+\li \l {Behavior} - Triggers animations when a property value is set
+\endlist
+
+\section1 Model/View Types And Data Storage And Access
+
+Models And Model Data
 \list
 \li \l {QtQuick2::ListModel}{ListModel} - Defines a list of data
 \li \l {QtQuick2::ListElement}{ListElement} - Defines a data item in a \l {QtQuick2::ListModel}{ListModel}
 \li \l {VisualItemModel} - Contains items that already defines its own visual delegate
 \li \l {VisualDataModel} - Encapsulates a model and a delegate
+\li \l {VisualDataGroup} -Encapsulates a filtered set of visual data items
 \li \l {XmlListModel} - Specifies a model using XPath expressions
 \li \l {XmlRole} - Specifies a role for an \l {XmlListModel}
-\li \l {Binding} - Binds any value to any property
-\li \l {Package} - Collection that enables sharing of items within different views
+\li \l {FolderListModel} - Provides a model of the contents of a file system folder
+\li \l {Repeater} - Provides a simple model to create multiple visual objects
 \endlist
 
-\section1 Views
+Views
 \list
 \li \l {ListView} - Provides a list visualization of a model
 \li \l {GridView} - Provides a grid visualization of a model
 \li \l {PathView} - Visualizes a model's contents along a path. See \l {Path Definition}{Path Elements} for more information.
+\li \l {Package} - Collection that enables sharing of items within different views
 \endlist
 
-\section1 Path Definition
+Data Storage
 \list
-\li \l {Path} - Defines a path used by \l {PathView}
-\li \l {PathLine} - Defines a line in \l {Path}
-\li \l {PathQuad} - Defines a quadratic Bezier curve in a \l {Path}
-\li \l {PathCubic} - Defines a cubic Bezier curve in a \l {Path}
-\li \l {PathArc} - Defines an arc in a \l {Path}
-\li \l {PathCurve} - Defines a point on a Catmull-Rom curve in a \l {Path}
-\li \l {PathSvg} - Defines a sub-path specified as a SVG path data string in a \l {Path}
-\li \l {PathAttribute} - Allows the setting of attributes along a \l {Path}
-\li \l {PathPercent} - Modifies the item distribution along a \l {Path}
+\li \l {LocalStorage} - Module API providing simplified SQL access
 \endlist
 
-\section1 Utility
-\list
-\li \l {Connections} - Explicitly connects signals and signal handlers
-\li \l {Timer} - Provides timed triggers
-\li \l {Loader} - Controls the loading of items or components
-\endlist
+\section1 Particles And Graphical Effects
 
-\section1 Graphical Effects
 \list
 \li \l {ShaderEffect} - Allows GLSL shaders to be used as graphical effects
 \li \l {ShaderEffectSource} - Usable as a texture in ShaderEffect
 \li \l {GridMesh} - Generates a gird mesh of vertices for use by ShaderEffect
-\li The \l{QtQuick.Particles 2} module provides a set of Particle System elements for QtQuick 2
+\li The \l{QtQuick.Particles 2} module provides a set of Particle System types for QtQuick 2
 \endlist
 
-\section1 Accessibility
+\section1 Canvas (similar to HTML5 canvas)
+
 \list
-\li \l {Accessible} - Attached property to make components accessible
+\li \l {Canvas} - Provides a 2D canvas type similar to the HTML5 canvas
+\li \l {Context2D} - Provides 2D context for shapes on a Canvas item
+\li \l {CanvasGradient} - Allows specification of a gradient on a Canvas
+\li \l {CanvasPixelArray} - Allows specification of a pixel array for use in a Canvas
+\li \l {CanvasImageData} - Allows specification of image data for use in a Canvas
+\li \l {TextMetrics} - Provides text and font measurement data for use in a Canvas
+\endlist
+
+\section1 Dynamic Instantiation Enablers
+
+\list
+\li \l {QML::Component} - Provides a type-instance factory allowing dynamic instantiation
+\li \l {Loader} - Controls the loading of items or components
+\endlist
+
+\section1 Threading
+
+\list
+\li \l {WorkerScript} - Enables the use of threads in a Qt Quick application
 \endlist
 
 */
diff --git a/src/quick/doc/src/qtdeclarative.qdoc b/src/quick/doc/src/qtdeclarative.qdoc
deleted file mode 100644
index 9ebac42fa0..0000000000
--- a/src/quick/doc/src/qtdeclarative.qdoc
+++ /dev/null
@@ -1,97 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-\title Qt Quick
-\page qtquick-reference.html
-\inqmlmodule QtQuick 2
-\ingroup qt-gui-concepts
-\ingroup overviews
-
-\brief Qt Quick provides a declarative framework for building highly
-dynamic applications.
-
-For App Developers and Designers, who want to deliver apps with amazing user
-experience, Qt provides the QML language, the Qt Quick types, and tools in Qt
-Creator that make it faster than ever to transform your brilliant idea into a
-winning App across mobile, embedded, and desktop platforms.
-
-\target qtquick-overviews
-\section1 QML - the Declarative Language
-
-    QML is a declarative language for creating flexible and reusable types.
-    The QML runtime powers QML based applications. The runtime includes a QML
-    engine, JavaScript engine, and mechanism to bind to C++ types.
-
-    \list
-    \li \l{QML - the Declarative Language}{QML} - the declarative language
-    \endlist
-
-\section1 Qt Quick User Interfaces
-
-Qt Quick features QML visual types, user input system, animation system, and data visualization through models and delegates.
-
-    \list
-    \li \l{UI Creation with Qt Quick}
-    \endlist
-
-\section1 QML Scene Graph
-
-Qt Quick features a high-performance rendering scene graph based on OpenGL.
-The scene graph offers a C++ API which allows developers to create their own unique
-and stunning graphical elements.
-
-    \list
-    \li \l{QML Scene Graph}
-    \endlist
-
-\section1 QML Engine
-There is a QML engine which runs QML applications. It includes C++ classes
-that loads and initializes QML code and a JavaScript engine for running
-expressions.
-    \list
-    \li \l{The QML Engine}
-    \li \l{Qt Declarative UI Runtime}{Declarative Runtime}
-    \endlist
-
-\section1 SQL Local Storage
-
-The SQL Local Storage provides a JavaScript interface to an SQLite database.
-To use, import the \c QtQuick.LocalStorage module into a namespace with the
-\c as keyword.
-
-\code
-import QtQuick.LocalStorage 2.0 as Sql
-\endcode
-
-The SQL Local Storage page has more information about the interface.
-\list
-    \li \l{Local Storage}{SQL Local Storage}
-\endlist
-
-*/
-
diff --git a/src/quick/doc/src/canvaspainting.qdoc b/src/quick/doc/src/qtquick-cpp.qdoc
index d99e31ff12..5a3384f51b 100644
--- a/src/quick/doc/src/canvaspainting.qdoc
+++ b/src/quick/doc/src/qtquick-cpp.qdoc
@@ -24,17 +24,27 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-
 /*!
-\group qtquick-canvas
-\ingroup qml-features
-\title Canvas API
-\brief Custom graphics with the Canvas API
+  \module QtQuick
+  \title Qt Quick Module C++ API Reference
+
+  \brief The Qt Quick module provides classes for embedding Qt Quick
+  in Qt/C++ applications.
+
+  To include the definitions of the module's classes, use the
+  following directive:
+
+  \code
+  #include <QtQuick>
+  \endcode
 
-\section1 Related Types
-\generatelist{related}
+  To link against the module, add this line to your \l qmake \c
+  .pro file:
 
-The Canvas and Context2D elements implement the \l{HTML Canvas API 2D Context}
-and allows applications to have custom painting routines.
+  \code
+  QT += quick
+  \endcode
 
+  For more information on the Qt Quick module, see the
+  \l{qtquick-main.html}{Qt Quick module} documentation.
 */
diff --git a/src/quick/doc/src/qtquick-intro.qdoc b/src/quick/doc/src/qtquick-intro.qdoc
deleted file mode 100644
index 56f507dd82..0000000000
--- a/src/quick/doc/src/qtquick-intro.qdoc
+++ /dev/null
@@ -1,143 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-\page qtquick-intro.html
-\title Introduction to Qt Quick
-
-Qt Quick is a collection of technologies that are designed to help developers
-create the kind of intuitive, modern, and fluid user interfaces that are
-increasingly used on mobile phones, media players, set-top boxes, and other
-portable devices. Qt Quick consists of a rich set of user interface
-\l{QML Elements}{elements}, a \l{QML Syntax}{declarative} language for
-describing user interfaces, and a language \l{QtQml Module}{runtime}. A
-collection of C++ APIs is used to integrate these high level features with
-classic Qt applications. Version 2.1 of the Qt Creator integrated development
-environment (IDE) introduces tools for developing Qt Quick applications.
-
-\image qml-clocks-example.png
-
-\section1 The QML Language
-
-QML is a high level language that uses a declarative syntax to define how the
-user interface should appear and behave. QML is used to build interfaces using
-a collection of standard elements for fundamental user interface features.
-These elements expose properties that can be changed at run-time, allowing
-visual elements to be animated and used in transitions between states of the
-user interfaces.
-
-\div{class="float-left"}
-\inlineimage qml-dialcontrol-example.png
-\enddiv
-A Dial element might define a \e value property that can be used to control
-the position of the needle on the dial. The element could be declared to
-use a slider that adjusts the value of this property.
-
-\snippet examples/tutorials/ui-components/dialcontrol/dialcontrol.qml the dial in use
-
-Building user interfaces by importing these elements and linking their properties
-together is one of the fundamental features of QML and Qt Quick.
-
-\clearfloat
-Behind the scenes, QML leverages the power and efficiency of the Qt libraries
-to provide rendering facilities, perform processor-intensive operations, and
-to access components written in C++.
-
-The QML language also gives the developer more flexibility to create parts
-of their user interface by allowing \l{About JavaScript}{JavaScript} to be
-used to implement high level user interface logic.
-
-\l{How to Learn QML} introduces the reader to the language and declarative
-concepts.
-
-\section1 QtQml Module
-
-To make Qt Quick possible, Qt introduces the \l{QtQml} module. The
-module creates a JavaScript runtime that QML runs under with a Qt based backend.
-Because QtQml and QML are built upon Qt, they inherit many of Qt's
-technology, namely the \l{Signals and Slots}{signals and slots} mechanism and
-the \l{The Meta-Object System}{meta-object} system. Data created using C++ are
-directly accessible from QML, and QML objects are also accessible from C++ code.
-
-The QtQml module separates the interface logic in QML from the
-application logic in C++. It also allows the range of standard QML elements
-to be \l{Extending QML with C++}{extended with new ones written in C++}.
-
-\section1 Qt Creator Tools
-
-Qt Creator is a complete integrated development environment (IDE) for creating
-applications with Qt Quick and the Qt application framework.
-
-\image qmldesigner-visual-editor.png
-
-The main goal for Qt Creator is meeting the development needs of Qt Quick
-developers who are looking for simplicity, usability, productivity,
-extendibility and openness, while aiming to lower the barrier of entry for
-newcomers to Qt Quick and Qt. The key features of Qt Creator allow UI designers
-and developers to accomplish the following tasks:
-\list
-\li Get started with Qt Quick application development quickly and easily with
-examples, tutorials, and project wizards.
-\li Design application user interface with the integrated editor, Qt Quick
-Designer, or use graphics software to design the user interface and use scripts
-to export the design to Qt Quick Designer.
-\li Develop applications with the advanced code editor that provides new powerful
-features for completing code snippets, refactoring code, and viewing the element
-hierarchy of QML files.
-\li Build and deploy Qt Quick applications that target multiple desktop and
-mobile platforms, such as Microsoft Windows, Mac OS X, Linux, and Maemo.
-\li Debug JavaScript functions and execute JavaScript expressions in the current
-context, and inspect QML at runtime to explore the object structure, debug
-animations, and inspect colors.
-\li Deploy applications to mobile devices and create application installation
-packages for Maemo devices that can be published in the Ovi Store
-and other channels.
-\li Easily access information with the integrated context-sensitive Qt Help
-system.
-\endlist
-
-\image qtcreator-target-selector.png
-
-\section1 Where to Go from Here
-
-\l{external: Developing Qt Quick Applications with Creator}
-{Developing Qt Quick Applications with Creator} provides an overview
-of user interface development using the visual \e{Qt Quick Designer} tool.
-
-\l{How to Learn QML} introduces the reader to the language and declarative
-concepts.
-
-The \l{QML Reference} page has links to various Qt Quick topics such as QML
-features, addons, and tools.
-
-The \l {Qt Quick Code Samples} page has a gallery of QML applications.
-
-\section1 License Information
-\list
-\li \l{Qt Quick Licensing Information}
-\endlist
-*/
diff --git a/src/quick/doc/src/qtquick.qdoc b/src/quick/doc/src/qtquick.qdoc
index c38ef3c801..d1f3755815 100644
--- a/src/quick/doc/src/qtquick.qdoc
+++ b/src/quick/doc/src/qtquick.qdoc
@@ -26,27 +26,82 @@
 ****************************************************************************/
 
 /*!
-  \module QtQuick
-  \title Qt Quick Module
-  \ingroup modules
+\page qtquick-main.html
+\title Qt Quick Module
+\brief The Qt Quick module implements the "standard library" for QML
 
-  \brief The Qt Quick module provides classes for embedding Qt Quick
-  in Qt/C++ applications.
+\section1 Overview Of The Qt Quick Module
 
-  To include the definitions of the module's classes, use the
-  following directive:
+The Qt Quick module is the standard library for the QML language (which is
+defined and implemented by the \l{qtqml-main.html}{Qt QML module}).
+The Qt Quick module provides a visual canvas, visual item types, an animation
+framework, and types which make dynamic instantiation of objects more
+convenient.  It also provides the QQuickView C++ class to enable displaying
+a user-interface written in Qt Quick.
 
-  \code
-  #include <QtQuick>
-  \endcode
+In summary, Qt Quick provides a library of visual types to allow building a
+user-interface, and the C++ API to instantiate and interact with it.
 
-  To link against the module, add this line to your \l qmake \c
-  .pro file:
+\section1 Qt Quick Module Documentation
 
-  \code
-  QT += quick
-  \endcode
+\list
+
+    \li \l{qtquick-concepts-topic.html}{Important Concepts In Qt Quick}
+        \list
+        \li \l{qtquick-concepts-topic.html#the-visual-canvas}{The Visual Canvas}
+        \li \l{qtquick-concepts-topic.html#positioning}{Positioning}
+        \li \l{qtquick-concepts-topic.html#user-input}{User Input}
+        \li \l{qtquick-concepts-topic.html#event-interceptors}{Event Interceptors}
+        \li \l{qtquick-concepts-statesanimations.html}{States, Transitions And Animations}
+        \li \l{qtquick-concepts-topic.html#data-models-views-and-data-storage}{Data - Models, Views and Data Storage}
+        \li \l{qtquick-concepts-topic.html#graphical-effects-and-particles}{Graphical Effects And Particles}
+        \li \l{qtquick-concepts-topic.html#defining-and-using-modular-components}{Defining And Using Modular Components}
+
+        \endlist
+
+    \li \l{qtquick-qmltypereference.html}{QML Types Provided By The Qt Quick Module}
+        \list
+        \li \l{qtquick-qmltypereference.html#visual-types}{Visual Types}
+        \li \l{qtquick-qmltypereference.html#user-input-types}{User Input Types}
+        \li \l{qtquick-qmltypereference.html#positioning}{Positioning}
+        \li \l{qtquick-qmltypereference.html#states-transitions-and-animations}{States, Transitions And Animations}
+        \li \l{qtquick-qmltypereference.html#interceptors}{Interceptors}
+        \li \l{qtquick-qmltypereference.html#model-view-types-and-data-storage-and-access}{Model/View Types And Data Storage And Access}
+        \li \l{qtquick-qmltypereference.html#particles-and-graphical-effects}{Particles And Graphical Effects}
+        \li \l{qtquick-qmltypereference.html#canvas-similar-to-html5-canvas}{Canvas (similar to HTML5 Canvas)}
+        \li \l{qtquick-qmltypereference.html#dynamic-instantiation-enablers}{Dynamic Instantiation Enablers}
+        \endlist
+
+    \li \l{qtquick-cppextensionpoints.html}{C++ Extension Points}
+        \list
+        \li \l{qtquick-cppextensionpoints.html#user-defined-qquickitem-derived-types}{User-Defined QQuickItem-Derived Types}
+        \li \l{qtquick-cppextensionpoints.html#scene-graph-related-classes}{Scene Graph-Related Classes}
+        \endlist
+
+\endlist
+
+\section1 Reference Documentation
+
+More information about the Qt Quick module is contained within the class and
+function documentation of the \l{qtquick-apireference.html}
+{Qt Quick Module API Reference}.  The QML types provided by the Qt Quick module
+are listed in the \l{qtquick-qmltypereference.html}
+{Qt Quick Module QML Type Reference} page.
+
+Application developers who are interested in writing applications using QML
+should start by reading the \l{qtquick-applicationdevelopers.html}
+{QML Application Developer Resources}.  The documentation for the
+\l{qtqml-main.html}{Qt QML} module is also an indispensible resource for
+application developers who are using Qt Quick, as it provides the definition
+and implementation of the QML language (for which Qt Quick is the standard
+library of types and functionality).
+
+Quick Links:
+\list
+\li \l{qtquick-qmltypereference.html}{Qt Quick Module QML Type Reference}
+\li \l{qtquick-module.html}{Qt Quick Module C++ API Reference}
+\li \l{qtqml-main.html}{Qt QML Module Documentation}
+\li \l{qtquick-applicationdevelopers.html}{QML Application Developer Resources}
+\endlist
 
-  For more information on the Qt Quick module, see the
-  \l{Qt Quick} documentation.
 */
diff --git a/src/quick/doc/src/qtquick2.qdoc b/src/quick/doc/src/qtquick2.qdoc
deleted file mode 100644
index 93f564025d..0000000000
--- a/src/quick/doc/src/qtquick2.qdoc
+++ /dev/null
@@ -1,38 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-    \qmlmodule QtQuick 2
-    \title QML Module QtQuick 2
-
-    \brief Contains QML types for creating applications
-
-    This QML module contains all the QML types that are
-    instantiated as objects of C++ classes in the QtQml
-    module. These types work with the Scenegraph renderer and
-    their own canvas.
- */
diff --git a/src/quick/doc/src/qtquicktypes.qdoc b/src/quick/doc/src/qtquicktypes.qdoc
deleted file mode 100644
index d064565714..0000000000
--- a/src/quick/doc/src/qtquicktypes.qdoc
+++ /dev/null
@@ -1,174 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-\page qtquick-types.html
-\title Qt Quick Types
-\brief A listing of standard types in Qt Quick
-
-
-
-These are the functionally grouped lists of Qt Quick types as part of
-\l{Qt Quick}. You can also browse the module pages for \l{QtQuick 2} and \l{QtQuick.Particles 2}
-
-\section1 Qt Quick Submodules
-
-    \section2 Particle Effects
-
-    The \l{QtQuick.Particles 2} module provides a set of Particle System types
-    for QtQuick 2. The \l{Using the Qt Quick Particle System} article describes
-    the particle system.
-
-    \section2 Local Storage
-    The \l{Local Storage}{SQL Local Storage} submodule contains a
-    JavaScript interface for an SQLite database.
-
-    \section2 XmlListModel
-
-    The \l{QtQuick.XmlListModel 2.0} submodule contains contains the
-    \l{XmlListModel} type, for using remote XML data as a model.
-
-\section1 Visual Types
-    These types are described in the \l{qtquick-visual-types}{Visual Types}
-    overview.
-    \annotatedlist qtquick-visual-types
-
-\section1 Images
-    These types are described in the
-    \l{qtquick-images}{Images} overview.
-    \annotatedlist qtquick-images
-
-\section2 Sprites
-    These types are described in the
-    \l{qtquick-images-sprites}{Sprite Animations} overview.
-    \annotatedlist qtquick-images-sprites
-
-\section1 Item Graphics
-    These types are described in the \l{qtquick-item-graphics}{Item Graphics}
-    overview.
-    \annotatedlist qtquick-item-graphics
-
-\section1 Shader Effects
-
-    These types are described in the \l{qtquick-shaders}{Shader Effects}
-    overview.
-    \annotatedlist qtquick-shaders
-
-\section1 Canvas API
-
-    These types are described in the \l{qtquick-canvas}{Canvas API} overview.
-    \annotatedlist qtquick-canvas
-\section1 Text Handling
-    These types are described in the
-    \l{Qt Quick Text Handling and Validators}{Text Handling and Validators}
-    overview.
-    \annotatedlist qtquick-text
-
-\section2 Validators
-    These types are described in the
-    \l{Qt Quick Text Handling and Validators}{Text Handling and Validators}
-    overview.
-    \annotatedlist qtquick-text-validator
-
-\section1 User Interaction
-
-    These types are described in the
-    \l{qtquick-interaction}{Interaction} overview.
-    \annotatedlist qtquick-interaction
-
-\section1 Transformations
-
-    These types are described in the \l{qtquick-transformations}{Transformation Types} overview.
-    \annotatedlist qtquick-transformations
-
-\section1 States
-
-    These types are described in the \l{qtquick-states}{States}
-    overview.
-    \annotatedlist qtquick-states
-
-\section1 Animation and Transitions
-    These types are described in the
-    \l{qtquick-animation-define}{Animation and Transitions} overview.
-    \annotatedlist qtquick-animation-define
-
-    \section2 Property Animation
-
-        These types animate property changes and are described in the
-        \l{qtquick-animation-define}{Animation and Transitions} overview.
-        \annotatedlist qtquick-animation-properties
-
-    \section2 Animation Controls
-
-        These types provide lower-level animation control. These types are
-        described in the
-        \l{qtquick-animation-define}{Animation and Transitions} overview.
-        \annotatedlist qtquick-animation-control
-
-    \section2 Animation Modifiers
-
-        These types provide specialized changes during the animation. These
-        types are described in the
-        \l{qtquick-animation-define}{Animation and Transitions} overview.
-        \annotatedlist qtquick-animation-modifiers
-
-\section1 Models
-        These types are described in the \l{qtquick-models}{Qt Quick Models}
-        overview. The \l{Models and Views} overview has information about displaying
-        data with views and delegates.
-        \annotatedlist qtquick-models
-
-\section1 Views, Positioners, and Specialized Containers
-
-    \section2 Views
-        These types are described in the \l{qtquick-views}{Views} overview.
-        The \l{Models and Views} overview has information about displaying data with
-        models and delegates.
-        \annotatedlist qtquick-views
-
-    \section2 Containers
-        These types are described in the \l{qtquick-containters}{Containers}
-        overview.
-        \annotatedlist qtquick-containers
-
-    \section1 Positioners
-        These types are described in the \l{qtquick-positioners}{Positioners}
-        overview.
-        \annotatedlist qtquick-positioners
-
-\section1 Paths
-
-    These types are described in the \l{qtquick-paths}{Paths} overview.
-    \annotatedlist qtquick-paths
-
-\section1 Utility
-
-    These types are described in the \l{qtquick-utility}{Object Utilities}
-    overview.
-    \annotatedlist qtquick-utility
-
-*/
diff --git a/src/quick/doc/src/uicreation.qdoc b/src/quick/doc/src/uicreation.qdoc
deleted file mode 100644
index 51ed521625..0000000000
--- a/src/quick/doc/src/uicreation.qdoc
+++ /dev/null
@@ -1,89 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-
-\page qtquick-uicreation.html
-\title UI Creation with Qt Quick
-
-Qt Quick features graphical types, user input system, animation system, and data
-visualization through models and delegates.
-
-\section1 Import the QtQuick Types
-Qt Quick module contains several submodules which implement application user
-interfaces.
-
-\list
-\li QtQuick - provides the visual types necessary for building dynamic user interfaces
-\li QtQuick.Particles - a particle system for creating special effects
-\li QtQuick.XmlListModel - for constructing a model from an XML data source
-\endlist
-
-To use the types in the modules, import the modules.
-\code
-import QtQuick 2.0
-import QtQuick.Particles 2.0
-import QtQuick.XmlListModel 2.0
-\endcode
-
-\section1 Graphics and Special Effects
- \list
- \li \l{Basic Elements}{Basic Elements}
- \li \l{qtquick-canvas}{Painting with Canvas API}
- \li \l{Using the Qt Quick Particle System}{Particle Effects}
- \li \l{qtquick-shaders}{Shader Effects}
- \endlist
-
-\section1 Anchoring and Layouts
- \list
- \li \l{Item Layouts}
- \li \l{Layouts with Anchors}
- \li \l{Right-to-left User Interfaces}{Right-to-left User Interfaces}
- \endlist
-
-\section1 Mouse and Keyboard Input
-
- \list
- \li \l{Mouse Events}{Mouse Events}
- \li \l{Text Handling and Validators}{Text Handling and Validators}
- \li \l{Keyboard Focus in QML}{Keyboard Focus}
- \endlist
-
-\section1 States and Transitions
-
- \list
- \li \l{Qt Quick States}{States}
- \li \l{Animation and Transitions}
- \endlist
-
-\section1 Data with Models and Views
-
-\list
-\li \l{Models and Views}
-\endlist
-
-*/
diff --git a/src/quick/doc/src/visualtypes.qdoc b/src/quick/doc/src/visualtypes.qdoc
deleted file mode 100644
index a16c0a19c6..0000000000
--- a/src/quick/doc/src/visualtypes.qdoc
+++ /dev/null
@@ -1,35 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:FDL$
-** GNU Free Documentation License
-** Alternatively, this file may be used under the terms of the GNU Free
-** Documentation License version 1.3 as published by the Free Software
-** Foundation and appearing in the file included in the packaging of
-** this file.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms
-** and conditions contained in a signed written agreement between you
-** and Nokia.
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-\group qtquick-visual-types
-\title Qt Quick Visual Types
-\brief Visible items in a scene
-
-\section1 Related Types
-\generatelist{related}
-*/
diff --git a/src/quick/doc/src/whatsnew.qdoc b/src/quick/doc/src/whatsnew.qdoc
index 56cb341373..9c0046c4e0 100644
--- a/src/quick/doc/src/whatsnew.qdoc
+++ b/src/quick/doc/src/whatsnew.qdoc
@@ -28,7 +28,7 @@
 /*!
 \title What's New in Qt Quick 2
 \page qtquick2-whatsnew.html
-\inqmlmodule QtQuick 2
+\inqmlmodule QtQuick 2.0
 
 \section1 Qt 5.0.0 includes QtQuick 2.0
 
diff --git a/src/quick/items/context2d/qquickcanvasitem.cpp b/src/quick/items/context2d/qquickcanvasitem.cpp
index 24d71acf26..2d55acee35 100644
--- a/src/quick/items/context2d/qquickcanvasitem.cpp
+++ b/src/quick/items/context2d/qquickcanvasitem.cpp
@@ -207,6 +207,7 @@ QQuickCanvasItemPrivate::~QQuickCanvasItemPrivate()
     \since QtQuick 2.0
     \inherits Item
     \ingroup qtquick-canvas
+    \ingroup qtquick-visual
     \brief For specifying a 2D canvas element which enables drawing via Javascript
 
     The Canvas item allows drawing of straight and curved lines, simple and
diff --git a/src/quick/items/qquickaccessibleattached.cpp b/src/quick/items/qquickaccessibleattached.cpp
index 0f1565cfac..1cccc01b74 100644
--- a/src/quick/items/qquickaccessibleattached.cpp
+++ b/src/quick/items/qquickaccessibleattached.cpp
@@ -52,7 +52,7 @@ QT_BEGIN_NAMESPACE
     \brief Enables accessibility of QML items
 
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-visual-utility
     \ingroup accessibility
 
     This class is part of \l {Accessibility for Qt Quick Applications}.
diff --git a/src/quick/items/qquickanimatedimage.cpp b/src/quick/items/qquickanimatedimage.cpp
index 97e0f0b4e1..b4c1bd435a 100644
--- a/src/quick/items/qquickanimatedimage.cpp
+++ b/src/quick/items/qquickanimatedimage.cpp
@@ -57,7 +57,7 @@ QT_BEGIN_NAMESPACE
     \inqmlmodule QtQuick 2
     \inherits Image
     \brief Plays animations stored as a series of images
-    \ingroup qtquick-images
+    \ingroup qtquick-visual
 
     The AnimatedImage element extends the features of the \l Image element, providing
     a way to play animations stored as images containing a series of frames,
diff --git a/src/quick/items/qquickanimatedsprite.cpp b/src/quick/items/qquickanimatedsprite.cpp
index 79a8d007c7..be1c6a0308 100644
--- a/src/quick/items/qquickanimatedsprite.cpp
+++ b/src/quick/items/qquickanimatedsprite.cpp
@@ -211,7 +211,7 @@ struct AnimatedSpriteVertices {
     \qmlclass AnimatedSprite QQuickAnimatedSprite
     \inqmlmodule QtQuick 2
     \inherits Item
-    \ingroup qtquick-images-sprites
+    \ingroup qtquick-visual
     \brief Draws a sprite animation
 
     AnimatedSprite provides rendering and control over animations which are provided
diff --git a/src/quick/items/qquickborderimage.cpp b/src/quick/items/qquickborderimage.cpp
index 355a745c06..5d4ce7f494 100644
--- a/src/quick/items/qquickborderimage.cpp
+++ b/src/quick/items/qquickborderimage.cpp
@@ -59,7 +59,7 @@ QT_BEGIN_NAMESPACE
     \inqmlmodule QtQuick 2
     \brief For specifying an image that can be used as a border
     \inherits Item
-    \ingroup qtquick-item-graphics
+    \ingroup qtquick-visual
 
     The BorderImage element is used to create borders out of images by scaling or tiling
     parts of each image.
diff --git a/src/quick/items/qquickcanvas.cpp b/src/quick/items/qquickcanvas.cpp
index 3cd894349c..82fabd047b 100644
--- a/src/quick/items/qquickcanvas.cpp
+++ b/src/quick/items/qquickcanvas.cpp
@@ -749,7 +749,7 @@ void QQuickCanvasPrivate::cleanup(QSGNode *n)
 /*!
     \qmlclass Window QQuickCanvas
     \inqmlmodule QtQuick.Window 2
-    \ingroup qtquick-visual-types
+    \ingroup qtquick-visual
     \brief Creates a new top-level window
 
     The Window object creates a new top-level window for a QtQuick scene. It automatically sets up the
diff --git a/src/quick/items/qquickdrag.cpp b/src/quick/items/qquickdrag.cpp
index 722dbb6b97..2357e3a7db 100644
--- a/src/quick/items/qquickdrag.cpp
+++ b/src/quick/items/qquickdrag.cpp
@@ -108,7 +108,7 @@ public:
 /*!
     \qmlclass Drag QQuickDrag
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \brief For specifying drag and drop events for moved Items
 
     Using the Drag attached property any Item can made a source of drag and drop
diff --git a/src/quick/items/qquickdroparea.cpp b/src/quick/items/qquickdroparea.cpp
index 5080fcdd41..6c178c5c1f 100644
--- a/src/quick/items/qquickdroparea.cpp
+++ b/src/quick/items/qquickdroparea.cpp
@@ -91,7 +91,7 @@ QQuickDropAreaPrivate::~QQuickDropAreaPrivate()
 /*!
     \qmlclass DropArea QQuickDropArea
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \brief For specifying drag and drop handling in an area
 
     A DropArea is an invisible item which receives events when other items are
@@ -327,7 +327,7 @@ void QQuickDropArea::dropEvent(QDropEvent *event)
 /*!
     \qmlclass DragEvent QQuickDragEvent
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input-events
     \brief Provides information about a drag event
 
     The position of the drag event can be obtained from the \l x and \l y
diff --git a/src/quick/items/qquickevents.cpp b/src/quick/items/qquickevents.cpp
index b0aeeb79d3..b2e73af6f7 100644
--- a/src/quick/items/qquickevents.cpp
+++ b/src/quick/items/qquickevents.cpp
@@ -46,7 +46,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass KeyEvent QQuickKeyEvent
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input-events
 
     \brief Provides information about a key event
 
@@ -141,7 +141,7 @@ Item {
 /*!
     \qmlclass MouseEvent QQuickMouseEvent
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input-events
 
     \brief Provides information about a mouse event
 
@@ -239,8 +239,7 @@ Item {
 /*!
     \qmlclass WheelEvent QQuickWheelEvent
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
-
+    \ingroup qtquick-input-events
     \brief Provides information about a mouse wheel event
 
     The position of the mouse can be found via the \l x and \l y properties.
diff --git a/src/quick/items/qquickflickable.cpp b/src/quick/items/qquickflickable.cpp
index 9e65d962b2..0218aa55f0 100644
--- a/src/quick/items/qquickflickable.cpp
+++ b/src/quick/items/qquickflickable.cpp
@@ -585,7 +585,7 @@ is finished.
 /*!
     \qmlclass Flickable QQuickFlickable
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \ingroup qtquick-containers
 
     \brief For specifying a surface that can be "flicked"
diff --git a/src/quick/items/qquickflipable.cpp b/src/quick/items/qquickflipable.cpp
index 56dc20f762..502b0aa4f9 100644
--- a/src/quick/items/qquickflipable.cpp
+++ b/src/quick/items/qquickflipable.cpp
@@ -91,6 +91,7 @@ public:
     \qmlclass Flipable QQuickFlipable
     \inqmlmodule QtQuick 2
     \inherits Item
+    \ingroup qtquick-input
     \ingroup qtquick-containers
     \brief For specifying a surface that can be flipped
 
diff --git a/src/quick/items/qquickfocusscope.cpp b/src/quick/items/qquickfocusscope.cpp
index 52102a4e32..14a85629ea 100644
--- a/src/quick/items/qquickfocusscope.cpp
+++ b/src/quick/items/qquickfocusscope.cpp
@@ -46,7 +46,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass FocusScope QQuickFocusScope
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
 
     \brief Explicitly creates a focus scope
     \inherits Item
diff --git a/src/quick/items/qquickgridview.cpp b/src/quick/items/qquickgridview.cpp
index 65ca1aee25..dc9a04f1bb 100644
--- a/src/quick/items/qquickgridview.cpp
+++ b/src/quick/items/qquickgridview.cpp
@@ -1259,7 +1259,7 @@ bool QQuickGridViewPrivate::flick(AxisData &data, qreal minExtent, qreal maxExte
             \image gridview-layout-toptobottom-rtl-btt.png
     \endtable
 
-    \sa {declarative/modelviews/gridview}{GridView example}
+    \sa {quick/modelviews/gridview}{GridView example}
 */
 
 QQuickGridView::QQuickGridView(QQuickItem *parent)
diff --git a/src/quick/items/qquickimage.cpp b/src/quick/items/qquickimage.cpp
index 113bb3461e..aa68477a9d 100644
--- a/src/quick/items/qquickimage.cpp
+++ b/src/quick/items/qquickimage.cpp
@@ -94,7 +94,7 @@ QQuickImagePrivate::QQuickImagePrivate()
 /*!
     \qmlclass Image QQuickImage
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-images
+    \ingroup qtquick-visual
     \inherits Item
     \brief Displays an image in a declarative user interface
 
diff --git a/src/quick/items/qquickitem.cpp b/src/quick/items/qquickitem.cpp
index e10572fd48..00e01828be 100644
--- a/src/quick/items/qquickitem.cpp
+++ b/src/quick/items/qquickitem.cpp
@@ -129,7 +129,7 @@ void QQuickItemPrivate::registerAccessorProperties()
 /*!
     \qmlclass Transform QQuickTransform
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-transformations
+    \ingroup qtquick-visual-transforms
     \brief For specifying advanced transformations on Items
 
     The Transform element is a base type which cannot be instantiated directly.
@@ -151,7 +151,7 @@ void QQuickItemPrivate::registerAccessorProperties()
 /*!
     \qmlclass Translate QQuickTranslate
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-transformations
+    \ingroup qtquick-visual-transforms
     \brief Provides a way to move an Item without changing its x or y properties
 
     The Translate object provides independent control over position in addition to the Item's x and y properties.
@@ -193,7 +193,7 @@ void QQuickItemPrivate::registerAccessorProperties()
 /*!
     \qmlclass Scale QQuickScale
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-transformations
+    \ingroup qtquick-visual-transforms
     \brief Provides a way to scale an Item
 
     The Scale element gives more control over scaling than using \l Item's \l{Item::scale}{scale} property. Specifically,
@@ -235,7 +235,7 @@ void QQuickItemPrivate::registerAccessorProperties()
 /*!
     \qmlclass Rotation QQuickRotation
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-transformations
+    \ingroup qtquick-visual-transforms
     \brief Provides a way to rotate an Item
 
     The Rotation object gives more control over rotation than using \l Item's \l{Item::rotation}{rotation} property.
@@ -503,7 +503,7 @@ void QQuickItemKeyFilter::componentComplete()
 /*!
     \qmlclass KeyNavigation QQuickKeyNavigationAttached
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \brief Supports key navigation by arrow keys
 
     Key-based user interfaces commonly allow the use of arrow keys to navigate between
@@ -917,7 +917,7 @@ bool QQuickKeysAttached::isConnected(const char *signalName)
 /*!
     \qmlclass Keys QQuickKeysAttached
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \brief Provides key handling to Items
 
     All visual primitives support key handling via the Keys
@@ -1463,7 +1463,7 @@ QQuickKeysAttached *QQuickKeysAttached::qmlAttachedProperties(QObject *obj)
 /*!
     \qmlclass LayoutMirroring QQuickLayoutMirroringAttached
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-positioners
     \ingroup qml-utility-elements
     \brief Property used to mirror layout behavior
 
@@ -1722,7 +1722,7 @@ void QQuickItemPrivate::updateSubFocusItem(QQuickItem *scope, bool focus)
     \qmlclass Item QQuickItem
     \inherits QtObject
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-visual-types
+    \ingroup qtquick-visual
     \brief A basic visual QML type
 
     All visual items in Qt Quick inherit from Item.  Although Item
diff --git a/src/quick/items/qquickitemanimation.cpp b/src/quick/items/qquickitemanimation.cpp
index c6e87bb72e..9c8dae2e07 100644
--- a/src/quick/items/qquickitemanimation.cpp
+++ b/src/quick/items/qquickitemanimation.cpp
@@ -560,7 +560,7 @@ QAbstractAnimationJob* QQuickAnchorAnimation::transition(QQuickStateActions &act
 /*!
     \qmlclass PathAnimation QQuickPathAnimation
     \inqmlmodule QtQuick 2
-    \ingroup qml-animation-transition
+    \ingroup qtquick-animation-properties
     \inherits Animation
     \since QtQuick 2.0
     \brief Animates an item along a path
diff --git a/src/quick/items/qquickitemviewtransition.cpp b/src/quick/items/qquickitemviewtransition.cpp
index 3411d7a34b..01a132452b 100644
--- a/src/quick/items/qquickitemviewtransition.cpp
+++ b/src/quick/items/qquickitemviewtransition.cpp
@@ -568,7 +568,7 @@ QQuickViewTransitionAttached::QQuickViewTransitionAttached(QObject *parent)
 /*!
     \qmlclass ViewTransition QQuickViewTransitionAttached
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-properties
+    \ingroup qtquick-transitions-animations
     \brief Specifies items under transition in a view
 
     With ListView and GridView, it is possible to specify transitions that should be applied whenever
diff --git a/src/quick/items/qquicklistview.cpp b/src/quick/items/qquicklistview.cpp
index 17851cd76b..5e91ec429a 100644
--- a/src/quick/items/qquicklistview.cpp
+++ b/src/quick/items/qquicklistview.cpp
@@ -1725,7 +1725,7 @@ bool QQuickListViewPrivate::flick(AxisData &data, qreal minExtent, qreal maxExte
             \image listview-layout-righttoleft.png
     \endtable
 
-    \sa {QML Data Models}, GridView, {declarative/modelviews/listview}{ListView examples}
+    \sa {QML Data Models}, GridView, {quick/modelviews/listview}{ListView examples}
 */
 QQuickListView::QQuickListView(QQuickItem *parent)
     : QQuickItemView(*(new QQuickListViewPrivate), parent)
@@ -1887,7 +1887,7 @@ QQuickListView::~QQuickListView()
     so as to stay with the current item, unless the highlightFollowsCurrentItem
     property is false.
 
-    \sa highlightItem, highlightFollowsCurrentItem, {declarative/modelviews/listview}{ListView examples}
+    \sa highlightItem, highlightFollowsCurrentItem, {quick/modelviews/listview}{ListView examples}
 */
 
 /*!
@@ -2173,7 +2173,7 @@ void QQuickListView::setOrientation(QQuickListView::Orientation orientation)
     differing sections will result in a section header being created
     even if that section exists elsewhere.
 
-    \sa {declarative/modelviews/listview}{ListView examples}
+    \sa {quick/modelviews/listview}{ListView examples}
 */
 QQuickViewSection *QQuickListView::sectionCriteria()
 {
diff --git a/src/quick/items/qquickloader.cpp b/src/quick/items/qquickloader.cpp
index a5740ac467..7945a359cc 100644
--- a/src/quick/items/qquickloader.cpp
+++ b/src/quick/items/qquickloader.cpp
@@ -160,7 +160,7 @@ qreal QQuickLoaderPrivate::getImplicitHeight() const
 /*!
     \qmlclass Loader QQuickLoader
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-dynamic
     \inherits Item
 
     \brief Allows dynamic loading of a subtree from a URL or Component
diff --git a/src/quick/items/qquickmousearea.cpp b/src/quick/items/qquickmousearea.cpp
index c1d1c9dd8d..f114292ad7 100644
--- a/src/quick/items/qquickmousearea.cpp
+++ b/src/quick/items/qquickmousearea.cpp
@@ -311,7 +311,7 @@ bool QQuickMouseAreaPrivate::propagateHelper(QQuickMouseEvent *ev, QQuickItem *i
 /*!
     \qmlclass MouseArea QQuickMouseArea
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \brief Enables simple mouse handling
     \inherits Item
 
diff --git a/src/quick/items/qquickmultipointtoucharea.cpp b/src/quick/items/qquickmultipointtoucharea.cpp
index f1b4596a14..f980fdce6c 100644
--- a/src/quick/items/qquickmultipointtoucharea.cpp
+++ b/src/quick/items/qquickmultipointtoucharea.cpp
@@ -55,7 +55,7 @@ DEFINE_BOOL_CONFIG_OPTION(qmlVisualTouchDebugging, QML_VISUAL_TOUCH_DEBUGGING)
 /*!
     \qmlclass TouchPoint QQuickTouchPoint
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input-events
     \brief Describes a touch point in a MultiPointTouchArea
 
     The TouchPoint element contains information about a touch point, such as the current
@@ -225,7 +225,7 @@ void QQuickTouchPoint::setSceneY(qreal sceneY)
     \qmlclass MultiPointTouchArea QQuickMultiPointTouchArea
     \inqmlmodule QtQuick 2
     \inherits Item
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \brief Enables handling of multiple touch points
 
 
diff --git a/src/quick/items/qquickpathview.cpp b/src/quick/items/qquickpathview.cpp
index 883edeca48..1c3b9aaf46 100644
--- a/src/quick/items/qquickpathview.cpp
+++ b/src/quick/items/qquickpathview.cpp
@@ -498,7 +498,7 @@ void QQuickPathViewPrivate::regenerate()
     to set \e {clip: true} in order to have the out of view items clipped
     nicely.
 
-    \sa Path, {declarative/modelviews/pathview}{PathView example}
+    \sa Path, {quick/modelviews/pathview}{PathView example}
 */
 
 QQuickPathView::QQuickPathView(QQuickItem *parent)
diff --git a/src/quick/items/qquickpincharea.cpp b/src/quick/items/qquickpincharea.cpp
index 90885d12c9..8c1c7bd096 100644
--- a/src/quick/items/qquickpincharea.cpp
+++ b/src/quick/items/qquickpincharea.cpp
@@ -54,7 +54,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass PinchEvent QQuickPinchEvent
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input-events
     \brief For specifying information about a pinch event
 
     \b {The PinchEvent element was added in QtQuick 1.1}
@@ -163,7 +163,7 @@ QQuickPinchAreaPrivate::~QQuickPinchAreaPrivate()
 /*!
     \qmlclass PinchArea QQuickPinchArea
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-interaction
+    \ingroup qtquick-input
     \inherits Item
     \brief Enables simple pinch gesture handling
 
diff --git a/src/quick/items/qquickrectangle.cpp b/src/quick/items/qquickrectangle.cpp
index f912d57954..3137ba93fd 100644
--- a/src/quick/items/qquickrectangle.cpp
+++ b/src/quick/items/qquickrectangle.cpp
@@ -130,7 +130,7 @@ bool QQuickPen::isValid() const
 /*!
     \qmlclass GradientStop QQuickGradientStop
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-item-graphics
+    \ingroup qtquick-visual-utility
     \brief Defines the color at a position in a Gradient
 
     \sa Gradient
@@ -181,7 +181,7 @@ void QQuickGradientStop::updateGradient()
 /*!
     \qmlclass Gradient QQuickGradient
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-item-graphics
+    \ingroup qtquick-visual-utility
     \brief Defines a gradient fill
 
     A gradient is defined by two or more colors, which will be blended seamlessly.
@@ -281,7 +281,7 @@ int QQuickRectanglePrivate::doUpdateSlotIdx = -1;
     \qmlclass Rectangle QQuickRectangle
     \inqmlmodule QtQuick 2
     \inherits Item
-    \ingroup qtquick-visual-types
+    \ingroup qtquick-visual
     \brief Describes a filled rectangle with an optional border
 
     Rectangle items are used to fill areas with solid color or gradients, and are
diff --git a/src/quick/items/qquickrepeater.cpp b/src/quick/items/qquickrepeater.cpp
index 8d034e5839..c688fade92 100644
--- a/src/quick/items/qquickrepeater.cpp
+++ b/src/quick/items/qquickrepeater.cpp
@@ -65,6 +65,7 @@ QQuickRepeaterPrivate::~QQuickRepeaterPrivate()
     \qmlclass Repeater QQuickRepeater
     \inqmlmodule QtQuick 2
     \ingroup qtquick-models
+    \ingroup qtquick-positioning
     \inherits Item
     \brief Specifies how to repeately create an Item-based component using a model
 
diff --git a/src/quick/items/qquickscreen.cpp b/src/quick/items/qquickscreen.cpp
index c3d32eb1c3..17f4ebc1f0 100644
--- a/src/quick/items/qquickscreen.cpp
+++ b/src/quick/items/qquickscreen.cpp
@@ -52,7 +52,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass Screen QQuickScreenAttached
     \inqmlmodule QtQuick.Window 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-visual-utility
     \brief The Screen attached object provides information about the Screen an Item is displayed on.
 
     The Screen attached object is only valid inside Item or Item derived elements, after component completion.
diff --git a/src/quick/items/qquickshadereffect.cpp b/src/quick/items/qquickshadereffect.cpp
index c14b8f2f29..ebc7d8f684 100644
--- a/src/quick/items/qquickshadereffect.cpp
+++ b/src/quick/items/qquickshadereffect.cpp
@@ -536,7 +536,7 @@ void QQuickShaderEffectCommon::propertyChanged(QQuickItem *item, int mappedId,
     \qmlclass ShaderEffect QQuickShaderEffect
     \inqmlmodule QtQuick 2
     \inherits Item
-    \ingroup qtquick-shaders
+    \ingroup qtquick-effects
     \brief Applies custom shaders to a rectangle
 
     The ShaderEffect element applies a custom OpenGL
diff --git a/src/quick/items/qquickshadereffectmesh.cpp b/src/quick/items/qquickshadereffectmesh.cpp
index a0d589780b..d1110c5a5b 100644
--- a/src/quick/items/qquickshadereffectmesh.cpp
+++ b/src/quick/items/qquickshadereffectmesh.cpp
@@ -53,7 +53,7 @@ QQuickShaderEffectMesh::QQuickShaderEffectMesh(QObject *parent)
 /*!
     \qmlclass GridMesh QQuickGridMesh
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-shaders
+    \ingroup qtquick-effects
     \brief Defines a mesh with vertices arranged in a grid
 
     GridMesh defines a rectangular mesh consisting of vertices arranged in an
diff --git a/src/quick/items/qquickshadereffectsource.cpp b/src/quick/items/qquickshadereffectsource.cpp
index 7fbab0d604..71a0aafe4b 100644
--- a/src/quick/items/qquickshadereffectsource.cpp
+++ b/src/quick/items/qquickshadereffectsource.cpp
@@ -456,7 +456,7 @@ QImage QQuickShaderEffectTexture::toImage() const
     \qmlclass ShaderEffectSource QQuickShaderEffectSource
     \since 5.0
     \inherits Item
-    \ingroup qtquick-shaders
+    \ingroup qtquick-effects
     \brief Renders a QML element into a texture and displays it
 
     The ShaderEffectSource element renders \l sourceItem into a texture and
diff --git a/src/quick/items/qquicksprite.cpp b/src/quick/items/qquicksprite.cpp
index 1628ed7633..8d56612a6c 100644
--- a/src/quick/items/qquicksprite.cpp
+++ b/src/quick/items/qquicksprite.cpp
@@ -48,7 +48,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass Sprite QQuickSprite
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-images-sprites
+    \ingroup qtquick-visual-utility
     \brief Specifies sprite animations
 
     QQuickSprite renders sprites of one or more frames and animates them. The sprites
diff --git a/src/quick/items/qquickspritesequence.cpp b/src/quick/items/qquickspritesequence.cpp
index 0e7d998fbb..feb43a4e3d 100644
--- a/src/quick/items/qquickspritesequence.cpp
+++ b/src/quick/items/qquickspritesequence.cpp
@@ -209,7 +209,7 @@ struct SpriteVertices {
 /*!
     \qmlclass SpriteSequence QQuickSpriteSequence
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-images-sprites
+    \ingroup qtquick-visual-utility
     \inherits Item
     \brief Draws a sprite animation
 
diff --git a/src/quick/items/qquicktext.cpp b/src/quick/items/qquicktext.cpp
index 4ab56494a0..f03afd657a 100644
--- a/src/quick/items/qquicktext.cpp
+++ b/src/quick/items/qquicktext.cpp
@@ -1139,7 +1139,7 @@ void QQuickTextPrivate::ensureDoc()
 /*!
     \qmlclass Text QQuickText
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-text
+    \ingroup qtquick-visual
     \inherits Item
     \brief Specifies how to add formatted text to a scene
 
diff --git a/src/quick/items/qquicktextedit.cpp b/src/quick/items/qquicktextedit.cpp
index 4b55ff1bd5..058b8161c4 100644
--- a/src/quick/items/qquicktextedit.cpp
+++ b/src/quick/items/qquicktextedit.cpp
@@ -67,7 +67,8 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass TextEdit QQuickTextEdit
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-text
+    \ingroup qtquick-visual
+    \ingroup qtquick-input
     \inherits Item
     \brief Displays multiple lines of editable formatted text
 
diff --git a/src/quick/items/qquicktextinput.cpp b/src/quick/items/qquicktextinput.cpp
index 477cf1c222..a8d10f3daf 100644
--- a/src/quick/items/qquicktextinput.cpp
+++ b/src/quick/items/qquicktextinput.cpp
@@ -68,7 +68,8 @@ DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD)
 /*!
     \qmlclass TextInput QQuickTextInput
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-text
+    \ingroup qtquick-visual
+    \ingroup qtquick-input
     \inherits Item
     \brief Displays an editable line of text
 
@@ -844,7 +845,7 @@ void QQuickTextInput::setAutoScroll(bool b)
 /*!
     \qmlclass IntValidator QIntValidator
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-text-validator
+    \ingroup qtquick-text-utility
     \brief Defines a validator for integer values
 
     This element provides a validator for integer values.
@@ -907,7 +908,7 @@ void QQuickIntValidator::resetLocaleName()
 /*!
     \qmlclass DoubleValidator QDoubleValidator
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-text-validator
+    \ingroup qtquick-text-utility
     \brief Defines a validator for non-integer numbers
 
     This element provides a validator for non-integer numbers.
@@ -1000,7 +1001,7 @@ void QQuickDoubleValidator::resetLocaleName()
 /*!
     \qmlclass RegExpValidator QRegExpValidator
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-text-validator
+    \ingroup qtquick-text-utility
     \brief Provides a string validator
 
     This element provides a validator, which counts as valid any string which
diff --git a/src/quick/items/qquickview.cpp b/src/quick/items/qquickview.cpp
index b3fba60fb8..20575d4af9 100644
--- a/src/quick/items/qquickview.cpp
+++ b/src/quick/items/qquickview.cpp
@@ -144,7 +144,7 @@ void QQuickViewPrivate::itemGeometryChanged(QQuickItem *resizeItem, const QRectF
     you can connect to the statusChanged() signal and monitor for QQuickView::Error.
     The errors are available via QQuickView::errors().
 
-    \sa {Using QML Bindings in C++ Applications}
+    \sa {Exposing C++ Data to QML}
 */
 
 
diff --git a/src/quick/items/qquickvisualitemmodel.cpp b/src/quick/items/qquickvisualitemmodel.cpp
index 2cd9106c4a..8405a41c80 100644
--- a/src/quick/items/qquickvisualitemmodel.cpp
+++ b/src/quick/items/qquickvisualitemmodel.cpp
@@ -150,7 +150,7 @@ public:
 
     \image visualitemmodel.png
 
-    \sa {declarative/modelviews/visualitemmodel}{VisualItemModel example}
+    \sa {quick/modelviews/visualitemmodel}{VisualItemModel example}
 */
 QQuickVisualItemModel::QQuickVisualItemModel(QObject *parent)
     : QQuickVisualModel(*(new QQuickVisualItemModelPrivate), parent)
diff --git a/src/quick/util/qquickanimation.cpp b/src/quick/util/qquickanimation.cpp
index 8162aaeee3..ebdde58c63 100644
--- a/src/quick/util/qquickanimation.cpp
+++ b/src/quick/util/qquickanimation.cpp
@@ -72,7 +72,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass Animation QQuickAbstractAnimation
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-properties
+    \ingroup qtquick-transitions-animations
     \brief Is the base of all QML animations
 
     The Animation element cannot be used directly in a QML file.  It exists
@@ -617,7 +617,7 @@ void QQuickAbstractAnimationPrivate::animationFinished(QAbstractAnimationJob*)
 /*!
     \qmlclass PauseAnimation QQuickPauseAnimation
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-modifiers
+    \ingroup qtquick-transitions-animations
     \inherits Animation
     \brief Provides a pause for an animation
 
@@ -831,7 +831,7 @@ void QActionAnimation::updateState(State newState, State oldState)
 /*!
     \qmlclass ScriptAction QQuickScriptAction
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-modifiers
+    \ingroup qtquick-transitions-animations
     \inherits Animation
     \brief Defines scripts to be run during an animation
 
@@ -957,7 +957,7 @@ QAbstractAnimationJob* QQuickScriptAction::transition(QQuickStateActions &action
 /*!
     \qmlclass PropertyAction QQuickPropertyAction
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-modifiers
+    \ingroup qtquick-transitions-animations
     \inherits Animation
     \brief Specifies immediate property changes during animation
 
@@ -1637,7 +1637,7 @@ QQmlListProperty<QQuickAbstractAnimation> QQuickAnimationGroup::animations()
 /*!
     \qmlclass SequentialAnimation QQuickSequentialAnimation
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-define
+    \ingroup qtquick-transitions-animations
     \inherits Animation
     \brief Allows animations to be run sequentially
 
@@ -1710,7 +1710,7 @@ QAbstractAnimationJob* QQuickSequentialAnimation::transition(QQuickStateActions
 /*!
     \qmlclass ParallelAnimation QQuickParallelAnimation
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-define
+    \ingroup qtquick-transitions-animations
     \inherits Animation
     \brief Enables animations to be run in parallel
 
diff --git a/src/quick/util/qquickbehavior.cpp b/src/quick/util/qquickbehavior.cpp
index 0de99d4db1..ee8a1e494d 100644
--- a/src/quick/util/qquickbehavior.cpp
+++ b/src/quick/util/qquickbehavior.cpp
@@ -75,7 +75,8 @@ public:
 /*!
     \qmlclass Behavior QQuickBehavior
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-define
+    \ingroup qtquick-transitions-animations
+    \ingroup qtquick-interceptors
     \brief Defines a default animation for a property change
 
     A Behavior defines the default animation to be applied whenever a
diff --git a/src/quick/util/qquickbind.cpp b/src/quick/util/qquickbind.cpp
index bd57efb29b..0a1cd27a76 100644
--- a/src/quick/util/qquickbind.cpp
+++ b/src/quick/util/qquickbind.cpp
@@ -77,7 +77,7 @@ public:
 /*!
     \qmlclass Binding QQuickBind
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-interceptors
     \brief Enables the arbitrary creation of property bindings
 
     \section1 Binding to an inaccessible property
diff --git a/src/quick/util/qquickconnections.cpp b/src/quick/util/qquickconnections.cpp
index be3d9539c5..9b086b9e03 100644
--- a/src/quick/util/qquickconnections.cpp
+++ b/src/quick/util/qquickconnections.cpp
@@ -73,7 +73,7 @@ public:
 /*!
     \qmlclass Connections QQuickConnections
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-interceptors
     \brief Describes generalized connections to signals
 
     A Connections object creates a connection to a QML signal.
diff --git a/src/quick/util/qquickfontloader.cpp b/src/quick/util/qquickfontloader.cpp
index 7e5f3de9af..1d982ce14c 100644
--- a/src/quick/util/qquickfontloader.cpp
+++ b/src/quick/util/qquickfontloader.cpp
@@ -148,7 +148,7 @@ QHash<QUrl, QQuickFontObject*> QQuickFontLoaderPrivate::fonts;
 /*!
     \qmlclass FontLoader QQuickFontLoader
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-text-utility
     \brief Allows fonts to be loaded by name or URL
 
     The FontLoader element is used to load fonts by name or URL.
diff --git a/src/quick/util/qquickimageprovider.cpp b/src/quick/util/qquickimageprovider.cpp
index b0bbf46489..42da519f58 100644
--- a/src/quick/util/qquickimageprovider.cpp
+++ b/src/quick/util/qquickimageprovider.cpp
@@ -189,7 +189,7 @@ QImage QQuickTextureFactory::image() const
     \image imageprovider.png
 
     A complete example is available in Qt's 
-    \l {declarative/cppextensions/imageprovider}{examples/qml/cppextensions/imageprovider}
+    \l {qml/cppextensions/imageprovider}{examples/qml/cppextensions/imageprovider}
     directory. Note the example registers the provider via a \l{QQmlExtensionPlugin}{plugin}
     instead of registering it in the application \c main() function as shown above.
 
diff --git a/src/quick/util/qquickpackage.cpp b/src/quick/util/qquickpackage.cpp
index 059a55ea88..33632357e9 100644
--- a/src/quick/util/qquickpackage.cpp
+++ b/src/quick/util/qquickpackage.cpp
@@ -72,7 +72,7 @@ QT_BEGIN_NAMESPACE
 
     \snippet examples/quick/modelviews/package/view.qml 0
 
-    \sa {declarative/modelviews/package}{Package example}, {declarative/photoviewer}{Photo Viewer example}, QtQml
+    \sa {quick/modelviews/package}{Package example}, {declarative/photoviewer}{Photo Viewer example}, QtQml
 */
 
 /*!
diff --git a/src/quick/util/qquickpath.cpp b/src/quick/util/qquickpath.cpp
index b1adfe3d68..ff220c61df 100644
--- a/src/quick/util/qquickpath.cpp
+++ b/src/quick/util/qquickpath.cpp
@@ -55,7 +55,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass PathElement QQuickPathElement
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief PathElement is the base path type
 
     This type is the base for all path types.  It cannot
@@ -67,7 +67,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass Path QQuickPath
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Defines a path for use by \l PathView
 
     A Path is composed of one or more path segments - PathLine, PathQuad,
@@ -805,7 +805,7 @@ bool QQuickCurve::hasRelativeY()
 /*!
     \qmlclass PathAttribute QQuickPathAttribute
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Specifies how to set an attribute at a given position in a Path
 
     The PathAttribute object allows attributes consisting of a name and
@@ -921,7 +921,7 @@ void QQuickPathAttribute::setValue(qreal value)
 /*!
     \qmlclass PathLine QQuickPathLine
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Defines a straight line
 
     The example below creates a path consisting of a straight line from
@@ -979,7 +979,7 @@ void QQuickPathLine::addToPath(QPainterPath &path, const QQuickPathData &data)
 /*!
     \qmlclass PathQuad QQuickPathQuad
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Defines a quadratic Bezier curve with a control point
 
     The following QML produces the path shown below:
@@ -1130,7 +1130,7 @@ void QQuickPathQuad::addToPath(QPainterPath &path, const QQuickPathData &data)
 /*!
     \qmlclass PathCubic QQuickPathCubic
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Defines a cubic Bezier curve with two control points
 
     The following QML produces the path shown below:
@@ -1353,7 +1353,7 @@ void QQuickPathCubic::addToPath(QPainterPath &path, const QQuickPathData &data)
 /*!
     \qmlclass PathCurve QQuickPathCurve
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Defines a point on a Catmull-Rom curve
 
     PathCurve provides an easy way to specify a curve passing directly through a set of points.
@@ -1498,7 +1498,7 @@ void QQuickPathCatmullRomCurve::addToPath(QPainterPath &path, const QQuickPathDa
 /*!
     \qmlclass PathArc QQuickPathArc
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Defines an arc with the given radius
 
     PathArc provides a simple way of specifying an arc that ends at a given position
@@ -1668,7 +1668,7 @@ void QQuickPathArc::addToPath(QPainterPath &path, const QQuickPathData &data)
 /*!
     \qmlclass PathSvg QQuickPathSvg
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Defines a path using an SVG path data string
 
     The following QML produces the path shown below:
@@ -1720,7 +1720,7 @@ void QQuickPathSvg::addToPath(QPainterPath &path, const QQuickPathData &)
 /*!
     \qmlclass PathPercent QQuickPathPercent
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-paths
+    \ingroup qtquick-animation-paths
     \brief Manipulates the way a path is interpreted
 
     PathPercent allows you to manipulate the spacing between items on a
diff --git a/src/quick/util/qquicksmoothedanimation.cpp b/src/quick/util/qquicksmoothedanimation.cpp
index b4986c0479..49dce04db3 100644
--- a/src/quick/util/qquicksmoothedanimation.cpp
+++ b/src/quick/util/qquicksmoothedanimation.cpp
@@ -309,7 +309,7 @@ void QSmoothedAnimation::init()
 /*!
     \qmlclass SmoothedAnimation QQuickSmoothedAnimation
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-properties
+    \ingroup qtquick-transitions-animations
     \inherits NumberAnimation
     \brief Allows a property to smoothly track a value
 
diff --git a/src/quick/util/qquickspringanimation.cpp b/src/quick/util/qquickspringanimation.cpp
index 3e0a1ce755..413f95edb3 100644
--- a/src/quick/util/qquickspringanimation.cpp
+++ b/src/quick/util/qquickspringanimation.cpp
@@ -342,7 +342,7 @@ void QQuickSpringAnimationPrivate::updateMode()
 /*!
     \qmlclass SpringAnimation QQuickSpringAnimation
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-properties
+    \ingroup qtquick-transitions-animations
     \inherits NumberAnimation
 
     \brief Allows a property to track a value in a spring-like motion
diff --git a/src/quick/util/qquicksystempalette.cpp b/src/quick/util/qquicksystempalette.cpp
index 1cbde6ef5a..b500f204f0 100644
--- a/src/quick/util/qquicksystempalette.cpp
+++ b/src/quick/util/qquicksystempalette.cpp
@@ -59,7 +59,7 @@ public:
 /*!
     \qmlclass SystemPalette QQuickSystemPalette
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-visual-utility
     \brief Provides access to the Qt palettes
 
     The SystemPalette element provides access to the Qt application
diff --git a/src/quick/util/qquicktimer.cpp b/src/quick/util/qquicktimer.cpp
index 84ede7b038..88dc0790d9 100644
--- a/src/quick/util/qquicktimer.cpp
+++ b/src/quick/util/qquicktimer.cpp
@@ -75,7 +75,7 @@ public:
 /*!
     \qmlclass Timer QQuickTimer
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-utility
+    \ingroup qtquick-interceptors
     \brief Triggers a handler at a specified interval
 
     A Timer can be used to trigger an action either once, or repeatedly
diff --git a/src/quick/util/qquicktransition.cpp b/src/quick/util/qquicktransition.cpp
index 2431642082..de32fefd18 100644
--- a/src/quick/util/qquicktransition.cpp
+++ b/src/quick/util/qquicktransition.cpp
@@ -55,7 +55,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass Transition QQuickTransition
     \inqmlmodule QtQuick 2
-    \ingroup qtquick-animation-define
+    \ingroup qtquick-transitions-animations
     \brief Defines animated transitions that occur on state changes
 
     A Transition defines the animations to be applied when a \l State change occurs.