Re-organized the Qt Quick page. Changed titles and links.

Task-number: QTBUG-16071

27 files changed, 1192 insertions, 671 deletions

diff --git a/doc/src/declarative/anchor-layout.qdoc b/doc/src/declarative/anchor-layout.qdoc
index 4953b22..11acbad 100644
--- a/doc/src/declarative/anchor-layout.qdoc
+++ b/doc/src/declarative/anchor-layout.qdoc
@@ -29,8 +29,8 @@
 \page qml-anchor-layout.html
 \target anchor-layout
 \contentspage QML Features
-\previouspage Using QML Positioner and Repeater Items
-\nextpage Using QML Positioner and Repeater Items
+\previouspage {Using QML Positioner and Repeater Items}{Component Layouts}
+\nextpage {QML Mouse Events}{Mouse Events}
 \title Anchor-based Layout in QML
 
 \section1 Overview
diff --git a/doc/src/declarative/animation.qdoc b/doc/src/declarative/animation.qdoc
index 708f412..099f02d 100644
--- a/doc/src/declarative/animation.qdoc
+++ b/doc/src/declarative/animation.qdoc
@@ -29,7 +29,9 @@
 \page qdeclarativeanimation.html
 \ingroup qml-features
 \contentspage QML Features
-\title QML Animation
+\previouspage {QML States}{States}
+\nextpage {QML Data Models}{Structuring Data with Models}
+\title QML Animation and Transitions
 
 
 In QML, animations are created by applying animation objects to object property
diff --git a/doc/src/declarative/basicelements.qdoc b/doc/src/declarative/basicelements.qdoc
new file mode 100644
index 0000000..d0c16b6
--- /dev/null
+++ b/doc/src/declarative/basicelements.qdoc
@@ -0,0 +1,37 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page qmlbasicelements.html
+    \ingroup qml-features
+    \contentspage QML Features
+    \previouspage {QML Basic Types}{Data Types}
+    \nextpage {Using QML Positioner and Repeater Items}{Component Layouts}
+
+    \title QML Basic Elements
+
+*/
diff --git a/doc/src/declarative/basictypes.qdoc b/doc/src/declarative/basictypes.qdoc
index 0277ccb..59772c5 100644
--- a/doc/src/declarative/basictypes.qdoc
+++ b/doc/src/declarative/basictypes.qdoc
@@ -29,13 +29,15 @@
     \page qdeclarativebasictypes.html
     \ingroup qml-features
     \contentspage QML Features
+    \previouspage {Property Binding}
+    \nextpage {QML Basic Elements}{Basic Elements}
     \title QML Basic Types
 
     QML has a set of primitive types, as listed below, that are used throughout
     the \l {QML Elements}.
 
     Some of these types can also be used for defining
-    \c property values in QML. See \l{Writing QML Components: Properties, Methods and Signals} for the
+    \c property values in QML. See \l{Importing Reusable Components} for the
     list of types that can be used for \c property values.
 
     \annotatedlist qmlbasictypes
diff --git a/doc/src/declarative/declarativeui.qdoc b/doc/src/declarative/declarativeui.qdoc
index 771a421..473cbdd 100644
--- a/doc/src/declarative/declarativeui.qdoc
+++ b/doc/src/declarative/declarativeui.qdoc
@@ -77,42 +77,41 @@ QML and the Qt Declarative Module separate the frontend UI logic from the backen
 \list
 \o \l{QML Syntax}
 \o \l{Property Binding}
+\o \l{QML Basic Types}{Data Types}
+\o \l{QML Basic Elements}{Basic Elements}
 \o \l{Using QML Positioner and Repeater Items}{Component Layouts}
-\o \l{Anchor-based Layout in QML}{Anchor Layout}
-\o \l{Writing QML Components: Properties, Methods and Signals}{Reusable Components}
-\o \l{Text Handling}
-\o \l{Keyboard Focus in QML}{Keyboard Focus}
+\o \l{Anchor-based Layout in QML}{Layouts using Anchors}
 \o \l{Mouse Events}
-\o \l{QML States} {States}
-\o \l{QML Animation}{Animation and Transitions}
-\o \l{QML Basic Types}{QML Basic Data Types}
+\o \l{QML Text Handling and Validators}{Text Handling and Validators}
+\o \l{Keyboard Focus in QML}{Keyboard Focus}
+\o \l{Importing Reusable Components}
+\o \l{QML States}{States}
+\o \l{QML Animation and Transitions}{Animation and Transitions}
 \o \l{QML Data Models}{Structuring Data with Models}
-\o \l{Presenting Data with QML}{Presenting Data with Views}
-\o \l{Affine Transformations}
+\o \l{Presenting Data with Views}
+\o \l{Extending QML Functionalities using C++}
+\o \l{Using QML Bindings in C++ Applications}
+\o \l{Integrating QML Code with Existing Qt UI Code}
+\o \l{QML Signal and Handler Event System}{Signal and Handler Event System}
 \o \l{Dynamic Object Management in QML}{Dynamic Object Management}
-\o \l{Network Transparency}{Resource Loading}
-\o \l{Extending QML in C++}{Extending QML Functionalities using C++}
-\o \l{Using QML in C++ Applications}
-\o \l{Integrating QML with existing Qt UI code}{Integrating QML Code with Existing Qt UI Code}
-\o \l{Signals and Slots Event System}
+\o \l{Network Transparency}{Loading Resources in QML}
 \o \l{QML Internationalization}{Internationalization}
-\o \l{Graphical Effects}
+\o \l{QML Graphical Effects}{Graphical Effects}
 \endlist
 
 \section1 QML Add-Ons
 
 \list
-\o \l{Qt WebKit}
-\o \l{Mobility QML bindings}
+\o \l{QtWebKit QML Module}
+\o \l{http://doc.qt.nokia.com/qtmobility-1.1.0/qml-plugins.html}{Mobility QML Plugins}
 \endlist
 
 \section1 Qt Quick Tools
 
 \list
 \o \l{Debugging QML}
+\o \l{Developing Qt Quick Applications with Creator}{Developing with Qt Creator}
 \o \l{QML Viewer}
-\o \l{QML Performance}
-\o \l{Developing Qt Quick Applications}{Developing with Qt Creator}
 \endlist
 
 \section1 Reference
@@ -160,6 +159,9 @@ examples for porting}
 \list
 \o \l{QML Best Practices: Data Types}{Using Data Types in QML}
 \o \l{QML Best Practices: Coding Conventions}{Coding Tips}
+\o \l{QML Performance}{Performance Tips}
+\omit
 \o \l{Geir's screen size document}
+\endomit
 \endlist
 */
diff --git a/doc/src/declarative/dynamicobjects.qdoc b/doc/src/declarative/dynamicobjects.qdoc
index 1e43166..e5077ba 100644
--- a/doc/src/declarative/dynamicobjects.qdoc
+++ b/doc/src/declarative/dynamicobjects.qdoc
@@ -29,13 +29,15 @@
 \page qdeclarativedynamicobjects.html
 \ingroup qml-features
 \contentspage {QML Features}
+\previouspage {QML Signal and Handler Event System}{Signal and Handler Event System}
+\nextpage {Network Transparency}{Loading Resources in QML}
 \title Dynamic Object Management in QML
 
 QML provides a number of ways to dynamically create and manage QML objects.
 The \l{Loader}, \l{Repeater}, \l{ListView}, \l{GridView} and \l{PathView} elements
 all support dynamic object management.  Objects can also be created and managed
 from C++, and this is the preferred method for hybrid QML/C++ applications
-(see \l{Using QML in C++ Applications}).
+(see \l{Using QML Bindings in C++ Applications}).
 
 QML also supports the dynamic creation of objects from within JavaScript
 code. This is useful if the existing QML elements do not fit the needs of your
diff --git a/doc/src/declarative/extending-tutorial.qdoc b/doc/src/declarative/extending-tutorial.qdoc
index c998c5c..25be0f9 100644
--- a/doc/src/declarative/extending-tutorial.qdoc
+++ b/doc/src/declarative/extending-tutorial.qdoc
@@ -33,7 +33,7 @@ The Qt Declarative module provides a set of APIs for extending QML through
 C++ extensions. You can write extensions to add your own QML types, extend existing
 Qt types, or call C/C++ functions that are not accessible from ordinary QML code.
 
-This tutorial shows how to write a QML extension using C++ that includes 
+This tutorial shows how to write a QML extension using C++ that includes
 core QML features, including properties, signals and bindings. It also shows how
 extensions can be deployed through plugins.
 
@@ -67,18 +67,18 @@ like network programming that are not accessible through built-in QML features.
 
 In this tutorial, we will show how to use the C++ classes in the Qt Declarative
 module to extend QML. The end result will be a simple Pie Chart display implemented by
-several custom QML types connected together through QML features like bindings and 
+several custom QML types connected together through QML features like bindings and
 signals, and made available to the QML runtime through a plugin.
 
 To begin with, let's create a new QML type called "PieChart" that has two properties: a name
 and a color.  We will make it available in a \l {Modules}{module} called "Charts", with
-a module version of 1.0. 
+a module version of 1.0.
 
 We want this \c PieChart type to be usable from QML like this:
 
 \code
     import Charts 1.0
-    
+
     PieChart {
         width: 100; height: 100
         name: "A simple pie chart"
@@ -99,16 +99,16 @@ Here is our \c PieChart class, defined in \c piechart.h:
 
 \snippet declarative/tutorials/extending/chapter1-basics/piechart.h 0
 
-The class inherits from QDeclarativeItem because we want to override 
+The class inherits from QDeclarativeItem because we want to override
 QDeclarativeItem::paint() in order to draw. If the class just represented some
 data type and was not an item that actually needed to be displayed, it could simply inherit
-from QObject. Or, if we want to extend the functionality of an existing QObject-based 
+from QObject. Or, if we want to extend the functionality of an existing QObject-based
 class, it could inherit from that class instead.
 
 The \c PieChart class defines the two properties, \c name and \c color, with the Q_PROPERTY macro,
-and overrides QDeclarativeItem::paint(). The class implementation in \c piechart.cpp 
-simply sets and returns the \c m_name and \c m_color values as appropriate, and 
-implements \c paint() to draw a simple pie chart. It also turns off the 
+and overrides QDeclarativeItem::paint(). The class implementation in \c piechart.cpp
+simply sets and returns the \c m_name and \c m_color values as appropriate, and
+implements \c paint() to draw a simple pie chart. It also turns off the
 QGraphicsItem::ItemHasNoContents flag to enable painting:
 
 \snippet declarative/tutorials/extending/chapter1-basics/piechart.cpp 0
@@ -150,19 +150,19 @@ Try it yourself with the code in Qt's \c examples/tutorials/extending/chapter1-b
 
 At the moment, the \c app.qml is run from within a C++ application.
 This may seem odd if you're used to running QML files with the \l {QML Viewer}.
-Later on, we'll show how to create a plugin so that you can run \c app.qml using the 
+Later on, we'll show how to create a plugin so that you can run \c app.qml using the
 \l {QML Viewer} instead.
 
 */
 
 
 /*!
-\title Chapter 2: Connecting to C++ Methods and Signals 
+\title Chapter 2: Connecting to C++ Methods and Signals
 
 \example declarative/tutorials/extending/chapter2-methods
 
 Suppose we want \c PieChart to have a "clearChart()" method that erases the
-chart and then emits a "chartCleared" signal. Our \c app.qml would be able 
+chart and then emits a "chartCleared" signal. Our \c app.qml would be able
 to call \c clearChart() and receive \c chartCleared() signals like this:
 
 \snippet declarative/tutorials/extending/chapter2-methods/app.qml 0
@@ -210,7 +210,7 @@ Property bindings is a powerful feature of QML that allows values of different
 elements to be synchronized automatically. It uses signals to notify and update
 other elements' values when property values are changed.
 
-Let's enable property bindings for the \c color property. That means 
+Let's enable property bindings for the \c color property. That means
 if we have code like this:
 
 \snippet declarative/tutorials/extending/chapter3-bindings/app.qml 0
@@ -224,7 +224,7 @@ updates to the same value. When the window is clicked, the \c onClicked
 handler in the MouseArea changes the color of \c chartA, thereby changing
 both charts to the color blue.
 
-It's easy to enable property binding for the \c color property. 
+It's easy to enable property binding for the \c color property.
 We add a \l{Qt's Property System}{NOTIFY} feature to its Q_PROPERTY() declaration to indicate that a "colorChanged" signal
 is emitted whenever the value changes.
 
@@ -244,7 +244,7 @@ It's important for \c setColor() to check that the color value has actually chan
 before emitting \c colorChanged(). This ensures the signal is not emitted unnecessarily and
 also prevents loops when other elements respond to the value change.
 
-The use of bindings is essential to QML. You should always add NOTIFY 
+The use of bindings is essential to QML. You should always add NOTIFY
 signals for properties if they are able to be implemented, so that your
 properties can be used in bindings. Properties that cannot be bound cannot be
 automatically updated and cannot be used as flexibly in QML. Also, since
@@ -299,7 +299,7 @@ listed in the \l{Adding Properties} documentation, which includes the following:
 If we want to create a property whose type is not supported by QML by default,
 we need to register the type with QML.
 
-For example, let's replace the use of the \c property with a type called 
+For example, let's replace the use of the \c property with a type called
 "PieSlice" that has a \c color property. Instead of assigning a color,
 we assign an \c PieSlice value which itself contains a \c color:
 
@@ -358,10 +358,10 @@ have a \c slices property that accepts a list of \c PieSlice items:
 \image extending-tutorial-chapter5.png
 
 To do this, we replace the \c pieSlice property in \c PieChart with a \c slices property,
-declared as a QDeclarativeListProperty type. The QDeclarativeListProperty class enables the 
+declared as a QDeclarativeListProperty type. The QDeclarativeListProperty class enables the
 creation of list properties in QML extensions. We replace the \c pieSlice()
-function with a \c slices() function that returns a list of slices, and add 
-an internal \c append_slice() function (discussed below). We also use a QList to 
+function with a \c slices() function that returns a list of slices, and add
+an internal \c append_slice() function (discussed below). We also use a QList to
 store the internal list of slices as \c m_slices:
 
 \snippet declarative/tutorials/extending/chapter5-listproperties/piechart.h 0
@@ -409,7 +409,7 @@ To create a plugin library, we need:
 
 \list
 \o A plugin class that registers our QML types
-\o A project file that describes the plugin 
+\o A project file that describes the plugin
 \o A \l{Writing a qmldir file}{qmldir} file that tells the QML engine to load the plugin
 \endlist
 
@@ -468,8 +468,9 @@ In this tutorial, we've shown the basic steps for creating a QML extension:
 \endlist
 
 
-The \l {Extending QML in C++} reference documentation shows other useful features that can be added to
-QML extensions. For example, we could use \l{Default Property}{default properties} to allow 
+The \l {Extending QML Functionalities using C++} reference documentation shows
+other useful features that can be added to QML extensions. For example, we
+could use \l{Default Property}{default properties} to allow
 slices to be added without using the \c slices property:
 
 \code
@@ -489,7 +490,8 @@ Or randomly add and remove slices from time to time using \l{Property Value Sour
 \endcode
 
 
-See the \l{Extending QML in C++}{reference documentation} for more information.
+See the \l{Extending QML Functionalities using C++} reference documentation
+for more information.
 
 */
 
diff --git a/doc/src/declarative/extending.qdoc b/doc/src/declarative/extending.qdoc
index 51b52b0..d3f1521 100644
--- a/doc/src/declarative/extending.qdoc
+++ b/doc/src/declarative/extending.qdoc
@@ -29,7 +29,9 @@
 \page qml-extending.html
 \ingroup qml-features
 \contentspage QML Features
-\title Extending QML in C++
+\previouspage {Presenting Data with Views}
+\nextpage {Using QML Bindings in C++ Applications}
+\title Extending QML Functionalities using C++
 
 The QML syntax declaratively describes how to construct an in-memory object
 tree.  In Qt, QML is mainly used to describe a visual scene graph, but it is
@@ -431,7 +433,7 @@ on<Property-name>Changed, regardless of the name used for the NOTIFY
 signal in C++. We recommend using <property-name>Changed() for the
 NOTIFY signal in C++.
 
-See also \l {Writing QML Components: Properties, Methods and Signals}
+See also \l {Importing Reusable Components}
 
 \section1 Methods
 
@@ -637,469 +639,3 @@ public:
 
 */
 
-/*!
-\page qml-extending-types.html
-\ingroup qml-features
-\title Writing QML Components: Properties, Methods and Signals
-
-One of the key concepts in QML is the ability to define your own QML components that suit
-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++.
-
-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 doc/src/snippets/declarative/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
-\o \snippet doc/src/snippets/declarative/qml-extending-types/components/application.qml 0
-\o \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 {Modules}{module} from a specific filesystem path or \l{QDeclarativeExtensionPlugin}{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
-\o \bold 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}
-\o \bold Methods of JavaScript code can be invoked internally or externally (for example,
-   \l Animation has a \l {Animation::}{start()} method)
-\o \bold 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
-\o \snippet doc/src/snippets/declarative/qml-extending-types/properties/ImageViewer.qml 0
-\o \snippet doc/src/snippets/declarative/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
-// 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 \o QML Type Name \o Default value \o C++ Type Name
-\row \o int \o 0 \o int
-\row \o bool \o \c false \o bool
-\row \o double \o 0.0 \o double
-\row \o real \o 0.0 \o double
-\row \o string \o "" (empty string) \o QString
-\row \o url \o "" (empty url) \o QUrl
-\row \o color \o #000000 (black) \o QColor
-\row \o date \o \c undefined \o QDateTime
-\row \o variant \o \c undefined \o QVariant
-\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:
-
-\qml
-property Item itemProperty
-property QtObject objectProperty
-property MyCustomType customProperty
-\endqml
-
-Such object-type properties default to an \c undefined value.
-
-\l{list}{List properties} are created with the \c list<Type> syntax, and default to an empty
-list:
-
-\qml
-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.
-
-For details about accessing and manipulating QML properties from C++, see \l {Using QML with C++}.
-
-
-\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}
-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 doc/src/snippets/declarative/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 doc/src/snippets/declarative/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
-\o \snippet doc/src/snippets/declarative/qml-extending-types/properties/alias/ImageViewer.qml 0
-\o \snippet doc/src/snippets/declarative/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 doc/src/snippets/declarative/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 doc/src/snippets/declarative/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 {Integrating 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 {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
-\o onClicked
-\o onHovered
-\o 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
-\o \snippet doc/src/snippets/declarative/qml-extending-types/signals/basic.qml 0
-\o \snippet doc/src/snippets/declarative/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
-\o \snippet doc/src/snippets/declarative/qml-extending-types/signals/Button.qml 0
-\o \snippet doc/src/snippets/declarative/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 {Signal Handlers}{signal handler}.
-
-For example, the \c application.qml above could be rewritten as:
-
-\snippet doc/src/snippets/declarative/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{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:
-
-\snippet doc/src/snippets/declarative/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}.
-
-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/doc/src/declarative/focus.qdoc b/doc/src/declarative/focus.qdoc
index 3da60f1..be1000e 100644
--- a/doc/src/declarative/focus.qdoc
+++ b/doc/src/declarative/focus.qdoc
@@ -30,11 +30,14 @@
 \page qdeclarativefocus.html
 \ingroup qml-features
 \contentspage QML Features
+\previouspage {QML Text Handling and Validators}{Text Handling and Validators}
+\nextpage {Importing Reusable Components}
+
 \title Keyboard Focus in QML
 
 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 a
+and to address some of the cases unique to fluid user interfaces, the QML items add aged
 \e scope based extension to Qt's traditional keyboard focus model.
 
 \tableofcontents
diff --git a/doc/src/declarative/graphicaleffects.qdoc b/doc/src/declarative/graphicaleffects.qdoc
new file mode 100644
index 0000000..b5ef601
--- /dev/null
+++ b/doc/src/declarative/graphicaleffects.qdoc
@@ -0,0 +1,36 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qmlgraphicaleffects.html
+\ingroup qml-features
+\contentspage QML Features
+\previouspage {QML Internationalization}{Internationalization}
+\nextpage {QML Features}
+\title QML Graphical Effects
+
+*/
diff --git a/doc/src/declarative/integrating.qdoc b/doc/src/declarative/integrating.qdoc
index 23235d7..caba2cd 100644
--- a/doc/src/declarative/integrating.qdoc
+++ b/doc/src/declarative/integrating.qdoc
@@ -28,7 +28,10 @@
 /*!
 \page qml-integration.html
 \ingroup qml-features
-\title Integrating QML with existing Qt UI code
+\previouspage {Using QML Bindings in C++ Applications}
+\nextpage {QML Signal and Handler Event System}
+\contentspage QML Features
+\title Integrating QML Code with Existing Qt UI Code
 
 There are a number of ways to integrate QML into QWidget-based UI applications,
 depending on the characteristics of your existing UI code.
@@ -102,6 +105,7 @@ which shows how to expose Qt's graphics layout classes to QML in order
 to use QGraphicsWidget with classes like QGraphicsLinearLayout and QGraphicsGridLayout.
 
 To expose your existing QGraphicsWidget classes to QML, use \l {qmlRegisterType()}.
-See \l{Extending QML in C++} for further information on using C++ types in QML.
+See \l{Extending QML Functionalities using C++} for further information on
+how to use C++ types in QML.
 
 */
diff --git a/doc/src/declarative/mouseevents.qdoc b/doc/src/declarative/mouseevents.qdoc
new file mode 100644
index 0000000..f6512a7
--- /dev/null
+++ b/doc/src/declarative/mouseevents.qdoc
@@ -0,0 +1,52 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page mouseevents.html
+\title QML Mouse Events
+\ingroup QML Features
+\previouspage {Anchor-based Layout in QML}{Layouts using Anchors}
+\nextpage {QML Text Handling and Validators}{Text Handling and Validators}
+\contentspage QML Features
+
+\tableofcontents
+
+\section1 Introduction
+
+\section1 Mouse Events
+
+\list
+\o \l{MouseArea} Element
+\o \l{MouseEvent} Object
+\endlist
+
+\section1 Mouse Event Handling
+go over the slots and signals feature (without the C++)
+
+To learn more about QML's event system, please read the \l {QML Signal and Handler Event System} document.
+
+*/
diff --git a/doc/src/declarative/network.qdoc b/doc/src/declarative/network.qdoc
index 4354f9d..3348eb8 100644
--- a/doc/src/declarative/network.qdoc
+++ b/doc/src/declarative/network.qdoc
@@ -28,6 +28,9 @@
 /*!
 \page qdeclarativenetwork.html
 \ingroup qml-features
+\previouspage {Dynamic Object Management in QML}{Dynamic Object Management}
+\nextpage {QML Internationalization}{Internationalization}
+\contentspage QML Features
 \title Network Transparency
 
 QML supports network transparency by using URLs (rather than file names) for all
diff --git a/doc/src/declarative/propertybinding.qdoc b/doc/src/declarative/propertybinding.qdoc
index 92cf874..6f7c40a 100644
--- a/doc/src/declarative/propertybinding.qdoc
+++ b/doc/src/declarative/propertybinding.qdoc
@@ -29,12 +29,179 @@
 \page propertybinding.html
 \ingroup qml-features
 \contentspage QML Features
-\previouspage QML Features
-\nextpage Using QML Positioner and Repeater Items
+\previouspage QML Syntax
+\nextpage {QML Basic Types}{Data Types}
 \title Property Binding
 
+\section1 Properties
 
-\section1 Introduction
+QML property rules coincide with many of JavaScript's property rules.
+Properties begin with a lowercase letter (with the exception of
+\l{Attached Properties}). \l {JavaScript Reserved Words}{JavaScript reserved words}
+are not valid property names.
+
+\section1 Property types
+
+QML supports properties of many types (see \l{QML Basic Types}). The basic types
+include int, real, bool, string, color, and lists.
+
+\code
+Item {
+    x: 10.5             // a 'real' property
+    ...
+    state: "details"    // a 'string' property
+    focus: true         // a 'bool' property
+}
+\endcode
+
+QML properties are \i type-safe. That is, properties only allow you to assign
+a value that matches the property type. For example, the \c x property of item is a real, and if you try to assign
+a string to it you will get an error.
+
+\badcode
+Item {
+    property real value: "hello"  // illegal!
+}
+\endcode
+
+\section1 The \c id Property
+
+Each object can be given a special unique property called an \c id. No other object within the
+same QML component (see \l{QML Documents}) can have the same \c id value. Assigning an id enables the object
+to be referred to by other objects and scripts.
+
+The first Rectangle element below has an \c id, "myRect". The second Rectangle element defines its
+own width by referring to \tt myRect.width, which means it will have the same \tt width
+value as the first Rectangle element.
+
+\code
+Item {
+    Rectangle {
+        id: myRect
+        width: 100
+        height: 100
+    }
+    Rectangle {
+        width: myRect.width
+        height: 200
+    }
+}
+\endcode
+
+Note that an \c id must begin with a lower-case letter or an underscore. The \c id cannot contain characters other than letters, numbers, underscores, and \l {JavaScript Reserved Words}{JavaScript reserved words}.
+
+
+\section1 List properties
+
+List properties look like this:
+
+\code
+Item {
+    children: [
+        Image {},
+        Text {}
+    ]
+}
+\endcode
+
+The list is enclosed in square brackets, with a comma separating the
+list elements. In cases where you are only assigning a single item to a
+list, you can omit the square brackets:
+
+\code
+Image {
+    children: Rectangle {}
+}
+\endcode
+
+Items in the list can be accessed by the \c index. See the \l{list}{list type} documentation
+for more details about list properties and their available operations.
+
+
+\section1 Default Properties
+
+Each object type can specify one of its list or object properties as its default property.
+If a property has been declared as the default property, the property tag can be omitted.
+
+For example this code:
+\code
+State {
+    changes: [
+        PropertyChanges {},
+        PropertyChanges {}
+    ]
+}
+\endcode
+
+can be simplified to:
+
+\code
+State {
+    PropertyChanges {}
+    PropertyChanges {}
+}
+\endcode
+
+because \c changes is the default property of the \c State type.
+
+\section1 Grouped Properties
+\target dot properties
+
+In some cases properties form a logical group and use a 'dot' or grouped notation
+to show this.
+
+Grouped properties can be written like this:
+\qml
+Text {
+    font.pixelSize: 12
+    font.bold: true
+}
+\endqml
+
+or like this:
+\qml
+Text {
+    font { pixelSize: 12; bold: true }
+}
+\endqml
+
+In the element documentation grouped properties are shown using the 'dot' notation.
+
+\section1 Attached Properties
+\target attached-properties
+
+Some objects attach properties to another object.  Attached Properties
+are of the form \c {Type.property} where \c Type is the type of the
+element that attaches \c property.
+
+For example:
+\code
+Component {
+    id: myDelegate
+    Text {
+        text: "Hello"
+        color: ListView.isCurrentItem ? "red" : "blue"
+    }
+}
+ListView {
+    delegate: myDelegate
+}
+\endcode
+
+The \l ListView element attaches the \c ListView.isCurrentItem property
+to each delegate it creates.
+
+Another example of attached properties is the \l Keys element which
+attaches properties for handling key presses to
+any visual Item, for example:
+
+\code
+Item {
+    focus: true
+    Keys.onSelectPressed: console.log("Selected")
+}
+\endcode
+\section1 Property Binding
 Property binding is a declarative way of specifying the value of a property.  Binding allows
 a property's value to be expressed as an JavaScript expression that defines the value relative
 to other property values or data accessible in the application.  The property value is
@@ -103,7 +270,7 @@ Rectangle {
 
 \section1 Effects of Property Assignment in JavaScript
 
-Assigning a property value from JavaScript does \i not create a property binding.
+Assigning a property value from JavaScript does \e not create a property binding.
 For example:
 
 \code
@@ -153,7 +320,5 @@ Binding {
     value: slider.value
 }
 \endqml
-
-
 */
 
diff --git a/doc/src/declarative/qdeclarativei18n.qdoc b/doc/src/declarative/qdeclarativei18n.qdoc
index fac1e55..cd4ccf0 100644
--- a/doc/src/declarative/qdeclarativei18n.qdoc
+++ b/doc/src/declarative/qdeclarativei18n.qdoc
@@ -28,6 +28,9 @@
 /*!
 \page qdeclarativei18n.html
 \ingroup qml-features
+\contentspage QML Features
+\previouspage {Network Transparency}{Loading Resources in QML}
+\nextpage {QML Graphical Effects}{Graphical Effects}
 \title QML Internationalization
 
 \section1 Overview
diff --git a/doc/src/declarative/qdeclarativemodels.qdoc b/doc/src/declarative/qdeclarativemodels.qdoc
index 0be29e1..e1a425f 100644
--- a/doc/src/declarative/qdeclarativemodels.qdoc
+++ b/doc/src/declarative/qdeclarativemodels.qdoc
@@ -29,6 +29,8 @@
 \page qdeclarativemodels.html
 \ingroup qml-features
 \contentspage QML Features
+\previouspage {QML Animation and Transitions}{Animation and Transitions}
+\nextpage {Presenting Data with Views}
 \target qmlmodels
 \title QML Data Models
 
@@ -70,7 +72,8 @@ QML provides several types of data models among the built-in set of
 QML elements. In addition, models can be created with C++ and then
 made available to QML components.
 
-The views used to access data models are described in \l{Presenting Data with QML}.
+The views used to access data models are described in the
+\l{Presenting Data with Views} overview.
 The use of positioner items to arrange items from a model is covered in
 \l{Using QML Positioner and Repeater Items}.
 
@@ -465,86 +468,3 @@ a function in the model, e.g.:
 updated, and that \e{value} holds the new value.
 
 */
-
-/*!
-\page qml-presenting-data.html
-\ingroup qml-features
-\contentspage QML Features
-\title Presenting Data with QML
-
-\section1 Introduction
-
-Qt Quick contains a set of standard items that can be used to present data in a
-number of different ways. For simple user interfaces,
-\l{Using QML Positioner and Repeater Items#Repeaters}{Repeaters} can be used
-in combination with
-\l{Using QML Positioner and Repeater Items#Positioners}{Positioners}
-to obtain pieces of data and arrange them in a user interface. However, when
-large quantities of data are involved, it is often better to use models with
-the standard views since these contain many built-in display and navigation
-features.
-
-\section1 Views
-
-Views are scrolling containers for collections of items. They are feature-rich,
-supporting many of the use cases found in typical applications, and can be
-customized to meet requirements on style and behavior.
-
-A set of standard views are provided in the basic set of Qt Quick
-graphical elements:
-
-\list
-\o \l{#ListView}{ListView} arranges items in a horizontal or vertical list
-\o \l{#GridView}{GridView} arranges items in a grid within the available space
-\o \l{#PathView}{PathView} arranges items on a path
-\endlist
-
-Unlike these items, \l WebView is not a fully-featured view item, and needs
-to be combined with a \l Flickable item to create a view that performs like
-a Web browser.
-
-\section2 ListView
-
-\l ListView shows a classic list of items with horizontal or vertical placing
-of items.
-
-\div{float-right}
-\inlineimage qml-listview-snippet.png
-\enddiv
-
-The following example shows a minimal ListView displaying a sequence of
-numbers (using an \l{QML Data Models#An Integer}{integer as a model}).
-A simple delegate is used to define an items for each piece of data in the
-model.
-
-\clearfloat
-\snippet doc/src/snippets/declarative/listview/listview-snippet.qml document
-
-
-
-\section2 GridView
-
-\l GridView displays items in a grid like an file manager's icon view.
-
-\section2 PathView
-
-\l PathView displays items on a path, where the selection remains in
-the same place and the items move around it.
-
-\section1 Decorating Views
-
-\section2 Headers and Footers
-
-\section2 Sections
-
-\section2 Navigation
-
-In traditional user interfaces, views can be scrolled using standard
-controls, such as scroll bars and arrow buttons. In some situations, it
-is also possible to drag the view directly by pressing and holding a
-mouse button while moving the cursor. In touch-based user interfaces,
-this dragging action is often complemented with a flicking action, where
-scrolling continues after the user has stopped touching the view.
-
-\section1 Further Reading
-*/
diff --git a/doc/src/declarative/qdeclarativestates.qdoc b/doc/src/declarative/qdeclarativestates.qdoc
index f378ce6..3266bae 100644
--- a/doc/src/declarative/qdeclarativestates.qdoc
+++ b/doc/src/declarative/qdeclarativestates.qdoc
@@ -29,6 +29,8 @@
 \page qdeclarativestates.html
 \ingroup qml-features
 \contentspage QML Features
+\previouspage {Importing Reusable Components}
+\nextpage {QML Animation and Transitions}{Animation and Transitions}
 \target qmlstates
 \title QML States
 
diff --git a/doc/src/declarative/qmlevents.qdoc b/doc/src/declarative/qmlevents.qdoc
new file mode 100644
index 0000000..3c1c8df
--- /dev/null
+++ b/doc/src/declarative/qmlevents.qdoc
@@ -0,0 +1,37 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page qmlevents.html
+    \ingroup qml-features
+    \contentspage QML Features
+    \previouspage {Integrating QML Code with Existing Qt UI Code}
+    \nextpage {Dynamic Object Management in QML}{Dynamic Object Management}
+
+    \title QML Signal and Handler Event System
+
+*/
diff --git a/doc/src/declarative/qmlreusablecomponents.qdoc b/doc/src/declarative/qmlreusablecomponents.qdoc
new file mode 100644
index 0000000..78865a1
--- /dev/null
+++ b/doc/src/declarative/qmlreusablecomponents.qdoc
@@ -0,0 +1,497 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qmlreusablecomponents.html
+\ingroup qml-features
+\previouspage {Keyboard Focus in QML}{Keyboard Focus}
+\nextpage {QML States}{States}
+\contentspage QML Features
+
+\title Importing Reusable Components
+
+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++.
+
+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 doc/src/snippets/declarative/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
+\o \snippet doc/src/snippets/declarative/qml-extending-types/components/application.qml 0
+\o \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 {Modules}{module} from a specific filesystem path or \l{QDeclarativeExtensionPlugin}{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
+\o \bold 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}
+\o \bold Methods of JavaScript code can be invoked internally or externally (for example,
+   \l Animation has a \l {Animation::}{start()} method)
+\o \bold 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
+\o \snippet doc/src/snippets/declarative/qml-extending-types/properties/ImageViewer.qml 0
+\o \snippet doc/src/snippets/declarative/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
+// 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 \o QML Type Name \o Default value \o C++ Type Name
+\row \o int \o 0 \o int
+\row \o bool \o \c false \o bool
+\row \o double \o 0.0 \o double
+\row \o real \o 0.0 \o double
+\row \o string \o "" (empty string) \o QString
+\row \o url \o "" (empty url) \o QUrl
+\row \o color \o #000000 (black) \o QColor
+\row \o date \o \c undefined \o QDateTime
+\row \o variant \o \c undefined \o QVariant
+\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:
+
+\qml
+property Item itemProperty
+property QtObject objectProperty
+property MyCustomType customProperty
+\endqml
+
+Such object-type properties default to an \c undefined value.
+
+\l{list}{List properties} are created with the \c list<Type> syntax, and default to an empty
+list:
+
+\qml
+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.
+
+For details about accessing and manipulating QML properties from C++, see \l {Using QML Bindings in C++ Applications}.
+
+
+\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}
+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 doc/src/snippets/declarative/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 doc/src/snippets/declarative/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
+\o \snippet doc/src/snippets/declarative/qml-extending-types/properties/alias/ImageViewer.qml 0
+\o \snippet doc/src/snippets/declarative/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 doc/src/snippets/declarative/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 doc/src/snippets/declarative/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 {Integrating 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 {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
+\o onClicked
+\o onHovered
+\o 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
+\o \snippet doc/src/snippets/declarative/qml-extending-types/signals/basic.qml 0
+\o \snippet doc/src/snippets/declarative/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
+\o \snippet doc/src/snippets/declarative/qml-extending-types/signals/Button.qml 0
+\o \snippet doc/src/snippets/declarative/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 {Signal Handlers}{signal handler}.
+
+For example, the \c application.qml above could be rewritten as:
+
+\snippet doc/src/snippets/declarative/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{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:
+
+\snippet doc/src/snippets/declarative/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}.
+
+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/doc/src/declarative/qmlruntime.qdoc b/doc/src/declarative/qmlruntime.qdoc
index dfc0ad9..7a59959 100644
--- a/doc/src/declarative/qmlruntime.qdoc
+++ b/doc/src/declarative/qmlruntime.qdoc
@@ -29,13 +29,13 @@
 \page qmlruntime.html
 \title Qt Declarative UI Runtime
 
-QML documents are loaded and executed by the QML runtime. This includes the 
+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 QDeclarativeView 
-or a QDeclarativeEngine, as described below. In addition, the Declarative UI 
+Applications that use QML need to invoke the QML runtime in order to
+execute QML documents. This can be done by creating a QDeclarativeView
+or a QDeclarativeEngine, as described below. In addition, the Declarative UI
 package includes the \QQV 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.
@@ -44,7 +44,7 @@ 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 
+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
 QDeclarativeEngine by either:
 
@@ -61,12 +61,12 @@ For example, if there is a QML file, \c application.qml, like this:
 
 \qml
     import QtQuick 1.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 <QDeclarativeView>
@@ -82,10 +82,10 @@ It can be loaded in a Qt application's \c main.cpp file like this:
         return app.exec();
     }
 \endcode
-       
-This creates a QWidget-based view that displays the contents of 
+
+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:
 
@@ -97,36 +97,36 @@ the \c declarative module for the \c QT variable. For example:
 
 
 \section2 Creating a QDeclarativeEngine directly
-     
-If \c application.qml does not have any graphical components, or if it is 
+
+If \c application.qml does not have any graphical components, or if it is
 preferred to avoid QDeclarativeView for other reasons, the QDeclarativeEngine
 can be constructed directly instead. In this case, \c application.qml is
 loaded as a QDeclarativeComponent instance rather than placed into a view:
 
 \code
     #include <QApplication>
-    #include <QDeclarativeEngine>    
+    #include <QDeclarativeEngine>
     #include <QDeclarativeContext>
     #include <QDeclarativeComponent>
 
     int main(int argc, char *argv[])
     {
         QApplication app(argc, argv);
-    
+
         QDeclarativeEngine engine;
         QDeclarativeContext *objectContext = new QDeclarativeContext(engine.rootContext());
-    
+
         QDeclarativeComponent component(&engine, "application.qml");
         QObject *object = component.create(objectContext);
-         
+
         // ... delete object and objectContext when necessary
-    
+
         return app.exec();
     }
 \endcode
 
-See \l {Using QML in C++ Applications} for more information about using 
-QDeclarativeEngine, QDeclarativeContext and QDeclarativeComponent, as well 
+See \l {Using QML Bindings in C++ Applications} for more information about using
+QDeclarativeEngine, QDeclarativeContext and QDeclarativeComponent, as well
 as details on including QML files through \l{The Qt Resource System}{Qt's Resource system}.
 
 
@@ -135,8 +135,8 @@ as details on including QML files through \l{The Qt Resource System}{Qt's Resour
 
 The Declarative UI package includes a QML runtime tool, the \QQV, 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. 
+phase for prototyping QML-based applications without writing your own C++
+applications to invoke the QML runtime.
 
 See the \l{QML Viewer} documentation for more details.
 
diff --git a/doc/src/declarative/qmlsyntax.qdoc b/doc/src/declarative/qmlsyntax.qdoc
index 4ff2437..908b924 100644
--- a/doc/src/declarative/qmlsyntax.qdoc
+++ b/doc/src/declarative/qmlsyntax.qdoc
@@ -30,6 +30,7 @@
 \title QML Syntax
 \ingroup QML Features
 \previouspage QML Features
+\nextpage Property Binding
 \contentspage QML Features
 
 \tableofcontents
@@ -38,11 +39,9 @@ QML is a declarative language designed to describe the user interface of a
 program: both what it looks like, and how it behaves. In QML, a user
 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
+JavaScript is used as a scripting language in QML, so you may want
 to learn a bit more about it (\l{Javascript Guide}) before diving
-deeper into QML. It's also helpful to have a basic understanding of other web
-technologies like HTML and CSS, but it's not required.
+deeper into QML.
 
 \section1 Basic QML Syntax
 
diff --git a/doc/src/declarative/qmltexthandling.qdoc b/doc/src/declarative/qmltexthandling.qdoc
new file mode 100644
index 0000000..c5a6bc9
--- /dev/null
+++ b/doc/src/declarative/qmltexthandling.qdoc
@@ -0,0 +1,55 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page texthandling.html
+\title QML Text Handling and Validators
+\ingroup QML Features
+\previouspage {QML Mouse Events}{Mouse Events}
+\nextpage {Keyboard Focus in QML}{Keyboard Focus}
+\contentspage QML Features
+
+\tableofcontents
+
+\section1 Introduction
+
+\section1 Text Elements
+
+\list
+\o \l{Text}
+\o \l{TextInput}
+\o \l{TextEdit}
+\endlist
+
+\section1 Validators
+\list
+\o \l{IntValidator}
+\o \l{DoubleValidator}
+\o \l{RegExpValidator}
+\endlist
+
+*/
diff --git a/doc/src/declarative/qmlviewer.qdoc b/doc/src/declarative/qmlviewer.qdoc
index 82f1fec..551b20c 100644
--- a/doc/src/declarative/qmlviewer.qdoc
+++ b/doc/src/declarative/qmlviewer.qdoc
@@ -31,34 +31,34 @@
 \title QML Viewer
 \ingroup qttools
 
-The Declarative UI package includes \QQV, a tool for loading QML documents that 
-makes it easy to quickly develop and debug QML applications. It invokes the QML 
-runtime to load QML documents and also includes additional features useful for 
+The Declarative UI package includes \QQV, a tool for loading QML documents that
+makes it easy to quickly develop and debug QML applications. It invokes the QML
+runtime to load QML documents and also includes additional features useful for
 the development of QML-based applications.
 
-The QML Viewer is a tool for testing and developing QML applications. It is 
-\e not intended for use in a production environment and should not be used for the 
+The QML Viewer is a tool 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, the QML runtime should be invoked
 from a Qt application instead; see \l {Qt Declarative UI Runtime} for more
 information.
 
 The viewer is located at \c QTDIR/bin/qmlviewer. To load a \c .qml file
-with the viewer, run the viewer and select the file to be opened, or provide the 
+with the viewer, run the viewer and select the file to be opened, or provide the
 file path on the command line:
 
 \code
     qmlviewer myqmlfile.qml
 \endcode
-    
+
 On Mac OS X, the QML Viewer application is named "QMLViewer" instead. You
-can launch the viewer by opening the QMLViewer application from the Finder, or 
+can launch the viewer by opening the QMLViewer application from the Finder, or
 from the command line:
 
 \code
     QMLViewer.app/Contents/MacOS/QMLViewer myqmlfile.qml
 \endcode
 
-The QML Viewer has a number of configuration options involving features such as 
+The QML Viewer has a number of configuration options involving features such as
 fullscreen display, module import path configurations, video recording of QML
 animations, and OpenGL support.
 
@@ -68,7 +68,7 @@ To see the configuration options, run \c qmlviewer 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 
+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, the viewer has to be run with the \c -I flag from the example's
 base directory:
@@ -87,16 +87,16 @@ the path is explicitly added.
 
 \section1 Loading translation files
 
-When the QML Viewer loads a QML file, it installs a translation file from a 
-"i18n" subdirectory relative to that initial file. This directory should contain 
+When the QML Viewer loads a QML file, it installs a translation file from a
+"i18n" subdirectory relative to that initial file. This directory should contain
 translation files named "qml_<language>.qm", where <language> is a two-letter
 ISO 639 language, such as "qml_fr.qm", optionally followed by an underscore and
 an uppercase two-letter ISO 3166 country code, such as "qml_fr_FR.qm" or
-"qml_fr_CA.qm". 
+"qml_fr_CA.qm".
 
 Such files can be created using \l {Qt Linguist}.
 
-The actual translation file that is loaded depends on the system locale. 
+The actual translation file that is loaded depends on the system locale.
 Additionally, the viewer will load any translation files specified on the command
 line via the \c -translation option.
 
@@ -110,7 +110,7 @@ shows how JavaScript code in QML files can be made to use translatable strings.
 Often, QML applications are prototyped with fake data that is later replaced
 by real data sources from C++ plugins. QML Viewer 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 
+"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.
 
@@ -124,7 +124,7 @@ ListView {
     width: 200; height: 300
     model: lottoNumbers
     delegate: Text { text: number }
-}        
+}
 \endqml
 
 If within the document's directory, there is a "dummydata" directory which
@@ -146,30 +146,30 @@ Child properties are included when loaded from dummy data. The following documen
 refers to a \c clock.time property:
 
 \qml
-import QtQuick 1.0    
+import QtQuick 1.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 1.0    
+import QtQuick 1.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 QDeclarativeContext::setContextProperty(). This
-is detailed in \l {Using QML in C++ Applications}.
+is detailed in \l {Using QML Bindings in C++ Applications}.
 
 \section1 Using the \c runtime object
 
 QML applications that are loaded with the QML Viewer have access to a special
-\c runtime property on the root context. This property provides additional 
+\c runtime property on the root context. This property provides additional
 information about the application's runtime environment through the following properties:
 
 \table
-\row 
+\row
 
 \o \c runtime.isActiveWindow
 
@@ -177,9 +177,9 @@ information about the application's runtime environment through the following pr
 window on the system. It is useful for "pausing" an application, particularly
 animations, when the QML Viewer loses focus or moves to the background.
 
-For example, the following animation is only played when the QML Viewer is 
+For example, the following animation is only played when the QML Viewer is
 the active window:
-    
+
 \qml
 Rectangle {
     width: 200; height: 200
@@ -197,9 +197,9 @@ Rectangle {
 \o \c runtime.orientation
 
 \o This property indicates the current orientation of the QML Viewer. On the
-N900 platform and most S60 5.0-based or newer Symbian devices, this property 
-automatically updates to reflect the device's actual orientation; on other platforms, 
-this indicates the orientation currently selected in the QML Viewer's 
+N900 platform and most S60 5.0-based or newer Symbian devices, this property
+automatically updates to reflect the device's actual orientation; on other platforms,
+this indicates the orientation currently selected in the QML Viewer's
 \e {Settings -> Properties} menu. The \c orientation value can be one of the following:
 
 \list
@@ -210,7 +210,7 @@ this indicates the orientation currently selected in the QML Viewer's
 \endlist
 
 When the viewer's orientation changes, the appearance of the loaded QML document
-does not change unless it has been set to respond to changes in 
+does not change unless it has been set to respond to changes in
 \c runtime.orientation. For example, the following Rectangle changes its
 aspect ratio depending on the orientation of the QML Viewer:
 
@@ -218,12 +218,12 @@ aspect ratio depending on the orientation of the QML Viewer:
 Rectangle {
     id: window
     width: 640; height: 480
-            
+
     states: State {
         name: "landscape"
         PropertyChanges { target: window; width: 480; height: 640 }
     }
-    state: (runtime.orientation == Orientation.Landscape 
+    state: (runtime.orientation == Orientation.Landscape
             || runtime.orientation == Orientation.LandscapeInverted) ? 'landscape' : ''
 }
 \endqml
diff --git a/doc/src/declarative/qmlviews.qdoc b/doc/src/declarative/qmlviews.qdoc
new file mode 100644
index 0000000..3f74214
--- /dev/null
+++ b/doc/src/declarative/qmlviews.qdoc
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qml-views.html
+\ingroup qml-features
+\contentspage QML Features
+\previouspage {QML Data Models}{Structuring Data with Models}
+\nextpage {Extending QML Functionalities using C++}
+\title Presenting Data with Views
+
+\section1 Introduction
+
+Qt Quick contains a set of standard items that can be used to present data in a
+number of different ways. For simple user interfaces,
+\l{Using QML Positioner and Repeater Items#Repeaters}{Repeaters} can be used
+in combination with
+\l{Using QML Positioner and Repeater Items#Positioners}{Positioners}
+to obtain pieces of data and arrange them in a user interface. However, when
+large quantities of data are involved, it is often better to use models with
+the standard views since these contain many built-in display and navigation
+features.
+
+\section1 Views
+
+Views are scrolling containers for collections of items. They are feature-rich,
+supporting many of the use cases found in typical applications, and can be
+customized to meet requirements on style and behavior.
+
+A set of standard views are provided in the basic set of Qt Quick
+graphical elements:
+
+\list
+\o \l{#ListView}{ListView} arranges items in a horizontal or vertical list
+\o \l{#GridView}{GridView} arranges items in a grid within the available space
+\o \l{#PathView}{PathView} arranges items on a path
+\endlist
+
+Unlike these items, \l WebView is not a fully-featured view item, and needs
+to be combined with a \l Flickable item to create a view that performs like
+a Web browser.
+
+\section2 ListView
+
+\l ListView shows a classic list of items with horizontal or vertical placing
+of items.
+
+\beginfloatright
+\inlineimage qml-listview-snippet.png
+\endfloat
+
+The following example shows a minimal ListView displaying a sequence of
+numbers (using an \l{QML Data Models#An Integer}{integer as a model}).
+A simple delegate is used to define an items for each piece of data in the
+model.
+
+\clearfloat
+\snippet doc/src/snippets/declarative/listview/listview-snippet.qml document
+
+
+
+\section2 GridView
+
+\l GridView displays items in a grid like an file manager's icon view.
+
+\section2 PathView
+
+\l PathView displays items on a path, where the selection remains in
+the same place and the items move around it.
+
+\section1 Decorating Views
+
+\section2 Headers and Footers
+
+\section2 Sections
+
+\section2 Navigation
+
+In traditional user interfaces, views can be scrolled using standard
+controls, such as scroll bars and arrow buttons. In some situations, it
+is also possible to drag the view directly by pressing and holding a
+mouse button while moving the cursor. In touch-based user interfaces,
+this dragging action is often complemented with a flicking action, where
+scrolling continues after the user has stopped touching the view.
+
+\section1 Further Reading
+*/
diff --git a/doc/src/declarative/qmlwebkit.qdoc b/doc/src/declarative/qmlwebkit.qdoc
new file mode 100644
index 0000000..0f4e86b
--- /dev/null
+++ b/doc/src/declarative/qmlwebkit.qdoc
@@ -0,0 +1,47 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page qmlwebkit.html
+
+    \title QtWebKit QML Module
+
+    Qt WebKit QML
+
+    \section1 WebKit QML Elements
+    \list
+    \o \l WebView
+    \o \l FlickableWebView
+    \endlist
+
+    \section1 Content
+
+    \section1 Usage Ideas
+
+    \section1 Other Suggestions
+
+*/
diff --git a/doc/src/declarative/qtbinding.qdoc b/doc/src/declarative/qtbinding.qdoc
index 0a66226..a7aacdb 100644
--- a/doc/src/declarative/qtbinding.qdoc
+++ b/doc/src/declarative/qtbinding.qdoc
@@ -28,10 +28,12 @@
 /*!
 \page qtbinding.html
 \ingroup qml-features
-\target qtbinding
-\title Using QML in C++ Applications
+\previouspage {Extending QML Functionalities using C++}
+\nextpage {Integrating QML Code with Existing Qt UI Code}
+\contentspage QML Features
+\title Using QML Bindings in C++ Applications
 
-QML is designed to be easily extensible from C++. The classes in the
+QML is designed to be easily extensible to and from C++. The classes in the
 Qt Declarative module allow QML components to be loaded and manipulated from C++, and through
 Qt's \l{The Meta-Object System}{meta-object system}, QML and C++ objects can easily
 communicate through Qt signals and slots. In addition, QML plugins can be written to create
@@ -86,7 +88,7 @@ delete rectangleInstance;
 
 QML documents can also be loaded using QDeclarativeView. This class provides a convenient
 QWidget-based view for embedding QML components into QGraphicsView-based applications. (For other
-methods of integrating QML into QWidget-based applications, see \l {Integrating QML with existing Qt
+methods of integrating QML into QWidget-based applications, see \l {Integrating QML Code with existing Qt
 UI code}.)
 
 
@@ -254,8 +256,8 @@ Note that custom C++ types do not have to inherit from QDeclarativeItem; this is
 a displayable item. If the item is not displayable, it can simply inherit from QObject.
 
 For more information on defining new QML elements, see the \l {Tutorial: Writing QML extensions with C++}
-{Writing QML extensions with C++} tutorial and the \l {Extending QML in C++} reference
-documentation.
+{Writing QML extensions with C++} tutorial and the
+\l {Extending QML Functionalities using C++} reference documentation.
 
 
 
@@ -485,7 +487,8 @@ can be registered using qmlRegisterUncreatableType().  To be accessible from QML
 must begin with a capital letter.
 
 See the \l {Tutorial: Writing QML extensions with C++}{Writing QML extensions with C++} tutorial and
-the \l {Extending QML in C++} reference documentation for more information.
+the \l {Extending QML Functionalities using C++} reference documentation for
+more information.
 
 
 \section2 Automatic type conversion from strings
diff --git a/doc/src/declarative/qtprogrammers.qdoc b/doc/src/declarative/qtprogrammers.qdoc
index 0c14093..1746c31 100644
--- a/doc/src/declarative/qtprogrammers.qdoc
+++ b/doc/src/declarative/qtprogrammers.qdoc
@@ -48,7 +48,8 @@ QML provides direct access to the following concepts from Qt:
  \o Qt models - used directly in data binding (QAbstractItemModel)
 \endlist
 
-Qt knowledge is \e required for \l {Extending QML in C++}, and also for \l{Integrating QML with existing Qt UI code}.
+Qt knowledge is \e required for \l {Extending QML Functionalities using C++},
+and also for \l{Integrating QML Code with existing Qt UI code}.
 
 \section1 QML Items compared with QWidgets