30 files changed, 724 insertions, 914 deletions

diff --git a/src/quick/doc/src/concepts/components.qdoc b/src/quick/doc/src/concepts/components.qdoc
deleted file mode 100644
index 5050e535bb..0000000000
--- a/src/quick/doc/src/concepts/components.qdoc
+++ /dev/null
@@ -1,514 +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-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{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
-sets of operations, instead of creating mammoth QML files with large, combined functionality
-that is more difficult to manage and may contain duplicated code.
-
-
-\section1 Defining New Components
-
-A component is a reusable type with a well-defined interface, built entirely in QML.
-Any snippet of QML code can become a component, by placing the code in a file "<Name>.qml" where
-<Name> is the new component name, beginning with an uppercase letter. These QML files automatically
-become available as new QML element types to other QML components and applications in the same directory.
-
-For example, one of the simplest and most common components you can build in QML is a
-button-type component. Below, we implement this component as a \l Rectangle with a clickable
-\l MouseArea, in a file named \c Button.qml:
-
-\snippet qml/qml-extending-types/components/Button.qml 0
-
-Now this component can be reused by another file within the same directory. Since the file is
-named \c Button.qml, the component is referred to as \c Button:
-
-\table
-\row
-\li \snippet qml/qml-extending-types/components/application.qml 0
-\li \image qml-extending-types.png
-\endtable
-
-The root object in \c Button.qml defines the attributes that are available to users of the
-\c Button component. In this case, the root object is a \l Rectangle, so any properties, methods
-and signals of \l Rectangle are made available, allowing \c application.qml to
-customize the \c width, \c height, \c radius and \c color properties of \c Button objects.
-
-
-If \c Button.qml was not in the same directory, \c application.qml would need to load it as a
-\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
-QML component will be deployed.
-
-To write a useful component, it is generally necessary to provide it with custom attributes that store and
-communicate specific data. This is achieved by adding the following attributes to your components:
-
-\list
-\li \b Properties that can be accessed externally to modify an object (for example, \l Item has
-   \l {Item::}{width} and \l {Item::}{height} properties) and used in \l {Property Binding}
-\li \b Methods of JavaScript code can be invoked internally or externally (for example,
-   \l Animation has a \l {Animation::}{start()} method)
-\li \b Signals to notify other objects when an event has occurred (for example, MouseArea has a
-   \c clicked signal)
-\endlist
-
-The following sections show how these attributes can be added to QML components.
-
-
-\section1 Adding Properties
-
-A property is a value of a QML component that can be read and modified by other objects. For
-example, a \l Rectangle component has \l {Item::}{width}, \l {Item::}{height} and \l
-{Rectangle::}{color} properties. Significantly, properties be used with \l {Property Binding}, where
-a property value is automatically updated using the value of another property.
-
-The syntax for defining a new property is:
-
-\code
-[default] property <type> <name>[: defaultValue]
-\endcode
-
-A \c property declaration can appear anywhere within a QML component definition, but it is customary
-to place it at the top. A component cannot declare more than one property with the same name. (It is
-possible to have a property name that is the same as an existing property in a type, but this is not
-recommended as the existing property becomes hidden and inaccessible.)
-
-Below is an example. The \c ImageViewer component has defined a \c string type property named
-\c currentImage, and its initial value is "default-image.png". This property is used to set the image
-displayed in the child \l Image object. Another file, \c application.qml, can create
-an \c ImageViewer object and read or modify the \c currentImage value:
-
-\table
-\row
-\li \snippet qml/qml-extending-types/properties/ImageViewer.qml 0
-\li \snippet qml/qml-extending-types/properties/application.qml 0
-\endtable
-
-It is optional for a property to have a default value. The default value is a convenient shortcut, and is
-behaviorally identical to doing it in two steps, like this:
-
-\qml
-import QtQuick 2.0
-
-Item {
-    // Use default value
-    property int myProperty: 10
-
-    // Longer, but behaviorally identical
-    property int myProperty
-    myProperty: 10
-}
-\endqml
-
-
-\section2 Supported property types
-
-All QML properties are typed. The examples above show properties with \c int and \c string types;
-notice that the type of the property must be declared. The type is used to determine the property
-behavior, and how the property is defined in C++.
-
-A number of property types are supported by default. These are listed in the table below,
-with their default values and the corresponding C++ type:
-
-\table
-\header \li QML Type Name \li Default value \li C++ Type Name
-\row \li \l int \li 0 \li int
-\row \li \l bool \li \c false \li bool
-\row \li \l double \li 0.0 \li double
-\row \li \l real \li 0.0 \li double
-\row \li \l string \li "" (empty string) \li QString
-\row \li \l url \li "" (empty url) \li QUrl
-\row \li \l color \li #000000 (black) \li QColor
-\row \li \l date \li \c undefined \li QDateTime
-\row \li \l variant \li \c undefined \li QVariant
-\endtable
-
-QML object types can also be used as property types. This includes
-\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
-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.
-
-It is also possible to store a copy of a JavaScript object using the \c variant
-property type. This creates some restrictions on how the property should be used;
-see the \l {variant}{variant type documentation} for details.
-
-\l{list}{List properties} are created with the \c list<Type> syntax, and default to an empty
-list:
-
-\qml
-import QtQuick 2.0
-
-Item {
-    property list<Item> listOfItems
-}
-\endqml
-
-Note that list properties cannot be modified like ordinary JavaScript
-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{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.
-
-For example, the following \c onMyNumberChanged signal handler is automatically called whenever the
-\c myNumber property changes:
-
-\snippet qml/qml-extending-types/properties/property-signals.qml 0
-
-
-\section2 Default properties
-
-The optional \c default attribute for a property marks it as the \e {default property}
-for a type. This allows other items to specify the default property's value
-as child elements. For example, the \l Item element's default property is its
-\l{Item::children}{children} property. This allows the children of an \l Item
-to be set like this:
-
-\qml
-Item {
-    Rectangle {}
-    Rectangle {}
-}
-\endqml
-
-If the \l{Item::children}{children} property was not the default property for
-\l Item, its value would have to be set like this instead:
-
-\qml
-Item {
-    children: [
-        Rectangle {},
-        Rectangle {}
-    ]
-}
-\endqml
-
-See the \l{declarative/ui-components/tabwidget}{TabWidget} example for a
-demonstration of using default properties.
-
-Specifying a default property overrides any existing default property (for
-example, any default property inherited from a parent item). Using the
-\c default attribute twice in the same type block is an error.
-
-
-\section2 Property aliases
-
-Property aliases are a more advanced form of property declaration.  Unlike a
-property definition, which allocates a new, unique storage space for the
-property, a property alias connects the newly declared property (called the
-aliasing property) as a direct reference to an existing property (the aliased property).  Read
-operations on the aliasing property act as read operations on the aliased
-property, and write operations on the aliasing property as write operations on
-the aliased property.
-
-A property alias declaration looks a lot like an ordinary property definition:
-\code
-    [default] property alias <name>: <alias reference>
-\endcode
-
-As the aliasing property has the same type as the aliased property, an explicit
-type is omitted, and the special "alias" keyword is used.  Instead of a default
-value, a property alias includes a compulsory alias reference.  The alias
-reference is used to locate the aliased property.  While similar to a property
-binding, the alias reference syntax is highly restricted.
-
-An alias reference takes one of the following forms:
-\code
-    <id>.<property>
-    <id>
-\endcode
-
-where <id> must refer to an object id within the same component as the type
-declaring the alias, and, optionally, <property> refers to a property on that object.
-
-For example, below is a \c Button.qml component with a \c buttonText aliased property which is
-connected to the child Text object's \c text property:
-
-\snippet qml/qml-extending-types/properties/alias.qml 0
-
-The following code would create a \c Button with a defined text string for the
-child \l Text object:
-
-\qml
-Button { buttonText: "This is a button" }
-\endqml
-
-Here, modifying \c buttonText directly modifies the \c textItem.text value; it does not
-change some other value that then updates \c textItem.text.
-
-In this case, the use of aliased properties is essential. If \c buttonText was not an alias,
-changing its value would not actually change the displayed text at all, as
-\l {Property Binding}{property bindings} are not bi-directional: the \c buttonText value would
-change when \c textItem.text changes, but not the other way around.
-
-Aliased properties are also useful for allowing external objects to directly modify and
-access child objects in a component. For example, here is a modified version of the \c ImageViewer
-component shown \l {Adding Properties}{earlier} on this page. The \c currentImage property has
-been changed to an alias to the child \l Image object:
-
-\table
-\row
-\li \snippet qml/qml-extending-types/properties/alias/ImageViewer.qml 0
-\li \snippet qml/qml-extending-types/properties/alias/application.qml 0
-\endtable
-
-Instead of being limited to setting the \l Image source, \c application.qml can now directly
-access and modify the child \l Image object and its properties.
-
-Obviously, exposing child objects in this manner should be done with care, as it allows external
-objects to modify them freely. However, this use of aliased properties can be quite useful in
-particular situations, such as for the \l {declarative/ui-components/tabwidget}{TabWidget}
-example, where new tab items are actually parented to a child object that displays the current tab.
-
-
-\section3 Considerations for property aliases
-
-Aliases are only activated once the component specifying them is completed.  The
-most obvious consequence of this is that the component itself cannot generally
-use the aliased property directly during creation.  For example, this will not work:
-
-\code
-    // Does NOT work
-    property alias buttonText: textItem.text
-    buttonText: "Some text" // buttonText is not yet defined when this value is set
-\endcode
-
-A second, much less significant, consequence of the delayed activation of
-aliases is that an alias reference cannot refer to another aliasing property
-declared within the same component.  This will not work:
-
-\code
-    // Does NOT work
-    id: root
-    property alias buttonText: textItem.text
-    property alias buttonText2: root.buttonText
-\endcode
-
-At the time the component is created, the \c buttonText value has not yet been assigned,
-so \c root.buttonText would refer to an undefined value. (From outside the component,
-however, aliasing properties appear as regular Qt properties and consequently can be
-used in alias references.)
-
-It is possible for an aliased property to have the same name as an existing property. For example,
-the following component has a \c color alias property, named the same as the built-in
-\l {Rectangle::color} property:
-
-\snippet qml/qml-extending-types/properties/alias-override.qml 0
-
-Any objects that use this component and refer to its \c color property will be
-referring to the alias rather than the ordinary \l {Rectangle::color} property. Internally,
-however, the rectangle can correctly set this property to "red" and refer to the actual defined
-property rather than the alias.
-
-
-\section1 Adding Methods
-
-A QML component can define methods of JavaScript code. These methods can be invoked
-either internally or by other objects.
-
-The syntax for defining a method is:
-
-\code
-function <name>([<parameter name>[, ...]]) { <body> }
-\endcode
-
-This declaration may appear anywhere within a type body, but it is customary to
-include it at the top.  Attempting to declare two methods or signals with the
-same name in the same type block is an error.  However, a new method may reuse
-the name of an existing method on the type.  (This should be done with caution,
-as the existing method may be hidden and become inaccessible.)
-
-Unlike \l{Adding Signals}{signals}, method parameter types do not have to be declared as they
-default to the \c variant type. The body of the method is written in JavaScript and may access
-the parameters by name.
-
-Here is an example of a component with a \c say() method that accepts a single \c text argument:
-
-\snippet qml/qml-extending-types/methods/app.qml 0
-
-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{qtqml-javascript-topic.html}{Integrating QML and JavaScript} for more information
-on using JavaScript with QML.
-
-
-\section1 Adding Signals
-
-Signals provide a way to notify other objects when an event has occurred. For example, the MouseArea
-\c clicked signal notifies other objects that the mouse has been clicked within the area.
-
-The syntax for defining a new signal is:
-
-\code
-signal <name>[([<type> <parameter name>[, ...]])]
-\endcode
-
-This declaration may appear anywhere within a type body, but it is customary to
-include it at the top.  Attempting to declare two signals or methods with the
-same name in the same type block is an error.  However, a new signal may reuse
-the name of an existing signal on the type. (This should be done with caution,
-as the existing signal may be hidden and become inaccessible.)
-
-Here are three examples of signal declarations:
-
-\code
-Item {
-    signal clicked
-    signal hovered()
-    signal performAction(string action, variant actionArgument)
-}
-\endcode
-
-If the signal has no parameters, the "()" brackets are optional. If parameters are used, the
-parameter types must be declared, as for the \c string and \c variant arguments for the \c
-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{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:
-
-\list
-\li onClicked
-\li onHovered
-\li onPerformAction
-\endlist
-
-To emit a signal, simply invoke it in the same way as a method. Below left, when the \l MouseArea is
-clicked, it emits the parent \c buttonClicked signal by invoking \c rect.buttonClicked(). The
-signal is received by \c application.qml through an \c onButtonClicked signal handler:
-
-\table
-\row
-\li \snippet qml/qml-extending-types/signals/basic.qml 0
-\li \snippet qml/qml-extending-types/signals/no-parameters.qml 0
-\endtable
-
-If the signal has parameters, they are accessible by parameter name in the signal handler.
-In the example below, \c buttonClicked is emitted with \c xPos and \c yPos parameters instead:
-
-\table
-\row
-\li \snippet qml/qml-extending-types/signals/Button.qml 0
-\li \snippet qml/qml-extending-types/signals/parameters.qml 0
-\endtable
-
-
-\section2 Connecting signals to methods and other signals
-
-Signal objects have a \c connect() method that can be used to a connect a signal to a method or
-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{qtqml-syntax-objectattributes.html#signal-handlers}
-{signal handler}.
-
-For example, the \c application.qml above could be rewritten as:
-
-\snippet qml/qml-extending-types/signals/connectslots.qml 0
-
-The \c myMethod() method will be called whenever the \c buttonClicked signal is received.
-
-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{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{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:
-
-\qml
-// application.qml
-Item {
-    // ...
-
-    function removeSignal() {
-        button.clicked.disconnect(item.myMethod)
-    }
-}
-\endqml
-
-
-\section3 Forwarding signals
-
-The \c connect() method can also connect a signal to other signals. This has the effect
-of "forwarding" a signal: it is automatically emitted whenever the relevant signal is emitted. For
-example, the MouseArea \c onClicked handler in \c Button.qml above could have been replaced with
-a call to \c connect():
-
-\qml
-MouseArea {
-    anchors.fill: parent
-    Component.onCompleted: clicked.connect(item.buttonClicked)
-}
-\endqml
-
-Whenever the \l MouseArea \c clicked signal is emitted, the \c rect.buttonClicked signal will
-automatically be emitted as well.
-
-*/
diff --git a/src/quick/doc/src/concepts/dynamicinstantiation/topic.qdoc b/src/quick/doc/src/concepts/dynamicinstantiation/topic.qdoc
new file mode 100644
index 0000000000..4040a63655
--- /dev/null
+++ b/src/quick/doc/src/concepts/dynamicinstantiation/topic.qdoc
@@ -0,0 +1,48 @@
+/****************************************************************************
+**
+** 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-dynamicinstantiation-topic.html
+\title Important Concepts In Qt Quick - Dynamic and Lazy Instantiation
+\brief Overview of the dynamic and lazy instantiation concepts
+
+QML provides a number of ways to dynamically create and manage QML objects.
+The \l{Loader}, \l{Repeater}, \l{ListView}, \l{GridView} and \l{PathView} elements
+all support dynamic object management.
+
+Objects can be created and deleted at runtime from JavaScript code. See
+\l{qtqml-javascript-dynamicobjectcreation.html}{Dynamic QML object creation from JavaScript}
+for more details.
+
+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/effects-particles.qdoc b/src/quick/doc/src/concepts/effects/particles.qdoc
index 9fbe85c5bb..2809ce4f85 100644
--- a/src/quick/doc/src/concepts/effects-particles.qdoc
+++ b/src/quick/doc/src/concepts/effects/particles.qdoc
@@ -38,12 +38,12 @@
 
   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{qtquick-concepts-particles-performance.html}{Qt Quick Particle System Performance}.
+  For details on the performance characteristics see \l{qtquick-particles-performance.html}{Qt Quick Particle System Performance}.
 
 */
 
 /*!
-    \page qtquick-concepts-effects-particles.html
+    \page qtquick-effects-particles.html
     \inqmlmodule QtQuick.Particles 2.0
     \title Using the Qt Quick Particle System
 
@@ -131,7 +131,7 @@
 */
 
 /*!
-    \page qtquick-concepts-particles-performance.html
+    \page qtquick-particles-performance.html
     \inqmlmodule QtQuick 2.0
     \title Particle System Performance Guide
 
diff --git a/src/quick/doc/src/concepts/effects-shaders.qdoc b/src/quick/doc/src/concepts/effects/shaders.qdoc
index 8355b2758b..c778cec789 100644
--- a/src/quick/doc/src/concepts/effects-shaders.qdoc
+++ b/src/quick/doc/src/concepts/effects/shaders.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \group qtquick-shaders
-\page qtquick-concepts-effects-shaders.html
+\page qtquick-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/concepts/effects-sprites.qdoc b/src/quick/doc/src/concepts/effects/sprites.qdoc
index 50b380ebee..e4bd2e0c31 100644
--- a/src/quick/doc/src/concepts/effects-sprites.qdoc
+++ b/src/quick/doc/src/concepts/effects/sprites.qdoc
@@ -28,7 +28,7 @@
 /*!
 \group qtquick-images-sprites
 \ingroup qml-features
-\page qtquick-concepts-effects-sprites.html
+\page qtquick-effects-sprites.html
 \title Sprite Animations
 \brief Sprite-based animations with flexible transitioning
 
diff --git a/src/quick/doc/src/concepts/effects/topic.qdoc b/src/quick/doc/src/concepts/effects/topic.qdoc
new file mode 100644
index 0000000000..aa6b998c49
--- /dev/null
+++ b/src/quick/doc/src/concepts/effects/topic.qdoc
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** 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-effects-topic.html
+\title Important Concepts In Qt Quick - Graphical Effects
+\brief Overview of graphical effects concepts
+
+\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.
+
+\section1 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-effects-transformations.html}
+{Qt Quick Transformation Types}.
+
+\section1 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-effects-shaders.html}
+{Qt Quick Shader Effects}.
+
+\section1 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-effects-particles.html}{Qt Quick Particle System}.
+
+\section1 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-effects-sprites.html}{Sprite Animations}.
+
+
+*/
+
diff --git a/src/quick/doc/src/concepts/effects-transformations.qdoc b/src/quick/doc/src/concepts/effects/transformations.qdoc
index b2ff5955fb..d286a29797 100644
--- a/src/quick/doc/src/concepts/effects-transformations.qdoc
+++ b/src/quick/doc/src/concepts/effects/transformations.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \group qtquick-transformations
-\page qtquick-concepts-effects-transformations.html
+\page qtquick-effects-transformations.html
 \title Qt Quick Transformation Types
 \brief Types for applying transformations to visual types
 
diff --git a/src/quick/doc/src/concepts/eventinterceptors/topic.qdoc b/src/quick/doc/src/concepts/eventinterceptors/topic.qdoc
new file mode 100644
index 0000000000..f6d2e7fe14
--- /dev/null
+++ b/src/quick/doc/src/concepts/eventinterceptors/topic.qdoc
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** 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-eventinterceptors-topic.html
+\title Important Concepts In Qt Quick - Event Interceptors
+\brief Overview of event interceptor concepts
+
+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.
+
+\section1 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.
+
+\section1 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.
+
+\section1 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 Timer-Based Events
+
+*/
+
diff --git a/src/quick/doc/src/concepts/input-focus.qdoc b/src/quick/doc/src/concepts/input/focus.qdoc
index d18407972c..4af74e1eb1 100644
--- a/src/quick/doc/src/concepts/input-focus.qdoc
+++ b/src/quick/doc/src/concepts/input/focus.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-input-focus.html
+\page qtquick-input-focus.html
 \ingroup qml-features
 \title Keyboard Focus in Qt Quick
 \brief handling keyboard focus
diff --git a/src/quick/doc/src/concepts/input-mouse.qdoc b/src/quick/doc/src/concepts/input/mouse.qdoc
index 4890f2e20d..0c3956f0ab 100644
--- a/src/quick/doc/src/concepts/input-mouse.qdoc
+++ b/src/quick/doc/src/concepts/input/mouse.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-input-mouseevents.html
+\page qtquick-input-mouseevents.html
 \ingroup QML Features
 \title Mouse Events
 \brief handling mouse events in Qt Quick
diff --git a/src/quick/doc/src/concepts/input-text.qdoc b/src/quick/doc/src/concepts/input/textinput.qdoc
index 6387221670..0b15c11c4a 100644
--- a/src/quick/doc/src/concepts/input-text.qdoc
+++ b/src/quick/doc/src/concepts/input/textinput.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \group qtquick-text
-\page qtquick-concepts-input-text.html
+\page qtquick-input-textinput.html
 \title Qt Quick Text Input Handling and Validators
 \brief Text input and validation
 
diff --git a/src/quick/doc/src/concepts/input/topic.qdoc b/src/quick/doc/src/concepts/input/topic.qdoc
new file mode 100644
index 0000000000..94c29e120e
--- /dev/null
+++ b/src/quick/doc/src/concepts/input/topic.qdoc
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** 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-input-topic.html
+\title Important Concepts In Qt Quick - User Input
+\brief Overview of user input concepts
+
+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.
+
+\section1 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).
+
+\section1 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.
+
+\section1 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-input-textinput.html}{text input} for
+in-depth information on the topic.
+
+\section1 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-input-mouseevents.html}
+{mouse events in Qt Quick} for more information on the topic.
+
+\section1 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-input-focus.html}{keyboard focus in Qt Quick} for more
+information on this topic.
+
+*/
+
diff --git a/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
new file mode 100644
index 0000000000..e8b18ece4c
--- /dev/null
+++ b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
@@ -0,0 +1,216 @@
+/****************************************************************************
+**
+** 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-modelviewsdata-cppmodels.html
+\title Using C++ Models with QtQuick Views
+\brief using QtQuick views with models defined in C++
+
+
+\section1 Data Provided In A Custom C++ Model
+
+Models can be defined in C++ and then made available to QML. This is useful
+for exposing existing C++ data models or otherwise complex datasets to QML.
+
+A C++ model class can be defined as a \l QStringList, a QObjectList or a
+\l QAbstractItemModel. The first two are useful for exposing simpler datasets,
+while QAbstractItemModel provides a more flexible solution for more complex
+models.
+
+\section2 QStringList-based Model
+
+A model may be a simple \l QStringList, which provides the contents of the list
+via the \e modelData role.
+
+Here is a ListView with a delegate that references its model item's
+value using the \c modelData role:
+
+\snippet examples/quick/modelviews/stringlistmodel/view.qml 0
+
+A Qt application can load this QML document and set the value of \c myModel
+to a QStringList:
+
+\snippet examples/quick/modelviews/stringlistmodel/main.cpp 0
+
+The complete example is available in Qt's \l {quick/modelviews/stringlistmodel}{examples/quick/modelviews/stringlistmodel} directory.
+
+\b{Note:} There is no way for the view to know that the contents of a QStringList
+have changed.  If the QStringList changes, it will be necessary to reset
+the model by calling QQmlContext::setContextProperty() again.
+
+
+\section2 QObjectList-based model
+
+A list of QObject* values can also be used as a model. A QList<QObject*> provides
+the properties of the objects in the list as roles.
+
+The following application creates a \c DataObject class that with
+Q_PROPERTY values that will be accessible as named roles when a
+QList<DataObject*> is exposed to QML:
+
+\snippet examples/quick/modelviews/objectlistmodel/dataobject.h 0
+\dots 4
+\snippet examples/quick/modelviews/objectlistmodel/dataobject.h 1
+\codeline
+\snippet examples/quick/modelviews/objectlistmodel/main.cpp 0
+\dots
+
+The QObject* is available as the \c modelData property.  As a convenience,
+the properties of the object are also made available directly in the
+delegate's context. Here, \c view.qml references the \c DataModel properties in
+the ListView delegate:
+
+\snippet examples/quick/modelviews/objectlistmodel/view.qml 0
+
+Note the use of the fully qualified access to the \c color property.
+The properties of the object are not replicated in the \c model
+object, since they are easily available via the \c modelData
+object.
+
+The complete example is available in Qt's \l {quick/modelviews/objectlistmodel}{examples/quick/modelviews/objectlistmodel} directory.
+
+Note: There is no way for the view to know that the contents of a QList
+have changed.  If the QList changes, it will be necessary to reset
+the model by calling QQmlContext::setContextProperty() again.
+
+
+\section2 QAbstractItemModel
+
+A model can be defined by subclassing QAbstractItemModel. This is the
+best approach if you have a more complex model that cannot be supported
+by the other approaches. A QAbstractItemModel can also automatically
+notify a QML view when the model data has changed.
+
+The roles of a QAbstractItemModel subclass can be exposed to QML by calling
+QAbstractItemModel::setRoleNames(). The default role names set by Qt are:
+
+\table
+\header
+\li Qt Role
+\li QML Role Name
+\row
+\li Qt::DisplayRole
+\li display
+\row
+\li Qt::DecorationRole
+\li decoration
+\endtable
+
+Here is an application with a QAbstractListModel subclass named \c AnimalModel
+that has \e type and \e size roles. It calls QAbstractItemModel::setRoleNames() to set the
+role names for accessing the properties via QML:
+
+\snippet examples/quick/modelviews/abstractitemmodel/model.h 0
+\dots
+\snippet examples/quick/modelviews/abstractitemmodel/model.h 1
+\dots
+\snippet examples/quick/modelviews/abstractitemmodel/model.h 2
+\codeline
+\snippet examples/quick/modelviews/abstractitemmodel/model.cpp 0
+\codeline
+\snippet examples/quick/modelviews/abstractitemmodel/main.cpp 0
+\dots
+
+This model is displayed by a ListView delegate that accesses the \e type and \e size
+roles:
+
+\snippet examples/quick/modelviews/abstractitemmodel/view.qml 0
+
+QML views are automatically updated when the model changes. Remember the model
+must follow the standard rules for model changes and notify the view when
+the model has changed by using QAbstractItemModel::dataChanged(),
+QAbstractItemModel::beginInsertRows(), etc. See the \l {Model subclassing reference} for
+more information.
+
+The complete example is available in Qt's \l {quick/modelviews/abstractitemmodel}{examples/quick/modelviews/abstractitemmodel} directory.
+
+QAbstractItemModel presents a hierarchy of tables, but the views currently provided by QML
+can only display list data.
+In order to display child lists of a hierarchical model
+the VisualDataModel element provides several properties and functions for use
+with models of type QAbstractItemModel:
+
+\list
+\li \e hasModelChildren role property to determine whether a node has child nodes.
+\li \l VisualDataModel::rootIndex allows the root node to be specified
+\li \l VisualDataModel::modelIndex() returns a QModelIndex which can be assigned to VisualDataModel::rootIndex
+\li \l VisualDataModel::parentModelIndex() returns a QModelIndex which can be assigned to VisualDataModel::rootIndex
+\endlist
+
+\section2 Exposing C++ Data Models to QML
+
+The above examples use QQmlContext::setContextProperty() to set
+model values directly in QML components. An alternative to this is to
+register the C++ model class as a QML type (either
+\l{qtqml-registercpptypes.html}{directly} from a C++ entry-point, or within
+the initialization function of a \l{qtqml-modules-cppplugins.html}
+{QML C++ plugin}, as shown below).  This would allow the model classes to be
+created directly as elements within QML:
+
+\table
+\row
+
+\li
+\code
+class MyModelPlugin : public QQmlExtensionPlugin
+{
+public:
+    void registerTypes(const char *uri)
+    {
+        qmlRegisterType<MyModel>(uri, 1, 0,
+                "MyModel");
+    }
+}
+
+Q_EXPORT_PLUGIN2(mymodelplugin, MyModelPlugin);
+\endcode
+
+\li
+\qml
+MyModel {
+    id: myModel
+    ListElement { someProperty: "some value" }
+}
+\endqml
+
+\qml
+ListView {
+    width: 200; height: 250
+    model: myModel
+    delegate: Text { text: someProperty }
+}
+\endqml
+
+\endtable
+
+See \l {Tutorial: Extending QML with C++} for details on writing QML C++
+plugins.
+
+
+*/
+
+
diff --git a/src/quick/doc/src/concepts/data-localstorage.qdoc b/src/quick/doc/src/concepts/modelviewsdata/localstorage.qdoc
index 2de521a2a6..8dc264c50a 100644
--- a/src/quick/doc/src/concepts/data-localstorage.qdoc
+++ b/src/quick/doc/src/concepts/modelviewsdata/localstorage.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-data-localstorage.html
+\page qtquick-modelviewsdata-localstorage.html
 \title Local Storage
 \brief SQL storage for Qt Quick
 
diff --git a/src/quick/doc/src/concepts/data-modelview.qdoc b/src/quick/doc/src/concepts/modelviewsdata/modelview.qdoc
index 49522b93bf..d2c0307d03 100644
--- a/src/quick/doc/src/concepts/data-modelview.qdoc
+++ b/src/quick/doc/src/concepts/modelviewsdata/modelview.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-data-modelview.html
+\page qtquick-modelviewsdata-modelview.html
 \title Models and Views in Qt Quick
 \brief how to display and form data in Qt Quick
 
@@ -189,8 +189,8 @@ To visualize data, bind the view's \c model property to a model and the
     elements. In addition, models can be created with Qt C++ and then made
     available to the \l{qtqml-cppclasses-engine.html}{QML engine} for use by
     QML components. For information about creating these models, visit the
-    \l{qtqml-cppintegration-data.html#data-provided-in-a-custom-c++-model}
-    {exposing C++ models} and \l{qtqml-typesystem-topic.html#qml-object-types}
+    \l{qtquick-modelviewsdata-cppmodels.html}{Using C++ Models with QtQuick Views}
+    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
@@ -329,8 +329,8 @@ To visualize data, bind the view's \c model property to a model and the
     datasets to QML.
 
     For information, visit the
-    \l{qtqml-cppintegration-data.html#data-provided-in-a-custom-c++-model}
-    {exposing C++ models} article.
+    \l{qtquick-modelviewsdata-cppmodels.html}{Using C++ Models with QtQuick Views}
+    article.
 
 
 \section1 Repeaters
diff --git a/src/quick/doc/src/concepts/modelviewsdata/topic.qdoc b/src/quick/doc/src/concepts/modelviewsdata/topic.qdoc
new file mode 100644
index 0000000000..f405a493b2
--- /dev/null
+++ b/src/quick/doc/src/concepts/modelviewsdata/topic.qdoc
@@ -0,0 +1,55 @@
+/****************************************************************************
+**
+** 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-modelviewsdata-topic.html
+\title Important Concepts In Qt Quick - Data - Models, Views and Data Storage
+\brief Overview of the data, model and view concepts
+
+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.
+
+\section1 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-modelviewsdata-modelview.html}
+{Models and Views in Qt Quick}.
+
+\section1 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-modelviewsdata-localstorage.html}{Qt Quick local storage module}.
+
+*/
+
diff --git a/src/quick/doc/src/concepts/positioning-anchors.qdoc b/src/quick/doc/src/concepts/positioning/anchors.qdoc
index 62b99948ce..7e20807825 100644
--- a/src/quick/doc/src/concepts/positioning-anchors.qdoc
+++ b/src/quick/doc/src/concepts/positioning/anchors.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-positioning-anchors.html
+\page qtquick-positioning-anchors.html
 \title Positioning with Anchors
 \brief placing items with anchor properties
 
diff --git a/src/quick/doc/src/concepts/positioning-layouts.qdoc b/src/quick/doc/src/concepts/positioning/layouts.qdoc
index 2cf4066525..ea37d14bdd 100644
--- a/src/quick/doc/src/concepts/positioning-layouts.qdoc
+++ b/src/quick/doc/src/concepts/positioning/layouts.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \group qtquick-positioners
-\page qtquick-concepts-positioning-layouts.html
+\page qtquick-positioning-layouts.html
 \ingroup qml-features
 \title Item Layouts
 
diff --git a/src/quick/doc/src/concepts/positioning-righttoleft.qdoc b/src/quick/doc/src/concepts/positioning/righttoleft.qdoc
index 09488a064c..cc8add1286 100644
--- a/src/quick/doc/src/concepts/positioning-righttoleft.qdoc
+++ b/src/quick/doc/src/concepts/positioning/righttoleft.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-positioning-righttoleft.html
+\page qtquick-positioning-righttoleft.html
 \ingroup qml-features
 \title Right-to-left User Interfaces
 \brief switching text flow and layout
diff --git a/src/quick/doc/src/concepts/positioning.qdoc b/src/quick/doc/src/concepts/positioning/topic.qdoc
index a02ef5574d..6c44e66f31 100644
--- a/src/quick/doc/src/concepts/positioning.qdoc
+++ b/src/quick/doc/src/concepts/positioning/topic.qdoc
@@ -26,16 +26,22 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-positioning.html
-\title Concepts - Positioning
-\brief Description of the concept of visual object positioning in Qt Quick
+\page qtquick-positioning-topic.html
+\title Important Concepts In Qt Quick - Positioning
+\brief Overview of positioning concepts
+
+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.
 
-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
 
+Items can be positioned manually.  If the user-interface is going to be
+static, manual positioning provides the most efficient form of 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
@@ -45,7 +51,7 @@ 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}
+\l{qtquick-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].
@@ -92,6 +98,11 @@ Thus, the following example will display three rectangles positioned manually:
 
 \section1 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.
+
 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
@@ -101,15 +112,22 @@ 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
 
+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.
+
 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}
+\l{qtquick-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
@@ -119,15 +137,22 @@ 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
+\section1 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.
 
 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
+\l{qtquick-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
@@ -136,7 +161,9 @@ 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}
+\l{qtquick-positioning-righttoleft.html}
 {right-to-left support in Qt Quick} for in-depth information on the topic.
 
+
 */
+
diff --git a/src/quick/doc/src/concepts/statesanimations-animations.qdoc b/src/quick/doc/src/concepts/statesanimations/animations.qdoc
index 37975f5bae..bb0a6506e5 100644
--- a/src/quick/doc/src/concepts/statesanimations-animations.qdoc
+++ b/src/quick/doc/src/concepts/statesanimations/animations.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \group qtquick-transitions-animations
-\page qtquick-concepts-statesanimations-animations.html
+\page qtquick-statesanimations-animations.html
 \title Animation and Transitions In Qt Quick
 \brief the animation system in Qt Quick
 
diff --git a/src/quick/doc/src/concepts/statesanimations-behaviors.qdoc b/src/quick/doc/src/concepts/statesanimations/behaviors.qdoc
index a41b50f015..a513aaad0c 100644
--- a/src/quick/doc/src/concepts/statesanimations-behaviors.qdoc
+++ b/src/quick/doc/src/concepts/statesanimations/behaviors.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-qmltypereference-behaviors.html
+\page qtquick-statesanimations-behaviors.html
 \title Using Qt Quick Behaviors with States
 \brief animating property changes with behaviors
 
diff --git a/src/quick/doc/src/concepts/statesanimations-states.qdoc b/src/quick/doc/src/concepts/statesanimations/states.qdoc
index d20e7cc3f2..e3ac12549c 100644
--- a/src/quick/doc/src/concepts/statesanimations-states.qdoc
+++ b/src/quick/doc/src/concepts/statesanimations/states.qdoc
@@ -26,8 +26,8 @@
 ****************************************************************************/
 
 /*!
-\group qtquick--states
-\page qtquick-concepts-statesanimations-states.html
+\group qtquick-states
+\page qtquick-statesanimations-states.html
 \title Qt Quick States
 \brief Creating and setting states
 
@@ -117,7 +117,7 @@ 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{qtquick-concepts-statesanimations-animations.html}
+\l{qtquick-statesanimations-animations.html}
 {Animation and Transitions} article has more information about creating state
 animations.
 
@@ -125,7 +125,7 @@ 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{qtquick-qmltypereference-behaviors.html}{Using QML Behaviors with States}
+\l{qtquick-statesanimations-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/topic.qdoc
index 090b9ac816..8ca02fd444 100644
--- a/src/quick/doc/src/concepts/statesanimations.qdoc
+++ b/src/quick/doc/src/concepts/statesanimations/topic.qdoc
@@ -26,10 +26,14 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-statesanimations.html
+\page qtquick-statesanimations-topic.html
 \title Concepts - States And Animations
 \brief Description of the concepts of states, transitions and animations in Qt Quick
 
+In any modern user-interface, transitioning between states and animating
+the user-interface is highly beneficial.  These are first-class concepts 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
@@ -52,7 +56,7 @@ 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
+\l{qtquick-statesanimations-states.html}{Qt Quick States} for more
 information.
 
 \section1 Transitions
@@ -65,7 +69,7 @@ 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}
+\l{qtquick-statesanimations-animations.html#transitions-during-state-changes}
 {Transitions during State Changes} for more information about transitions.
 
 \section1 Animations
@@ -81,7 +85,7 @@ 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}
+\l{qtquick-statesanimations-animations.html}
 {Animations and Transitions In Qt Quick} for information about these elements
 and how to use them.
 
@@ -94,14 +98,14 @@ 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}
+\l{qtquick-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}
+\l{qtquick-statesanimations-behaviors.html}
 {using Qt Quick Behaviors with States} for more information about this topic.
 
 \section1 Animated Sprites
@@ -109,6 +113,6 @@ results in undefined behavior occurring.  Please see the documentation about
 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}.
+\l{qtquick-effects-sprites.html}{sprite animations}.
 
 */
diff --git a/src/quick/doc/src/concepts/topic.qdoc b/src/quick/doc/src/concepts/topic.qdoc
deleted file mode 100644
index 9fd960850c..0000000000
--- a/src/quick/doc/src/concepts/topic.qdoc
+++ /dev/null
@@ -1,347 +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-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/visualcanvas/coordinates.qdoc
index aff25980d4..bcbf8ae54d 100644
--- a/src/quick/doc/src/concepts/visual-coordinates.qdoc
+++ b/src/quick/doc/src/concepts/visualcanvas/coordinates.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-visual-coordinates.html
+\page qtquick-visualcanvas-coordinates.html
 \title Concepts - Visual Coordinates in Qt Quick
 \brief Description of the concept of visual coordinates in Qt Quick
 
diff --git a/src/quick/doc/src/concepts/visual-scenegraph.qdoc b/src/quick/doc/src/concepts/visualcanvas/scenegraph.qdoc
index e244917a4f..d74510bffc 100644
--- a/src/quick/doc/src/concepts/visual-scenegraph.qdoc
+++ b/src/quick/doc/src/concepts/visualcanvas/scenegraph.qdoc
@@ -27,7 +27,7 @@
 
 /*!
 \title Qt Quick Scene Graph
-\page qtquick-concepts-visual-scenegraph.html
+\page qtquick-visualcanvas-scenegraph.html
 
 \section1 What is a Scene Graph?
 
diff --git a/src/quick/doc/src/concepts/visualcanvas/topic.qdoc b/src/quick/doc/src/concepts/visualcanvas/topic.qdoc
new file mode 100644
index 0000000000..dda22b2bcf
--- /dev/null
+++ b/src/quick/doc/src/concepts/visualcanvas/topic.qdoc
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** 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-visualcanvas-topic.html
+\title Important Concepts In Qt Quick - The Visual Canvas
+\brief Overview of visual canvas concepts
+
+The visual canvas provided by the Qt Quick is a two dimensional canvas with
+z-ordering.
+
+\section1 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-visualcanvas-coordinates.html}{Coordinate System} for
+in-depth information about the coordinate system utilized by Qt Quick.
+
+\section1 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-visualcanvas-visualparent.html}
+{Visual Parent}for more in-depth information on the topic.
+
+\section1 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-visualcanvas-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.
+
+*/
diff --git a/src/quick/doc/src/concepts/visual-parent.qdoc b/src/quick/doc/src/concepts/visualcanvas/visualparent.qdoc
index 30f1d18b92..72658e53eb 100644
--- a/src/quick/doc/src/concepts/visual-parent.qdoc
+++ b/src/quick/doc/src/concepts/visualcanvas/visualparent.qdoc
@@ -26,7 +26,7 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-visual-parent.html
+\page qtquick-visualcanvas-visualparent.html
 \title Concepts - Visual Parent in Qt Quick
 \brief Description of the concept of visual parent in Qt Quick
 
diff --git a/src/quick/doc/src/concepts/interceptors.qdoc b/src/quick/doc/src/concepts/visualtypes/topic.qdoc
index 0b53e2bc8b..9d9075ad73 100644
--- a/src/quick/doc/src/concepts/interceptors.qdoc
+++ b/src/quick/doc/src/concepts/visualtypes/topic.qdoc
@@ -26,16 +26,19 @@
 ****************************************************************************/
 
 /*!
-\page qtquick-concepts-interceptors.html
-\title Concepts - Event Interceptors
-\brief Description of the concept of property interception in Qt Quick
+\page qtquick-visualtypes-topic.html
+\title Important Concepts In Qt Quick - Visual Types
+\brief Overview of visual type concepts
 
-\section1 Animating Property Assignments
+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.
 
-\section1 Dynamic Bindings
+See the \l{qtquick-qmltypereference.html}{Qt Quick QML type reference} for the
+complete list of visual object types provided by Qt Quick.
 
-\section1 Dynamic Signal Connections
+*/
 
-\section1 Timer-Based Events
 
-*/