116 files changed, 2958 insertions, 2385 deletions

diff --git a/doc/src/annotated.qdoc b/doc/src/annotated.qdoc
deleted file mode 100644
index a817df6..0000000
--- a/doc/src/annotated.qdoc
+++ /dev/null
@@ -1,62 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** 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 either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at http://www.qtsoftware.com/contact.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/****************************************************************************
-**
-** Documentation for class overview.
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Qt GUI Toolkit.
-** EDITIONS: FREE, PROFESSIONAL, ENTERPRISE
-**
-****************************************************************************/
-
-/*!
-    \page annotated.html
-    \title Annotated Class Index
-    \ingroup classlists
-
-    Qt's classes with brief descriptions:
-
-    \generatelist annotatedclasses
-*/
diff --git a/doc/src/bughowto.qdoc b/doc/src/bughowto.qdoc
index 927cb04..fae1180 100644
--- a/doc/src/bughowto.qdoc
+++ b/doc/src/bughowto.qdoc
@@ -52,7 +52,9 @@
     Notes}, and the \l{Task Tracker} on the Qt website to see
     if the issue is already known.
 
-    Always include the following information in your bug report:
+    If you have found a new bug, please submit a bug report using
+    the \l{Bug Report Form}. Always include the following information
+    in your bug report:
 
     \list 1
     \o The name and version number of your compiler
@@ -66,6 +68,6 @@
     such a program can be created with some minor changes to one
     of the many example programs in Qt's \c examples directory.
 
-    Please submit the bug report using the \l{Task Tracker} on the Qt
-    website.
+    If you have implemented a bug fix and want to contribute your fix
+    directly, then you can do so through the \l{Public Qt Repository}.
 */
diff --git a/doc/src/classes.qdoc b/doc/src/classes.qdoc
index 9a5d3ec..e955a5a 100644
--- a/doc/src/classes.qdoc
+++ b/doc/src/classes.qdoc
@@ -40,6 +40,18 @@
 ****************************************************************************/
 
 /*!
+    \group groups
+    \title Grouped Classes
+    \ingroup classlists
+
+    This page provides a way of navigating Qt's classes by grouping
+    related classes together. Some classes may appear in more than one group.
+
+    \generatelist{related}
+
+*/
+
+/*!
     \page classes.html
     \title Qt's Classes
     \ingroup classlists
@@ -65,3 +77,77 @@
 
     \generatelist{namespaces}
 */
+
+/*!
+    \page obsoleteclasses.html
+    \title Obsolete Classes
+    \ingroup classlists
+
+
+    This is a list of Qt classes that are obsolete (deprecated). These
+    classes are provided to keep old source code working but they are
+    no longer maintained. We strongly advise against using these
+    classes in new code.
+
+    \generatelist obsoleteclasses
+
+    \sa {Qt's Classes}, {Qt's Modules}
+*/
+
+/*!
+    \page annotated.html
+    \title Annotated Class Index
+    \ingroup classlists
+
+    Qt's classes with brief descriptions:
+
+    \generatelist annotatedclasses
+*/
+
+/*!
+    \page functions.html
+    \title Member Function Index
+    \ingroup classlists
+
+    Here is the list of all the documented member functions in the Qt
+    API with links to the class documentation for each function.
+
+    \generatelist functionindex
+*/
+
+/*!
+    \page hierarchy.html
+
+    \title Class Inheritance Hierarchy
+    \ingroup classlists
+
+    This list shows the C++ class inheritance relations between the
+    classes in the Qt API.
+
+    \generatelist classhierarchy
+*/
+
+/*!
+    \page mainclasses.html
+    \title Qt's Main Classes
+    \ingroup classlists
+
+    These are the most frequently used Qt classes. For the complete
+    list see \link classes.html Qt's Classes \endlink.
+
+    \generatelist mainclasses
+*/
+
+/*!
+    \page compatclasses.html
+    \title Qt 3 Compatibility Classes
+    \ingroup classlists
+
+    This is a list of the classes that Qt provides for compatibility
+    with Qt 3. The vast majority of these are provided by the
+    Qt3Support module.
+
+    \generatelist compatclasses
+
+    \sa {Qt's Classes}, {Qt's Modules}
+*/
diff --git a/doc/src/phonon-api.qdoc b/doc/src/classes/phonon-api.qdoc
index 09274bf..09274bf 100644
--- a/doc/src/phonon-api.qdoc
+++ b/doc/src/classes/phonon-api.qdoc
diff --git a/doc/src/q3asciicache.qdoc b/doc/src/classes/q3asciicache.qdoc
index 43537cc..43537cc 100644
--- a/doc/src/q3asciicache.qdoc
+++ b/doc/src/classes/q3asciicache.qdoc
diff --git a/doc/src/q3asciidict.qdoc b/doc/src/classes/q3asciidict.qdoc
index 9a51db1..9a51db1 100644
--- a/doc/src/q3asciidict.qdoc
+++ b/doc/src/classes/q3asciidict.qdoc
diff --git a/doc/src/q3cache.qdoc b/doc/src/classes/q3cache.qdoc
index d8799b6..d8799b6 100644
--- a/doc/src/q3cache.qdoc
+++ b/doc/src/classes/q3cache.qdoc
diff --git a/doc/src/q3dict.qdoc b/doc/src/classes/q3dict.qdoc
index 0e6d51d..0e6d51d 100644
--- a/doc/src/q3dict.qdoc
+++ b/doc/src/classes/q3dict.qdoc
diff --git a/doc/src/q3intcache.qdoc b/doc/src/classes/q3intcache.qdoc
index dfff679..dfff679 100644
--- a/doc/src/q3intcache.qdoc
+++ b/doc/src/classes/q3intcache.qdoc
diff --git a/doc/src/q3intdict.qdoc b/doc/src/classes/q3intdict.qdoc
index cef2e79..cef2e79 100644
--- a/doc/src/q3intdict.qdoc
+++ b/doc/src/classes/q3intdict.qdoc
diff --git a/doc/src/q3memarray.qdoc b/doc/src/classes/q3memarray.qdoc
index b9c1f73..b9c1f73 100644
--- a/doc/src/q3memarray.qdoc
+++ b/doc/src/classes/q3memarray.qdoc
diff --git a/doc/src/q3popupmenu.qdoc b/doc/src/classes/q3popupmenu.qdoc
index a2cfe08..a2cfe08 100644
--- a/doc/src/q3popupmenu.qdoc
+++ b/doc/src/classes/q3popupmenu.qdoc
diff --git a/doc/src/q3ptrdict.qdoc b/doc/src/classes/q3ptrdict.qdoc
index 38ca0bb..38ca0bb 100644
--- a/doc/src/q3ptrdict.qdoc
+++ b/doc/src/classes/q3ptrdict.qdoc
diff --git a/doc/src/q3ptrlist.qdoc b/doc/src/classes/q3ptrlist.qdoc
index 3000940..3000940 100644
--- a/doc/src/q3ptrlist.qdoc
+++ b/doc/src/classes/q3ptrlist.qdoc
diff --git a/doc/src/q3ptrqueue.qdoc b/doc/src/classes/q3ptrqueue.qdoc
index b3af5f6..b3af5f6 100644
--- a/doc/src/q3ptrqueue.qdoc
+++ b/doc/src/classes/q3ptrqueue.qdoc
diff --git a/doc/src/q3ptrstack.qdoc b/doc/src/classes/q3ptrstack.qdoc
index 1650d69..1650d69 100644
--- a/doc/src/q3ptrstack.qdoc
+++ b/doc/src/classes/q3ptrstack.qdoc
diff --git a/doc/src/q3ptrvector.qdoc b/doc/src/classes/q3ptrvector.qdoc
index fa78de5..fa78de5 100644
--- a/doc/src/q3ptrvector.qdoc
+++ b/doc/src/classes/q3ptrvector.qdoc
diff --git a/doc/src/q3sqlfieldinfo.qdoc b/doc/src/classes/q3sqlfieldinfo.qdoc
index ba064f3..ba064f3 100644
--- a/doc/src/q3sqlfieldinfo.qdoc
+++ b/doc/src/classes/q3sqlfieldinfo.qdoc
diff --git a/doc/src/q3sqlrecordinfo.qdoc b/doc/src/classes/q3sqlrecordinfo.qdoc
index 64236d2..64236d2 100644
--- a/doc/src/q3sqlrecordinfo.qdoc
+++ b/doc/src/classes/q3sqlrecordinfo.qdoc
diff --git a/doc/src/q3valuelist.qdoc b/doc/src/classes/q3valuelist.qdoc
index fd73763..fd73763 100644
--- a/doc/src/q3valuelist.qdoc
+++ b/doc/src/classes/q3valuelist.qdoc
diff --git a/doc/src/q3valuestack.qdoc b/doc/src/classes/q3valuestack.qdoc
index e3ae677..e3ae677 100644
--- a/doc/src/q3valuestack.qdoc
+++ b/doc/src/classes/q3valuestack.qdoc
diff --git a/doc/src/q3valuevector.qdoc b/doc/src/classes/q3valuevector.qdoc
index 353b7fa..353b7fa 100644
--- a/doc/src/q3valuevector.qdoc
+++ b/doc/src/classes/q3valuevector.qdoc
diff --git a/doc/src/qalgorithms.qdoc b/doc/src/classes/qalgorithms.qdoc
index 7634322..7634322 100644
--- a/doc/src/qalgorithms.qdoc
+++ b/doc/src/classes/qalgorithms.qdoc
diff --git a/doc/src/qcache.qdoc b/doc/src/classes/qcache.qdoc
index 6c88ede..6c88ede 100644
--- a/doc/src/qcache.qdoc
+++ b/doc/src/classes/qcache.qdoc
diff --git a/doc/src/qcolormap.qdoc b/doc/src/classes/qcolormap.qdoc
index 95f7dc0..95f7dc0 100644
--- a/doc/src/qcolormap.qdoc
+++ b/doc/src/classes/qcolormap.qdoc
diff --git a/doc/src/qdesktopwidget.qdoc b/doc/src/classes/qdesktopwidget.qdoc
index 56a882d..56a882d 100644
--- a/doc/src/qdesktopwidget.qdoc
+++ b/doc/src/classes/qdesktopwidget.qdoc
diff --git a/doc/src/qiterator.qdoc b/doc/src/classes/qiterator.qdoc
index 416b4bc..416b4bc 100644
--- a/doc/src/qiterator.qdoc
+++ b/doc/src/classes/qiterator.qdoc
diff --git a/doc/src/qstyles.qdoc b/doc/src/classes/qmacstyle.qdoc
index ae2d95b..ae2d95b 100644
--- a/doc/src/qstyles.qdoc
+++ b/doc/src/classes/qmacstyle.qdoc
diff --git a/doc/src/qnamespace.qdoc b/doc/src/classes/qnamespace.qdoc
index 2d40fdd..a49e079 100644
--- a/doc/src/qnamespace.qdoc
+++ b/doc/src/classes/qnamespace.qdoc
@@ -1884,7 +1884,10 @@
                    We refer to a top-level window that has a parent
                    as a \e secondary window.
 
-    \value Sheet   Indicates that the widget is a Macintosh sheet.
+    \value Sheet   Indicates that the window is a Macintosh sheet. Since
+                   using a sheet implies window modality, the recommended
+                   way is to use QWidget::setWindowModality(), or
+                   QDialog::open(), instead.
 
     \value Drawer  Indicates that the widget is a Macintosh drawer.
 
@@ -2415,6 +2418,30 @@
 */
 
 /*!
+    \enum Qt::InputMethodHint
+
+    \value ImhNone                   No hints.
+    \value ImhHiddenText             Characters should be hidden, as is typically used when entering passwords.
+                                     This is automatically set when setting QLineEdit::echoMode to \c Password.
+    \value ImhNumbersOnly            Only number input is allowed.
+    \value ImhUppercaseOnly          Only upper case letter input is allowed.
+    \value ImhLowercaseOnly          Only lower case letter input is allowed.
+    \value ImhNoAutoUppercase        The input method should not try to automatically switch to upper case
+                                     when a sentence ends.
+    \value ImhPreferNumbers          Numbers are preferred (but not required).
+    \value ImhPreferUppercase        Upper case letters are preferred (but not required).
+    \value ImhPreferLowercase        Lower case letters are preferred (but not required).
+    \value ImhNoPredictiveText       Do not use predictive text (i.e. dictionary lookup) while typing.
+    \value ImhDialableCharactersOnly Only characters suitable for phone dialling are allowed.
+
+    \note If several flags ending with \c Only are ORed together, the resulting character set will
+          consist of the union of the specified sets. For instance specifying \c ImhNumbersOnly and
+          \c ImhUppercaseOnly would yield a set consisting of numbers and uppercase letters.
+
+    \sa QGraphicsItem::inputMethodHints()
+*/
+
+/*!
     \enum Qt::InputMethodQuery
 
     \value ImMicroFocus       The rectangle covering the area of the input cursor in widget coordinates.
diff --git a/doc/src/qpagesetupdialog.qdoc b/doc/src/classes/qpagesetupdialog.qdoc
index 7f0b09e..7f0b09e 100644
--- a/doc/src/qpagesetupdialog.qdoc
+++ b/doc/src/classes/qpagesetupdialog.qdoc
diff --git a/doc/src/qpaintdevice.qdoc b/doc/src/classes/qpaintdevice.qdoc
index 0f4e9a0..0f4e9a0 100644
--- a/doc/src/qpaintdevice.qdoc
+++ b/doc/src/classes/qpaintdevice.qdoc
diff --git a/doc/src/qpair.qdoc b/doc/src/classes/qpair.qdoc
index 6d8a0f9..6d8a0f9 100644
--- a/doc/src/qpair.qdoc
+++ b/doc/src/classes/qpair.qdoc
diff --git a/doc/src/qpatternistdummy.cpp b/doc/src/classes/qpatternistdummy.cpp
index a690184..a690184 100644
--- a/doc/src/qpatternistdummy.cpp
+++ b/doc/src/classes/qpatternistdummy.cpp
diff --git a/doc/src/qplugin.qdoc b/doc/src/classes/qplugin.qdoc
index 4fbd198..4fbd198 100644
--- a/doc/src/qplugin.qdoc
+++ b/doc/src/classes/qplugin.qdoc
diff --git a/doc/src/qprintdialog.qdoc b/doc/src/classes/qprintdialog.qdoc
index 8011f62..8011f62 100644
--- a/doc/src/qprintdialog.qdoc
+++ b/doc/src/classes/qprintdialog.qdoc
diff --git a/doc/src/qprinterinfo.qdoc b/doc/src/classes/qprinterinfo.qdoc
index a4ffeb2..a4ffeb2 100644
--- a/doc/src/qprinterinfo.qdoc
+++ b/doc/src/classes/qprinterinfo.qdoc
diff --git a/doc/src/qset.qdoc b/doc/src/classes/qset.qdoc
index 0db3775..0db3775 100644
--- a/doc/src/qset.qdoc
+++ b/doc/src/classes/qset.qdoc
diff --git a/doc/src/qsignalspy.qdoc b/doc/src/classes/qsignalspy.qdoc
index 4ee7590..4ee7590 100644
--- a/doc/src/qsignalspy.qdoc
+++ b/doc/src/classes/qsignalspy.qdoc
diff --git a/doc/src/qsizepolicy.qdoc b/doc/src/classes/qsizepolicy.qdoc
index c74beb8..c74beb8 100644
--- a/doc/src/qsizepolicy.qdoc
+++ b/doc/src/classes/qsizepolicy.qdoc
diff --git a/doc/src/classes/qtdesigner-api.qdoc b/doc/src/classes/qtdesigner-api.qdoc
new file mode 100644
index 0000000..d7c47b1
--- /dev/null
+++ b/doc/src/classes/qtdesigner-api.qdoc
@@ -0,0 +1,1413 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QDesignerMemberSheetExtension
+
+    \brief The QDesignerMemberSheetExtension class allows you to
+    manipulate a widget's member functions which is displayed when
+    configuring connections using Qt Designer's mode for editing
+    signals and slots.
+
+    \inmodule QtDesigner
+
+    QDesignerMemberSheetExtension is a collection of functions that is
+    typically used to query a widget's member functions, and to
+    manipulate the member functions' appearance in \QD's signals and
+    slots editing mode. For example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 2
+
+    When implementing a custom widget plugin, a pointer to \QD's
+    current QDesignerFormEditorInterface object (\c formEditor in the
+    example above) is provided by the
+    QDesignerCustomWidgetInterface::initialize() function's parameter.
+
+    The member sheet (and any other extension), can be retrieved by
+    querying \QD's extension manager using the qt_extension()
+    function. When you want to release the extension, you only need to
+    delete the pointer.
+
+    All widgets have a default member sheet used in \QD's signals and
+    slots editing mode with the widget's member functions. But
+    QDesignerMemberSheetExtension also provides an interface for
+    creating custom member sheet extensions.
+
+    \warning \QD uses the QDesignerMemberSheetExtension to facilitate
+    the signal and slot editing mode. Whenever a connection between
+    two widgets is requested, \QD will query for the widgets' member
+    sheet extensions. If a widget has an implemented member sheet
+    extension, this extension will override the default member sheet.
+
+    To create a member sheet extension, your extension class must
+    inherit from both QObject and QDesignerMemberSheetExtension. Then,
+    since we are implementing an interface, we must ensure that it's
+    made known to the meta object system using the Q_INTERFACES()
+    macro:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 3
+
+    This enables \QD to use qobject_cast() to query for
+    supported interfaces using nothing but a QObject pointer.
+
+    In \QD the extensions are not created until they are
+    required. For that reason, when implementing a member sheet
+    extension, you must also create a QExtensionFactory, i.e a class
+    that is able to make an instance of your extension, and register
+    it using \QD's \l {QExtensionManager}{extension manager}.
+
+    When a widget's member sheet extension is required, \QD's \l
+    {QExtensionManager}{extension manager} will run through all its
+    registered factories calling QExtensionFactory::createExtension()
+    for each until the first one that is able to create a member sheet
+    extension for that widget, is found. This factory will then make
+    an instance of the extension. If no such factory is found, \QD
+    will use the default member sheet.
+
+    There are four available types of extensions in \QD:
+    QDesignerContainerExtension, QDesignerMemberSheetExtension,
+    QDesignerPropertySheetExtension and
+    QDesignerTaskMenuExtension. \QD's behavior is the same whether the
+    requested extension is associated with a multi page container, a
+    member sheet, a property sheet or a task menu.
+
+    The QExtensionFactory class provides a standard extension
+    factory, and can also be used as an interface for custom
+    extension factories. You can either create a new
+    QExtensionFactory and reimplement the
+    QExtensionFactory::createExtension() function. For example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 4
+
+    Or you can use an existing factory, expanding the
+    QExtensionFactory::createExtension() function to make the factory
+    able to create a member sheet extension as well. For example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 5
+
+    For a complete example using an extension class, see \l
+    {designer/taskmenuextension}{Task Menu Extension example}. The
+    example shows how to create a custom widget plugin for Qt
+    Designer, and how to to use the QDesignerTaskMenuExtension class
+    to add custom items to \QD's task menu.
+
+    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
+    Extensions}
+*/
+
+/*!
+    \fn QDesignerMemberSheetExtension::~QDesignerMemberSheetExtension()
+
+    Destroys the member sheet extension.
+*/
+
+/*!
+    \fn int QDesignerMemberSheetExtension::count() const
+
+    Returns the extension's number of member functions.
+*/
+
+/*!
+    \fn int QDesignerMemberSheetExtension::indexOf(const QString &name) const
+
+    Returns the index of the member function specified by the given \a
+    name.
+
+    \sa memberName()
+*/
+
+/*!
+    \fn QString QDesignerMemberSheetExtension::memberName(int index) const
+
+    Returns the name of the member function with the given \a index.
+
+    \sa indexOf()
+*/
+
+/*!
+    \fn QString QDesignerMemberSheetExtension::memberGroup(int index) const
+
+    Returns the name of the member group specified for the function
+    with the given \a index.
+
+    \sa indexOf(), setMemberGroup()
+*/
+
+/*!
+    \fn void QDesignerMemberSheetExtension::setMemberGroup(int index, const QString &group)
+
+    Sets the member group of the member function with the given \a
+    index, to \a group.
+
+    \sa indexOf(), memberGroup()
+*/
+
+/*!
+    \fn bool QDesignerMemberSheetExtension::isVisible(int index) const
+
+    Returns true if the member function with the given \a index is
+    visible in \QD's signal and slot editor, otherwise false.
+
+    \sa indexOf(), setVisible()
+*/
+
+/*!
+    \fn void QDesignerMemberSheetExtension::setVisible(int index, bool visible)
+
+    If \a visible is true, the member function with the given \a index
+    is visible in \QD's signals and slots editing mode; otherwise the
+    member function is hidden.
+
+    \sa indexOf(), isVisible()
+*/
+
+/*!
+    \fn virtual bool QDesignerMemberSheetExtension::isSignal(int index) const
+
+    Returns true if the member function with the given \a index is a
+    signal, otherwise false.
+
+    \sa indexOf()
+*/
+
+/*!
+    \fn bool QDesignerMemberSheetExtension::isSlot(int index) const
+
+    Returns true if the member function with the given \a index is a
+    slot, otherwise false.
+
+    \sa indexOf()
+*/
+
+/*!
+    \fn bool QDesignerMemberSheetExtension::inheritedFromWidget(int index) const
+
+    Returns true if the member function with the given \a index is
+    inherited from QWidget, otherwise false.
+
+    \sa indexOf()
+*/
+
+/*!
+    \fn QString QDesignerMemberSheetExtension::declaredInClass(int index) const
+
+    Returns the name of the class in which the member function with
+    the given \a index is declared.
+
+    \sa indexOf()
+*/
+
+/*!
+    \fn QString QDesignerMemberSheetExtension::signature(int index) const
+
+    Returns the signature of the member function with the given \a
+    index.
+
+    \sa indexOf()
+*/
+
+/*!
+    \fn QList<QByteArray> QDesignerMemberSheetExtension::parameterTypes(int index) const
+
+    Returns the parameter types of the member function with the given
+    \a index, as a QByteArray list.
+
+    \sa indexOf(), parameterNames()
+*/
+
+/*!
+    \fn QList<QByteArray> QDesignerMemberSheetExtension::parameterNames(int index) const
+
+    Returns the parameter names of the member function with the given
+    \a index, as a QByteArray list.
+
+    \sa indexOf(), parameterTypes()
+*/
+
+
+// Doc: Interface only
+
+/*!
+    \class QDesignerLayoutDecorationExtension
+    \brief The QDesignerLayoutDecorationExtension class provides an extension to a layout in \QD.
+    \inmodule QtDesigner
+    \internal
+*/
+
+/*!
+    \enum QDesignerLayoutDecorationExtension::InsertMode
+
+    This enum describes the modes that are used to insert items into a layout.
+
+    \value InsertWidgetMode Widgets are inserted into empty cells in a layout.
+    \value InsertRowMode    Whole rows are inserted into a vertical or grid layout.
+    \value InsertColumnMode Whole columns are inserted into a horizontal or grid layout.
+*/
+
+/*!
+    \fn virtual QDesignerLayoutDecorationExtension::~QDesignerLayoutDecorationExtension()
+
+    Destroys the extension.
+*/
+
+/*!
+    \fn virtual QList<QWidget*> QDesignerLayoutDecorationExtension::widgets(QLayout *layout) const
+
+    Returns the widgets that are managed by the given \a layout.
+
+    \sa insertWidget(), removeWidget()
+*/
+
+/*!
+    \fn QRect QDesignerLayoutDecorationExtension::itemInfo(int index) const
+
+    Returns the rectangle covered by the item at the given \a index in the layout.
+*/
+
+/*!
+    \fn int QDesignerLayoutDecorationExtension::indexOf(QWidget *widget) const
+
+    Returns the index of the specified \a widget in the layout.
+*/
+
+/*!
+    \fn int QDesignerLayoutDecorationExtension::indexOf(QLayoutItem *item) const
+
+    Returns the index of the specified layout \a item.
+*/
+
+/*!
+    \fn QDesignerLayoutDecorationExtension::InsertMode QDesignerLayoutDecorationExtension::currentInsertMode() const
+
+    Returns the current insertion mode.
+*/
+
+/*!
+    \fn int QDesignerLayoutDecorationExtension::currentIndex() const
+
+    Returns the current index in the layout.
+*/
+
+/*!
+    \fn QPair<int, int> QDesignerLayoutDecorationExtension::currentCell() const
+
+    Returns a pair containing the row and column of the current cell in the layout.
+*/
+
+/*!
+    \fn void QDesignerLayoutDecorationExtension::insertWidget(QWidget *widget, const QPair<int, int> &cell)
+
+    Inserts the given \a widget into the specified \a cell in the layout.
+
+    \sa removeWidget()
+*/
+
+/*!
+    \fn void QDesignerLayoutDecorationExtension::removeWidget(QWidget *widget)
+
+    Removes the specified \a widget from the layout.
+
+    \sa insertWidget()
+*/
+
+/*!
+    \fn void QDesignerLayoutDecorationExtension::insertRow(int row)
+
+    Inserts a new row into the form at the position specified by \a row.
+*/
+
+/*!
+    \fn void QDesignerLayoutDecorationExtension::insertColumn(int column)
+
+    Inserts a new column into the form at the position specified by \a column.
+*/
+
+/*!
+    \fn void QDesignerLayoutDecorationExtension::simplify()
+
+    Simplifies the layout by removing unnecessary empty rows and columns, and by changing the
+    number of rows or columns spanned by widgets.
+*/
+
+/*!
+    \fn int QDesignerLayoutDecorationExtension::findItemAt(const QPoint &position) const
+
+    Returns the index of the item in the layout that covers the given \a position.
+*/
+
+/*!
+    \fn int QDesignerLayoutDecorationExtension::findItemAt(int row, int column) const
+
+    Returns the item in the layout that occupies the specified \a row and \a column in the layout.
+
+    Currently, this only applies to grid layouts.
+*/
+
+/*!
+    \fn void QDesignerLayoutDecorationExtension::adjustIndicator(const QPoint &position, int index)
+
+    Adjusts the indicator for the item specified by \a index so that
+    it lies at the given \a position on the form.
+*/
+
+
+// Doc: Interface only
+
+/*!
+    \class QDesignerContainerExtension
+    \brief The QDesignerContainerExtension class allows you to add pages to
+    a custom multi-page container in Qt Designer's workspace.
+    \inmodule QtDesigner
+
+    QDesignerContainerExtension provide an interface for creating
+    custom container extensions. A container extension consists of a
+    collection of functions that \QD needs to manage a multi-page
+    container plugin, and a list of the container's pages.
+
+    \image containerextension-example.png
+
+    \warning This is \e not an extension for container plugins in
+    general, only custom \e multi-page containers.
+
+    To create a container extension, your extension class must inherit
+    from both QObject and QDesignerContainerExtension. For example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 6
+
+    Since we are implementing an interface, we must ensure that it's
+    made known to the meta object system using the Q_INTERFACES()
+    macro. This enables \QD to use the qobject_cast() function to
+    query for supported interfaces using nothing but a QObject
+    pointer.
+
+    You must reimplement several functions to enable \QD to manage a
+    custom multi-page container widget: \QD uses count() to keep track
+    of the number pages in your container, widget() to return the page
+    at a given index in the list of the container's pages, and
+    currentIndex() to return the list index of the selected page. \QD
+    uses the addWidget() function to add a given page to the
+    container, expecting it to be appended to the list of pages, while
+    it expects the insertWidget() function to add a given page to the
+    container by inserting it at a given index.
+
+    In \QD the extensions are not created until they are
+    required. For that reason you must also create a
+    QExtensionFactory, i.e a class that is able to make an instance of
+    your extension, and register it using \QD's \l
+    {QExtensionManager}{extension manager}.
+
+    When a container extension is required, \QD's \l
+    {QExtensionManager}{extension manager} will run through all its
+    registered factories calling QExtensionFactory::createExtension()
+    for each until the first one that is able to create a container
+    extension, is found. This factory will then create the extension
+    for the plugin.
+
+    There are four available types of extensions in \QD:
+    QDesignerContainerExtension , QDesignerMemberSheetExtension,
+    QDesignerPropertySheetExtension and QDesignerTaskMenuExtension.
+    \QD's behavior is the same whether the requested extension is
+    associated with a multi page container, a member sheet, a property
+    sheet or a task menu.
+
+    The QExtensionFactory class provides a standard extension factory,
+    and can also be used as an interface for custom extension
+    factories. You can either create a new QExtensionFactory and
+    reimplement the QExtensionFactory::createExtension() function. For
+    example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 7
+
+    Or you can use an existing factory, expanding the
+    QExtensionFactory::createExtension() function to make the factory
+    able to create a container extension as well. For example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 8
+
+    For a complete example using the QDesignerContainerExtension
+    class, see the \l {designer/containerextension}{Container
+    Extension example}. The example shows how to create a custom
+    multi-page plugin for \QD.
+
+    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
+    Extensions}
+*/
+
+/*!
+    \fn QDesignerContainerExtension::~QDesignerContainerExtension()
+
+    Destroys the extension.
+*/
+
+/*!
+    \fn int QDesignerContainerExtension::count() const
+
+    Returns the number of pages in the container.
+*/
+
+/*!
+    \fn QWidget *QDesignerContainerExtension::widget(int index) const
+
+    Returns the page at the given \a index in the extension's list of
+    pages.
+
+    \sa addWidget(), insertWidget()
+*/
+
+/*!
+    \fn int QDesignerContainerExtension::currentIndex() const
+
+    Returns the index of the currently selected page in the
+    container.
+
+    \sa setCurrentIndex()
+*/
+
+/*!
+    \fn void QDesignerContainerExtension::setCurrentIndex(int index)
+
+    Sets the currently selected page in the container to be the
+    page at the given \a index in the extension's list of pages.
+
+    \sa currentIndex()
+*/
+
+/*!
+    \fn void QDesignerContainerExtension::addWidget(QWidget *page)
+
+    Adds the given \a page to the container by appending it to the
+    extension's list of pages.
+
+    \sa insertWidget(), remove(), widget()
+*/
+
+/*!
+    \fn void QDesignerContainerExtension::insertWidget(int index, QWidget *page)
+
+    Adds the given \a page to the container by inserting it at the
+    given \a index in the extension's list of pages.
+
+    \sa addWidget(), remove(), widget()
+*/
+
+/*!
+    \fn void QDesignerContainerExtension::remove(int index)
+
+    Removes the page at the given \a index from the extension's list
+    of pages.
+
+    \sa addWidget(), insertWidget()
+*/
+
+
+// Doc: Interface only
+
+/*!
+    \class QDesignerTaskMenuExtension
+    \brief The QDesignerTaskMenuExtension class allows you to add custom
+    menu entries to Qt Designer's task menu.
+    \inmodule QtDesigner
+
+    QDesignerTaskMenuExtension provides an interface for creating
+    custom task menu extensions. It is typically used to create task
+    menu entries that are specific to a plugin in \QD.
+
+    \QD uses the QDesignerTaskMenuExtension to feed its task
+    menu. Whenever a task menu is requested, \QD will query
+    for the selected widget's task menu extension.
+
+    \image taskmenuextension-example-faded.png
+
+    A task menu extension is a collection of QActions. The actions
+    appear as entries in the task menu when the plugin with the
+    specified extension is selected. The image above shows the custom
+    \gui {Edit State...} action which appears in addition to \QD's
+    default task menu entries: \gui Cut, \gui Copy, \gui Paste etc.
+
+    To create a custom task menu extension, your extension class must
+    inherit from both QObject and QDesignerTaskMenuExtension. For
+    example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 9
+
+    Since we are implementing an interface, we must ensure that it
+    is made known to the meta-object system using the Q_INTERFACES()
+    macro. This enables \QD to use the qobject_cast() function to
+    query for supported interfaces using nothing but a QObject
+    pointer.
+
+    You must reimplement the taskActions() function to return a list
+    of actions that will be included in \QD task menu. Optionally, you
+    can reimplement the preferredEditAction() function to set the
+    action that is invoked when selecting your plugin and pressing
+    \key F2. The preferred edit action must be one of the actions
+    returned by taskActions() and, if it's not defined, pressing the
+    \key F2 key will simply be ignored.
+
+    In \QD, extensions are not created until they are required. A
+    task menu extension, for example, is created when you click the
+    right mouse button over a widget in \QD's workspace. For that
+    reason you must also construct an extension factory, using either
+    QExtensionFactory or a subclass, and register it using \QD's
+    \l {QExtensionManager}{extension manager}.
+
+    When a task menu extension is required, \QD's \l
+    {QExtensionManager}{extension manager} will run through all its
+    registered factories calling QExtensionFactory::createExtension()
+    for each until it finds one that is able to create a task menu
+    extension for the selected widget. This factory will then make an
+    instance of the extension.
+
+    There are four available types of extensions in \QD:
+    QDesignerContainerExtension, QDesignerMemberSheetExtension,
+    QDesignerPropertySheetExtension, and QDesignerTaskMenuExtension.
+    \QD's behavior is the same whether the requested extension is
+    associated with a container, a member sheet, a property sheet or a
+    task menu.
+
+    The QExtensionFactory class provides a standard extension factory,
+    and can also be used as an interface for custom extension
+    factories. You can either create a new QExtensionFactory and
+    reimplement the QExtensionFactory::createExtension() function. For
+    example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 10
+
+    Or you can use an existing factory, expanding the
+    QExtensionFactory::createExtension() function to make the factory
+    able to create a task menu extension as well. For example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 11
+
+    For a complete example using the QDesignerTaskMenuExtension class,
+    see the \l {designer/taskmenuextension}{Task Menu Extension
+    example}. The example shows how to create a custom widget plugin
+    for \QD, and how to to use the QDesignerTaskMenuExtension
+    class to add custom items to \QD's task menu.
+
+    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
+    Extensions}
+*/
+
+/*!
+    \fn QDesignerTaskMenuExtension::~QDesignerTaskMenuExtension()
+
+    Destroys the task menu extension.
+*/
+
+/*!
+    \fn QAction *QDesignerTaskMenuExtension::preferredEditAction() const
+
+    Returns the action that is invoked when selecting a plugin with
+    the specified extension and pressing \key F2.
+
+    The action must be one of the actions returned by taskActions().
+*/
+
+/*!
+    \fn QList<QAction*> QDesignerTaskMenuExtension::taskActions() const
+
+    Returns the task menu extension as a list of actions which will be
+    included in \QD's task menu when a plugin with the specified
+    extension is selected.
+
+    The function must be reimplemented to add actions to the list.
+*/
+
+
+// Doc: Interface only
+
+/*!
+    \class QDesignerCustomWidgetCollectionInterface
+
+    \brief The QDesignerCustomWidgetCollectionInterface class allows
+    you to include several custom widgets in one single library.
+
+    \inmodule QtDesigner
+
+    When implementing a custom widget plugin, you build it as a
+    separate library. If you want to include several custom widget
+    plugins in the same library, you must in addition subclass
+    QDesignerCustomWidgetCollectionInterface.
+
+    QDesignerCustomWidgetCollectionInterface contains one single
+    function returning a list of the collection's
+    QDesignerCustomWidgetInterface objects. For example, if you have
+    several custom widgets \c CustomWidgetOne, \c CustomWidgetTwo and
+    \c CustomWidgetThree, the class definition may look like this:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 12
+
+    In the class constructor you add the interfaces to your custom
+    widgets to the list which you return in the customWidgets()
+    function:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 13
+
+    Note that instead of exporting each custom widget plugin using the
+    Q_EXPORT_PLUGIN2() macro, you export the entire collection. The
+    Q_EXPORT_PLUGIN2() macro ensures that \QD can access and construct
+    the custom widgets. Without this macro, there is no way for \QD to
+    use them.
+
+    \sa QDesignerCustomWidgetInterface, {Creating Custom Widgets for
+    Qt Designer}
+*/
+
+/*!
+    \fn QDesignerCustomWidgetCollectionInterface::~QDesignerCustomWidgetCollectionInterface() {
+
+    Destroys the custom widget collection interface.
+*/
+
+/*!
+    \fn QList<QDesignerCustomWidgetInterface*> QDesignerCustomWidgetCollectionInterface::customWidgets() const
+
+    Returns a list of interfaces to the collection's custom widgets.
+*/
+
+
+// Doc: Interface only
+
+/*!
+    \class QDesignerCustomWidgetInterface
+
+    \brief The QDesignerCustomWidgetInterface class enables Qt Designer
+    to access and construct custom widgets.
+
+    \inmodule QtDesigner
+
+    QDesignerCustomWidgetInterface provides a custom widget with an
+    interface. The class contains a set of functions that must be subclassed
+    to return basic information about the widget, such as its class name and
+    the name of its header file. Other functions must be implemented to
+    initialize the plugin when it is loaded, and to construct instances of
+    the custom widget for \QD to use.
+
+    When implementing a custom widget you must subclass
+    QDesignerCustomWidgetInterface to expose your widget to \QD. For
+    example, this is the declaration for the plugin used in the
+    \l{Custom Widget Plugin Example}{Custom Widget Plugin example} that
+    enables an analog clock custom widget to be used by \QD:
+
+    \snippet examples/designer/customwidgetplugin/customwidgetplugin.h 0
+
+    Note that the only part of the class definition that is specific
+    to this particular custom widget is the class name. In addition,
+    since we are implementing an interface, we must ensure that it's
+    made known to the meta object system using the Q_INTERFACES()
+    macro. This enables \QD to use the qobject_cast() function to
+    query for supported interfaces using nothing but a QObject
+    pointer.
+
+    After \QD loads a custom widget plugin, it calls the interface's
+    initialize() function to enable it to set up any resources that it
+    may need. This function is called with a QDesignerFormEditorInterface
+    parameter that provides the plugin with a gateway to all of \QD's API.
+
+    \QD constructs instances of the custom widget by calling the plugin's
+    createWidget() function with a suitable parent widget. Plugins must
+    construct and return an instance of a custom widget with the specified
+    parent widget. 
+
+    In the implementation of the class you must remember to export
+    your custom widget plugin to \QD using the Q_EXPORT_PLUGIN2()
+    macro. For example, if a library called \c libcustomwidgetplugin.so
+    (on Unix) or \c libcustomwidget.dll (on Windows) contains a widget
+    class called \c MyCustomWidget, we can export it by adding the
+    following line to the file containing the plugin implementation:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 14
+
+    This macro ensures that \QD can access and construct the custom widget.
+    Without this macro, there is no way for \QD to use it.
+
+    When implementing a custom widget plugin, you build it as a
+    separate library. If you want to include several custom widget
+    plugins in the same library, you must in addition subclass
+    QDesignerCustomWidgetCollectionInterface.
+
+    \warning If your custom widget plugin contains QVariant
+    properties, be aware that only the following \l
+    {QVariant::Type}{types} are supported:
+
+    \list
+    \o QVariant::ByteArray
+    \o QVariant::Bool
+    \o QVariant::Color
+    \o QVariant::Cursor
+    \o QVariant::Date
+    \o QVariant::DateTime
+    \o QVariant::Double
+    \o QVariant::Int
+    \o QVariant::Point
+    \o QVariant::Rect
+    \o QVariant::Size
+    \o QVariant::SizePolicy
+    \o QVariant::String
+    \o QVariant::Time
+    \o QVariant::UInt
+    \endlist
+
+    For a complete example using the QDesignerCustomWidgetInterface
+    class, see the \l {designer/customwidgetplugin}{Custom Widget
+    Example}. The example shows how to create a custom widget plugin
+    for \QD.
+
+    \sa QDesignerCustomWidgetCollectionInterface {Creating Custom
+    Widgets for Qt Designer}
+*/
+
+/*!
+    \fn QDesignerCustomWidgetInterface::~QDesignerCustomWidgetInterface()
+
+    Destroys the custom widget interface.
+*/
+
+/*!
+    \fn QString QDesignerCustomWidgetInterface::name() const
+
+    Returns the class name of the custom widget supplied by the interface.
+
+    The name returned \e must be identical to the class name used for the
+    custom widget.
+*/
+
+/*!
+    \fn QString QDesignerCustomWidgetInterface::group() const
+
+    Returns the name of the group to which the custom widget belongs.
+*/
+
+/*!
+    \fn QString QDesignerCustomWidgetInterface::toolTip() const
+
+    Returns a short description of the widget that can be used by \QD
+    in a tool tip.
+*/
+
+/*!
+    \fn QString QDesignerCustomWidgetInterface::whatsThis() const
+
+    Returns a description of the widget that can be used by \QD in
+    "What's This?" help for the widget.
+*/
+
+/*!
+    \fn QString QDesignerCustomWidgetInterface::includeFile() const
+
+    Returns the path to the include file that \l uic uses when
+    creating code for the custom widget.
+*/
+
+/*!
+    \fn QIcon QDesignerCustomWidgetInterface::icon() const
+
+    Returns the icon used to represent the custom widget in \QD's
+    widget box.
+*/
+
+/*!
+    \fn bool QDesignerCustomWidgetInterface::isContainer() const
+
+    Returns true if the custom widget is intended to be used as a
+    container; otherwise returns false.
+
+    Most custom widgets are not used to hold other widgets, so their
+    implementations of this function will return false, but custom
+    containers will return true to ensure that they behave correctly
+    in \QD.
+*/
+
+/*!
+    \fn QWidget *QDesignerCustomWidgetInterface::createWidget(QWidget *parent)
+
+    Returns a new instance of the custom widget, with the given \a
+    parent.
+*/
+
+/*!
+    \fn bool QDesignerCustomWidgetInterface::isInitialized() const
+
+    Returns true if the widget has been initialized; otherwise returns
+    false.
+
+    \sa initialize()
+*/
+
+/*!
+    \fn void QDesignerCustomWidgetInterface::initialize(QDesignerFormEditorInterface *formEditor)
+
+    Initializes the widget for use with the specified \a formEditor
+    interface.
+
+    \sa isInitialized()
+*/
+
+/*!
+    \fn QString QDesignerCustomWidgetInterface::domXml() const
+
+    Returns the XML that is used to describe the custom widget's
+    properties to \QD.
+*/
+
+/*!
+    \fn QString QDesignerCustomWidgetInterface::codeTemplate() const
+
+    This function is reserved for future use by \QD.
+
+    \omit
+    Returns the code template that \QD includes in forms that contain
+    the custom widget when they are saved.
+    \endomit
+*/
+
+/*!
+    \macro QDESIGNER_WIDGET_EXPORT
+    \relates QDesignerCustomWidgetInterface
+    \since 4.1
+
+    This macro is used when defining custom widgets to ensure that they are
+    correctly exported from plugins for use with \QD.
+
+    On some platforms, the symbols required by \QD to create new widgets
+    are removed from plugins by the build system, making them unusable.
+    Using this macro ensures that the symbols are retained on those platforms,
+    and has no side effects on other platforms.
+
+    For example, the \l{designer/worldtimeclockplugin}{World Time Clock Plugin}
+    example exports a custom widget class with the following declaration:
+
+    \snippet examples/designer/worldtimeclockplugin/worldtimeclock.h 0
+    \dots
+    \snippet examples/designer/worldtimeclockplugin/worldtimeclock.h 2
+
+    \sa {Creating Custom Widgets for Qt Designer}
+*/
+
+
+// Doc: Abstract class
+
+/*!
+    \class QDesignerDnDItemInterface
+    \brief The QDesignerDnDItemInterface class provides an interface that is used to manage items
+    during a drag and drop operation.
+    \inmodule QtDesigner
+    \internal
+*/
+
+/*!
+    \enum QDesignerDnDItemInterface::DropType
+
+    This enum describes the result of a drag and drop operation.
+
+    \value MoveDrop The item was moved.
+    \value CopyDrop The item was copied.
+*/
+
+/*!
+    \fn QDesignerDnDItemInterface::QDesignerDnDItemInterface()
+
+    Constructs a new interface to a drag and drop item.
+*/
+
+/*!
+    \fn QDesignerDnDItemInterface::~QDesignerDnDItemInterface()
+
+    Destroys the interface to the item.
+*/
+
+/*!
+    \fn DomUI *QDesignerDnDItemInterface::domUi() const
+
+    Returns a user interface object for the item.
+*/
+
+/*!
+    \fn QWidget *QDesignerDnDItemInterface::widget() const
+
+    Returns the widget being copied or moved in the drag and drop operation.
+
+    \sa source()
+*/
+
+/*!
+    \fn QWidget *QDesignerDnDItemInterface::decoration() const
+
+    Returns the widget used to represent the item.
+*/
+
+/*!
+    \fn QPoint QDesignerDnDItemInterface::hotSpot() const
+
+    Returns the cursor's hotspot.
+
+    \sa QDrag::hotSpot()
+*/
+
+/*!
+    \fn DropType QDesignerDnDItemInterface::type() const
+
+    Returns the type of drag and drop operation in progress.
+*/
+
+/*!
+    \fn QWidget *QDesignerDnDItemInterface::source() const
+
+    Returns the widget that is the source of the drag and drop operation; i.e. the original
+    container of the widget being dragged.
+
+    \sa widget()
+*/
+
+
+// Doc: Abstract class
+
+/*!
+    \class QDesignerIconCacheInterface
+    \brief The QDesignerIconCacheInterface class provides an interface to \QD's icon cache.
+    \inmodule QtDesigner
+    \internal
+*/
+
+/*!
+    \fn QDesignerIconCacheInterface::QDesignerIconCacheInterface(QObject *parent)
+
+    Constructs a new interface with the given \a parent.
+*/
+
+/*!
+    \fn QIcon QDesignerIconCacheInterface::nameToIcon(const QString &filePath, const QString &qrcPath)
+
+    Returns the icon associated with the name specified by \a filePath in the resource
+    file specified by \a qrcPath.
+
+    If \a qrcPath refers to a valid resource file, the name used for the file path is a path
+    within those resources; otherwise the file path refers to a local file.
+
+    \sa {The Qt Resource System}, nameToPixmap()
+*/
+
+/*!
+    \fn QPixmap QDesignerIconCacheInterface::nameToPixmap(const QString &filePath, const QString &qrcPath)
+
+    Returns the pixmap associated with the name specified by \a filePath in the resource
+    file specified by \a qrcPath.
+
+    If \a qrcPath refers to a valid resource file, the name used for the file path is a path
+    within those resources; otherwise the file path refers to a local file.
+
+    \sa {The Qt Resource System}, nameToIcon()
+*/
+
+/*!
+    \fn QString QDesignerIconCacheInterface::iconToFilePath(const QIcon &icon) const
+
+    Returns the file path associated with the given \a icon. The file path is a path within
+    an application resources.
+*/
+
+/*!
+    \fn QString QDesignerIconCacheInterface::iconToQrcPath(const QIcon &icon) const
+
+    Returns the path to the resource file that refers to the specified \a icon. The resource
+    path refers to a local file.
+*/
+
+/*!
+    \fn QString QDesignerIconCacheInterface::pixmapToFilePath(const QPixmap &pixmap) const
+
+    Returns the file path associated with the given \a pixmap. The file path is a path within
+    an application resources.
+*/
+
+/*!
+    \fn QString QDesignerIconCacheInterface::pixmapToQrcPath(const QPixmap &pixmap) const
+
+    Returns the path to the resource file that refers to the specified \a pixmap. The resource
+    path refers to a local file.
+*/
+
+/*!
+    \fn QList<QPixmap> QDesignerIconCacheInterface::pixmapList() const
+
+    Returns a list of pixmaps for the icons provided by the icon cache.
+*/
+
+/*!
+    \fn QList<QIcon> QDesignerIconCacheInterface::iconList() const
+
+    Returns a list of icons provided by the icon cache.
+*/
+
+/*!
+    \fn QString QDesignerIconCacheInterface::resolveQrcPath(const QString &filePath, const QString &qrcPath, const QString &workingDirectory) const
+
+    Returns a path to a resource specified by the \a filePath within
+    the resource file located at \a qrcPath. If \a workingDirectory is
+    a valid path to a directory, the path returned will be relative to
+    that directory; otherwise an absolute path is returned.
+
+    \omit
+    ### Needs checking
+    \endomit
+*/
+
+
+// Doc: Interface only
+
+/*!
+    \class QDesignerPropertySheetExtension
+
+    \brief The QDesignerPropertySheetExtension class allows you to
+    manipulate a widget's properties which is displayed in Qt
+    Designer's property editor.
+
+    \sa QDesignerDynamicPropertySheetExtension
+
+    \inmodule QtDesigner
+
+    QDesignerPropertySheetExtension provides a collection of functions that
+    are typically used to query a widget's properties, and to
+    manipulate the properties' appearance in the property editor. For
+    example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 15
+
+    Note that if you change the value of a property using the
+    QDesignerPropertySheetExtension::setProperty() function, the undo
+    stack is not updated. To ensure that a property's value can be
+    reverted using the undo stack, you must use the
+    QDesignerFormWindowCursorInterface::setProperty() function, or its
+    buddy \l
+    {QDesignerFormWindowCursorInterface::setWidgetProperty()}{setWidgetProperty()},
+    instead.
+
+    When implementing a custom widget plugin, a pointer to \QD's
+    current QDesignerFormEditorInterface object (\c formEditor in the
+    example above) is provided by the
+    QDesignerCustomWidgetInterface::initialize() function's parameter.
+
+    The property sheet, or any other extension, can be retrieved by
+    querying \QD's extension manager using the qt_extension()
+    function. When you want to release the extension, you only need to
+    delete the pointer.
+
+    All widgets have a default property sheet which populates \QD's
+    property editor with the widget's properties (i.e the ones defined
+    with the Q_PROPERTY() macro). But QDesignerPropertySheetExtension
+    also provides an interface for creating custom property sheet
+    extensions.
+
+    \warning \QD uses the QDesignerPropertySheetExtension to feed its
+    property editor. Whenever a widget is selected in its workspace,
+    \QD will query for the widget's property sheet extension. If the
+    selected widget has an implemented property sheet extension, this
+    extension will override the default property sheet.
+
+    To create a property sheet extension, your extension class must
+    inherit from both QObject and
+    QDesignerPropertySheetExtension. Then, since we are implementing
+    an interface, we must ensure that it's made known to the meta
+    object system using the Q_INTERFACES() macro:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 16
+
+    This enables \QD to use qobject_cast() to query for supported
+    interfaces using nothing but a QObject pointer.
+
+    In \QD the extensions are not created until they are
+    required. For that reason, when implementing a property sheet
+    extension, you must also create a QExtensionFactory, i.e a class
+    that is able to make an instance of your extension, and register
+    it using \QD's \l {QExtensionManager}{extension manager}.
+
+    When a property sheet extension is required, \QD's \l
+    {QExtensionManager}{extension manager} will run through all its
+    registered factories calling QExtensionFactory::createExtension()
+    for each until the first one that is able to create a property
+    sheet extension for the selected widget, is found. This factory
+    will then make an instance of the extension. If no such factory
+    can be found, \QD will use the default property sheet.
+
+    There are four available types of extensions in \QD:
+    QDesignerContainerExtension, QDesignerMemberSheetExtension,
+    QDesignerPropertySheetExtension and QDesignerTaskMenuExtension. Qt
+    Designer's behavior is the same whether the requested extension is
+    associated with a multi page container, a member sheet, a property
+    sheet or a task menu.
+
+    The QExtensionFactory class provides a standard extension factory,
+    and can also be used as an interface for custom extension
+    factories. You can either create a new QExtensionFactory and
+    reimplement the QExtensionFactory::createExtension() function. For
+    example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 17
+
+    Or you can use an existing factory, expanding the
+    QExtensionFactory::createExtension() function to make the factory
+    able to create a property sheet extension extension as well. For
+    example:
+
+    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 18
+
+    For a complete example using an extension class, see the \l
+    {designer/taskmenuextension}{Task Menu Extension example}. The
+    example shows how to create a custom widget plugin for Qt
+    Designer, and how to to use the QDesignerTaskMenuExtension class
+    to add custom items to \QD's task menu.
+
+    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
+    Extensions}
+*/
+
+/*!
+    \fn QDesignerPropertySheetExtension::~QDesignerPropertySheetExtension()
+
+    Destroys the property sheet extension.
+*/
+
+/*!
+    \fn int QDesignerPropertySheetExtension::count() const
+
+    Returns the selected widget's number of properties.
+*/
+
+/*!
+    \fn int QDesignerPropertySheetExtension::indexOf(const QString &name) const
+
+    Returns the index for a given property \a name.
+
+    \sa propertyName()
+*/
+
+/*!
+    \fn QString QDesignerPropertySheetExtension::propertyName(int index) const
+
+    Returns the name of the property at the given \a index.
+
+    \sa indexOf()
+*/
+
+/*!
+    \fn QString QDesignerPropertySheetExtension::propertyGroup(int index) const
+
+    Returns the property group for the property at the given \a index.
+
+    \QD's property editor supports property groups, i.e. sections of
+    related properties. A property can be related to a group using the
+    setPropertyGroup() function. The default group of any property is
+    the name of the class that defines it. For example, the
+    QObject::objectName property appears within the QObject property
+    group.
+
+    \sa indexOf(), setPropertyGroup()
+*/
+
+/*!
+    \fn void QDesignerPropertySheetExtension::setPropertyGroup(int index, const QString &group)
+
+    Sets the property group for the property at the given \a index to
+    \a group.
+
+    Relating a property to a group makes it appear within that group's
+    section in the property editor. The default property group of any
+    property is the name of the class that defines it. For example,
+    the QObject::objectName property appears within the QObject
+    property group.
+
+    \sa indexOf(), property(), propertyGroup()
+*/
+
+/*!
+    \fn bool QDesignerPropertySheetExtension::hasReset(int index) const
+
+    Returns true if the property at the given \a index has a reset
+    button in \QD's property editor, otherwise false.
+
+    \sa indexOf(), reset()
+*/
+
+/*!
+    \fn bool QDesignerPropertySheetExtension::reset(int index)
+
+    Resets the value of the property at the given \a index, to the
+    default value. Returns true if a default value could be found, otherwise false.
+
+    \sa indexOf(), hasReset(), isChanged()
+*/
+
+/*!
+    \fn bool QDesignerPropertySheetExtension::isVisible(int index) const
+
+    Returns true if the property at the given \a index is visible in
+    \QD's property editor, otherwise false.
+
+    \sa indexOf(), setVisible()
+*/
+
+/*!
+    \fn void QDesignerPropertySheetExtension::setVisible(int index, bool visible)
+
+    If \a visible is true, the property at the given \a index is
+    visible in \QD's property editor; otherwise the property is
+    hidden.
+
+    \sa indexOf(), isVisible()
+*/
+
+/*!
+    \fn bool QDesignerPropertySheetExtension::isAttribute(int index) const
+
+    Returns true if the property at the given \a index is an attribute,
+    which will be \e excluded from the UI file, otherwise false.
+
+    \sa indexOf(), setAttribute()
+*/
+
+/*!
+    \fn void QDesignerPropertySheetExtension::setAttribute(int index, bool attribute)
+
+    If \a attribute is true, the property at the given \a index is
+    made an attribute which will be \e excluded from the UI file;
+    otherwise it will be included.
+
+    \sa indexOf(), isAttribute()
+*/
+
+/*!
+    \fn QVariant QDesignerPropertySheetExtension::property(int index) const
+
+    Returns the value of the property at the given \a index.
+
+    \sa indexOf(), setProperty(), propertyGroup()
+*/
+
+/*!
+    \fn void QDesignerPropertySheetExtension::setProperty(int index, const QVariant &value)
+
+    Sets the \a value of the property at the given \a index.
+
+    \warning If you change the value of a property using this
+    function, the undo stack is not updated. To ensure that a
+    property's value can be reverted using the undo stack, you must
+    use the QDesignerFormWindowCursorInterface::setProperty()
+    function, or its buddy \l
+    {QDesignerFormWindowCursorInterface::setWidgetProperty()}{setWidgetProperty()},
+    instead.
+
+    \sa indexOf(), property(), propertyGroup()
+*/
+
+/*!
+    \fn bool QDesignerPropertySheetExtension::isChanged(int index) const
+
+    Returns true if the value of the property at the given \a index
+    differs from the property's default value, otherwise false.
+
+    \sa indexOf(), setChanged(), reset()
+*/
+
+/*!
+    \fn void QDesignerPropertySheetExtension::setChanged(int index, bool changed)
+
+    Sets whether the property at the given \a index is different from
+    its default value, or not, depending on the \a changed parameter.
+
+    \sa indexOf(), isChanged()
+*/
+
+// Doc: Interface only
+
+/*!
+    \class QDesignerDynamicPropertySheetExtension
+
+    \brief The QDesignerDynamicPropertySheetExtension class allows you to
+    manipulate a widget's dynamic properties in Qt Designer's property editor.
+
+    \sa QDesignerPropertySheetExtension, {QObject#Dynamic Properties}{Dynamic Properties}
+
+    \inmodule QtDesigner
+    \since 4.3
+*/
+
+/*!
+    \fn QDesignerDynamicPropertySheetExtension::~QDesignerDynamicPropertySheetExtension()
+
+    Destroys the dynamic property sheet extension.
+*/
+
+/*!
+    \fn bool QDesignerDynamicPropertySheetExtension::dynamicPropertiesAllowed() const
+
+    Returns true if the widget supports dynamic properties; otherwise returns false.
+*/
+
+/*!
+    \fn int QDesignerDynamicPropertySheetExtension::addDynamicProperty(const QString &propertyName, const QVariant &value)
+
+    Adds a dynamic property named \a propertyName and sets its value to \a value.
+    Returns the index of the property if it was added successfully; otherwise returns -1 to
+    indicate failure.
+*/
+
+/*!
+    \fn bool QDesignerDynamicPropertySheetExtension::removeDynamicProperty(int index)
+
+    Removes the dynamic property at the given \a index.
+    Returns true if the operation succeeds; otherwise returns false.
+*/
+
+/*!
+    \fn bool QDesignerDynamicPropertySheetExtension::isDynamicProperty(int index) const
+
+    Returns true if the property at the given \a index is a dynamic property; otherwise
+    returns false.
+*/
+
+/*!
+    \fn bool QDesignerDynamicPropertySheetExtension::canAddDynamicProperty(const QString &propertyName) const
+
+    Returns true if \a propertyName is a valid, unique name for a dynamic
+    property; otherwise returns false.
+
+*/
diff --git a/doc/src/qtendian.qdoc b/doc/src/classes/qtendian.qdoc
index dcffb5d..dcffb5d 100644
--- a/doc/src/qtendian.qdoc
+++ b/doc/src/classes/qtendian.qdoc
diff --git a/doc/src/qtestevent.qdoc b/doc/src/classes/qtestevent.qdoc
index 2e111b3..2e111b3 100644
--- a/doc/src/qtestevent.qdoc
+++ b/doc/src/classes/qtestevent.qdoc
diff --git a/doc/src/qvarlengtharray.qdoc b/doc/src/classes/qvarlengtharray.qdoc
index ac6bb6e..ac6bb6e 100644
--- a/doc/src/qvarlengtharray.qdoc
+++ b/doc/src/classes/qvarlengtharray.qdoc
diff --git a/doc/src/qwaitcondition.qdoc b/doc/src/classes/qwaitcondition.qdoc
index ae94e35..ae94e35 100644
--- a/doc/src/qwaitcondition.qdoc
+++ b/doc/src/classes/qwaitcondition.qdoc
diff --git a/doc/src/compiler-notes.qdoc b/doc/src/compiler-notes.qdoc
new file mode 100644
index 0000000..4a7451d
--- /dev/null
+++ b/doc/src/compiler-notes.qdoc
@@ -0,0 +1,278 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page compiler-notes.html
+    \ingroup platform-notes
+    \title Compiler Notes
+    \brief Information about the C++ compilers and tools used to build Qt.
+
+    This page contains information about the C++ compilers and tools used
+    to build Qt on various platforms.
+
+    \tableofcontents
+
+    Please refer to the \l{Platform Notes} for information on the platforms
+    Qt is currently known to run on, and see the \l{Supported Platforms}
+    page for information about the status of each platform.
+
+    If you have anything to add to this list or any of the platform or
+    compiler-specific pages, please submit it via the \l{Bug Report Form}
+    or through the \l{Public Qt Repository}.
+
+    \section1 Supported Features
+
+    Not all compilers used to build Qt are able to compile all modules. The following table
+    shows the compiler support for five modules that are not uniformly available for all
+    platforms and compilers.
+
+    \table
+    \header \o Compiler \o{5,1} Features
+    \header \o                  \o Concurrent \o XmlPatterns \o WebKit   \o CLucene  \o Phonon
+    \row    \o g++ 3.3          \o            \o \bold{X}    \o          \o \bold{X} \o \bold{X}
+    \row    \o g++ 3.4 and up   \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
+    \row
+    \row    \o SunCC 5.5        \o            \o             \o          \o \bold{X} \o \bold{X}
+    \row
+    \row    \o aCC series 3     \o            \o             \o          \o \bold{X} \o \bold{X}
+    \row    \o aCC series 6     \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
+    \row    \o xlC 6            \o            \o             \o          \o \bold{X} \o \bold{X}
+    \row    \o Intel CC 10      \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
+    \row
+    \row    \o MSVC 2003        \o \bold{X}   \o \bold{X}    \o          \o \bold{X} \o \bold{X}
+    \row    \o MSVC 2005 and up \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
+    \endtable
+
+    \target GCC
+    \section1 GCC
+
+    \section2 GCC on Windows (MinGW)
+
+    We have tested Qt with this compiler on Windows XP.
+    The minimal version of MinGW supported is:
+
+    \list
+    \o GCC 3.4.2
+    \o MinGW runtime 3.7
+    \o win32api 3.2
+    \o binutils 2.15.91
+    \o mingw32-make 3.80.0-3
+    \endlist
+
+    \section2 GCC 4.0.0
+
+    The released package of the compiler has some bugs that lead to miscompilations.
+    We recommend using GCC 4.0.1 or later, or to use a recent CVS snapshot of the
+    GCC 4.0 branch. The version of GCC 4.0.0 that is shipped with Mac OS X 10.4
+    "Tiger" is known to work with Qt for Mac OS X.
+
+    \section2 HP-UX
+
+    The hpux-g++ platform is tested with GCC 3.4.4.
+
+    \section2 Solaris
+
+    Please use GCC 3.4.2 or later.
+
+    \section2 Mac OS X
+
+    Please use the latest GCC 3.3 from Apple or a later version of GCC 3.
+    The gcc 3.3 that is provided with Xcode 1.5 is known to generate bad code.
+    Use the November 2004 GCC 3.3 updater \l{http://connect.apple.com}{available from Apple}.
+
+    \section2 GCC 3.4.6 (Debian 3.4.6-5) on AMD64 (x86_64)
+
+    This compiler is known to miscompile some parts of Qt when doing a
+    release build. There are several workarounds:
+
+    \list 1
+    \o Use a debug build instead.
+    \o For each miscompilation encountered, recompile the file, removing the -O2 option.
+    \o Add -fno-gcse to the QMAKE_CXXFLAGS_RELEASE.
+    \endlist
+
+    \section1 HP ANSI C++ (aCC)
+
+    The hpux-acc-32 and hpux-acc-64 platforms are tested with aCC A.03.57. The
+    hpuxi-acc-32 and hpuxi-acc-64 platforms are tested with aCC A.06.10.
+
+    \section1 Intel C++ Compiler
+
+    Qt supports the Intel C++ compiler on both Windows and Linux.
+    However, there are a few issues on Linux (see the following
+    section).
+
+    \section2 Intel C++ Compiler for Linux
+
+    Nokia currently tests the following compilers:
+
+    \list
+
+    \o Intel(R) C++ Compiler for applications running on IA-32,
+    Version 10.1 Build 20080602 Package ID: l_cc_p_10.1.017
+
+    \o Intel(R) C++ Compiler for applications running on Intel(R) 64,
+    Version 10.1 Build 20080602 Package ID: l_cc_p_10.1.017
+
+    \endlist
+
+    We do not currently test the IA-64 (Itanium) compiler.
+
+    \section2 Known Issues with Intel C++ Compiler for Linux
+
+    \list
+
+    \o Precompiled header support does not work in version 10.0.025
+       and older. For these compilers, you should configure Qt with
+       -no-pch. Precompiled header support works properly in version
+       10.0.026 and later.
+    \o Version 10.0.026 for Intel 64 is known to miscompile qmake when
+       building in release mode. For now, configure Qt with
+       -debug. Version 10.1.008 and later can compile qmake in release
+       mode.
+    \o Versions 10.1.008 to 10.1.015 for both IA-32 and Intel 64 are
+       known crash with "(0): internal error: 0_47021" when compiling
+       QtXmlPatterns, QtWebKit, and Designer in release mode. Version
+       10.1.017 compiles these modules correctly in release mode.
+    \endlist
+
+    \section2 Intel C++ Compiler (Windows, Altix)
+
+    Qt 4 has been tested successfully with:
+
+    \list
+    \o Windows - Intel(R) C++ Compiler for 32-bit applications,
+       Version 8.1 Build 20050309Z Package ID: W_CC_PC_8.1.026
+    \o Altix - Intel(R) C++ Itanium(R) Compiler for Itanium(R)-based
+       applications Version 8.1 Build 20050406 Package ID: l_cc_pc_8.1.030
+    \endlist
+
+    We currently only test the Intel compiler on 32-bit Windows versions.
+
+    \section1 MIPSpro (IRIX)
+
+    \bold{IRIX is an unsupported platform. See the \l{Supported Platforms} page
+    and Qt's Software's online \l{Platform Support Policy} page for details.}
+
+    Qt 4.4.x requires MIPSpro version 7.4.2m.
+
+    Note that MIPSpro version 7.4.4m is currently not supported, since it has
+    introduced a number of problems that have not yet been resolved.
+    We recommend using 7.4.2m for Qt development. However, please note the
+    unsupported status of this platform.
+
+    \target Sun Studio
+    \section1 Forte Developer / Sun Studio (Solaris)
+
+    \section2 Sun Studio
+
+    Qt is tested using Sun Studio 8 (Sun CC 5.5). Go to
+    \l{Sun Studio Patches} page on Sun's Web site to download
+    the latest patches for your Sun compiler.
+
+    \section2 Sun WorkShop 5.0
+
+    Sun WorkShop 5.0 is not supported with Qt 4.
+
+    \section1 Visual Studio (Windows)
+
+    We do most of our Windows development on Windows XP, using Microsoft
+    Visual Studio .NET 2005 and Visual Studio 2008 (both the 32- and 64-bit
+    versions).
+
+    Qt works with the Standard Edition, the Professional Edition and Team
+    System Edition of Visual Studio 2005.
+
+    We also test Qt 4 on Windows XP with Visual Studio .NET and Visual Studio 2003.
+
+    In order to use Qt with the Visual Studio 2005/2008 Express Edition you need
+    to download and install the platform SDK. Due to limitations in the
+    Express Edition it is not possible for us to install the Qt Visual
+    Studio Integration. You will need to use our command line tools to
+    build Qt applications with this edition.
+
+    The Visual C++ Linker doesn't understand filenames with spaces (as in
+    \c{C:\Program files\Qt\}) so you will have to move it to another place,
+    or explicitly set the path yourself; for example:
+
+    \snippet doc/src/snippets/code/doc_src_compiler-notes.qdoc 0
+
+    If you are experiencing strange problems with using special flags that
+    modify the alignment of structure and union members (such as \c{/Zp2})
+    then you will need to recompile Qt with the flags set for the
+    application as well.
+
+    If you're using Visual Studio .NET (2002) Standard Edition, you should be
+    using the Qt binary package provided, and not the source package.
+    As the Standard Edition does not optimize compiled code, your compiled
+    version of Qt would perform suboptimally with respect to speed.
+
+    With Visual Studio 2005 Service Pack 1 a bug was introduced which
+    causes Qt not to compile, this has been fixed with a hotfix available
+    from Microsoft. See this
+    \l{http://www.qtsoftware.com/developer/faqs/faq.2006-12-18.3281869860}{Knowledge Base entry}
+    for more information.
+
+    \section1 IBM xlC (AIX)
+
+    The makeC++SharedLib utility must be in your PATH and be up to date to
+    build shared libraries. From IBM's
+    \l{http://www.redbooks.ibm.com/abstracts/sg245674.html}{C and C++ Application Development on AIX}
+    Redbook:
+
+    \list
+    \o "The second step is to use the makeC++SharedLib command to create the
+       shared object. The command has many optional arguments, but in its
+       simplest form, can be used as follows:"
+       \snippet doc/src/snippets/code/doc_src_compiler-notes.qdoc 1
+    \o "The full path name to the command is not required; however, to avoid
+       this, you will have to add the directory in which it is located to
+       your PATH environment variable. The command is located in the
+       /usr/vacpp/bin directory with the VisualAge C++ Professional for AIX,
+       Version 5 compiler."
+    \endlist
+
+    \section2 VisualAge C++ for AIX, Version 6.0
+
+    Make sure you have the
+    \l{http://www-1.ibm.com/support/search.wss?rs=32&amp;tc=SSEP5D&amp;dc=D400}{latest upgrades}
+    installed.
+*/
diff --git a/doc/src/coordsys.qdoc b/doc/src/coordsys.qdoc
index 7ba3946..4a73d67 100644
--- a/doc/src/coordsys.qdoc
+++ b/doc/src/coordsys.qdoc
@@ -224,12 +224,12 @@
     Transformations} demo for a visualization of a sheared coordinate
     system. All the transformation operations operate on QPainter's
     transformation matrix that you can retrieve using the
-    QPainter::worldMatrix() function. A matrix transforms a point in the
-    plane to another point.
+    QPainter::worldTransform() function. A matrix transforms a point
+    in the plane to another point.
 
     If you need the same transformations over and over, you can also
-    use QMatrix objects and the QPainter::worldMatrix() and
-    QPainter::setWorldMatrix() functions. You can at any time save the
+    use QTransform objects and the QPainter::worldTransform() and
+    QPainter::setWorldTransform() functions. You can at any time save the
     QPainter's transformation matrix by calling the QPainter::save()
     function which saves the matrix on an internal stack. The
     QPainter::restore() function pops it back.
@@ -318,7 +318,7 @@
     transformations affects the result.
 
     For more information about the transformation matrix, see the
-    QMatrix documentation.
+    QTransform documentation.
 
     \section1 Window-Viewport Conversion
 
@@ -328,7 +328,7 @@
 
     The mapping of the logical coordinates to the physical coordinates
     are handled by QPainter's world transformation \l
-    {QPainter::worldMatrix()}{worldMatrix()} (described in the \l
+    {QPainter::worldTransform()}{worldTransform()} (described in the \l
     Transformations section), and QPainter's \l
     {QPainter::viewport()}{viewport()} and \l
     {QPainter::window()}{window()}.  The viewport represents the
@@ -419,14 +419,14 @@
     \endtable
 
     The 2D transformations of the coordinate system are specified
-    using the QMatrix class:
+    using the QTransform class:
 
     \table
     \header \o Class \o Description
     \row
-    \o QMatrix
+    \o QTransform
     \o
-    A 3 x 3 transformation matrix. Use QMatrix to rotate, shear,
+    A 3 x 3 transformation matrix. Use QTransform to rotate, shear,
     scale, or translate the coordinate system.
     \endtable
 
diff --git a/doc/src/datastreamformat.qdoc b/doc/src/datastreamformat.qdoc
index dea193f..5db85cb 100644
--- a/doc/src/datastreamformat.qdoc
+++ b/doc/src/datastreamformat.qdoc
@@ -220,6 +220,25 @@
             \o dx (double)
             \o dy (double)
             \endlist
+    \row \o QMatrix4x4
+         \o \list
+            \o m11 (double)
+            \o m12 (double)
+            \o m13 (double)
+            \o m14 (double)
+            \o m21 (double)
+            \o m22 (double)
+            \o m23 (double)
+            \o m24 (double)
+            \o m31 (double)
+            \o m32 (double)
+            \o m33 (double)
+            \o m34 (double)
+            \o m41 (double)
+            \o m42 (double)
+            \o m43 (double)
+            \o m44 (double)
+            \endlist
     \row \o QPair<T1, T2>
          \o \list
             \o first (T1)
@@ -266,6 +285,13 @@
             \o The x coordinate (qint32)
             \o The y coordinate (qint32)
             \endlist
+    \row \o QQuaternion
+         \o \list
+            \o The scalar component (double)
+            \o The x coordinate (double)
+            \o The y coordinate (double)
+            \o The z coordinate (double)
+            \endlist
     \row \o QRect
          \o \list
             \o left (qint32)
@@ -301,6 +327,18 @@
          \o \list
             \o Milliseconds since midnight (quint32)
             \endlist
+    \row \o QTransform
+         \o \list
+            \o m11 (double)
+            \o m12 (double)
+            \o m13 (double)
+            \o m21 (double)
+            \o m22 (double)
+            \o m23 (double)
+            \o m31 (double)
+            \o m32 (double)
+            \o m33 (double)
+            \endlist
     \row \o QUrl
          \o \list
             \o Holds an URL (QString)
@@ -311,6 +349,24 @@
             \o The null flag (qint8)
             \o The data of the specified type
             \endlist
+    \row \o QVector2D
+         \o \list
+            \o the x coordinate (double)
+            \o the y coordinate (double)
+            \endlist
+    \row \o QVector3D
+         \o \list
+            \o the x coordinate (double)
+            \o the y coordinate (double)
+            \o the z coordinate (double)
+            \endlist
+    \row \o QVector4D
+         \o \list
+            \o the x coordinate (double)
+            \o the y coordinate (double)
+            \o the z coordinate (double)
+            \o the w coordinate (double)
+            \endlist
     \row \o QVector<T>
          \o \list
             \o The number of items (quint32)
diff --git a/doc/src/obsoleteclasses.qdoc b/doc/src/demos/sub-attaq.qdoc
index 3658dfc..6bbf763 100644
--- a/doc/src/obsoleteclasses.qdoc
+++ b/doc/src/demos/sub-attaq.qdoc
@@ -40,20 +40,15 @@
 ****************************************************************************/
 
 /*!
-    \page obsoleteclasses.html
-    \group obsolete
-    \title Obsolete Classes
-    \ingroup classlists
-    \ingroup groups
+    \example demos/sub-attaq
+    \title Sub-Attaq
 
-    \brief Qt classes that are obsolete (deprecated).
+    This demo shows Qt's ability to combine \l{The Animation Framework}{the animation framework} 
+    and \l{The State Machine Framework}{the state machine framework} to create a game.
+    
+    \image sub-attaq-demo.png
 
-    This is a list of Qt classes that are obsolete (deprecated). These
-    classes are provided to keep old source code working but they are
-    no longer maintained. We strongly advise against using these
-    classes in new code.
-
-    \generatelist obsoleteclasses
-
-    \sa {Qt's Classes}, {Qt's Modules}
+    The purpose of the game is to destroy all submarines to win the current level.
+    The boat can be controlled using left and right keys. To fire a bomb you can press
+    up and down keys.
 */
diff --git a/doc/src/designer-manual.qdoc b/doc/src/designer-manual.qdoc
index c67865d..ab33185 100644
--- a/doc/src/designer-manual.qdoc
+++ b/doc/src/designer-manual.qdoc
@@ -402,7 +402,7 @@
     while setting as few widget size constraints as possible.
 
     For a more technical perspective on Qt's layout classes, refer to the
-    \l{Layout Classes} document.
+    \l{Layout Management} documentation.
 */
 
 
diff --git a/doc/src/emb-charinput.qdoc b/doc/src/emb-charinput.qdoc
index c9c768c..dc4eed5 100644
--- a/doc/src/emb-charinput.qdoc
+++ b/doc/src/emb-charinput.qdoc
@@ -82,13 +82,13 @@
 
     \section1 Available Keyboard Drivers
 
-    \l {Qt for Embedded Linux} provides ready-made drivers for the SL5000, Yopy,
-    Vr41XX, console (TTY) and USB protocols. Run the \c configure
-    script to list the available drivers:
+    \l {Qt for Embedded Linux} provides ready-made drivers for the console
+    (TTY) and the standard Linux Input Subsystem (USB, PS/2, ...).  Run the
+    \c configure script to list the available drivers:
 
     \snippet doc/src/snippets/code/doc_src_emb-charinput.qdoc 0
 
-    Note that the console keyboard driver also handles console
+    Note that only the console (TTY) keyboard driver handles console
     switching (\bold{Ctrl+Alt+F1}, ..., \bold{Ctrl+Alt+F10}) and
     termination (\bold{Ctrl+Alt+Backspace}).
 
@@ -105,6 +105,17 @@
     detect the plugin, loading the driver into the server application
     at run-time.
 
+    \section1 Keymaps
+
+    Starting with 4.6, \l {Qt for Embedded Linux} has gained support for
+    user defined keymaps.  Keymap handling is supported by the built-in
+    keyboard drivers \c TTY and \c LinuxInput.  Custom keyboard drivers can
+    use the existing keymap handling code via
+    QWSKeyboardHandler::processKeycode().
+
+    By default Qt will use an internal, compiled-in US keymap.
+    See the options below for how to load a different keymap.
+
     \section1 Specifying a Keyboard Driver
 
     To specify which driver to use, set the QWS_KEYBOARD environment
@@ -113,14 +124,41 @@
 
     \snippet doc/src/snippets/code/doc_src_emb-charinput.qdoc 2
 
-    The \c <driver> argument are \c SL5000, \c Yopy, \c VR41xx, \c
-    TTY, \c USB and \l {QKbdDriverPlugin::keys()}{keys} identifying
-    custom drivers, and the driver specific options are typically a
-    device, e.g., \c /dev/tty0.
+    The \c <driver> arguments are \c TTY, \c LinuxInput and \l
+    {QKbdDriverPlugin::keys()}{keys} identifying custom drivers, and the
+    driver specific options are typically a device, e.g., \c /dev/tty0.
 
     Multiple keyboard drivers can be specified in one go:
 
     \snippet doc/src/snippets/code/doc_src_emb-charinput.qdoc 3
 
     Input will be read from all specified drivers.
+
+    Currently the following options are supported by both the \c TTY and \c
+    LinuxInput driver:
+
+    \table
+    \header \o Option \o Description
+    \row \o \c /dev/xxx \o
+    Open the specified device, instead of the driver's default device.
+    \row \o \c repeat-delay=<d> \o
+    Time (in milliseconds) until auto-repeat kicks in.
+    \row \o \c repeat-rate=<r> \o
+    Time (in milliseconds) specifying the interval between auto-repeats.
+    \row \o \c keymap=xx.qmap \o
+    File name of a keymap file in Qt's \c qmap format. See \l {kmap2qmap}
+    for instructions on how to create thoes files.\br Note that the file
+    name can of course also be the name of a QResource.
+    \row \o \c disable-zap \o
+    Disable the QWS server "Zap" shortcut \bold{Ctrl+Alt+Backspace}
+    \row \o \c enable-compose \o
+    Activate Latin-1 composing features in the built-in US keymap. You can
+    use the right \c AltGr or right \c Alt is used as a dead key modifier,
+    while \c AltGr+.  is the compose key.  For example:
+    \list
+    \o \c AltGr + \c " + \c u = \uuml (u with diaeresis / umlaut u)
+    \o \c AltGr + \c . + \c / + \c o = \oslash (slashed o)
+    \endlist
+    \endtable
+
 */
diff --git a/doc/src/emb-kmap2qmap.qdoc b/doc/src/emb-kmap2qmap.qdoc
new file mode 100644
index 0000000..19d33c1
--- /dev/null
+++ b/doc/src/emb-kmap2qmap.qdoc
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page qt-embedded-kmap2qmap.html
+    \title kmap2qmap
+    \ingroup qt-embedded-linux
+
+    \c kmap2qmap is a tool to generate keymaps for use on Embedded Linux.
+    The source files have to be in standard Linux \c kmap format that is
+    e.g.  understood by the kernel's \c loadkeys command.  This means you
+    can use the following sources to generate \c qmap files:
+
+    \list
+    \o The \l {http://lct.sourceforge.net/}{Linux Console Tools (LCT)} project.
+    \o \l {http://www.x.org/}{Xorg} X11 keymaps can be converted to the \c
+    kmap format with the \c ckbcomp utility.
+    \o Since \c kmap files are plain text files, they can also be hand crafted.
+    \endlist
+
+    The generated \c qmap files are size optimized binary files.
+
+    \c kmap2qmap is a command line program, that needs at least 2 files as
+    parameters.  The last one will be the generated \c .qmap file, while all
+    the others will be parsed as input \c .kmap files.  For example:
+
+    \code
+    kmap2qmap i386/qwertz/de-latin1-nodeadkeys.kmap include/compose.latin1.inc de-latin1-nodeadkeys.qmap
+    \endcode
+
+    \c kmap2qmap does not support all the (pseudo) symbols that the Linux
+    kernel supports.  If you are converting a standard keymap you will get a
+    lot of warnings for things like \c Show_Registers, \c Hex_A, etc.: you
+    can safely ignore those.
+
+    It also doesn't support numeric symbols (e.g. \c{keycode 1 = 4242},
+    instead of \c{keycode 1 = colon}), since these are deprecated and can
+    change from one kernel version to the other.
+
+    On the other hand, \c kmap2qmap supports one additional, Qt specific,
+    symbol: \c QtZap.  The built-in US keymap has that symbol mapped tp
+    \c{Ctrl+Alt+Backspace} and it serves as a shortcut to kill your QWS
+    server (similiar to the X11 server).
+
+    See also \l {Qt for Embedded Linux Character Input}
+*/
diff --git a/doc/src/emb-pointer.qdoc b/doc/src/emb-pointer.qdoc
index b13dec0..49504fe 100644
--- a/doc/src/emb-pointer.qdoc
+++ b/doc/src/emb-pointer.qdoc
@@ -64,9 +64,10 @@
     \section1 Available Drivers
 
     \l{Qt for Embedded Linux} provides ready-made drivers for the MouseMan,
-    IntelliMouse, Microsoft, NEC Vr41XX, Linux Touch Panel and Yopy
-    protocols as well as the universal touch screen library,
-    tslib. Run the \c configure script to list the available drivers:
+    IntelliMouse, Microsoft and Linux Touch Panel protocols, for the
+    standard Linux Input Subsystem as well as the universal touch screen
+    library, tslib.  Run the \c configure script to list the available
+    drivers:
 
     \if defined(QTOPIA_PHONE)
 
@@ -125,7 +126,7 @@
     \snippet doc/src/snippets/code/doc_src_emb-pointer.qdoc 4
 
     The valid values for the \c <driver> argument are \c MouseMan, \c
-    IntelliMouse, \c Microsoft, \c VR41xx, \c LinuxTP, \c Yopy, \c
+    IntelliMouse, \c Microsoft, \c LinuxTP, \c LinuxInput, \c
     Tslib and \l {QMouseDriverPlugin::keys()}{keys} identifying custom
     drivers, and the driver specific options are typically a device,
     e.g., \c /dev/mouse for mouse devices and \c /dev/ts for touch
@@ -137,14 +138,6 @@
 
     Input will be read from all specified drivers.
 
-    Note that the \c Vr41xx driver also accepts two optional
-    arguments: \c press=<value> defining a mouse click (the default
-    value is 750) and \c filter=<value> specifying the length of the
-    filter used to eliminate noise (the default length is 3). For
-    example:
-
-    \snippet doc/src/snippets/code/doc_src_emb-pointer.qdoc 6
-
     \table
     \header \o The Tslib Mouse Driver
     \row
diff --git a/doc/src/examples-overview.qdoc b/doc/src/examples-overview.qdoc
index 4313c43..3db4a45 100644
--- a/doc/src/examples-overview.qdoc
+++ b/doc/src/examples-overview.qdoc
@@ -238,6 +238,17 @@
   These examples demonstrate the basic techniques used to take advantage of
   OpenGL in Qt applications.
 
+  \section1 \l{Qt Examples#Multimedia}{Multimedia}
+
+  \l{Qt Examples#Multimedia}
+
+  Qt provides low-level audio support on linux,windows and mac platforms by default and
+  an audio plugin API to allow developers to implement there own audio support for
+  custom devices and platforms.
+
+  These examples demonstrate the basic techniques used to take advantage of
+  Audio API in Qt applications.
+
   \section1 \l{Qt Examples#SQL}{SQL}
 
   \l{Qt Examples#SQL}{\inlineimage sql-examples.png
diff --git a/doc/src/examples.qdoc b/doc/src/examples.qdoc
index 2861c90..7f9264b 100644
--- a/doc/src/examples.qdoc
+++ b/doc/src/examples.qdoc
@@ -255,6 +255,14 @@
     \o \l{phonon/musicplayer}{Music Player}\raisedaster
     \endlist
 
+    \section1 Multimedia
+
+    \list
+    \o \l{multimedia/audio/audiodevices}{Audio Devices}\raisedaster
+    \o \l{multimedia/audio/audiooutput}{Audio Output}\raisedaster
+    \o \l{multimedia/audio/audioinput}{Audio Input}\raisedaster
+    \endlist
+
     \section1 Qt Designer
 
     \list
@@ -322,9 +330,9 @@
     \o \l{statemachine/eventtransitions}{Event Transitions}\raisedaster
     \o \l{statemachine/factorial}{Factorial States}\raisedaster
     \o \l{statemachine/pingpong}{Ping Pong States}\raisedaster
+    \o \l{statemachine/rogue}{Rogue}\raisedaster
     \o \l{statemachine/trafficlight}{Traffic Light}\raisedaster
     \o \l{statemachine/twowaybutton}{Two-way Button}\raisedaster
-    \o \l{statemachine/tankgame}{Tank Game}\raisedaster
     \endlist
 
     \section1 Threads
diff --git a/doc/src/mainclasses.qdoc b/doc/src/examples/audiodevices.qdoc
index 33bb91a..3b8cdd8 100644
--- a/doc/src/mainclasses.qdoc
+++ b/doc/src/examples/audiodevices.qdoc
@@ -40,12 +40,15 @@
 ****************************************************************************/
 
 /*!
-    \page mainclasses.html
-    \title Qt's Main Classes
-    \ingroup classlists
+    \example multimedia/audio/audiodevices
+    \title Audio Devices Example
 
-    These are the most frequently used Qt classes. For the complete
-    list see \link classes.html Qt's Classes \endlink.
+    The Audio Devices example demonstrates the basic use of QAudioDeviceInfo class
+    provided with Qt.
 
-    \generatelist mainclasses
+    Qt provides the QAudioDeviceInfo class to enable audio querying within
+    a standard application user interface.
+
+    This example allows you to browse audio devices available and  try out different
+    configurations to see if they are supported.
 */
diff --git a/doc/src/compatclasses.qdoc b/doc/src/examples/audioinput.qdoc
index cb6d7dd..5dfe76e 100644
--- a/doc/src/compatclasses.qdoc
+++ b/doc/src/examples/audioinput.qdoc
@@ -40,15 +40,15 @@
 ****************************************************************************/
 
 /*!
-    \page compatclasses.html
-    \title Qt 3 Compatibility Classes
-    \ingroup classlists
+    \example multimedia/audio/audioinput
+    \title AudioInput Example
 
-    This is a list of the classes that Qt provides for compatibility
-    with Qt 3. The vast majority of these are provided by the
-    Qt3Support module.
+    The Audio Input example demonstrates the basic use of QAudioInput class
+    provided with Qt.
 
-    \generatelist compatclasses
+    Qt provides the QAudioInput class to enable audio functionality within
+    a standard application user interface.
 
-    \sa {Qt's Classes}, {Qt's Modules}
+    This example uses a fast-fourier transform on the input audio from the microphone
+    and displays the output.
 */
diff --git a/doc/src/hierarchy.qdoc b/doc/src/examples/audiooutput.qdoc
index 4a278dc..9c8a75f 100644
--- a/doc/src/hierarchy.qdoc
+++ b/doc/src/examples/audiooutput.qdoc
@@ -40,13 +40,13 @@
 ****************************************************************************/
 
 /*!
-    \page hierarchy.html
+    \example multimedia/audio/audiooutput
+    \title Audio Output Example
 
-    \title Class Inheritance Hierarchy
-    \ingroup classlists
+    The Audio Output example demonstrates the basic use of the QAudioOutput class
+    provided with Qt.
 
-    This list shows the C++ class inheritance relations between the
-    classes in the Qt API.
-
-    \generatelist classhierarchy
+    This example provides a tone generator to supply continuous audio playback.
+    The first button allows pause and resume of the playback.
+    The second button allows toggling between push and pull modes of operation.
 */
diff --git a/doc/src/examples/collidingmice-example.qdoc b/doc/src/examples/collidingmice-example.qdoc
index 5b124f9..f627fbf 100644
--- a/doc/src/examples/collidingmice-example.qdoc
+++ b/doc/src/examples/collidingmice-example.qdoc
@@ -95,11 +95,11 @@
     the global qrand() function which is a thread-safe version of the
     standard C++ rand() function.
 
-    Then we call the \l {QGraphicsItem::rotate()}{rotate()} function
+    Then we call the \l {QGraphicsItem::setRotation()}{setRotation()} function
     inherited from QGraphicsItem. Items live in their own local
     coordinate system. Their coordinates are usually centered around
     (0, 0), and this is also the center for all transformations. By
-    calling the item's \l {QGraphicsItem::rotate()}{rotate()} function
+    calling the item's \l {QGraphicsItem::setRotation()}{setRotation()} function
     we alter the direction in which the mouse will start moving.
 
 	When the QGraphicsScene decides to advance the scene a frame it will call 
diff --git a/doc/src/examples/googlechat.qdoc b/doc/src/examples/googlechat.qdoc
index 42a0198..7c9d7db 100644
--- a/doc/src/examples/googlechat.qdoc
+++ b/doc/src/examples/googlechat.qdoc
@@ -48,4 +48,5 @@
 
     \image googlechat-example.png
 
+    \note The Google Talk instant messaging service is a registered trademark of Google Inc.
 */
diff --git a/doc/src/examples/googlesuggest.qdoc b/doc/src/examples/googlesuggest.qdoc
index 1752420..e3d2b1f 100644
--- a/doc/src/examples/googlesuggest.qdoc
+++ b/doc/src/examples/googlesuggest.qdoc
@@ -48,4 +48,5 @@
 
     \image googlesuggest-example.png
 
+    \note The Google Suggest suggestion service is a registered trademark of Google Inc.
 */
diff --git a/doc/src/examples/rogue.qdoc b/doc/src/examples/rogue.qdoc
new file mode 100644
index 0000000..8fa2c69
--- /dev/null
+++ b/doc/src/examples/rogue.qdoc
@@ -0,0 +1,222 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/rogue
+    \title Rogue Example
+
+    The Rogue example shows how to use the Qt state machine for event
+    handling.
+
+    \image rogue-example.png
+
+    This example implements a simple text based game. Do you see the
+    \c{@} in the screenshot? That's you, the rogue. The \c{#}
+    characters are walls, and the dots represent floor. In a real
+    game, other ASCII characters would represent all kinds of objects
+    and creatures. For instance, ancient dragons (\c{D}'s) or food
+    rations (\c{%}'s). But let's not get carried away. In this game,
+    the rogue is simply running around in an empty room.
+
+    The rogue is moved with the keypad (2, 4, 8, 6). That aside, we
+    have implemented a \c quit command that triggers if the player
+    types \c {q}. The player is then asked if he/she really wants to
+    quit.
+
+    Most games have commands that need more than one key press and
+    that may require a different sequence of keys based on questions
+    asked the user. In this game, only the \c quit command falls under
+    this category, but for the sake of argument, let's imagine a
+    fully-fledged game with a rich set of commands. If we were to
+    implement these by catching key events in
+    \l{QWidget::}{keyPressEvent()}, we would have to keep a lot of
+    class member variables to track the sequence of keys already typed
+    (or find some other way of deducing the current state of a
+    command). This can easily lead to spaghetti, which is--as we all
+    well know, I'm sure--unpleasant. With a state machine, on the
+    other hand, separate states can wait for a single key press, and
+    that makes our lives a lot simpler.
+
+    The example consists of two classes:
+
+    \list
+        \o \c Window draws the text display of the game and sets
+            up the state machine. The window also has a status bar
+            above the area in which the rouge moves.
+        \o \c MovementTransition is a transition that carries out
+            a single move of the rogue.
+    \endlist
+
+    Before we embark on a code walkthrough, it is necessary to take a
+    closer look at the design of the machine. Here is a state chart
+    that shows what we want to achieve:
+
+    \image rogue-statechart.png
+
+    The input state waits for a key press to start a new command.
+    When receiving a key it recognizes, it transitions to one of the
+    two commands of the game; though, as we will see, movement is
+    handled by the transition itself. The quit state waits for the
+    player to answer yes or no (by typing \c y or \c n) when asked
+    whether he/she really wants to quit the game.
+
+    The chart demonstrates how we use one state to wait for a single
+    key press. The press received may trigger one of the transitions
+    connected to the state.
+
+    \section1 Window Class Definition
+
+    The \c Window class is a widget that draws the text display of the
+    game. It also sets up the state machine, i.e., creates and
+    connects the states in the machine. It is the key events from this
+    widget that are used by the machine.
+
+    \snippet examples/statemachine/rogue/window.h 0
+
+    \c Direction specifies the direction in which the rogue is to
+    move. We use this in \c movePlayer(), which moves the rogue and
+    repaints the window. The game has a status line above the area in
+    which the rogue moves. The \c status property contains the text of
+    this line. We use a property because the QState class allows
+    setting any Qt \l{Qt's Property System}{property} when entered.
+    More on this later.
+
+    \snippet examples/statemachine/rogue/window.h 1
+
+    The \c map is an array with the characters that are currently
+    displayed. We set up the array in \c setupMap(), and update it
+    when the rogue is moved. \c pX and \c pY is the current position
+    of the rogue. \c WIDTH and \c HEIGHT are macros specifying the
+    dimensions of the map.
+
+    The \c paintEvent() function is left out of this walkthrough. We
+    also do not discuss other code that does not concern the state
+    machine (the \c setupMap(), \c status(), \c setStatus(), \c
+    movePlayer(), and \c sizeHint() functions). If you wish to take a
+    look at the code, click on the link for the \c window.cpp file at
+    the top of this page.
+
+    \section1 Window Class Implementation
+
+    Here is the constructor of \c Window:
+
+    \snippet examples/statemachine/rogue/window.cpp 0
+    \dots
+    \snippet examples/statemachine/rogue/window.cpp 1
+
+    The player starts off at position (5, 5). We then set up the map
+    and statemachine. Let's proceed with the \c buildMachine()
+    function:
+
+    \snippet examples/statemachine/rogue/window.cpp 2
+
+    We enter \c inputState when the machine is started and from the \c
+    quitState if the user wants to continue playing. We then set the
+    status to a helpful reminder of how to play the game.
+
+    First, the \c Movement transition is added to the input state.
+    This will enable the rogue to be moved with the keypad.  Notice
+    that we don't set a target state for the movement transition. This
+    will cause the transition to be triggered (and the
+    \l{QAbstractTransition::}{onTransition()} function to be invoked),
+    but the machine will not leave the \c inputState. If we had set \c
+    inputState as the target state, we would first have left and then
+    entered the \c inputState again.
+
+    \snippet examples/statemachine/rogue/window.cpp 3
+
+    When we enter \c quitState, we update the status bar of the
+    window.
+    
+    \c QKeyEventTransition is a utility class that removes the hassle
+    of implementing transitions for \l{QKeyEvent}s. We simply need to
+    specify the key on which the transition should trigger and the
+    target state of the transition.
+
+    \snippet examples/statemachine/rogue/window.cpp 4
+
+    The transition from \c inputState allows triggering the quit state
+    when the player types \c {q}.
+    
+    \snippet examples/statemachine/rogue/window.cpp 5
+
+    The machine is set up, so it's time to start it.
+
+    \section1 The MovementTransition Class
+
+    \c MovementTransition is triggered when the player request the
+    rogue to be moved (by typing 2, 4, 6, or 8) when the machine is in
+    the \c inputState.
+
+    \snippet examples/statemachine/rogue/movementtransition.h 0
+
+    In the constructor, we tell QEventTransition to only send
+    \l{QEvent::}{KeyPress} events to the
+    \l{QAbstractTransition::}{eventTest()} function:
+
+    \snippet examples/statemachine/rogue/movementtransition.h 1
+
+    The KeyPress events come wrapped in \l{QWrappedEvent}s. \c event
+    must be confirmed to be a wrapped event because Qt uses other
+    events internally. After that, it is simply a matter of checking
+    which key has been pressed.
+
+    Let's move on to the \c onTransition() function:
+
+    \snippet examples/statemachine/rogue/movementtransition.h 2
+
+    When \c onTransition() is invoked, we know that we have a
+    \l{QEvent::}{KeyPress} event with 2, 4, 6, or 8, i.e., the event
+    is already unwrapped.
+
+    \section1 The Roguelike Tradition
+
+    You might have been wondering why the game features a rogue. Well,
+    these kinds of text based dungeon exploration games date back to a
+    game called, yes, "Rogue". Although outflanked by the technology
+    of modern 3D computer games, roguelikes have a solid community of
+    hard-core, devoted followers.
+
+    Playing these games can be surprisingly addictive (despite the
+    lack of graphics). Angband, the perhaps most well-known rougelike,
+    is found here: \l{http://rephial.org/}.
+*/
+
diff --git a/doc/src/examples/scribble.qdoc b/doc/src/examples/scribble.qdoc
index 3a5e018..f32440a 100644
--- a/doc/src/examples/scribble.qdoc
+++ b/doc/src/examples/scribble.qdoc
@@ -354,7 +354,7 @@
     To retrieve a new pen width in the \c penWidth() slot, we use
     QInputDialog. The QInputDialog class provides a simple
     convenience dialog to get a single value from the user. We use
-    the static QInputDialog::getInteger() function, which combines a
+    the static QInputDialog::getInt() function, which combines a
     QLabel and a QSpinBox. The QSpinBox is initialized with the
     scribble area's pen width, allows a range from 1 to 50, a step of
     1 (meaning that the up and down arrow increment or decrement the
diff --git a/doc/src/examples/tankgame.qdoc b/doc/src/examples/tankgame.qdoc
deleted file mode 100644
index 536e582..0000000
--- a/doc/src/examples/tankgame.qdoc
+++ /dev/null
@@ -1,117 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** 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 either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at http://www.qtsoftware.com/contact.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
-    \example statemachine/tankgame
-    \title Tank Game Example
-
-    The Tank Game example is part of the in \l{The State Machine Framework}. It shows how to use 
-    parallel states to implement artificial intelligence controllers that run in parallel, and error 
-    states to handle run-time errors in parts of the state graph created by external plugins.
-
-    \image tankgame-example.png
-
-    In this example we write a simple game. The application runs a state machine with two main 
-    states: A "stopped" state and a "running" state. The user can load plugins from the disk by 
-    selecting the "Add tank" menu item. 
-    
-    When the "Add tank" menu item is selected, the "plugins" subdirectory in the example's 
-    directory is searched for compatible plugins. If any are found, they will be listed in a 
-    dialog box created using QInputDialog::getItem().
-    
-    \snippet examples/statemachine/tankgame/mainwindow.cpp 1
-    
-    If the user selects a plugin, the application will construct a TankItem object, which inherits
-    from QGraphicsItem and QObject, and which implements an agreed-upon interface using the 
-    meta-object mechanism.
-    
-    \snippet examples/statemachine/tankgame/tankitem.h 0
-    
-    The tank item will be passed to the plugin's create() function. This will in turn return a 
-    QState object which is expected to implement an artificial intelligence which controls the 
-    tank and attempts to destroy other tanks it detects.
-    
-    \snippet examples/statemachine/tankgame/mainwindow.cpp 2
-    
-    Each returned QState object becomes a descendant of a \c region in the "running" state, which is 
-    defined as a parallel state. This means that entering the "running" state will cause each of the 
-    plugged-in QState objects to be entered simultaneously, allowing the tanks to run independently
-    of each other.
-    
-    \snippet examples/statemachine/tankgame/mainwindow.cpp 0
-    
-    The maximum number of tanks on the map is four, and when this number is reached, the 
-    "Add tank" menu item should be disabled. This is implemented by giving the "stopped" state two
-    children which define whether the map is full or not. 
-    
-    \snippet examples/statemachine/tankgame/mainwindow.cpp 5
-    
-    To make sure that we go into the correct child state when returning from the "running" state 
-    (if the "Stop game" menu item is selected while the game is running) we also give the "stopped" 
-    state a history state which we make the initial state of "stopped" state.
-    
-    \snippet examples/statemachine/tankgame/mainwindow.cpp 3
-    
-    Since part of the state graph is defined by external plugins, we have no way of controlling
-    whether they contain errors. By default, run-time errors are handled in the state machine by
-    entering a top level state which prints out an error message and never exits. If we were to 
-    use this default behavior, a run-time error in any of the plugins would cause the "running"
-    state to exit, and thus all the other tanks to stop running as well. A better solution would
-    be if the broken plugin was disabled and the rest of the tanks allowed to continue as before.
-    
-    This is done by setting the error state of the plugin's top-most state to a special error state
-    defined specifically for the plugin in question.
-    
-    \snippet examples/statemachine/tankgame/mainwindow.cpp 4
-    
-    If a run-time error occurs in \c pluginState or any of its descendants, the state machine will
-    search the hierarchy of ancestors until it finds a state whose error state is different from
-    \c null. (Note that if we are worried that a plugin could inadvertedly be overriding our 
-    error state, we could search the descendants of \c pluginState and verify that their error 
-    states are set to \c null before accepting the plugin.)
-    
-    The specialized \c errorState sets the "enabled" property of the tank item in question to false, 
-    causing it to be painted with a red cross over it to indicate that it is no longer running. 
-    Since the error state is a child of the same region in the parallel "running" state as 
-    \c pluginState, it will not exit the "running" state, and the other tanks will continue running
-    without disruption.
-
-*/
diff --git a/doc/src/examples/transformations.qdoc b/doc/src/examples/transformations.qdoc
index a449d4c..a5f92a8 100644
--- a/doc/src/examples/transformations.qdoc
+++ b/doc/src/examples/transformations.qdoc
@@ -85,10 +85,10 @@
 
     All the tranformation operations operate on QPainter's
     tranformation matrix that you can retrieve using the
-    QPainter::matrix() function. A matrix transforms a point in the
+    QPainter::worldTransform() function. A matrix transforms a point in the
     plane to another point. For more information about the
     transformation matrix, see the \l {The Coordinate System} and
-    QMatrix documentation.
+    QTransform documentation.
 
     \snippet examples/painting/transformations/renderarea.h 0
 
@@ -375,7 +375,7 @@
     All the tranformation operations operate on QPainter's
     tranformation matrix. For more information about the
     transformation matrix, see the \l {The Coordinate System} and
-    QMatrix documentation.
+    QTransform documentation.
 
     The Qt reference documentation provides several painting
     demos. Among these is the \l {demos/affine}{Affine
diff --git a/doc/src/functions.qdoc b/doc/src/functions.qdoc
deleted file mode 100644
index e4c8c57..0000000
--- a/doc/src/functions.qdoc
+++ /dev/null
@@ -1,63 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** 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 either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at http://www.qtsoftware.com/contact.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/****************************************************************************
-**
-** Documentation for class overview.
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Qt GUI Toolkit.
-** EDITIONS: FREE, PROFESSIONAL, ENTERPRISE
-**
-****************************************************************************/
-
-/*!
-    \page functions.html
-    \title Member Function Index
-    \ingroup classlists
-
-    Here is the list of all the documented member functions in the Qt
-    API with links to the class documentation for each function.
-
-    \generatelist functionindex
-*/
diff --git a/doc/src/graphicsview.qdoc b/doc/src/graphicsview.qdoc
index f42c0d4..89f9f3d 100644
--- a/doc/src/graphicsview.qdoc
+++ b/doc/src/graphicsview.qdoc
@@ -141,7 +141,7 @@
         to scene coordinates where appropriate), before sending the events
         to the visualized scene.
 
-        Using its transformation matrix, QGraphicsView::matrix(), the view can
+        Using its transformation matrix, QGraphicsView::transform(), the view can
         \e transform the scene's coordinate system. This allows advanced
         navigation features such as zooming and rotation. For convenience,
         QGraphicsView also provides functions for translating between view and
@@ -174,7 +174,7 @@
         also provides many functions for mapping coordinates between the item
         and the scene, and from item to item. Also, like QGraphicsView, it can
         transform its coordinate system using a matrix:
-        QGraphicsItem::matrix(). This is useful for rotating and scaling
+        QGraphicsItem::transform(). This is useful for rotating and scaling
         individual items.
 
         Items can contain other items (children). Parent items'
@@ -461,11 +461,7 @@
 
         By making an item a child of another, you can achieve the most
         essential feature of item grouping: the items will move together, and
-        all transformations are propagated from parent to child. QGraphicsItem
-        can also handle all events for its children (see
-        QGraphicsItem::setHandlesChildEvents()). This allows the parent item
-        to act on behalf of its children, effectively treating all items as
-        one.
+        all transformations are propagated from parent to child.
 
         In addition, QGraphicsItemGroup is a special item that combines child
         event handling with a useful interface for adding and removing items
diff --git a/doc/src/groups.qdoc b/doc/src/groups.qdoc
index 2733853..f7296a3 100644
--- a/doc/src/groups.qdoc
+++ b/doc/src/groups.qdoc
@@ -40,24 +40,6 @@
 ****************************************************************************/
 
 /*!
-    \group groups
-    \title Grouped Classes
-    \ingroup classlists
-
-    This page provides a way of navigating Qt's classes by grouping
-    related classes together. Some classes may appear in more than one group.
-
-    \generatelist{related}
-
-    \omit
-    \row
-    \o \l{Component Model}
-    \o Interfaces and helper classes for the Qt Component Model.
-    \endomit
-
-*/
-
-/*!
     \group advanced
     \title Advanced Widgets
     \ingroup groups
@@ -147,12 +129,6 @@
 
 */
 
-/* \group componentmodel
-   \title Component Model
-
-    These classes and interfaces form the basis of the \l{Qt Component Model}.
-
-*/
 
 /*!
     \group database
@@ -226,22 +202,8 @@
 */
 
 /*!
-    \group explicitly-shared
-    \ingroup groups
-
-    \title Explicitly Shared Classes
-    \brief Classes that use explicit sharing to manage internal data.
-
-    \keyword explicit sharing
-    \keyword explicitly shared
-
-    Unlike many of Qt's data types, which use \l{implicit sharing}, these
-    classes use explicit sharing to manage internal data.
-*/
-
-/*!
     \group geomanagement
-    \title Layout Management
+    \title Layout Classes
     \ingroup groups
 
     \brief Classes handling automatic resizing and moving of widgets, for
@@ -401,103 +363,6 @@
 */
 
 /*!
-    \group shared
-    \title Implicitly Shared Classes
-    \ingroup architecture
-    \ingroup groups
-
-    \brief Classes that use reference counting for fast copying.
-
-    \keyword implicit data sharing
-    \keyword implicit sharing
-    \keyword implicitly shared
-    \keyword reference counting
-    \keyword shared implicitly
-    \keyword shared classes
-
-    Many C++ classes in Qt use implicit data sharing to maximize
-    resource usage and minimize copying. Implicitly shared classes are
-    both safe and efficient when passed as arguments, because only a
-    pointer to the data is passed around, and the data is copied only
-    if and when a function writes to it, i.e., \e {copy-on-write}.
-
-    \tableofcontents
-
-    \section1 Overview
-
-    A shared class consists of a pointer to a shared data block that
-    contains a reference count and the data.
-
-    When a shared object is created, it sets the reference count to 1. The
-    reference count is incremented whenever a new object references the
-    shared data, and decremented when the object dereferences the shared
-    data. The shared data is deleted when the reference count becomes
-    zero.
-
-    \keyword deep copy
-    \keyword shallow copy
-
-    When dealing with shared objects, there are two ways of copying an
-    object. We usually speak about \e deep and \e shallow copies. A deep
-    copy implies duplicating an object. A shallow copy is a reference
-    copy, i.e. just a pointer to a shared data block. Making a deep copy
-    can be expensive in terms of memory and CPU. Making a shallow copy is
-    very fast, because it only involves setting a pointer and incrementing
-    the reference count.
-
-    Object assignment (with operator=()) for implicitly shared objects is
-    implemented using shallow copies.
-
-    The benefit of sharing is that a program does not need to duplicate
-    data unnecessarily, which results in lower memory use and less copying
-    of data. Objects can easily be assigned, sent as function arguments,
-    and returned from functions.
-
-    Implicit sharing takes place behind the scenes; the programmer
-    does not need to worry about it. Even in multithreaded
-    applications, implicit sharing takes place, as explained in
-    \l{Threads and Implicit Sharing}.
-
-    \section1 Implicit Sharing in Detail
-
-    Implicit sharing automatically detaches the object from a shared
-    block if the object is about to change and the reference count is
-    greater than one. (This is often called \e {copy-on-write} or
-    \e {value semantics}.)
-
-    An implicitly shared class has total control of its internal data. In
-    any member functions that modify its data, it automatically detaches
-    before modifying the data.
-
-    The QPen class, which uses implicit sharing, detaches from the shared
-    data in all member functions that change the internal data.
-
-    Code fragment:
-    \snippet doc/src/snippets/code/doc_src_groups.qdoc 0
-
-    \section1 List of Classes
-
-    The classes listed below automatically detach from common data if
-    an object is about to be changed. The programmer will not even
-    notice that the objects are shared. Thus you should treat
-    separate instances of them as separate objects. They will always
-    behave as separate objects but with the added benefit of sharing
-    data whenever possible. For this reason, you can pass instances
-    of these classes as arguments to functions by value without
-    concern for the copying overhead.
-
-    Example:
-    \snippet doc/src/snippets/code/doc_src_groups.qdoc 1
-
-    In this example, \c p1 and \c p2 share data until QPainter::begin()
-    is called for \c p2, because painting a pixmap will modify it.
-
-    \warning Do not copy an implicitly shared container (QMap,
-    QVector, etc.) while you are iterating over it using an non-const
-    \l{STL-style iterator}.
-*/
-
-/*!
     \group ssl
     \title Secure Sockets Layer (SSL) Classes
     \ingroup groups
diff --git a/doc/src/i18n.qdoc b/doc/src/i18n.qdoc
index 5964926..d043f45 100644
--- a/doc/src/i18n.qdoc
+++ b/doc/src/i18n.qdoc
@@ -144,13 +144,13 @@
     aligned, so for these languages use the version of drawText() that
     takes a QRect since this will align in accordance with the language.
 
-    \o When you write your own text input controls, use \l
-    QFontMetrics::charWidth() to determine the width of a character in a
-    string. In some languages (e.g. Arabic or languages from the Indian
+    \o When you write your own text input controls, use QTextLayout.
+    In some languages (e.g. Arabic or languages from the Indian
     subcontinent), the width and shape of a glyph changes depending on the
-    surrounding characters. Writing input controls usually requires a
-    certain knowledge of the scripts it is going to be used in. Usually
-    the easiest way is to subclass QLineEdit or QTextEdit.
+    surrounding characters, which QTextLayout takes into account.
+    Writing input controls usually requires a certain knowledge of the
+    scripts it is going to be used in. Usually the easiest way is to
+    subclass QLineEdit or QTextEdit.
 
     \endlist
 
diff --git a/doc/src/images/cursor-hsplit.png b/doc/src/images/cursor-hsplit.png
index 1beda25..a5667e3 100644
--- a/doc/src/images/cursor-hsplit.png
+++ b/doc/src/images/cursor-hsplit.png
diff --git a/doc/src/images/cursor-vsplit.png b/doc/src/images/cursor-vsplit.png
index a5667e3..1beda25 100644
--- a/doc/src/images/cursor-vsplit.png
+++ b/doc/src/images/cursor-vsplit.png
diff --git a/doc/src/images/rogue-example.png b/doc/src/images/rogue-example.png
new file mode 100644
index 0000000..7aeb0e5
--- /dev/null
+++ b/doc/src/images/rogue-example.png
diff --git a/doc/src/images/rogue-statechart.png b/doc/src/images/rogue-statechart.png
new file mode 100644
index 0000000..c5f4048
--- /dev/null
+++ b/doc/src/images/rogue-statechart.png
diff --git a/doc/src/images/sub-attaq-demo.png b/doc/src/images/sub-attaq-demo.png
new file mode 100644
index 0000000..5a35ec6
--- /dev/null
+++ b/doc/src/images/sub-attaq-demo.png
diff --git a/doc/src/implicit-sharing.qdoc b/doc/src/implicit-sharing.qdoc
new file mode 100644
index 0000000..85630dc
--- /dev/null
+++ b/doc/src/implicit-sharing.qdoc
@@ -0,0 +1,144 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/* TODO: Move some of the documentation from QSharedDataPointer into this
+   document. */
+
+/*!
+    \group shared
+    \title Implicitly Shared Classes
+    \ingroup architecture
+    \ingroup groups
+
+    \brief Classes that use reference counting for fast copying.
+
+    \keyword implicit data sharing
+    \keyword implicit sharing
+    \keyword implicitly shared
+    \keyword reference counting
+    \keyword shared implicitly
+    \keyword shared classes
+
+    Many C++ classes in Qt use implicit data sharing to maximize
+    resource usage and minimize copying. Implicitly shared classes are
+    both safe and efficient when passed as arguments, because only a
+    pointer to the data is passed around, and the data is copied only
+    if and when a function writes to it, i.e., \e {copy-on-write}.
+
+    \tableofcontents
+
+    \section1 Overview
+
+    A shared class consists of a pointer to a shared data block that
+    contains a reference count and the data.
+
+    When a shared object is created, it sets the reference count to 1. The
+    reference count is incremented whenever a new object references the
+    shared data, and decremented when the object dereferences the shared
+    data. The shared data is deleted when the reference count becomes
+    zero.
+
+    \keyword deep copy
+    \keyword shallow copy
+
+    When dealing with shared objects, there are two ways of copying an
+    object. We usually speak about \e deep and \e shallow copies. A deep
+    copy implies duplicating an object. A shallow copy is a reference
+    copy, i.e. just a pointer to a shared data block. Making a deep copy
+    can be expensive in terms of memory and CPU. Making a shallow copy is
+    very fast, because it only involves setting a pointer and incrementing
+    the reference count.
+
+    Object assignment (with operator=()) for implicitly shared objects is
+    implemented using shallow copies.
+
+    The benefit of sharing is that a program does not need to duplicate
+    data unnecessarily, which results in lower memory use and less copying
+    of data. Objects can easily be assigned, sent as function arguments,
+    and returned from functions.
+
+    Implicit sharing takes place behind the scenes; the programmer
+    does not need to worry about it. Even in multithreaded
+    applications, implicit sharing takes place, as explained in
+    \l{Threads and Implicit Sharing}.
+
+    When implementing your own implicitly shared classes, use the
+    QSharedData and QSharedDataPointer classes.
+
+    \section1 Implicit Sharing in Detail
+
+    Implicit sharing automatically detaches the object from a shared
+    block if the object is about to change and the reference count is
+    greater than one. (This is often called \e {copy-on-write} or
+    \e {value semantics}.)
+
+    An implicitly shared class has total control of its internal data. In
+    any member functions that modify its data, it automatically detaches
+    before modifying the data.
+
+    The QPen class, which uses implicit sharing, detaches from the shared
+    data in all member functions that change the internal data.
+
+    Code fragment:
+    \snippet doc/src/snippets/code/doc_src_groups.qdoc 0
+
+
+    \section1 List of Classes
+
+    The classes listed below automatically detach from common data if
+    an object is about to be changed. The programmer will not even
+    notice that the objects are shared. Thus you should treat
+    separate instances of them as separate objects. They will always
+    behave as separate objects but with the added benefit of sharing
+    data whenever possible. For this reason, you can pass instances
+    of these classes as arguments to functions by value without
+    concern for the copying overhead.
+
+    Example:
+    \snippet doc/src/snippets/code/doc_src_groups.qdoc 1
+
+    In this example, \c p1 and \c p2 share data until QPainter::begin()
+    is called for \c p2, because painting a pixmap will modify it.
+
+    \warning Do not copy an implicitly shared container (QMap,
+    QVector, etc.) while you are iterating over it using an non-const
+    \l{STL-style iterator}.
+*/
diff --git a/doc/src/ipc.qdoc b/doc/src/ipc.qdoc
index 1349fde..1f9d36d 100644
--- a/doc/src/ipc.qdoc
+++ b/doc/src/ipc.qdoc
@@ -61,12 +61,12 @@
 
     \section1 TCP/IP
 
-    The cross-platform \l{QtNetwork} module
-    provides classes that make network programming portable and
-    easy. It offers high-level classes (e.g., QHttp, QFtp) that
-    communicate using specific application-level protocols, and
-    lower-level classes (e.g., QTcpSocket, QTcpServer, QSslSocket) for
-    implementing protocols.
+    The cross-platform \l{QtNetwork} module provides classes that make
+    network programming portable and easy. It offers high-level
+    classes (e.g., QNetworkAccessManager, QFtp) that communicate using
+    specific application-level protocols, and lower-level classes
+    (e.g., QTcpSocket, QTcpServer, QSslSocket) for implementing
+    protocols.
 
     \section1 Shared Memory
 
diff --git a/doc/src/layout.qdoc b/doc/src/layout.qdoc
index ec88089..9350aa8 100644
--- a/doc/src/layout.qdoc
+++ b/doc/src/layout.qdoc
@@ -42,9 +42,8 @@
 /*!
     \page layout.html
 
-    \title Layout Classes
+    \title Layout Management
     \ingroup architecture
-    \ingroup classlists
     \brief A tour of the standard layout managers and an introduction to custom
     layouts.
 
diff --git a/doc/src/3rdparty.qdoc b/doc/src/legal/3rdparty.qdoc
index 0d86ab3..0d86ab3 100644
--- a/doc/src/3rdparty.qdoc
+++ b/doc/src/legal/3rdparty.qdoc
diff --git a/doc/src/commercialeditions.qdoc b/doc/src/legal/commercialeditions.qdoc
index b6d80c2..b6d80c2 100644
--- a/doc/src/commercialeditions.qdoc
+++ b/doc/src/legal/commercialeditions.qdoc
diff --git a/doc/src/editions.qdoc b/doc/src/legal/editions.qdoc
index 9ed4c9c..9ed4c9c 100644
--- a/doc/src/editions.qdoc
+++ b/doc/src/legal/editions.qdoc
diff --git a/doc/src/gpl.qdoc b/doc/src/legal/gpl.qdoc
index 97959e8..97959e8 100644
--- a/doc/src/gpl.qdoc
+++ b/doc/src/legal/gpl.qdoc
diff --git a/doc/src/licenses.qdoc b/doc/src/legal/licenses.qdoc
index 7597e7f..4689114 100644
--- a/doc/src/licenses.qdoc
+++ b/doc/src/legal/licenses.qdoc
@@ -39,6 +39,19 @@
 **
 ****************************************************************************/
 
+/*!
+    \group licensing
+    \title Licensing Information
+    \ingroup topics
+    \brief Information about licenses and licensing issues.
+
+    These documents include information about Qt's licenses and the licenses
+    of third party components used in Qt.
+
+    \generatelist{related}
+*/
+
+
 /*! 
     \page licenses.html
     \title Other Licenses Used in Qt
diff --git a/doc/src/opensourceedition.qdoc b/doc/src/legal/opensourceedition.qdoc
index e7bb26a..e7bb26a 100644
--- a/doc/src/opensourceedition.qdoc
+++ b/doc/src/legal/opensourceedition.qdoc
diff --git a/doc/src/trademarks.qdoc b/doc/src/legal/trademarks.qdoc
index 0e659d2..0e659d2 100644
--- a/doc/src/trademarks.qdoc
+++ b/doc/src/legal/trademarks.qdoc
diff --git a/doc/src/model-view-programming.qdoc b/doc/src/model-view-programming.qdoc
index e216591..7d7db19 100644
--- a/doc/src/model-view-programming.qdoc
+++ b/doc/src/model-view-programming.qdoc
@@ -1352,7 +1352,7 @@
     The \l{QAbstractItemModel::data()}{data()} function is responsible for
     returning the item of data that corresponds to the index argument:
 
-    \snippet doc/src/snippets/stringlistmodel/model.cpp 1
+    \snippet doc/src/snippets/stringlistmodel/model.cpp 1-data-read-only
 
     We only return a valid QVariant if the model index supplied is valid,
     the row number is within the range of items in the string list, and the
@@ -1390,6 +1390,7 @@
     The read-only model shows how simple choices could be presented to the
     user but, for many applications, an editable list model is much more
     useful. We can modify the read-only model to make the items editable
+    by changing the data() function we implemented for read-only, and
     by implementing two extra functions:
     \l{QAbstractItemModel::flags()}{flags()} and
     \l{QAbstractItemModel::setData()}{setData()}.
@@ -1399,7 +1400,7 @@
     \snippet doc/src/snippets/stringlistmodel/model.h 3
 
     \section2 Making the Model Editable
-
+    
     A delegate checks whether an item is editable before creating an
     editor. The model must let the delegate know that its items are
     editable. We do this by returning the correct flags for each item in
@@ -1434,6 +1435,10 @@
     one item of data has changed, the range of items specified in the signal
     is limited to just one model index.
 
+    Also the data() function needs to be changed to add the Qt::EditRole test:
+    
+    \snippet doc/src/snippets/stringlistmodel/model.cpp 1
+
     \section2 Inserting and Removing Rows
 
     It is possible to change the number of rows and columns in a model. In the
diff --git a/doc/src/paintsystem.qdoc b/doc/src/paintsystem.qdoc
index 56f60a3..c2434e0 100644
--- a/doc/src/paintsystem.qdoc
+++ b/doc/src/paintsystem.qdoc
@@ -121,7 +121,7 @@
 
     Normally, QPainter draws in a "natural" coordinate system, but it
     is able to perform view and world transformations using the
-    QMatrix class. For more information, see \l {The Coordinate
+    QTransform class. For more information, see \l {The Coordinate
     System} documentation which also describes the rendering process,
     i.e. the relation between the logical representation and the
     rendered pixels, and the benefits of anti-aliased painting.
@@ -292,9 +292,7 @@
     looking the same.
 
     Qt provides the QPicture::load() and QPicture::save() functions
-    for loading and saving pictures. But in addition the QPictureIO
-    class is provided to enable the programmer to install new picture
-    file formats in addition to those that Qt provides.
+    as well as streaming operators for loading and saving pictures.
 
     \section2 Printer
 
diff --git a/doc/src/platform-notes-rtos.qdoc b/doc/src/platform-notes-rtos.qdoc
new file mode 100644
index 0000000..8a52d84
--- /dev/null
+++ b/doc/src/platform-notes-rtos.qdoc
@@ -0,0 +1,220 @@
+/*!
+    \page platform-notes-vxworks.html
+    \title Platform Notes - VxWorks
+    \contentspage Platform Notes
+    \target VxWorks
+
+    \note VxWorks is a community supported platform. See the
+    \l{Supported Platforms} page for more information.
+
+    This page contains information about the Qt for VxWorks port. More
+    information about the combinations of platforms and compilers supported
+    by Qt can be found on the \l{Supported Platforms} page.
+
+    \tableofcontents
+
+    \section1 Supported Versions
+
+    Qt has been tested on WindRiver VxWorks 6.7 in kernel mode using the
+    vendor supplied GCC compiler, targetting both the x86 simulator
+    (simpentium) and Power-PC devices (ppc).
+    VxWorks' RTP mode is currently not supported.
+
+    \section1 Limitations
+
+    The VxWorks kernel has an optional POSIX compatibility layer, but this
+    layer does not implement all POSIX functionality needed for a complete
+    Qt port.
+
+    \table
+    \header \o Function \o Notes
+    \row \o QProcess
+         \o Not available - VxWorks has no concept of processes.
+    \row \o QSharedMemory
+         \o Not available - VxWorks has only a global, flat address space.
+    \row \o QSystemSemaphore
+         \o Not available - VxWorks has no concept of processes.
+    \row \o QLibrary
+         \o QLibrary is only a small stub to make it possible to build
+            static plugins.
+    \row \o QCoreApplication
+         \o Can only be instantiated once. Qt's Q(CoreE)Application is
+            tightly coupled to one address space and process, while VxWorks
+            only supports one global address space and has no concept of
+            processes.
+    \row \o Phonon
+         \o There is no standard audio backend, which could be integrated into Phonon.
+    \row \o Qt3Support
+         \o The Qt3Support library is not available on QNX.
+
+    \endtable
+
+    \section1 Build Instructions
+
+    Qt for VxWorks needs to be \l{Cross-Compiling Qt for Embedded Linux
+    Applications}{cross-compiled} on a Linux host.  \c configure and \c make
+    the build like you would with a standard \l{Cross-Compiling Qt for
+    Embedded Linux Applications}{embedded Linux cross build}.  Building the
+    VxWorks simulator would be done like this:
+
+    \code
+    <path/to/qt/sources>/configure -xplatform unsupported/vxworks-simpentium-g++ -embedded vxworks -exceptions -no-gfx-linuxfb -no-mouse-linuxtp -no-mouse-pc -no-kbd-tty
+    make
+    \endcode
+
+    \list
+    \o \c{-xplatform unsupported/qws/vxworks-simpentium-g++} - selects the x86 simulator mkspec for VxWorks
+    \o \c{-embedded vxworks} - builds the embedded version of Qt and sets the architecture to VxWorks
+    \o \c{-exceptions} - see General Notes below
+    \o \c{-no-gfx-linuxfb}, \c{-no-mouse-linuxtp}, \c{-no-mouse-pc} and \c{-no-kbd-tty} are Linux specific and won't work on VxWorks
+    \endlist
+
+    \section1 General Notes
+
+    \list
+
+    \o Configuring with \c{-exceptions} is necessary, because the VxWorks
+    6.7 g++ headers require exceptions to be enabled when compiling C++
+    code.
+
+    \o Configure's \c{-xplatform} can be any of
+    \c{unsupported/vxworks-(simpentium|ppc)-(g++|dcc)}, but \c{dcc}
+    (WindRiver DIAB compiler) has not yet tested been tested with Qt 4.6 and
+    VxWorks 6.7.
+
+    \o Building shared libraries with \c{-shared} (the default) doesn't
+    really build shared libraries, like e.g.  on Linux, since these are not
+    supported by VxWorks.  Instead, qmake will created partially linked
+    objects, that can be loaded at runtime with \c{ld}.
+
+    \o Creating static builds with \c{-static} is fully supported.
+
+    \o "Munching" (generating constructors/destructors for static C++
+    objects) is done automatically by a special qmake extension (for both
+    shared libraries and executables)
+
+    \o VxWorks does not have a file system layer, but the low level storage
+    drivers have to supply a file system like interface to the applications.
+    Since each driver implements a different subset of the functionality
+    supported by this interface, Qt's file system auto-tests show wildly
+    differing results running on different "file systems".  The best results
+    can be achieved when running on a (writable) NFS mount, since that
+    provides the most Unix-ish interface.  The worst results come from the
+    FTP file system driver, which may crash when accessed by a
+    \c{QFileInfo}.
+
+    \o Keep in mind that VxWorks doesn't call your \c{main()} function with
+    the standard \c{argc}/\c{argv} parameters.  So either add a special
+    \c{vxmain()} function or use a tool like \c{callmain} to translate
+    VxWorks' commandline arguments to an \c{argc}/\c{argv} array.
+
+    \o Some example will fail to build, due to some missing dependencies
+    (e.g. shared memory) - this will be fixed in a later release.
+
+    \endlist
+*/
+
+/*!
+    \page platform-notes-qnx.html
+    \title Platform Notes - QNX
+    \contentspage Platform Notes
+    \target QNX
+
+    \note QNX is a community supported platform. See the
+    \l{Supported Platforms} page for more information.
+
+    This page contains information about the Qt for QNX port. More
+    information about the combinations of platforms and compilers supported
+    by Qt can be found on the \l{Supported Platforms} page.
+
+    Note that Qt for QNX is currently based on \l{Qt for Embedded Linux}, which
+    contains its own windowing system. Mixing QNX's Photon environment with
+    Qt for QNX is currently not possible. Building Qt for QNX with Photon's
+    X11 embedded server is not recommended due to missing support for X11 extensions,
+    resulting in poor rendering quality.
+
+    Qt for QNX contains experimental screen and input drivers based on QNX's
+    \c devi-hid and \c io-display. For more information, check the class documentation
+    for QQnxScreen, QWSQnxKeyboardHandler and QQnxMouseHandler. See the
+    \l{Porting Qt for Embedded Linux to a New Architecture} document for information
+    on how to add custom screen or input drivers.
+
+    \tableofcontents
+
+    \section1 Supported Versions
+
+    Qt has been tested on QNX 6.4 on i386 and PowerPC targets with QNX's default
+    gcc compiler.
+
+    \section1 Limitations
+
+    Some of Qt's functionality is currently not available on QNX:
+
+    \table
+    \header \o Function \o Notes
+    \row \o QProcess
+         \o Not available - QNX doesn't support mixing threads and processes.
+    \row \o QSharedMemory
+         \o Not available - QNX doesn't support SYSV style shared memory.
+    \row \o QSystemSemaphore
+         \o Not available - QNX doesn't support SYSV style system semaphores.
+    \row \o QWS Multi Process
+         \o QT_NO_QWS_MULTIPROCESS is always on due to missing shared memory support.
+    \row \o Phonon
+         \o There is no standard audio backend, which could be integrated into Phonon.
+    \row \o Qt3Support
+         \o The Qt3Support library is not available on QNX.
+    \endtable
+
+    \section1 Build Instructions
+
+    Qt for QNX needs to be built either on a QNX system, or \l{Cross-Compiling Qt
+    for Embedded Linux Applications}{cross-compiled} on a Linux host. In either
+    case, The QNX Software Development Platform must be installed.
+
+    Example configure line for cross-compiling Qt for QNX on a Linux host for an
+    i386 QNX target:
+
+    \code
+    configure -xplatform unsupported/qws/qnx-i386-g++ -embedded i386 -no-gfx-linuxfb -no-mouse-linuxtp -no-kbd-tty -no-qt3support -qt-gfx-qnx -qt-mouse-qnx -qt-kbd-qnx -no-exceptions
+    \endcode
+
+    \list
+    \o \c{-xplatform unsupported/qws/qnx-i386-g++} - selects the i386-g++ mkspec for QNX
+    \o \c{-embedded i386} - builds the embedded version of Qt and sets the architecture to i386
+    \o \c{-no-gfx-linuxfb},  \c{-no-mouse-linuxtp} and \c{-no-kbd-tty} are Linux specific and won't work on QNX
+    \o \c{-no-qt3support} - required since the Qt3 support classes are not supported on QNX
+    \o \c{-no-exceptions} - reduces the size of the library by disabling exception support
+    \o \c{-qt-gfx-qnx} - enables the experimental \c{io-graphics} based display driver
+    \o \c{-qt-mouse-qnx} - enables the experimental \c{devi-hig} based mouse driver
+    \o \c{-qt-kbd-qnx} - enables the experimental \c{devi-hig} based keyboard driver
+    \endlist
+
+    \section1 General Notes
+
+    \list
+    \o To enable the experimental QNX display and input drivers, \c{io-display} needs to be
+       up and running. The \c devi-hid based Qt input drivers require \c devi-hid to run
+       in resource mode without Photon support. To enable a standard mouse and keyboard
+       combination, run \c devi-hid as follows: \c{/usr/photon/bin/devi-hid -Pr kbd mouse}.
+       Note that your current shell will not accept keyboard and mouse input anymore after
+       running that command, so run it either from a script that launches a Qt application
+       afterwards, or make sure to have remote login available to launch a Qt application.
+       In addition, the \c QWS_DISPLAY, \c QWS_MOUSE_PROTO and \c QWS_KEYBOARD environment
+       variables should all be set to \c{qnx} before running a Qt application.
+
+    \o The 3rd party TIFF library currently doesn't build due to the missing \c inflateSync
+       symbol from QNX's \c{libz.so.2}. Workarounds would be to manually replace QNX's libz
+       with a newer version, or disable the TIFF plugin entierly by appending
+       \c{QT_CONFIG += no-tiff} to \c{.qmake.cache} after configuring Qt.
+
+    \o Some of the tools, examples and demos do not compile due to dependencies on QProcess
+       or other classes that are not available on QNX.
+    \endlist
+
+    \section1 Platform Regressions
+
+    Qt for QNX's behavior is mostly identical with \l{Qt for Embedded Linux}. However,
+    some regressions were spotted in QDateTime computation around year 0 and year 1970,
+    which have been tracked back to faulty time zone data on some QNX versions.
+*/
diff --git a/doc/src/platform-notes.qdoc b/doc/src/platform-notes.qdoc
index 8fe8170..4738928 100644
--- a/doc/src/platform-notes.qdoc
+++ b/doc/src/platform-notes.qdoc
@@ -60,6 +60,10 @@
     \tableofcontents{1 Platform Notes - Embedded Linux}
     \o \l{Platform Notes - Windows CE}
     \tableofcontents{1 Platform Notes - Windows CE}
+    \o \l{Platform Notes - QNX}
+    \tableofcontents{1 Platform Notes - QNX}
+    \o \l{Platform Notes - VxWorks}
+    \tableofcontents{1 Platform Notes - VxWorks}
     \endlist
 
     See also the \l{Compiler Notes} for information about compiler-specific
@@ -67,7 +71,8 @@
     supported by Qt can be found on the \l{Supported Platforms} page.
 
     If you have anything to add to this list or any of the platform or
-    compiler-specific pages, please submit it via the \l{Bug Report Form}.
+    compiler-specific pages, please submit it via the \l{Bug Report Form}
+    or through the \l{Public Qt Repository}.
 */
 
 /*!
@@ -374,133 +379,6 @@
 */
 
 /*!
-    \page supported-platforms.html
-    \title Supported Platforms
-    \brief The platforms supported by Nokia for Qt.
-    \ingroup platform-notes
-
-    Qt is supported on a variety of 32-bit and 64-bit platforms, and can
-    usually be built on each platform with GCC, a vendor-supplied compiler, or
-    a third party compiler. Although Qt may be built on a range of platform-compiler
-    combinations, only a subset of these are actively supported by Qt.
-
-    A more general overview of the platforms Qt runs on can be found on the
-    \l{Platform Notes} page. Information about the compilers used on each platform
-    can be found on the \l{Compiler Notes} page.
-
-    \tableofcontents
-
-    \section1 Most Common Actively Supported Platforms 
-
-    \table
-    \header \o Platform                \o Compilers
-    \row    \o Apple Mac OS X (32-bit) \o gcc 4.0.1
-    \row    \o Linux (32 and 64-bit)   \o gcc 4.1, 4.2, 4.3
-    \row    \o Microsoft Windows       \o gcc 3.4.2 (MinGW) (32-bit), MSVC 2003, 2005 (32 and 64-bit), 2008,
-                                          \l{Intel C++ Compiler}{Intel icc (see note)}
-    \endtable
-
-    Any platform-compiler combinations not listed here should be considered unsupported.
-
-    \section1 Actively Supported Platforms
-
-    \table
-    \header \o OS                \o Architecture        \o Makespec        \o Compiler version(s)
-    \row    \o AIX               \o PowerPC             \o aix-xlc         \o xlC 6
-    \row    \o AIX               \o PowerPC             \o aix-xlc-64      \o xlC 6
-    \row    \o HPUX              \o PA/RISC             \o hpux-acc*       \o A.03.57 (aCC 3.57)
-    \row    \o HPUX              \o PA/RISC             \o hpux-g++        \o GCC 3.4.4
-    \row    \o HPUX              \o PA/RISC             \o hpux-g++-64     \o GCC 3.4.4
-    \row    \o HPUX              \o Itanium             \o hpuxi-acc*      \o A.06.10 (aCC 6.10)
-    \row    \o Embedded Linux    \o ARM                 \o qws/linux-arm-g++ \o GCC 3.4, 4.1, 4.2, 4.3
-    \row    \o Embedded Linux    \o Intel 32-bit        \o qws/linux-x86-g++ \o GCC 3.4, 4.1, 4.2, 4.3
-    \row    \o Linux             \o Intel 32/64-bit     \o linux-g++       \o GCC 4.1, 4.2, 4.3
-    \row    \o Linux             \o Intel 32/64-bit     \o linux-icc       \o icc 10.1
-    \row    \o Linux             \o Intel 32-bit        \o linux-icc-32    \o icc 10.1
-    \row    \o Linux             \o Intel 64-bit        \o linux-icc-64    \o icc 10.1
-    \row    \o Mac OS X          \o Intel 32/64-bit, PowerPC \o macx-g++   \o GCC 4.0.1
-    \row    \o Mac OS X          \o Intel 32/64-bit, PowerPC \o macx-g++42 \o GCC 4.2
-    \row    \o Solaris           \o SPARC, Intel 32-bit \o solaris-cc*     \o Sun CC 5.5
-    \row    \o Solaris           \o SPARC, Intel 32-bit \o solaris-g++*    \o GCC 3.4.2
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit     \o win32-g++       \o GCC 3.4.2 (MinGW 5.1.4)
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit     \o win32-icc       \o icc 9.1
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit     \o win32-msvc2003  \o Visual Studio 2003
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit     \o win32-msvc2005  \o Visual Studio 2005
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit     \o win32-msvc2008  \o Visual Studio 2008
-    \row    \o Windows CE        \o Intel 32-bit, ARMv4i, MIPS
-                                                        \o wince*-msvc2005 \o Visual Studio 2005
-    \row    \o Windows CE        \o Intel 32-bit, ARMv4i, MIPS
-                                                        \o wince*-msvc2008 \o Visual Studio 2008
-    \endtable
-
-    \section1 Community Supported Platforms
-
-    \table
-    \header \o OS                \o Architecture    \o Makespec            \o Compiler version(s)
-    \row    \o Mac OS X          \o Intel 32-bit, PowerPC \o darwin-g++    \o -
-    \row    \o FreeBSD           \o -               \o freebsd-g++         \o -
-    \row    \o FreeBSD           \o -               \o freebsd-g++34       \o -
-    \row    \o FreeBSD           \o -               \o freebsd-g++40       \o -
-    \row    \o FreeBSD           \o -               \o freebsd-icc         \o -
-    \row    \o HPUX              \o Itanium         \o hpuxi-g++*          \o GCC 4.1
-    \row    \o Linux             \o -               \o linux-cxx           \o -
-    \row    \o Linux             \o -               \o linux-ecc-64        \o -
-    \row    \o Linux             \o Itanium         \o linux-g++           \o GCC 3.4
-    \row    \o Linux             \o Intel 32/64-bit \o linux-g++           \o GCC 3.3, 3.4
-    \row    \o Linux             \o Intel 32/64-bit \o linux-g++           \o GCC 4.0
-    \row    \o Linux             \o -               \o linux-kcc           \o -
-    \row    \o Linux             \o -               \o linux-llvm          \o -
-    \row    \o Linux             \o -               \o linux-lsb-g++       \o -
-    \row    \o LynxOS            \o -               \o lynxos-g++          \o -
-    \row    \o Mac OS X          \o -               \o macx-llvm           \o -
-    \row    \o NetBSD            \o -               \o netbsd-g++          \o -
-    \row    \o OpenBSD           \o -               \o openbsd-g++         \o -
-    \row    \o Embedded Linux    \o MIPS, PowerPC   \o qws/linux-g++       \o GCC 3.4, 4.1, 4.2, 4.3
-    \endtable
-
-    \section1 Unsupported Platforms
-
-    The following platforms were supported in previous releases, either as actively supported
-    or community supported platforms, but are now unsupported.
-
-    \table
-    \header \o OS                \o Architecture    \o Makespec            \o Compiler version(s)
-    \row    \o IRIX              \o MIPS            \o irix-cc*            \o MIPS Pro
-    \row    \o IRIX              \o MIPS            \o irix-g++*           \o GCC 3.3
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit \o win32-msvc      \o Visual C++ 6.0
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit \o win32-msvc2002      \o Visual Studio 2002
-    \row    \o Windows XP/Vista  \o Intel 32/64-bit \o win32-msvc.net      \o Visual Studio 2002
-    \endtable
-
-    Qt's online \l{Platform Support Policy} for Qt describes the level of
-    support you should expect for these platforms.
-
-    \section1 Supported Features
-
-    Not all compilers used to build Qt are able to compile all modules. The following table
-    shows the compiler support for five modules that are not uniformly available for all
-    platforms and compilers.
-
-    \table
-    \header \o Compiler \o{5,1} Features
-    \header \o                  \o Concurrent \o XmlPatterns \o WebKit   \o CLucene  \o Phonon
-    \row    \o g++ 3.3          \o            \o \bold{X}    \o          \o \bold{X} \o \bold{X}
-    \row    \o g++ 3.4 and up   \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
-    \row
-    \row    \o SunCC 5.5        \o            \o             \o          \o \bold{X} \o \bold{X}
-    \row
-    \row    \o aCC series 3     \o            \o             \o          \o \bold{X} \o \bold{X}
-    \row    \o aCC series 6     \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
-    \row    \o xlC 6            \o            \o             \o          \o \bold{X} \o \bold{X}
-    \row    \o \l{Known Issues in %VERSION%}{Intel CC 10 (see note)}
-                                \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
-    \row
-    \row    \o MSVC 2003        \o \bold{X}   \o \bold{X}    \o          \o \bold{X} \o \bold{X}
-    \row    \o MSVC 2005 and up \o \bold{X}   \o \bold{X}    \o \bold{X} \o \bold{X} \o \bold{X}
-    \endtable
-*/
-
-/*!
     \page platform-notes-windows-ce.html
     \title Platform Notes - Windows CE
     \contentspage Platform Notes
@@ -521,218 +399,3 @@
     information about the combinations of platforms and compilers supported
     by Qt can be found on the \l{Supported Platforms} page.
 */
-
-/*!
-    \page compiler-notes.html
-    \ingroup platform-notes
-    \title Compiler Notes
-    \brief Information about the C++ compilers and tools used to build Qt.
-
-    This page contains information about the C++ compilers and tools used
-    to build Qt on various platforms.
-
-    \tableofcontents
-
-    Please refer to the \l{Platform Notes} for information on the platforms
-    Qt is currently known to run on, and see the \l{Supported Platforms}
-    page for information about the status of each platform.
-
-    If you have anything to add to this list or any of the platform or
-    compiler-specific pages, please submit it via the
-    \l{Bug Report Form}.
-
-    \target GCC
-    \section1 GCC
-
-    \section2 GCC on Windows (MinGW)
-
-    We have tested Qt with this compiler on Windows XP.
-    The minimal version of MinGW supported is:
-
-    \list
-    \o GCC 3.4.2
-    \o MinGW runtime 3.7
-    \o win32api 3.2
-    \o binutils 2.15.91
-    \o mingw32-make 3.80.0-3
-    \endlist
-
-    \section2 GCC 4.0.0
-
-    The released package of the compiler has some bugs that lead to miscompilations.
-    We recommend using GCC 4.0.1 or later, or to use a recent CVS snapshot of the
-    GCC 4.0 branch. The version of GCC 4.0.0 that is shipped with Mac OS X 10.4
-    "Tiger" is known to work with Qt for Mac OS X.
-
-    \section2 HP-UX
-
-    The hpux-g++ platform is tested with GCC 3.4.4.
-
-    \section2 Solaris
-
-    Please use GCC 3.4.2 or later.
-
-    \section2 Mac OS X
-
-    Please use the latest GCC 3.3 from Apple or a later version of GCC 3.
-    The gcc 3.3 that is provided with Xcode 1.5 is known to generate bad code.
-    Use the November 2004 GCC 3.3 updater \l{http://connect.apple.com}{available from Apple}.
-
-    \section2 GCC 3.4.6 (Debian 3.4.6-5) on AMD64 (x86_64)
-
-    This compiler is known to miscompile some parts of Qt when doing a
-    release build. There are several workarounds:
-
-    \list 1
-    \o Use a debug build instead.
-    \o For each miscompilation encountered, recompile the file, removing the -O2 option.
-    \o Add -fno-gcse to the QMAKE_CXXFLAGS_RELEASE.
-    \endlist
-
-    \section1 HP ANSI C++ (aCC)
-
-    The hpux-acc-32 and hpux-acc-64 platforms are tested with aCC A.03.57. The
-    hpuxi-acc-32 and hpuxi-acc-64 platforms are tested with aCC A.06.10.
-
-    \section1 Intel C++ Compiler
-
-    Qt supports the Intel C++ compiler on both Windows and Linux.
-    However, there are a few issues on Linux (see the following
-    section).
-
-    \section2 Intel C++ Compiler for Linux
-
-    Nokia currently tests the following compilers:
-
-    \list
-
-    \o Intel(R) C++ Compiler for applications running on IA-32,
-    Version 10.1 Build 20080602 Package ID: l_cc_p_10.1.017
-
-    \o Intel(R) C++ Compiler for applications running on Intel(R) 64,
-    Version 10.1 Build 20080602 Package ID: l_cc_p_10.1.017
-
-    \endlist
-
-    We do not currently test the IA-64 (Itanium) compiler.
-
-    \section2 Known Issues with Intel C++ Compiler for Linux
-
-    \list
-
-    \o Precompiled header support does not work in version 10.0.025
-       and older. For these compilers, you should configure Qt with
-       -no-pch. Precompiled header support works properly in version
-       10.0.026 and later.
-    \o Version 10.0.026 for Intel 64 is known to miscompile qmake when
-       building in release mode. For now, configure Qt with
-       -debug. Version 10.1.008 and later can compile qmake in release
-       mode.
-    \o Versions 10.1.008 to 10.1.015 for both IA-32 and Intel 64 are
-       known crash with "(0): internal error: 0_47021" when compiling
-       QtXmlPatterns, QtWebKit, and Designer in release mode. Version
-       10.1.017 compiles these modules correctly in release mode.
-    \endlist
-
-    \section2 Intel C++ Compiler (Windows, Altix)
-
-    Qt 4 has been tested successfully with:
-
-    \list
-    \o Windows - Intel(R) C++ Compiler for 32-bit applications,
-       Version 8.1 Build 20050309Z Package ID: W_CC_PC_8.1.026
-    \o Altix - Intel(R) C++ Itanium(R) Compiler for Itanium(R)-based
-       applications Version 8.1 Build 20050406 Package ID: l_cc_pc_8.1.030
-    \endlist
-
-    We currently only test the Intel compiler on 32-bit Windows versions.
-
-    \section1 MIPSpro (IRIX)
-
-    \bold{IRIX is an unsupported platform. See the \l{Supported Platforms} page
-    and Qt's Software's online \l{Platform Support Policy} page for details.}
-
-    Qt 4.4.x requires MIPSpro version 7.4.2m.
-
-    Note that MIPSpro version 7.4.4m is currently not supported, since it has
-    introduced a number of problems that have not yet been resolved.
-    We recommend using 7.4.2m for Qt development. However, please note the
-    unsupported status of this platform.
-
-    \target Sun Studio
-    \section1 Forte Developer / Sun Studio (Solaris)
-
-    \section2 Sun Studio
-
-    Qt is tested using Sun Studio 8 (Sun CC 5.5). Go to
-    \l{Sun Studio Patches} page on Sun's Web site to download
-    the latest patches for your Sun compiler.
-
-    \section2 Sun WorkShop 5.0
-
-    Sun WorkShop 5.0 is not supported with Qt 4.
-
-    \section1 Visual Studio (Windows)
-
-    We do most of our Windows development on Windows XP, using Microsoft
-    Visual Studio .NET 2005 and Visual Studio 2008 (both the 32- and 64-bit
-    versions).
-
-    Qt works with the Standard Edition, the Professional Edition and Team
-    System Edition of Visual Studio 2005.
-
-    We also test Qt 4 on Windows XP with Visual Studio .NET and Visual Studio 2003.
-
-    In order to use Qt with the Visual Studio 2005/2008 Express Edition you need
-    to download and install the platform SDK. Due to limitations in the
-    Express Edition it is not possible for us to install the Qt Visual
-    Studio Integration. You will need to use our command line tools to
-    build Qt applications with this edition.
-
-    The Visual C++ Linker doesn't understand filenames with spaces (as in
-    \c{C:\Program files\Qt\}) so you will have to move it to another place,
-    or explicitly set the path yourself; for example:
-
-    \snippet doc/src/snippets/code/doc_src_compiler-notes.qdoc 0
-
-    If you are experiencing strange problems with using special flags that
-    modify the alignment of structure and union members (such as \c{/Zp2})
-    then you will need to recompile Qt with the flags set for the
-    application as well.
-
-    If you're using Visual Studio .NET (2002) Standard Edition, you should be
-    using the Qt binary package provided, and not the source package.
-    As the Standard Edition does not optimize compiled code, your compiled
-    version of Qt would perform suboptimally with respect to speed.
-
-    With Visual Studio 2005 Service Pack 1 a bug was introduced which
-    causes Qt not to compile, this has been fixed with a hotfix available
-    from Microsoft. See this
-    \l{http://www.qtsoftware.com/developer/faqs/faq.2006-12-18.3281869860}{Knowledge Base entry}
-    for more information.
-
-    \section1 IBM xlC (AIX)
-
-    The makeC++SharedLib utility must be in your PATH and be up to date to
-    build shared libraries. From IBM's
-    \l{http://www.redbooks.ibm.com/abstracts/sg245674.html}{C and C++ Application Development on AIX}
-    Redbook:
-
-    \list
-    \o "The second step is to use the makeC++SharedLib command to create the
-       shared object. The command has many optional arguments, but in its
-       simplest form, can be used as follows:"
-       \snippet doc/src/snippets/code/doc_src_compiler-notes.qdoc 1
-    \o "The full path name to the command is not required; however, to avoid
-       this, you will have to add the directory in which it is located to
-       your PATH environment variable. The command is located in the
-       /usr/vacpp/bin directory with the VisualAge C++ Professional for AIX,
-       Version 5 compiler."
-    \endlist
-
-    \section2 VisualAge C++ for AIX, Version 6.0
-
-    Make sure you have the
-    \l{http://www-1.ibm.com/support/search.wss?rs=32&amp;tc=SSEP5D&amp;dc=D400}{latest upgrades}
-    installed.
-*/
diff --git a/doc/src/plugins-howto.qdoc b/doc/src/plugins-howto.qdoc
index 4c37f8e..3e5cc93 100644
--- a/doc/src/plugins-howto.qdoc
+++ b/doc/src/plugins-howto.qdoc
@@ -92,7 +92,6 @@
     \row    \o QInputContextPlugin     \o \c inputmethods     \o Case Sensitive
     \row    \o QKbdDriverPlugin        \o \c kbddrivers       \o Case Insensitive
     \row    \o QMouseDriverPlugin      \o \c mousedrivers     \o Case Insensitive
-    \row    \o QPictureFormatPlugin    \o \c pictureformats   \o Case Sensitive
     \row    \o QScreenDriverPlugin     \o \c gfxdrivers       \o Case Insensitive
     \row    \o QScriptExtensionPlugin  \o \c script           \o Case Sensitive
     \row    \o QSqlDriverPlugin        \o \c sqldrivers       \o Case Sensitive
diff --git a/doc/src/porting4-overview.qdoc b/doc/src/porting4-overview.qdoc
index 3494c6d..3c3c085 100644
--- a/doc/src/porting4-overview.qdoc
+++ b/doc/src/porting4-overview.qdoc
@@ -195,9 +195,9 @@
     QNetworkRequest, QNetworkReply, and QNetworkAccessManager documentation
     for further details.
 
-    It is also possible to perform operations on remote files
-    through the QHttp and QFtp classes, and on local files with
-    the QFile class.
+    It is also possible to perform operations on remote files through
+    the QNetworkAccessManager and QFtp classes, and on local files
+    with the QFile class.
 
     \section2 SQL Cursors (QSqlCursor)
 
diff --git a/doc/src/porting4.qdoc b/doc/src/porting4.qdoc
index 2414c4d..963b918 100644
--- a/doc/src/porting4.qdoc
+++ b/doc/src/porting4.qdoc
@@ -1977,7 +1977,7 @@
 
     \table
     \header \o Qt 3 function              \o Qt 4 equivalents
-    \row    \o QImageIO::description()    \o QImageWriter::description()
+    \row    \o QImageIO::description()    \o QImageWriter::text()
     \row    \o QImageIO::fileName()       \o QImageReader::fileName() and QImageWriter::fileName()
     \row    \o QImageIO::format()         \o QImageReader::format() and QImageWriter::format()
     \row    \o QImageIO::gamma()          \o QImageWriter::gamma()
@@ -1988,7 +1988,7 @@
     \row    \o QImageIO::parameters()     \o N/A
     \row    \o QImageIO::quality()        \o QImageWriter::quality()
     \row    \o QImageIO::read()           \o QImageReader::read()
-    \row    \o QImageIO::setDescription() \o QImageWriter::setDescription()
+    \row    \o QImageIO::setDescription() \o QImageWriter::setText()
     \row    \o QImageIO::setFileName()    \o QImageReader::setFileName() and QImageWriter::setFileName()
     \row    \o QImageIO::setFormat()      \o QImageReader::setFormat() and QImageWriter::setFormat()
     \row    \o QImageIO::setGamma()       \o QImageWriter::setGamma()
@@ -2350,8 +2350,9 @@
     Q3NetworkProtocolFactory<T>, and Q3NetworkOperation and have been
     moved to the Qt3Support library.
 
-    In Qt 4 applications, you can use classes like QFtp and QHttp
-    directly to perform file-related actions on a remote host.
+    In Qt 4 applications, you can use classes like QFtp and
+    QNetworkAccessManager directly to perform file-related actions on
+    a remote host.
 
     \section1 QObject
 
@@ -3241,12 +3242,11 @@
     moved to the Qt3Support library. In Qt 4, there is no
     direct equivalent to Q3SocketDevice:
 
-    \list
-    \o If you use Q3SocketDevice in a thread to perform blocking network
-    I/O (a technique encouraged by the \e{Qt Quarterly} article
-    \l{http://doc.trolltech.com/qq/qq09-networkthread.html}{Unblocking Networking}),
-    you can now use QTcpSocket, QFtp, or QHttp instead, which can now be used from
-    non-GUI threads.
+    \list \o If you use Q3SocketDevice in a thread to perform blocking
+    network I/O (a technique encouraged by the \e{Qt Quarterly}
+    article \l{http://doc.trolltech.com/qq/qq09-networkthread.html}
+    {Unblocking Networking}), you can now use QTcpSocket, QFtp, or
+    QNetworkAccessManager, which can be used from non-GUI threads.
 
     \o If you use Q3SocketDevice for UDP, you can now use QUdpSocket instead.
 
diff --git a/doc/src/properties.qdoc b/doc/src/properties.qdoc
index 5490dd0..d0a9ccc 100644
--- a/doc/src/properties.qdoc
+++ b/doc/src/properties.qdoc
@@ -122,6 +122,17 @@
     editable property for (checkable) buttons. Note that QItemDelegate
     gets and sets a widget's \c USER property.
 
+    \o The presence of the \c CONSTANT attibute indicates that the property 
+    value is constant.  For a given object instance, the READ method of a 
+    constant property must return the same value every time it is called.  This
+    constant value may be different for different instances of the object.  A
+    constant property cannot have a WRITE method or a NOTIFY signal.
+
+    \o The presence of the \c FINAL attribute indicates that the property
+    will not be overridden by a derived class.  This can be used for performance
+    optimizations in some cases, but is not enforced by moc.  Care must be taken
+    never to override a \c FINAL property.
+
     \endlist
 
     The \c READ, \c WRITE, and \c RESET functions can be inherited.
diff --git a/doc/src/qmake-manual.qdoc b/doc/src/qmake-manual.qdoc
index 0921ae7..211d7e9 100644
--- a/doc/src/qmake-manual.qdoc
+++ b/doc/src/qmake-manual.qdoc
@@ -558,7 +558,8 @@
     \o \c -makefile \BR
         \c qmake output will be a Makefile.
     \o \c -project \BR
-        \c qmake output will be a project file.
+        \c qmake output will be a project file. \BR
+\bold{Note:} It is likely that the created file will need to be edited for example adding the \c QT variable to suit what modules are required for the project.
     \endlist
 
     The following \c options are used to specify both general and mode-specific
diff --git a/doc/src/qsqldatatype-table.qdoc b/doc/src/qsqldatatype-table.qdoc
index 2055e6a..bc88c30 100644
--- a/doc/src/qsqldatatype-table.qdoc
+++ b/doc/src/qsqldatatype-table.qdoc
@@ -1,7 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the documentation of the Qt Toolkit.
 **
diff --git a/doc/src/qt4-network.qdoc b/doc/src/qt4-network.qdoc
index 3b3091e..5e1999e 100644
--- a/doc/src/qt4-network.qdoc
+++ b/doc/src/qt4-network.qdoc
@@ -109,9 +109,10 @@
     of programming, with the networking logic concentrated in one or
     two functions instead of spread across multiple slots.
 
-    QFtp and QHttp use QTcpSocket internally to implement the FTP and
-    HTTP protocols. Both classes work asynchronously and can schedule
-    (i.e., queue) requests.
+    QFtp and QNetworkAccessManager and its associated classes use
+    QTcpSocket internally to implement the FTP and HTTP protocols. The
+    classes work asynchronously and can schedule (i.e., queue)
+    requests.
 
     The network module contains four helper classes: QHostAddress,
     QHostInfo, QUrl, and QUrlInfo. QHostAddress stores an IPv4 or IPv6
@@ -198,8 +199,7 @@
     level QNetworkProtocol and QUrlOperator abstraction has been
     eliminated. These classes attempted the impossible (unify FTP and
     HTTP under one roof), and unsurprisingly failed at that. Qt 4
-    still provides QFtp and QHttp classes, but only with the more
-    mature API that appeared in Qt 3.1.
+    still provides QFtp, and it also proveds the QNetworkAccessManager.
 
     The QSocket class in Qt 3 has been renamed QTcpSocket. The new
     class is reentrant and supports blocking. It's also easier to
diff --git a/doc/src/qtdesigner.qdoc b/doc/src/qtdesigner.qdoc
index d913b32..0959bd9 100644
--- a/doc/src/qtdesigner.qdoc
+++ b/doc/src/qtdesigner.qdoc
@@ -166,1376 +166,3 @@
 
     \sa {Qt Designer Manual}, {QtUiTools Module}
 */
-
-/*!
-    \class QDesignerMemberSheetExtension
-
-    \brief The QDesignerMemberSheetExtension class allows you to
-    manipulate a widget's member functions which is displayed when
-    configuring connections using Qt Designer's mode for editing
-    signals and slots.
-
-    \inmodule QtDesigner
-
-    QDesignerMemberSheetExtension is a collection of functions that is
-    typically used to query a widget's member functions, and to
-    manipulate the member functions' appearance in \QD's signals and
-    slots editing mode. For example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 2
-
-    When implementing a custom widget plugin, a pointer to \QD's
-    current QDesignerFormEditorInterface object (\c formEditor in the
-    example above) is provided by the
-    QDesignerCustomWidgetInterface::initialize() function's parameter.
-
-    The member sheet (and any other extension), can be retrieved by
-    querying \QD's extension manager using the qt_extension()
-    function. When you want to release the extension, you only need to
-    delete the pointer.
-
-    All widgets have a default member sheet used in \QD's signals and
-    slots editing mode with the widget's member functions. But
-    QDesignerMemberSheetExtension also provides an interface for
-    creating custom member sheet extensions.
-
-    \warning \QD uses the QDesignerMemberSheetExtension to facilitate
-    the signal and slot editing mode. Whenever a connection between
-    two widgets is requested, \QD will query for the widgets' member
-    sheet extensions. If a widget has an implemented member sheet
-    extension, this extension will override the default member sheet.
-
-    To create a member sheet extension, your extension class must
-    inherit from both QObject and QDesignerMemberSheetExtension. Then,
-    since we are implementing an interface, we must ensure that it's
-    made known to the meta object system using the Q_INTERFACES()
-    macro:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 3
-
-    This enables \QD to use qobject_cast() to query for
-    supported interfaces using nothing but a QObject pointer.
-
-    In \QD the extensions are not created until they are
-    required. For that reason, when implementing a member sheet
-    extension, you must also create a QExtensionFactory, i.e a class
-    that is able to make an instance of your extension, and register
-    it using \QD's \l {QExtensionManager}{extension manager}.
-
-    When a widget's member sheet extension is required, \QD's \l
-    {QExtensionManager}{extension manager} will run through all its
-    registered factories calling QExtensionFactory::createExtension()
-    for each until the first one that is able to create a member sheet
-    extension for that widget, is found. This factory will then make
-    an instance of the extension. If no such factory is found, \QD
-    will use the default member sheet.
-
-    There are four available types of extensions in \QD:
-    QDesignerContainerExtension, QDesignerMemberSheetExtension,
-    QDesignerPropertySheetExtension and
-    QDesignerTaskMenuExtension. \QD's behavior is the same whether the
-    requested extension is associated with a multi page container, a
-    member sheet, a property sheet or a task menu.
-
-    The QExtensionFactory class provides a standard extension
-    factory, and can also be used as an interface for custom
-    extension factories. You can either create a new
-    QExtensionFactory and reimplement the
-    QExtensionFactory::createExtension() function. For example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 4
-
-    Or you can use an existing factory, expanding the
-    QExtensionFactory::createExtension() function to make the factory
-    able to create a member sheet extension as well. For example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 5
-
-    For a complete example using an extension class, see \l
-    {designer/taskmenuextension}{Task Menu Extension example}. The
-    example shows how to create a custom widget plugin for Qt
-    Designer, and how to to use the QDesignerTaskMenuExtension class
-    to add custom items to \QD's task menu.
-
-    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
-    Extensions}
-*/
-
-/*!
-    \fn QDesignerMemberSheetExtension::~QDesignerMemberSheetExtension()
-
-    Destroys the member sheet extension.
-*/
-
-/*!
-    \fn int QDesignerMemberSheetExtension::count() const
-
-    Returns the extension's number of member functions.
-*/
-
-/*!
-    \fn int QDesignerMemberSheetExtension::indexOf(const QString &name) const
-
-    Returns the index of the member function specified by the given \a
-    name.
-
-    \sa memberName()
-*/
-
-/*!
-    \fn QString QDesignerMemberSheetExtension::memberName(int index) const
-
-    Returns the name of the member function with the given \a index.
-
-    \sa indexOf()
-*/
-
-/*!
-    \fn QString QDesignerMemberSheetExtension::memberGroup(int index) const
-
-    Returns the name of the member group specified for the function
-    with the given \a index.
-
-    \sa indexOf(), setMemberGroup()
-*/
-
-/*!
-    \fn void QDesignerMemberSheetExtension::setMemberGroup(int index, const QString &group)
-
-    Sets the member group of the member function with the given \a
-    index, to \a group.
-
-    \sa indexOf(), memberGroup()
-*/
-
-/*!
-    \fn bool QDesignerMemberSheetExtension::isVisible(int index) const
-
-    Returns true if the member function with the given \a index is
-    visible in \QD's signal and slot editor, otherwise false.
-
-    \sa indexOf(), setVisible()
-*/
-
-/*!
-    \fn void QDesignerMemberSheetExtension::setVisible(int index, bool visible)
-
-    If \a visible is true, the member function with the given \a index
-    is visible in \QD's signals and slots editing mode; otherwise the
-    member function is hidden.
-
-    \sa indexOf(), isVisible()
-*/
-
-/*!
-    \fn virtual bool QDesignerMemberSheetExtension::isSignal(int index) const
-
-    Returns true if the member function with the given \a index is a
-    signal, otherwise false.
-
-    \sa indexOf()
-*/
-
-/*!
-    \fn bool QDesignerMemberSheetExtension::isSlot(int index) const
-
-    Returns true if the member function with the given \a index is a
-    slot, otherwise false.
-
-    \sa indexOf()
-*/
-
-/*!
-    \fn bool QDesignerMemberSheetExtension::inheritedFromWidget(int index) const
-
-    Returns true if the member function with the given \a index is
-    inherited from QWidget, otherwise false.
-
-    \sa indexOf()
-*/
-
-/*!
-    \fn QString QDesignerMemberSheetExtension::declaredInClass(int index) const
-
-    Returns the name of the class in which the member function with
-    the given \a index is declared.
-
-    \sa indexOf()
-*/
-
-/*!
-    \fn QString QDesignerMemberSheetExtension::signature(int index) const
-
-    Returns the signature of the member function with the given \a
-    index.
-
-    \sa indexOf()
-*/
-
-/*!
-    \fn QList<QByteArray> QDesignerMemberSheetExtension::parameterTypes(int index) const
-
-    Returns the parameter types of the member function with the given
-    \a index, as a QByteArray list.
-
-    \sa indexOf(), parameterNames()
-*/
-
-/*!
-    \fn QList<QByteArray> QDesignerMemberSheetExtension::parameterNames(int index) const
-
-    Returns the parameter names of the member function with the given
-    \a index, as a QByteArray list.
-
-    \sa indexOf(), parameterTypes()
-*/
-
-
-// Doc: Interface only
-
-/*!
-    \class QDesignerLayoutDecorationExtension
-    \brief The QDesignerLayoutDecorationExtension class provides an extension to a layout in \QD.
-    \inmodule QtDesigner
-    \internal
-*/
-
-/*!
-    \enum QDesignerLayoutDecorationExtension::InsertMode
-
-    This enum describes the modes that are used to insert items into a layout.
-
-    \value InsertWidgetMode Widgets are inserted into empty cells in a layout.
-    \value InsertRowMode    Whole rows are inserted into a vertical or grid layout.
-    \value InsertColumnMode Whole columns are inserted into a horizontal or grid layout.
-*/
-
-/*!
-    \fn virtual QDesignerLayoutDecorationExtension::~QDesignerLayoutDecorationExtension()
-
-    Destroys the extension.
-*/
-
-/*!
-    \fn virtual QList<QWidget*> QDesignerLayoutDecorationExtension::widgets(QLayout *layout) const
-
-    Returns the widgets that are managed by the given \a layout.
-
-    \sa insertWidget(), removeWidget()
-*/
-
-/*!
-    \fn QRect QDesignerLayoutDecorationExtension::itemInfo(int index) const
-
-    Returns the rectangle covered by the item at the given \a index in the layout.
-*/
-
-/*!
-    \fn int QDesignerLayoutDecorationExtension::indexOf(QWidget *widget) const
-
-    Returns the index of the specified \a widget in the layout.
-*/
-
-/*!
-    \fn int QDesignerLayoutDecorationExtension::indexOf(QLayoutItem *item) const
-
-    Returns the index of the specified layout \a item.
-*/
-
-/*!
-    \fn QDesignerLayoutDecorationExtension::InsertMode QDesignerLayoutDecorationExtension::currentInsertMode() const
-
-    Returns the current insertion mode.
-*/
-
-/*!
-    \fn int QDesignerLayoutDecorationExtension::currentIndex() const
-
-    Returns the current index in the layout.
-*/
-
-/*!
-    \fn QPair<int, int> QDesignerLayoutDecorationExtension::currentCell() const
-
-    Returns a pair containing the row and column of the current cell in the layout.
-*/
-
-/*!
-    \fn void QDesignerLayoutDecorationExtension::insertWidget(QWidget *widget, const QPair<int, int> &cell)
-
-    Inserts the given \a widget into the specified \a cell in the layout.
-
-    \sa removeWidget()
-*/
-
-/*!
-    \fn void QDesignerLayoutDecorationExtension::removeWidget(QWidget *widget)
-
-    Removes the specified \a widget from the layout.
-
-    \sa insertWidget()
-*/
-
-/*!
-    \fn void QDesignerLayoutDecorationExtension::insertRow(int row)
-
-    Inserts a new row into the form at the position specified by \a row.
-*/
-
-/*!
-    \fn void QDesignerLayoutDecorationExtension::insertColumn(int column)
-
-    Inserts a new column into the form at the position specified by \a column.
-*/
-
-/*!
-    \fn void QDesignerLayoutDecorationExtension::simplify()
-
-    Simplifies the layout by removing unnecessary empty rows and columns, and by changing the
-    number of rows or columns spanned by widgets.
-*/
-
-/*!
-    \fn int QDesignerLayoutDecorationExtension::findItemAt(const QPoint &position) const
-
-    Returns the index of the item in the layout that covers the given \a position.
-*/
-
-/*!
-    \fn int QDesignerLayoutDecorationExtension::findItemAt(int row, int column) const
-
-    Returns the item in the layout that occupies the specified \a row and \a column in the layout.
-
-    Currently, this only applies to grid layouts.
-*/
-
-/*!
-    \fn void QDesignerLayoutDecorationExtension::adjustIndicator(const QPoint &position, int index)
-
-    Adjusts the indicator for the item specified by \a index so that
-    it lies at the given \a position on the form.
-*/
-
-
-// Doc: Interface only
-
-/*!
-    \class QDesignerContainerExtension
-    \brief The QDesignerContainerExtension class allows you to add pages to
-    a custom multi-page container in Qt Designer's workspace.
-    \inmodule QtDesigner
-
-    QDesignerContainerExtension provide an interface for creating
-    custom container extensions. A container extension consists of a
-    collection of functions that \QD needs to manage a multi-page
-    container plugin, and a list of the container's pages.
-
-    \image containerextension-example.png
-
-    \warning This is \e not an extension for container plugins in
-    general, only custom \e multi-page containers.
-
-    To create a container extension, your extension class must inherit
-    from both QObject and QDesignerContainerExtension. For example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 6
-
-    Since we are implementing an interface, we must ensure that it's
-    made known to the meta object system using the Q_INTERFACES()
-    macro. This enables \QD to use the qobject_cast() function to
-    query for supported interfaces using nothing but a QObject
-    pointer.
-
-    You must reimplement several functions to enable \QD to manage a
-    custom multi-page container widget: \QD uses count() to keep track
-    of the number pages in your container, widget() to return the page
-    at a given index in the list of the container's pages, and
-    currentIndex() to return the list index of the selected page. \QD
-    uses the addWidget() function to add a given page to the
-    container, expecting it to be appended to the list of pages, while
-    it expects the insertWidget() function to add a given page to the
-    container by inserting it at a given index.
-
-    In \QD the extensions are not created until they are
-    required. For that reason you must also create a
-    QExtensionFactory, i.e a class that is able to make an instance of
-    your extension, and register it using \QD's \l
-    {QExtensionManager}{extension manager}.
-
-    When a container extension is required, \QD's \l
-    {QExtensionManager}{extension manager} will run through all its
-    registered factories calling QExtensionFactory::createExtension()
-    for each until the first one that is able to create a container
-    extension, is found. This factory will then create the extension
-    for the plugin.
-
-    There are four available types of extensions in \QD:
-    QDesignerContainerExtension , QDesignerMemberSheetExtension,
-    QDesignerPropertySheetExtension and QDesignerTaskMenuExtension.
-    \QD's behavior is the same whether the requested extension is
-    associated with a multi page container, a member sheet, a property
-    sheet or a task menu.
-
-    The QExtensionFactory class provides a standard extension factory,
-    and can also be used as an interface for custom extension
-    factories. You can either create a new QExtensionFactory and
-    reimplement the QExtensionFactory::createExtension() function. For
-    example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 7
-
-    Or you can use an existing factory, expanding the
-    QExtensionFactory::createExtension() function to make the factory
-    able to create a container extension as well. For example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 8
-
-    For a complete example using the QDesignerContainerExtension
-    class, see the \l {designer/containerextension}{Container
-    Extension example}. The example shows how to create a custom
-    multi-page plugin for \QD.
-
-    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
-    Extensions}
-*/
-
-/*!
-    \fn QDesignerContainerExtension::~QDesignerContainerExtension()
-
-    Destroys the extension.
-*/
-
-/*!
-    \fn int QDesignerContainerExtension::count() const
-
-    Returns the number of pages in the container.
-*/
-
-/*!
-    \fn QWidget *QDesignerContainerExtension::widget(int index) const
-
-    Returns the page at the given \a index in the extension's list of
-    pages.
-
-    \sa addWidget(), insertWidget()
-*/
-
-/*!
-    \fn int QDesignerContainerExtension::currentIndex() const
-
-    Returns the index of the currently selected page in the
-    container.
-
-    \sa setCurrentIndex()
-*/
-
-/*!
-    \fn void QDesignerContainerExtension::setCurrentIndex(int index)
-
-    Sets the currently selected page in the container to be the
-    page at the given \a index in the extension's list of pages.
-
-    \sa currentIndex()
-*/
-
-/*!
-    \fn void QDesignerContainerExtension::addWidget(QWidget *page)
-
-    Adds the given \a page to the container by appending it to the
-    extension's list of pages.
-
-    \sa insertWidget(), remove(), widget()
-*/
-
-/*!
-    \fn void QDesignerContainerExtension::insertWidget(int index, QWidget *page)
-
-    Adds the given \a page to the container by inserting it at the
-    given \a index in the extension's list of pages.
-
-    \sa addWidget(), remove(), widget()
-*/
-
-/*!
-    \fn void QDesignerContainerExtension::remove(int index)
-
-    Removes the page at the given \a index from the extension's list
-    of pages.
-
-    \sa addWidget(), insertWidget()
-*/
-
-
-// Doc: Interface only
-
-/*!
-    \class QDesignerTaskMenuExtension
-    \brief The QDesignerTaskMenuExtension class allows you to add custom
-    menu entries to Qt Designer's task menu.
-    \inmodule QtDesigner
-
-    QDesignerTaskMenuExtension provides an interface for creating
-    custom task menu extensions. It is typically used to create task
-    menu entries that are specific to a plugin in \QD.
-
-    \QD uses the QDesignerTaskMenuExtension to feed its task
-    menu. Whenever a task menu is requested, \QD will query
-    for the selected widget's task menu extension.
-
-    \image taskmenuextension-example-faded.png
-
-    A task menu extension is a collection of QActions. The actions
-    appear as entries in the task menu when the plugin with the
-    specified extension is selected. The image above shows the custom
-    \gui {Edit State...} action which appears in addition to \QD's
-    default task menu entries: \gui Cut, \gui Copy, \gui Paste etc.
-
-    To create a custom task menu extension, your extension class must
-    inherit from both QObject and QDesignerTaskMenuExtension. For
-    example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 9
-
-    Since we are implementing an interface, we must ensure that it
-    is made known to the meta-object system using the Q_INTERFACES()
-    macro. This enables \QD to use the qobject_cast() function to
-    query for supported interfaces using nothing but a QObject
-    pointer.
-
-    You must reimplement the taskActions() function to return a list
-    of actions that will be included in \QD task menu. Optionally, you
-    can reimplement the preferredEditAction() function to set the
-    action that is invoked when selecting your plugin and pressing
-    \key F2. The preferred edit action must be one of the actions
-    returned by taskActions() and, if it's not defined, pressing the
-    \key F2 key will simply be ignored.
-
-    In \QD, extensions are not created until they are required. A
-    task menu extension, for example, is created when you click the
-    right mouse button over a widget in \QD's workspace. For that
-    reason you must also construct an extension factory, using either
-    QExtensionFactory or a subclass, and register it using \QD's
-    \l {QExtensionManager}{extension manager}.
-
-    When a task menu extension is required, \QD's \l
-    {QExtensionManager}{extension manager} will run through all its
-    registered factories calling QExtensionFactory::createExtension()
-    for each until it finds one that is able to create a task menu
-    extension for the selected widget. This factory will then make an
-    instance of the extension.
-
-    There are four available types of extensions in \QD:
-    QDesignerContainerExtension, QDesignerMemberSheetExtension,
-    QDesignerPropertySheetExtension, and QDesignerTaskMenuExtension.
-    \QD's behavior is the same whether the requested extension is
-    associated with a container, a member sheet, a property sheet or a
-    task menu.
-
-    The QExtensionFactory class provides a standard extension factory,
-    and can also be used as an interface for custom extension
-    factories. You can either create a new QExtensionFactory and
-    reimplement the QExtensionFactory::createExtension() function. For
-    example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 10
-
-    Or you can use an existing factory, expanding the
-    QExtensionFactory::createExtension() function to make the factory
-    able to create a task menu extension as well. For example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 11
-
-    For a complete example using the QDesignerTaskMenuExtension class,
-    see the \l {designer/taskmenuextension}{Task Menu Extension
-    example}. The example shows how to create a custom widget plugin
-    for \QD, and how to to use the QDesignerTaskMenuExtension
-    class to add custom items to \QD's task menu.
-
-    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
-    Extensions}
-*/
-
-/*!
-    \fn QDesignerTaskMenuExtension::~QDesignerTaskMenuExtension()
-
-    Destroys the task menu extension.
-*/
-
-/*!
-    \fn QAction *QDesignerTaskMenuExtension::preferredEditAction() const
-
-    Returns the action that is invoked when selecting a plugin with
-    the specified extension and pressing \key F2.
-
-    The action must be one of the actions returned by taskActions().
-*/
-
-/*!
-    \fn QList<QAction*> QDesignerTaskMenuExtension::taskActions() const
-
-    Returns the task menu extension as a list of actions which will be
-    included in \QD's task menu when a plugin with the specified
-    extension is selected.
-
-    The function must be reimplemented to add actions to the list.
-*/
-
-
-// Doc: Interface only
-
-/*!
-    \class QDesignerCustomWidgetCollectionInterface
-
-    \brief The QDesignerCustomWidgetCollectionInterface class allows
-    you to include several custom widgets in one single library.
-
-    \inmodule QtDesigner
-
-    When implementing a custom widget plugin, you build it as a
-    separate library. If you want to include several custom widget
-    plugins in the same library, you must in addition subclass
-    QDesignerCustomWidgetCollectionInterface.
-
-    QDesignerCustomWidgetCollectionInterface contains one single
-    function returning a list of the collection's
-    QDesignerCustomWidgetInterface objects. For example, if you have
-    several custom widgets \c CustomWidgetOne, \c CustomWidgetTwo and
-    \c CustomWidgetThree, the class definition may look like this:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 12
-
-    In the class constructor you add the interfaces to your custom
-    widgets to the list which you return in the customWidgets()
-    function:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 13
-
-    Note that instead of exporting each custom widget plugin using the
-    Q_EXPORT_PLUGIN2() macro, you export the entire collection. The
-    Q_EXPORT_PLUGIN2() macro ensures that \QD can access and construct
-    the custom widgets. Without this macro, there is no way for \QD to
-    use them.
-
-    \sa QDesignerCustomWidgetInterface, {Creating Custom Widgets for
-    Qt Designer}
-*/
-
-/*!
-    \fn QDesignerCustomWidgetCollectionInterface::~QDesignerCustomWidgetCollectionInterface() {
-
-    Destroys the custom widget collection interface.
-*/
-
-/*!
-    \fn QList<QDesignerCustomWidgetInterface*> QDesignerCustomWidgetCollectionInterface::customWidgets() const
-
-    Returns a list of interfaces to the collection's custom widgets.
-*/
-
-
-// Doc: Interface only
-
-/*!
-    \class QDesignerCustomWidgetInterface
-
-    \brief The QDesignerCustomWidgetInterface class enables Qt Designer
-    to access and construct custom widgets.
-
-    \inmodule QtDesigner
-
-    QDesignerCustomWidgetInterface provides a custom widget with an
-    interface. The class contains a set of functions that must be subclassed
-    to return basic information about the widget, such as its class name and
-    the name of its header file. Other functions must be implemented to
-    initialize the plugin when it is loaded, and to construct instances of
-    the custom widget for \QD to use.
-
-    When implementing a custom widget you must subclass
-    QDesignerCustomWidgetInterface to expose your widget to \QD. For
-    example, this is the declaration for the plugin used in the
-    \l{Custom Widget Plugin Example}{Custom Widget Plugin example} that
-    enables an analog clock custom widget to be used by \QD:
-
-    \snippet examples/designer/customwidgetplugin/customwidgetplugin.h 0
-
-    Note that the only part of the class definition that is specific
-    to this particular custom widget is the class name. In addition,
-    since we are implementing an interface, we must ensure that it's
-    made known to the meta object system using the Q_INTERFACES()
-    macro. This enables \QD to use the qobject_cast() function to
-    query for supported interfaces using nothing but a QObject
-    pointer.
-
-    After \QD loads a custom widget plugin, it calls the interface's
-    initialize() function to enable it to set up any resources that it
-    may need. This function is called with a QDesignerFormEditorInterface
-    parameter that provides the plugin with a gateway to all of \QD's API.
-
-    \QD constructs instances of the custom widget by calling the plugin's
-    createWidget() function with a suitable parent widget. Plugins must
-    construct and return an instance of a custom widget with the specified
-    parent widget. 
-
-    In the implementation of the class you must remember to export
-    your custom widget plugin to \QD using the Q_EXPORT_PLUGIN2()
-    macro. For example, if a library called \c libcustomwidgetplugin.so
-    (on Unix) or \c libcustomwidget.dll (on Windows) contains a widget
-    class called \c MyCustomWidget, we can export it by adding the
-    following line to the file containing the plugin implementation:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 14
-
-    This macro ensures that \QD can access and construct the custom widget.
-    Without this macro, there is no way for \QD to use it.
-
-    When implementing a custom widget plugin, you build it as a
-    separate library. If you want to include several custom widget
-    plugins in the same library, you must in addition subclass
-    QDesignerCustomWidgetCollectionInterface.
-
-    \warning If your custom widget plugin contains QVariant
-    properties, be aware that only the following \l
-    {QVariant::Type}{types} are supported:
-
-    \list
-    \o QVariant::ByteArray
-    \o QVariant::Bool
-    \o QVariant::Color
-    \o QVariant::Cursor
-    \o QVariant::Date
-    \o QVariant::DateTime
-    \o QVariant::Double
-    \o QVariant::Int
-    \o QVariant::Point
-    \o QVariant::Rect
-    \o QVariant::Size
-    \o QVariant::SizePolicy
-    \o QVariant::String
-    \o QVariant::Time
-    \o QVariant::UInt
-    \endlist
-
-    For a complete example using the QDesignerCustomWidgetInterface
-    class, see the \l {designer/customwidgetplugin}{Custom Widget
-    Example}. The example shows how to create a custom widget plugin
-    for \QD.
-
-    \sa QDesignerCustomWidgetCollectionInterface {Creating Custom
-    Widgets for Qt Designer}
-*/
-
-/*!
-    \fn QDesignerCustomWidgetInterface::~QDesignerCustomWidgetInterface()
-
-    Destroys the custom widget interface.
-*/
-
-/*!
-    \fn QString QDesignerCustomWidgetInterface::name() const
-
-    Returns the class name of the custom widget supplied by the interface.
-
-    The name returned \e must be identical to the class name used for the
-    custom widget.
-*/
-
-/*!
-    \fn QString QDesignerCustomWidgetInterface::group() const
-
-    Returns the name of the group to which the custom widget belongs.
-*/
-
-/*!
-    \fn QString QDesignerCustomWidgetInterface::toolTip() const
-
-    Returns a short description of the widget that can be used by \QD
-    in a tool tip.
-*/
-
-/*!
-    \fn QString QDesignerCustomWidgetInterface::whatsThis() const
-
-    Returns a description of the widget that can be used by \QD in
-    "What's This?" help for the widget.
-*/
-
-/*!
-    \fn QString QDesignerCustomWidgetInterface::includeFile() const
-
-    Returns the path to the include file that \l uic uses when
-    creating code for the custom widget.
-*/
-
-/*!
-    \fn QIcon QDesignerCustomWidgetInterface::icon() const
-
-    Returns the icon used to represent the custom widget in \QD's
-    widget box.
-*/
-
-/*!
-    \fn bool QDesignerCustomWidgetInterface::isContainer() const
-
-    Returns true if the custom widget is intended to be used as a
-    container; otherwise returns false.
-
-    Most custom widgets are not used to hold other widgets, so their
-    implementations of this function will return false, but custom
-    containers will return true to ensure that they behave correctly
-    in \QD.
-*/
-
-/*!
-    \fn QWidget *QDesignerCustomWidgetInterface::createWidget(QWidget *parent)
-
-    Returns a new instance of the custom widget, with the given \a
-    parent.
-*/
-
-/*!
-    \fn bool QDesignerCustomWidgetInterface::isInitialized() const
-
-    Returns true if the widget has been initialized; otherwise returns
-    false.
-
-    \sa initialize()
-*/
-
-/*!
-    \fn void QDesignerCustomWidgetInterface::initialize(QDesignerFormEditorInterface *formEditor)
-
-    Initializes the widget for use with the specified \a formEditor
-    interface.
-
-    \sa isInitialized()
-*/
-
-/*!
-    \fn QString QDesignerCustomWidgetInterface::domXml() const
-
-    Returns the XML that is used to describe the custom widget's
-    properties to \QD.
-*/
-
-/*!
-    \fn QString QDesignerCustomWidgetInterface::codeTemplate() const
-
-    This function is reserved for future use by \QD.
-
-    \omit
-    Returns the code template that \QD includes in forms that contain
-    the custom widget when they are saved.
-    \endomit
-*/
-
-/*!
-    \macro QDESIGNER_WIDGET_EXPORT
-    \relates QDesignerCustomWidgetInterface
-    \since 4.1
-
-    This macro is used when defining custom widgets to ensure that they are
-    correctly exported from plugins for use with \QD.
-
-    On some platforms, the symbols required by \QD to create new widgets
-    are removed from plugins by the build system, making them unusable.
-    Using this macro ensures that the symbols are retained on those platforms,
-    and has no side effects on other platforms.
-
-    For example, the \l{designer/worldtimeclockplugin}{World Time Clock Plugin}
-    example exports a custom widget class with the following declaration:
-
-    \snippet examples/designer/worldtimeclockplugin/worldtimeclock.h 0
-    \dots
-    \snippet examples/designer/worldtimeclockplugin/worldtimeclock.h 2
-
-    \sa {Creating Custom Widgets for Qt Designer}
-*/
-
-
-// Doc: Abstract class
-
-/*!
-    \class QDesignerDnDItemInterface
-    \brief The QDesignerDnDItemInterface class provides an interface that is used to manage items
-    during a drag and drop operation.
-    \inmodule QtDesigner
-    \internal
-*/
-
-/*!
-    \enum QDesignerDnDItemInterface::DropType
-
-    This enum describes the result of a drag and drop operation.
-
-    \value MoveDrop The item was moved.
-    \value CopyDrop The item was copied.
-*/
-
-/*!
-    \fn QDesignerDnDItemInterface::QDesignerDnDItemInterface()
-
-    Constructs a new interface to a drag and drop item.
-*/
-
-/*!
-    \fn QDesignerDnDItemInterface::~QDesignerDnDItemInterface()
-
-    Destroys the interface to the item.
-*/
-
-/*!
-    \fn DomUI *QDesignerDnDItemInterface::domUi() const
-
-    Returns a user interface object for the item.
-*/
-
-/*!
-    \fn QWidget *QDesignerDnDItemInterface::widget() const
-
-    Returns the widget being copied or moved in the drag and drop operation.
-
-    \sa source()
-*/
-
-/*!
-    \fn QWidget *QDesignerDnDItemInterface::decoration() const
-
-    Returns the widget used to represent the item.
-*/
-
-/*!
-    \fn QPoint QDesignerDnDItemInterface::hotSpot() const
-
-    Returns the cursor's hotspot.
-
-    \sa QDrag::hotSpot()
-*/
-
-/*!
-    \fn DropType QDesignerDnDItemInterface::type() const
-
-    Returns the type of drag and drop operation in progress.
-*/
-
-/*!
-    \fn QWidget *QDesignerDnDItemInterface::source() const
-
-    Returns the widget that is the source of the drag and drop operation; i.e. the original
-    container of the widget being dragged.
-
-    \sa widget()
-*/
-
-
-// Doc: Abstract class
-
-/*!
-    \class QDesignerIconCacheInterface
-    \brief The QDesignerIconCacheInterface class provides an interface to \QD's icon cache.
-    \inmodule QtDesigner
-    \internal
-*/
-
-/*!
-    \fn QDesignerIconCacheInterface::QDesignerIconCacheInterface(QObject *parent)
-
-    Constructs a new interface with the given \a parent.
-*/
-
-/*!
-    \fn QIcon QDesignerIconCacheInterface::nameToIcon(const QString &filePath, const QString &qrcPath)
-
-    Returns the icon associated with the name specified by \a filePath in the resource
-    file specified by \a qrcPath.
-
-    If \a qrcPath refers to a valid resource file, the name used for the file path is a path
-    within those resources; otherwise the file path refers to a local file.
-
-    \sa {The Qt Resource System}, nameToPixmap()
-*/
-
-/*!
-    \fn QPixmap QDesignerIconCacheInterface::nameToPixmap(const QString &filePath, const QString &qrcPath)
-
-    Returns the pixmap associated with the name specified by \a filePath in the resource
-    file specified by \a qrcPath.
-
-    If \a qrcPath refers to a valid resource file, the name used for the file path is a path
-    within those resources; otherwise the file path refers to a local file.
-
-    \sa {The Qt Resource System}, nameToIcon()
-*/
-
-/*!
-    \fn QString QDesignerIconCacheInterface::iconToFilePath(const QIcon &icon) const
-
-    Returns the file path associated with the given \a icon. The file path is a path within
-    an application resources.
-*/
-
-/*!
-    \fn QString QDesignerIconCacheInterface::iconToQrcPath(const QIcon &icon) const
-
-    Returns the path to the resource file that refers to the specified \a icon. The resource
-    path refers to a local file.
-*/
-
-/*!
-    \fn QString QDesignerIconCacheInterface::pixmapToFilePath(const QPixmap &pixmap) const
-
-    Returns the file path associated with the given \a pixmap. The file path is a path within
-    an application resources.
-*/
-
-/*!
-    \fn QString QDesignerIconCacheInterface::pixmapToQrcPath(const QPixmap &pixmap) const
-
-    Returns the path to the resource file that refers to the specified \a pixmap. The resource
-    path refers to a local file.
-*/
-
-/*!
-    \fn QList<QPixmap> QDesignerIconCacheInterface::pixmapList() const
-
-    Returns a list of pixmaps for the icons provided by the icon cache.
-*/
-
-/*!
-    \fn QList<QIcon> QDesignerIconCacheInterface::iconList() const
-
-    Returns a list of icons provided by the icon cache.
-*/
-
-/*!
-    \fn QString QDesignerIconCacheInterface::resolveQrcPath(const QString &filePath, const QString &qrcPath, const QString &workingDirectory) const
-
-    Returns a path to a resource specified by the \a filePath within
-    the resource file located at \a qrcPath. If \a workingDirectory is
-    a valid path to a directory, the path returned will be relative to
-    that directory; otherwise an absolute path is returned.
-
-    \omit
-    ### Needs checking
-    \endomit
-*/
-
-
-// Doc: Interface only
-
-/*!
-    \class QDesignerPropertySheetExtension
-
-    \brief The QDesignerPropertySheetExtension class allows you to
-    manipulate a widget's properties which is displayed in Qt
-    Designer's property editor.
-
-    \sa QDesignerDynamicPropertySheetExtension
-
-    \inmodule QtDesigner
-
-    QDesignerPropertySheetExtension provides a collection of functions that
-    are typically used to query a widget's properties, and to
-    manipulate the properties' appearance in the property editor. For
-    example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 15
-
-    Note that if you change the value of a property using the
-    QDesignerPropertySheetExtension::setProperty() function, the undo
-    stack is not updated. To ensure that a property's value can be
-    reverted using the undo stack, you must use the
-    QDesignerFormWindowCursorInterface::setProperty() function, or its
-    buddy \l
-    {QDesignerFormWindowCursorInterface::setWidgetProperty()}{setWidgetProperty()},
-    instead.
-
-    When implementing a custom widget plugin, a pointer to \QD's
-    current QDesignerFormEditorInterface object (\c formEditor in the
-    example above) is provided by the
-    QDesignerCustomWidgetInterface::initialize() function's parameter.
-
-    The property sheet, or any other extension, can be retrieved by
-    querying \QD's extension manager using the qt_extension()
-    function. When you want to release the extension, you only need to
-    delete the pointer.
-
-    All widgets have a default property sheet which populates \QD's
-    property editor with the widget's properties (i.e the ones defined
-    with the Q_PROPERTY() macro). But QDesignerPropertySheetExtension
-    also provides an interface for creating custom property sheet
-    extensions.
-
-    \warning \QD uses the QDesignerPropertySheetExtension to feed its
-    property editor. Whenever a widget is selected in its workspace,
-    \QD will query for the widget's property sheet extension. If the
-    selected widget has an implemented property sheet extension, this
-    extension will override the default property sheet.
-
-    To create a property sheet extension, your extension class must
-    inherit from both QObject and
-    QDesignerPropertySheetExtension. Then, since we are implementing
-    an interface, we must ensure that it's made known to the meta
-    object system using the Q_INTERFACES() macro:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 16
-
-    This enables \QD to use qobject_cast() to query for supported
-    interfaces using nothing but a QObject pointer.
-
-    In \QD the extensions are not created until they are
-    required. For that reason, when implementing a property sheet
-    extension, you must also create a QExtensionFactory, i.e a class
-    that is able to make an instance of your extension, and register
-    it using \QD's \l {QExtensionManager}{extension manager}.
-
-    When a property sheet extension is required, \QD's \l
-    {QExtensionManager}{extension manager} will run through all its
-    registered factories calling QExtensionFactory::createExtension()
-    for each until the first one that is able to create a property
-    sheet extension for the selected widget, is found. This factory
-    will then make an instance of the extension. If no such factory
-    can be found, \QD will use the default property sheet.
-
-    There are four available types of extensions in \QD:
-    QDesignerContainerExtension, QDesignerMemberSheetExtension,
-    QDesignerPropertySheetExtension and QDesignerTaskMenuExtension. Qt
-    Designer's behavior is the same whether the requested extension is
-    associated with a multi page container, a member sheet, a property
-    sheet or a task menu.
-
-    The QExtensionFactory class provides a standard extension factory,
-    and can also be used as an interface for custom extension
-    factories. You can either create a new QExtensionFactory and
-    reimplement the QExtensionFactory::createExtension() function. For
-    example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 17
-
-    Or you can use an existing factory, expanding the
-    QExtensionFactory::createExtension() function to make the factory
-    able to create a property sheet extension extension as well. For
-    example:
-
-    \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 18
-
-    For a complete example using an extension class, see the \l
-    {designer/taskmenuextension}{Task Menu Extension example}. The
-    example shows how to create a custom widget plugin for Qt
-    Designer, and how to to use the QDesignerTaskMenuExtension class
-    to add custom items to \QD's task menu.
-
-    \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
-    Extensions}
-*/
-
-/*!
-    \fn QDesignerPropertySheetExtension::~QDesignerPropertySheetExtension()
-
-    Destroys the property sheet extension.
-*/
-
-/*!
-    \fn int QDesignerPropertySheetExtension::count() const
-
-    Returns the selected widget's number of properties.
-*/
-
-/*!
-    \fn int QDesignerPropertySheetExtension::indexOf(const QString &name) const
-
-    Returns the index for a given property \a name.
-
-    \sa propertyName()
-*/
-
-/*!
-    \fn QString QDesignerPropertySheetExtension::propertyName(int index) const
-
-    Returns the name of the property at the given \a index.
-
-    \sa indexOf()
-*/
-
-/*!
-    \fn QString QDesignerPropertySheetExtension::propertyGroup(int index) const
-
-    Returns the property group for the property at the given \a index.
-
-    \QD's property editor supports property groups, i.e. sections of
-    related properties. A property can be related to a group using the
-    setPropertyGroup() function. The default group of any property is
-    the name of the class that defines it. For example, the
-    QObject::objectName property appears within the QObject property
-    group.
-
-    \sa indexOf(), setPropertyGroup()
-*/
-
-/*!
-    \fn void QDesignerPropertySheetExtension::setPropertyGroup(int index, const QString &group)
-
-    Sets the property group for the property at the given \a index to
-    \a group.
-
-    Relating a property to a group makes it appear within that group's
-    section in the property editor. The default property group of any
-    property is the name of the class that defines it. For example,
-    the QObject::objectName property appears within the QObject
-    property group.
-
-    \sa indexOf(), property(), propertyGroup()
-*/
-
-/*!
-    \fn bool QDesignerPropertySheetExtension::hasReset(int index) const
-
-    Returns true if the property at the given \a index has a reset
-    button in \QD's property editor, otherwise false.
-
-    \sa indexOf(), reset()
-*/
-
-/*!
-    \fn bool QDesignerPropertySheetExtension::reset(int index)
-
-    Resets the value of the property at the given \a index, to the
-    default value. Returns true if a default value could be found, otherwise false.
-
-    \sa indexOf(), hasReset(), isChanged()
-*/
-
-/*!
-    \fn bool QDesignerPropertySheetExtension::isVisible(int index) const
-
-    Returns true if the property at the given \a index is visible in
-    \QD's property editor, otherwise false.
-
-    \sa indexOf(), setVisible()
-*/
-
-/*!
-    \fn void QDesignerPropertySheetExtension::setVisible(int index, bool visible)
-
-    If \a visible is true, the property at the given \a index is
-    visible in \QD's property editor; otherwise the property is
-    hidden.
-
-    \sa indexOf(), isVisible()
-*/
-
-/*!
-    \fn bool QDesignerPropertySheetExtension::isAttribute(int index) const
-
-    Returns true if the property at the given \a index is an attribute,
-    which will be \e excluded from the UI file, otherwise false.
-
-    \sa indexOf(), setAttribute()
-*/
-
-/*!
-    \fn void QDesignerPropertySheetExtension::setAttribute(int index, bool attribute)
-
-    If \a attribute is true, the property at the given \a index is
-    made an attribute which will be \e excluded from the UI file;
-    otherwise it will be included.
-
-    \sa indexOf(), isAttribute()
-*/
-
-/*!
-    \fn QVariant QDesignerPropertySheetExtension::property(int index) const
-
-    Returns the value of the property at the given \a index.
-
-    \sa indexOf(), setProperty(), propertyGroup()
-*/
-
-/*!
-    \fn void QDesignerPropertySheetExtension::setProperty(int index, const QVariant &value)
-
-    Sets the \a value of the property at the given \a index.
-
-    \warning If you change the value of a property using this
-    function, the undo stack is not updated. To ensure that a
-    property's value can be reverted using the undo stack, you must
-    use the QDesignerFormWindowCursorInterface::setProperty()
-    function, or its buddy \l
-    {QDesignerFormWindowCursorInterface::setWidgetProperty()}{setWidgetProperty()},
-    instead.
-
-    \sa indexOf(), property(), propertyGroup()
-*/
-
-/*!
-    \fn bool QDesignerPropertySheetExtension::isChanged(int index) const
-
-    Returns true if the value of the property at the given \a index
-    differs from the property's default value, otherwise false.
-
-    \sa indexOf(), setChanged(), reset()
-*/
-
-/*!
-    \fn void QDesignerPropertySheetExtension::setChanged(int index, bool changed)
-
-    Sets whether the property at the given \a index is different from
-    its default value, or not, depending on the \a changed parameter.
-
-    \sa indexOf(), isChanged()
-*/
-
-// Doc: Interface only
-
-/*!
-    \class QDesignerDynamicPropertySheetExtension
-
-    \brief The QDesignerDynamicPropertySheetExtension class allows you to
-    manipulate a widget's dynamic properties in Qt Designer's property editor.
-
-    \sa QDesignerPropertySheetExtension, {QObject#Dynamic Properties}{Dynamic Properties}
-
-    \inmodule QtDesigner
-    \since 4.3
-*/
-
-/*!
-    \fn QDesignerDynamicPropertySheetExtension::~QDesignerDynamicPropertySheetExtension()
-
-    Destroys the dynamic property sheet extension.
-*/
-
-/*!
-    \fn bool QDesignerDynamicPropertySheetExtension::dynamicPropertiesAllowed() const
-
-    Returns true if the widget supports dynamic properties; otherwise returns false.
-*/
-
-/*!
-    \fn int QDesignerDynamicPropertySheetExtension::addDynamicProperty(const QString &propertyName, const QVariant &value)
-
-    Adds a dynamic property named \a propertyName and sets its value to \a value.
-    Returns the index of the property if it was added successfully; otherwise returns -1 to
-    indicate failure.
-*/
-
-/*!
-    \fn bool QDesignerDynamicPropertySheetExtension::removeDynamicProperty(int index)
-
-    Removes the dynamic property at the given \a index.
-    Returns true if the operation succeeds; otherwise returns false.
-*/
-
-/*!
-    \fn bool QDesignerDynamicPropertySheetExtension::isDynamicProperty(int index) const
-
-    Returns true if the property at the given \a index is a dynamic property; otherwise
-    returns false.
-*/
-
-/*!
-    \fn bool QDesignerDynamicPropertySheetExtension::canAddDynamicProperty(const QString &propertyName) const
-
-    Returns true if \a propertyName is a valid, unique name for a dynamic
-    property; otherwise returns false.
-
-*/
diff --git a/doc/src/qtnetwork.qdoc b/doc/src/qtnetwork.qdoc
index 0443f0f..3802273 100644
--- a/doc/src/qtnetwork.qdoc
+++ b/doc/src/qtnetwork.qdoc
@@ -145,11 +145,11 @@
     \l{QFtp::commandFinished()}{commandFinished()} signal with the
     command ID for each command that is executed. 
 
-    \o \e{Data transfer progress indicators.} QFtp emits
-    signals whenever data is transferred
-    (QFtp::dataTransferProgress(), QHttp::dataReadProgress(), and
-    QHttp::dataSendProgress()). You could connect these signals to
-    QProgressBar::setProgress() or QProgressDialog::setProgress(),
+    \o \e{Data transfer progress indicators.} QFtp emits signals
+    whenever data is transferred (QFtp::dataTransferProgress(),
+    QNetworkReply::downloadProgress(), and
+    QNetworkReply::uploadProgress()).  You could connect these signals
+    to QProgressBar::setProgress() or QProgressDialog::setProgress(),
     for example.
 
     \o \e{QIODevice support.} The class supports convenient
@@ -196,10 +196,10 @@
     will then stop immediately.
 
     QTcpSocket works asynchronously and emits signals to report status
-    changes and errors, just like QHttp and QFtp. It relies on the
-    event loop to detect incoming data and to automatically flush
-    outgoing data. You can write data to the socket using
-    QTcpSocket::write(), and read data using
+    changes and errors, just like QNetworkAccessManager and QFtp. It
+    relies on the event loop to detect incoming data and to
+    automatically flush outgoing data. You can write data to the
+    socket using QTcpSocket::write(), and read data using
     QTcpSocket::read(). QTcpSocket represents two independent streams
     of data: one for reading and one for writing.
 
diff --git a/doc/src/qtxmlpatterns.qdoc b/doc/src/qtxmlpatterns.qdoc
index 9f8677b..3177736 100644
--- a/doc/src/qtxmlpatterns.qdoc
+++ b/doc/src/qtxmlpatterns.qdoc
@@ -841,6 +841,12 @@
 
     \section2 XML Schema 1.0
 
+    There are two ways QtXmlPatterns can be used to validate schemas:
+    You can use the C++ API in your Qt application using the classes
+    QXmlSchema and QXmlSchemaValidator, or you can use the command line
+    utility named xmlpatternsvalidator (located in the "bin" directory
+    of your Qt build).
+
     The QtXmlPatterns implementation of XML Schema validation supports
     the schema specification version 1.0 in large parts. Known problems
     of the implementation and areas where conformancy may be questionable
diff --git a/doc/src/resources.qdoc b/doc/src/resources.qdoc
index e4d4c35..6f3f939 100644
--- a/doc/src/resources.qdoc
+++ b/doc/src/resources.qdoc
@@ -175,7 +175,7 @@
     Qt's resources support the concept of a search path list. If you then
     refer to a resource with \c : instead of \c :/ as the prefix, the
     resource will be looked up using the search path list. The search
-    path list is empty at startup; call QDir::addResourceSearchPath() to
+    path list is empty at startup; call QDir::addSearchPath() to
     add paths to it.
 
     If you have resources in a static library, you might need to
diff --git a/doc/src/richtext.qdoc b/doc/src/richtext.qdoc
index 1c76268..c43db0c 100644
--- a/doc/src/richtext.qdoc
+++ b/doc/src/richtext.qdoc
@@ -714,8 +714,8 @@ Ideas for other sections:
     \previouspage Common Rich Text Editing Tasks
 
     Qt's text widgets are able to display rich text, specified using a subset of \l{HTML 4}
-    markup. Widgets that use QTextDocument, such as QLabel, QTextEdit, QTreeWidgetItem and
-    the other item widgets, are able to display rich text specified in this way.
+    markup. Widgets that use QTextDocument, such as QLabel and QTextEdit, are able to display
+    rich text specified in this way.
 
     \tableofcontents
 
diff --git a/doc/src/snippets/code/doc_src_emb-charinput.qdoc b/doc/src/snippets/code/doc_src_emb-charinput.qdoc
index 2539e13..f6b33fe 100644
--- a/doc/src/snippets/code/doc_src_emb-charinput.qdoc
+++ b/doc/src/snippets/code/doc_src_emb-charinput.qdoc
@@ -4,7 +4,7 @@
 
 
 //! [1]
-configure -qt-kbd-s15000
+configure -qt-kbd-linuxinput
 //! [1]
 
 
diff --git a/doc/src/snippets/code/doc_src_properties.qdoc b/doc/src/snippets/code/doc_src_properties.qdoc
index 377cc9c..3c9109f 100644
--- a/doc/src/snippets/code/doc_src_properties.qdoc
+++ b/doc/src/snippets/code/doc_src_properties.qdoc
@@ -7,7 +7,9 @@ Q_PROPERTY(type name
            [DESIGNABLE bool]
            [SCRIPTABLE bool]
            [STORED bool]
-	   [USER bool])
+	   [USER bool]
+           [CONSTANT]
+           [FINAL])
 //! [0]
 
 
diff --git a/doc/src/snippets/code/doc_src_styles.qdoc b/doc/src/snippets/code/doc_src_styles.qdoc
index e11dc05..9d5756a 100644
--- a/doc/src/snippets/code/doc_src_styles.qdoc
+++ b/doc/src/snippets/code/doc_src_styles.qdoc
@@ -1,5 +1,5 @@
 //! [0]
-    opt.init(q);
+    opt.initFrom(q);
         if (down)
         opt.state |= QStyle::State_Sunken;
     if (tristate && noChange)
diff --git a/doc/src/snippets/code/src_corelib_io_qfileinfo.cpp b/doc/src/snippets/code/src_corelib_io_qfileinfo.cpp
index 2ab15ee..89b4f33 100644
--- a/doc/src/snippets/code/src_corelib_io_qfileinfo.cpp
+++ b/doc/src/snippets/code/src_corelib_io_qfileinfo.cpp
@@ -13,9 +13,9 @@ info1.size();               // returns 56201
 info1.symLinkTarget();      // returns "/opt/pretty++/bin/untabify"
 
 QFileInfo info2(info1.symLinkTarget());
-info1.isSymLink();          // returns false
-info1.absoluteFilePath();   // returns "/opt/pretty++/bin/untabify"
-info1.size();               // returns 56201
+info2.isSymLink();          // returns false
+info2.absoluteFilePath();   // returns "/opt/pretty++/bin/untabify"
+info2.size();               // returns 56201
 
 #endif
 //! [0]
diff --git a/doc/src/snippets/code/src_corelib_tools_qlistdata.cpp b/doc/src/snippets/code/src_corelib_tools_qlistdata.cpp
index 7d75e1b..3b9a756 100644
--- a/doc/src/snippets/code/src_corelib_tools_qlistdata.cpp
+++ b/doc/src/snippets/code/src_corelib_tools_qlistdata.cpp
@@ -190,10 +190,10 @@ QVector<QString> vect = list.toVector();
 
 
 //! [23]
-QSet<double> set;
-set << 20.0 << 30.0 << 40.0 << ... << 70.0;
+QSet<int> set;
+set << 20 << 30 << 40 << ... << 70;
 
-QList<double> list = QList<double>::fromSet(set);
+QList<int> list = QList<int>::fromSet(set);
 qSort(list);
 //! [23]
 
diff --git a/doc/src/snippets/stringlistmodel/model.cpp b/doc/src/snippets/stringlistmodel/model.cpp
index 76329dd..49e0fc7 100644
--- a/doc/src/snippets/stringlistmodel/model.cpp
+++ b/doc/src/snippets/stringlistmodel/model.cpp
@@ -59,6 +59,11 @@ int StringListModel::rowCount(const QModelIndex &parent) const
 }
 //! [0]
 
+
+#ifdef 0
+// This represents a read-only version of data(), an early stage in the 
+// development of the example leading to an editable StringListModel.
+
 /*!
     Returns an appropriate value for the requested data.
     If the view requests an invalid index, an invalid variant is returned.
@@ -66,7 +71,7 @@ int StringListModel::rowCount(const QModelIndex &parent) const
     string to be returned.
 */
 
-//! [1]
+//! [1-data-read-only]
 QVariant StringListModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid())
@@ -80,6 +85,31 @@ QVariant StringListModel::data(const QModelIndex &index, int role) const
     else
         return QVariant();
 }
+//! [1-data-read-only]
+#endif
+
+
+/*!
+    Returns an appropriate value for the requested data.
+    If the view requests an invalid index, an invalid variant is returned.
+    Any valid index that corresponds to a string in the list causes that
+    string to be returned.
+*/
+
+//! [1]
+QVariant StringListModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid())
+        return QVariant();
+
+    if (index.row() >= stringList.size())
+        return QVariant();
+        
+    if (role == Qt::DisplayRole || role == Qt::EditRole)
+        return stringList.at(index.row());
+    else
+        return QVariant();
+}
 //! [1]
 
 /*!
diff --git a/doc/src/styles.qdoc b/doc/src/styles.qdoc
index b818c4a..752fef0 100644
--- a/doc/src/styles.qdoc
+++ b/doc/src/styles.qdoc
@@ -246,7 +246,7 @@
     defined by the \l{QStyle::}{State} enum. Some of the state flags have
     different meanings depending on the widget, but others are common
     for all widgets like State_Disabled. It is QStyleOption that sets
-    the common states with QStyleOption::init(); the rest of the
+    the common states with QStyleOption::initFrom(); the rest of the
     states are set by the individual widgets.
 
     Most notably, the style options contain the palette and bounding
@@ -502,7 +502,7 @@
     \snippet doc/src/snippets/code/doc_src_styles.qdoc 0
 
     First we let QStyleOption set up the option with the information
-    that is common for all widgets with \c init().  We will look at
+    that is common for all widgets with \c initFrom().  We will look at
     this shortly.
 
     The down boolean is true when the user press the box down; this is
@@ -514,7 +514,7 @@
     set - you set this in QStyle::polish(). In addition, the style
     option also contains the text, icon, and icon size of the button.
 
-    \l{QStyleOption::}{init()} sets up the style option with the
+    \l{QStyleOption::}{initFrom()} sets up the style option with the
     attributes that are common for all widgets. We print its
     implementation here:
 
@@ -726,9 +726,9 @@
     \section2 Common Widget Properties
 
     Some states and variables are common for all widgets. These are
-    set with QStyleOption::init(). Not all elements use this function;
+    set with QStyleOption::initFrom(). Not all elements use this function;
     it is the widgets that create the style options, and for some
-    elements the information from \l{QStyleOption::}{init()} is not
+    elements the information from \l{QStyleOption::}{initFrom()} is not
     necessary.
 
     A table with the common states follows:
@@ -1451,7 +1451,7 @@
             \o Set if it is a horizontal splitter
     \endtable
 
-    QSplitter does not use \l{QStyleOption::}{init()} to set up its
+    QSplitter does not use \l{QStyleOption::}{initFrom()} to set up its
     option; it sets the State_MouseOver and State_Disabled flags
     itself.
 
@@ -1625,7 +1625,7 @@
 
     QToolBarSaparator uses QStyleOption for their style option. It
     sets the State_horizontal flag if the toolbar they live in is
-    horizontal. Other than that, they use \l{QStyleOption::}{init()}.
+    horizontal. Other than that, they use \l{QStyleOption::}{initFrom()}.
 
     The style option for QToolBar is QStyleOptionToolBar. The only
     state flag set (besides the common flags) is State_Horizontal
@@ -1757,7 +1757,7 @@
     The setup of the style option for CE_MenuTearOff and
     CE_MenuScroller also uses QStyleOptionMenuItem; they only set the
     \c menuRect variable in addition to the common settings with
-    QStyleOption's \l{QStyleOption::}{init()}. 
+    QStyleOption's \l{QStyleOption::}{initFrom()}. 
 
     \section3 Menu Bar
 
diff --git a/doc/src/supported-platforms.qdoc b/doc/src/supported-platforms.qdoc
new file mode 100644
index 0000000..3f35e14
--- /dev/null
+++ b/doc/src/supported-platforms.qdoc
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page supported-platforms.html
+    \title Supported Platforms
+    \brief The platforms supported by Nokia for Qt.
+    \ingroup platform-notes
+
+    Qt Software strives to provide support for the platforms most
+    frequently used by Qt users. We have designed our internal testing procedure to
+    divide platforms into three test categories (Tier 1, Tier 2 and Tier 3) in order
+    to prioritize internal testing and development resources so that the most
+    frequently used platforms are subjected to our most rigorous testing processes.
+
+    Qt is supported on a variety of 32-bit and 64-bit platforms, and can
+    usually be built on each platform with GCC, a vendor-supplied compiler, or
+    a third party compiler. Although Qt may be built on a range of platform-compiler
+    combinations, only a subset of these are actively supported by Nokia.
+
+    \tableofcontents
+
+    Information about the specific platforms Qt runs on can be found on the
+    \l{Platform Notes} page. Information about the compilers used on each platform
+    can be found on the \l{Compiler Notes} page.
+
+    \section1 Tier 1 Platforms
+
+    All Tier 1 platforms are subjected to our unit test suite and other internal
+    testing tools on a frequent basis (prior to new version releases, source tree
+    branching, and at other significant period points in the development process).
+    Errors or bugs discovered in these platforms are prioritized for correction
+    by the development team. Significant errors discovered in Tier 1 platforms can
+    impact release dates and Qt Development Frameworks strives to resolve all known
+    high priority errors in Tier 1 platforms prior to new version releases.
+
+    \table
+    \header \o Platform
+                                     \o Compilers
+    \row    \o Linux (32 and 64-bit)
+                                     \o gcc 4.2
+    \row    \o Microsoft Windows XP
+                                     \o gcc 3.4.2 (MinGW) (32-bit), MSVC 2003, 2005 (32 and 64-bit)
+    \row    \o Microsoft Windows Vista
+                                     \o MSVC 2005, 2008
+    \row    \o Microsoft Windows Vista 64bit
+                                     \o MSVC 2008
+    \row    \o Apple Mac OS X 10.5 "Leopard" x86_64 (Carbon, Cocoa 32 and 64bit)
+                                     \o As provided by Apple
+    \row    \o Embedded Linux QWS (ARM)
+                                     \o gcc (\l{http:\\www.codesourcery.com}{Codesourcery version)}
+    \row    \o Windows CE 5.0 (ARMv4i, x86, MIPS)
+                                     \o MSVC 2005 WinCE 5.0 Standard (x86, pocket, smart, mipsii)
+    \endtable
+
+    \section1 Tier 2 Platforms
+
+    Tier 2 platforms are subjected to our unit test suite and other internal testing
+    tools prior to release of new product versions.  Qt users should note, however,
+    that errors may be present in released product versions for Tier 2 platforms and,
+    subject to resource availability, known errors in Tier 2 platforms may or may not
+    be corrected prior to new version releases.
+
+    \table
+    \header \o Platform
+                                     \o Compilers
+    \row    \o Apple Mac OS X 10.4 "Tiger"
+                                     \o As provided by Apple
+    \row    \o HPUXi 11.11
+                                     \o aCC 3.57, gcc 3.4
+    \row    \o HPUXi 11.23
+                                     \o aCC 6.10
+    \row    \o Solaris 10 UltraSparc
+                                     \o Sun Studio 12
+    \row    \o AIX 6
+                                     \o Power5 xlC 7
+    \row    \o Microsoft Windows XP
+                                     \o Intel Compiler
+    \row    \o Linux
+                                     \o Intel Compiler
+    \row    \o Embedded Linux QWS (Mips, PowerPC)
+                                     \o gcc (\l{http:\\www.codesourcery.com}{Codesourcery version)}
+    \row    \o Windows CE 6.0 (ARMv4i, x86, MIPS)
+                                     \o MSVC 2008 WinCE 6.0 Professional
+    \endtable
+
+    \section1 Tier 3 Platforms (Not supported by Nokia)
+
+    All platforms not specifically listed above are not supported by Nokia. Nokia does
+    not run its unit test suite or perform any other internal tests on platforms not
+    listed above.  Qt users should note, however, that there may be various open source
+    projects, community users and/or Qt partners who are able to provide assistance with
+    platforms not supported by Nokia.
+
+    \section1 General Legal Disclaimer
+
+    Please note that Qt Software’s products are offered on an "as is" basis without warranty
+    of any kind and that our products are not error or bug free. To the maximum extent
+    permitted by applicable law, Nokia on behalf of itself and its suppliers, disclaims all
+    warranties and conditions, either express or implied, including, but not limited to,
+    implied warranties of merchantability, fitness for a particular purpose, title and
+    non-infringement with regard to the Licensed Software.
+*/
diff --git a/doc/src/tech-preview/images/mainwindow-docks-example.png b/doc/src/tech-preview/images/mainwindow-docks-example.png
deleted file mode 100644
index a5641fd..0000000
--- a/doc/src/tech-preview/images/mainwindow-docks-example.png
+++ /dev/null
diff --git a/doc/src/tech-preview/images/mainwindow-docks.png b/doc/src/tech-preview/images/mainwindow-docks.png
deleted file mode 100644
index 96dafc3..0000000
--- a/doc/src/tech-preview/images/mainwindow-docks.png
+++ /dev/null
diff --git a/doc/src/tech-preview/images/plaintext-layout.png b/doc/src/tech-preview/images/plaintext-layout.png
deleted file mode 100644
index 9a0f9c1..0000000
--- a/doc/src/tech-preview/images/plaintext-layout.png
+++ /dev/null
diff --git a/doc/src/tech-preview/known-issues.html b/doc/src/tech-preview/known-issues.html
deleted file mode 100644
index 885104e..0000000
--- a/doc/src/tech-preview/known-issues.html
+++ /dev/null
@@ -1,110 +0,0 @@
-<html>
-<head>
-<title>Known issues</title>
-<link rel="stylesheet" href="http://qtsoftware.com/trollstyle.css">
-<style type="text/css">
-    H2 { position: relative; top: 10px; }
-    H4 { margin-left: 15px; }
-    .issue { margin-left: 15px; }
-    .workaround { margin-left: 30px; margin-right: 30px; padding: 2px; border-style: solid; border-color: #AACA00; border-width: 1px; }
-</style>
-</head>
-<body bgcolor="#ffffff">
-<table border="0" cellpadding="0" cellspacing="0" width="100%">
-    <tr bgcolor="#E5E5E5">
-        <td><img src="http://doc.trolltech.com/doctitle.png" width="443" height="32" border="0"></td>
-        <td align="right" valign="middle"></td></tr></table>
-<h1>Known Issues: Qt 4.0.0 Technology Preview 1</h1>
-<p>
-    This is the list of known and reported issues for the Qt 4.0.0 
-    Technology Preview 1. This list is updated daily.
-</p>
-<br><br>
-<table width="100%">
-    <tr><td align="left"><b><a href="#buildissues">Build Issues</a></b></td></tr>
-    <tr><td align="left"><b><a href="#general">General</a></b></td></tr>
-    <tr><td align="left"><b><a href="#demos">Demos</a></b></td></tr>
-    <tr><td align="left"><b><a href="#window">Windows specific</a></b></td></tr>
-    <tr><td align="left"><b><a href="#x11">X11 specific</a></b></td></tr>
-    <tr><td align="left"><b><a href="#mac">Mac specific</a></b></td></tr>
-</table>
-<br><br>
-<!-- Build section ------------------------------------------------- -->
-<a name="buildissues"></a>
-<h2>Build Issues</h2>
-    <h4>Static libraries on Mac OS X</h4>
-    <p class="issue">Building a static build on mac will fail the first time.</p>
-    <p class="workaround">Run qmake a second time.</p>
-    
-    <h4>QTDIR</h4>
-    <p class="issue">Some applications(e.g. uic3) need QTDIR set and QTDIR/bin in the path to work.</p>
-    <p class="workaround">Set QTDIR and PATH as described in INSTALL.</p>
-
-    <h4>ODBC driver on Windows</h4>
-    <p class="issue">Problems compiling the ODBC driver.</p>
-    <p class="workaround">Change the include from qapplication.h to qcoreapplication.h</p>
-
-    <h4>QtGui does not link because of accessibility errors</h4>
-    <p class="issue">undefined reference to QAccessible::setRootObject(QObject*)</p>
-    <p class="workaround">Rerun configure and rebuild, if that does not help, add the contents of $QTDIR/.qt.config to $QTDIR/.qmake.cache</p>
-
-
-<!-- General section ---------------------------------------------- -->
-<a name="general"></a>
-<h2>General</h2>
-
-    <h4>No connection to Oracle</h4>
-    <p class="issue">I cannot connect to my Oracle server</p>
-    <p class="workaround">Use the Oracle &gt;= 9 client libraries, currently there is no workaround for OCI 8</p>
-
-    <h4>QSqlModel</h4>
-    <p class="issue">Only the first 16 rows from a database result are displayed</p>
-    <p class="workaround">You are using a database driver which does not report back the size of a result set and incremental fetching is not yet implemented in the itemviews. You can either use another database like MySQL or increase the QSQL_PREFETCH in qsqlmodel.cpp</p>
-
-
-<!-- Demos section ------------------------------------------------- -->
-<a name="demos"></a>
-<h2>Demos</h2>
-
-    <h4>-</h4>
-
-
-<!-- Windows platform section -------------------------------------- -->
-<a name="window"></a>
-<h2>Windows specific</h2>
-
-    <h4>Qt Assistant</h4>
-    <p class="issue">Problems with zooming and laying out text. Sometimes the text overlaps.</p>
-
-    <h4>GDI handle leak</h4>
-    <p class="issue">Setting fonts through QPainter::setFont() leaks GDI
-    handles on windows. This is for instance visible in the OpenGL
-    part of the Arthur demo. The issue will be fixed before the next
-    preview.</p>
-
-<!-- X11 platform section ------------------------------------------ -->
-<a name="x11"></a>
-<h2>X11 specific</h2>
-
-    <h4>-</h4>
-
-
-<!-- Mac platform section ------------------------------------------ -->
-<a name="mac"></a>
-<h2>Mac specific</h2>
-
-    <h4>QComboBox</h4>
-    <p class="issue">Does not have the native Mac look and feel yet. It is rendered in a Windows-like style.</p>
-
-    <h4>Clicking on widgets</h4>
-    <p class="issue"><i>Jaguar 10.2 only:</i> Clicking on widgets that has a focusrect may fail.</p>
-    <p class="workaround">Use 10.3 for now.</p>
-
-    
-<!-- [Page footer] ------------------------------------------------- -->
-<table width="100%">
-    <tr><td><hr size="1" noshade></td></tr>
-    <tr><td align="center" valign="bottom"><a href="http://qtsoftware.com">qtsoftware.com</a></td></tr>
-</table>
-</body>
-</html>
diff --git a/doc/src/threads.qdoc b/doc/src/threads.qdoc
index 8469f51..067de5f 100644
--- a/doc/src/threads.qdoc
+++ b/doc/src/threads.qdoc
@@ -362,13 +362,12 @@
     \section2 QObject Reentrancy
 
     QObject is reentrant. Most of its non-GUI subclasses, such as
-    QTimer, QTcpSocket, QUdpSocket, QHttp, QFtp, and QProcess, are
-    also reentrant, making it possible to use these classes from
-    multiple threads simultaneously. Note that these classes are
-    designed to be created and used from within a single thread;
-    creating an object in one thread and calling its functions from
-    another thread is not guaranteed to work. There are three
-    constraints to be aware of:
+    QTimer, QTcpSocket, QUdpSocket, QFtp, and QProcess, are also
+    reentrant, making it possible to use these classes from multiple
+    threads simultaneously. Note that these classes are designed to be
+    created and used from within a single thread; creating an object
+    in one thread and calling its functions from another thread is not
+    guaranteed to work. There are three constraints to be aware of:
 
     \list
     \o \e{The child of a QObject must always be created in the thread
diff --git a/doc/src/topics.qdoc b/doc/src/topics.qdoc
index 7f832ab..15be0ade 100644
--- a/doc/src/topics.qdoc
+++ b/doc/src/topics.qdoc
@@ -150,18 +150,6 @@ These guides provide specific help about specific Qt-related topics.
 */
 
 /*!
-\group licensing
-\title Licensing Information
-\ingroup topics
-\brief Information about licenses and licensing issues.
-
-These documents include information about Qt's licenses and the licenses
-of third party components used in Qt.
-
-\generatelist{related}
-*/
-
-/*!
 \group platform-notes
 \title Platform-Specific Notes
 \ingroup topics
diff --git a/doc/src/trolltech-webpages.qdoc b/doc/src/trolltech-webpages.qdoc
index 7d48167..abbe4e0 100644
--- a/doc/src/trolltech-webpages.qdoc
+++ b/doc/src/trolltech-webpages.qdoc
@@ -165,11 +165,6 @@
 */
 
 /*!
-    \externalpage http://www.qtsoftware.com/developer/supported-platforms/supported-platforms/
-    \title Qt 4 Supported Platforms
-*/
-
-/*!
     \externalpage http://www.qtsoftware.com/products/qtopia/
     \title Qt Extended
 */
@@ -243,3 +238,8 @@
     \externalpage http://www.qtsoftware.com/developer/faqs/qt/installation
     \title Installation FAQ
 */
+
+/*!
+    \externalpage http://qt.gitorious.org
+    \title Public Qt Repository
+*/
diff --git a/doc/src/tutorials/addressbook-fr.qdoc b/doc/src/tutorials/addressbook-fr.qdoc
index 78f6821..739f047 100644
--- a/doc/src/tutorials/addressbook-fr.qdoc
+++ b/doc/src/tutorials/addressbook-fr.qdoc
@@ -220,7 +220,7 @@
     On remarque que le label \c AddressLabel est positionné en utilisant Qt::AlignTop
     comme argument optionnel. Ceci est destiné à assurer qu'il ne sera pas centré
     verticalement dans la cellule (1,0). Pour un aperçu rapide des layouts de Qt,
-    consultez la section \l{Layout Classes}.
+    consultez la section \l{Layout Management}.
 
     Afin d'installer l'objet layout dans un widget, il faut appeler la méthode
     \l{QWidget::setLayout()}{setLayout()} du widget en question:
diff --git a/doc/src/tutorials/addressbook.qdoc b/doc/src/tutorials/addressbook.qdoc
index 95394eb..fd08bfe 100644
--- a/doc/src/tutorials/addressbook.qdoc
+++ b/doc/src/tutorials/addressbook.qdoc
@@ -222,8 +222,8 @@
 
     Notice that \c addressLabel is positioned using Qt::AlignTop as an
     additional argument. This is to make sure it is not vertically centered in
-    cell (1,0). For a basic overview on Qt Layouts, refer to the \l{Layout Classes}
-    document.
+    cell (1,0). For a basic overview on Qt Layouts, refer to the 
+    \l{Layout Management} documentation.
 
     In order to install the layout object onto the widget, we have to invoke
     the widget's \l{QWidget::setLayout()}{setLayout()} function: