Long live Qt 4.5!

1 files changed, 4215 insertions, 0 deletions

diff --git a/doc/src/porting4.qdoc b/doc/src/porting4.qdoc
new file mode 100644
index 0000000..c8a9e2b
--- /dev/null
+++ b/doc/src/porting4.qdoc
@@ -0,0 +1,4215 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page porting4.html
+    \title Porting to Qt 4
+    \contentspage {Porting Guides}{Contents}
+    \previouspage Porting Guides
+    \nextpage Porting to Qt 4 - Virtual Functions
+    \ingroup porting
+    \brief An overview of issues and techniques to consider when porting from Qt 3 to Qt 4.
+
+\omit
+    ### QFileInfo::PermissionSpec -> QFile::Permission(s?)
+    ### refer to porting4-renamedfunctions.qdoc
+    ### QApplication library mutex is gone
+    ### no integral conversion for containers? strings?
+    ### QVector etc. are initialized to 0 by default?
+    ### How to port from Qt 2.3 to Qt 4.
+    ### missing sort() functions?
+    ### QToolTipGroup
+    ### QServerSocket -> Q3ServerSocket
+
+    ### remove these when the classes are re-ported
+
+    ### QApplication::eventLoop()
+
+    \row \o void QCheckListItem::paintCell(QPainter *, const QColorGroup &, int, int, int)\row \o void Q3CheckListItem::paintCell(QPainter *, const QPalette &, int, int, int)
+    \row \o void QCheckListItem::paintFocus(QPainter *, const QColorGroup &, const QRect &) \o void Q3CheckListItem::paintFocus(QPainter *, const QPalette &, const QRect &)
+    \row \o QDataTable: a whole bunch of virtual functions have a different signature
+
+    <     Function: void QIconViewItem::paintFocus(QPainter *, const QColorGroup &)
+    >     Function: void QIconViewItem::paintFocus(QPainter *, const QPalette &)
+
+    <     Function: void QIconViewItem::paintItem(QPainter *, const QColorGroup &)
+    >     Function: void QIconViewItem::paintItem(QPainter *, const QPalette &)
+
+    <     Function: bool QUrlOperator::checkValid()
+
+    <     Function: void QWSInputMethod::setFont(const QFont &)
+
+    ### OpenMode or OpenMode
+
+    ### QWSDecoration
+\endomit
+
+    This document describes the process of porting applications from
+    Qt 3 to Qt 4.
+    If you haven't yet made the decision about porting, or are unsure
+    about whether it is worth it, take a look at the \l{What's New in
+    Qt 4}{key features} offered by Qt 4. See also
+    \l{Moving from Qt 3 to Qt 4} for tips on how to write Qt 3 code
+    that is easy to port to Qt 4.
+
+    \bold{Other porting guides:}
+
+    \list
+    \o \l{Moving from Qt 3 to Qt 4} \mdash covers some high level topics relevant
+       to developers porting from Qt 3 to Qt 4.
+    \o \l{Porting to Qt 4 - Drag and Drop} \mdash covers differences in the
+       way drag and drop is handled between Qt 3 and Qt 4.
+    \o \l{Porting .ui Files to Qt 4} \mdash describes the new format used to
+       describe forms created with \QD.
+    \o \l{Porting to Graphics View} \mdash provides a class-by-class overview
+       of the differences between Qt 3's canvas API and Qt 4's Graphics
+       View framework.
+    \o \l{qt3to4 - The Qt 3 to 4 Porting Tool} \mdash provides an overview
+       of a tool aimed at helping developers start the process of porting an
+       application to Qt 4.
+    \endlist
+
+    The Qt 4 series is not binary compatible with the 3 series. This
+    means programs compiled for Qt 3 must be recompiled to work with
+    Qt 4. Qt 4 is also not completely \e source compatible with 3,
+    however nearly all points of incompatibility cause compiler
+    errors or run-time messages (rather than mysterious results). Qt
+    4 includes many additional features and discards obsolete
+    functionality. Porting from Qt 3 to Qt 4 requires some effort,
+    but once completed the considerable additional power and
+    flexibility of Qt 4 is available for use in your applications.
+
+    To port code from Qt 3 to Qt 4:
+
+    \list 1
+
+    \o Briefly read the porting notes below to get an idea of what to expect.
+
+    \o Be sure that your code compiles and runs well on all your target
+       platforms with Qt 3.
+
+    \o Add the line \c{QT += qt3support} to your \c .pro file if you use
+       \c qmake; otherwise, edit your makefile or project file to
+       link against the Qt3Support library and add \c -DQT3_SUPPORT to your
+       compiler flags. (You might also need to specify other
+       libraries. See \l{What's New in Qt 4} for details.)
+
+    \o Run the \l qt3to4 porting tool. The tool will go through your
+       source code and adapt it to Qt 4.
+
+    \o Follow the instructions in the \l{Porting .ui Files to Qt 4}
+       page to port Qt Designer files.
+
+    \o Recompile with Qt 4. For each error, search below for related
+       identifiers (e.g., function names, class names). This document
+       mentions all relevant identifiers to help you get the information
+       you need at the cost of being a little verbose.
+
+    \endlist
+
+    The \l qt3to4 porting tool replaces occurrences of Qt 3 classes
+    that don't exist anymore in Qt 4 with the corresponding Qt 3
+    support class; for example, \c QListBox is turned into \c
+    Q3ListBox.
+
+    At some point, you might want to stop linking against the Qt 3
+    support library (\l{Qt3Support}) and take advantage of Qt 4's
+    new features. The instructions below explain how to do that for
+    each compatibility class.
+
+    In addition to the Qt3Support classes (such as \c Q3Action, \c
+    Q3ListBox, and \c Q3ValueList), Qt 4 provides compatibility
+    functions when it's possible for an old API to cohabit with the
+    new one. For example, QString provides a
+    QString::simplifyWhiteSpace() compatibility function that's
+    implemented inline and that simply calls QString::simplified().
+    \bold{The compatibility functions are not documented here; instead,
+    they are documented for each class.}
+
+    If you have the line \c{QT += qt3support} in your \c .pro file, \c
+    qmake will automatically define the \c QT3_SUPPORT symbol, turning
+    on compatibility function support. You can also define the symbol
+    manually (e.g., if you don't want to link against the \c
+    Qt3Support library), or you can define \c QT3_SUPPORT_WARNINGS
+    instead, telling the compiler to emit a warning when a
+    compatibility function is called. (This works only with GCC 3.2+
+    and MSVC 7.)
+
+    If you get stuck, ask on the
+    \l{http://lists.trolltech.com/qt-interest/}{qt-interest}
+    mailing list. If you are a licensed customer, you can also contact
+    Qt's technical support team.
+
+\omit
+    ### what to do with slots that aren't slots anymore
+    ### what to do with virtual functions that aren't virtual anymore
+    ### what to do with virtual functions that changed signature
+\endomit
+
+\omit
+    ### <qtl.h> -- stuff that vanished?
+    ### implicit sharing
+    ### uint -> int indexes
+\endomit
+
+    Table of contents:
+
+    \tableofcontents{4}
+
+\omit
+    \section1 Header Files
+
+    ### New style of headers
+
+    \table
+    \header \o Old header \o New header
+    \row \o \c{<qtl.h>} \o \c{<qalgorithms.h>} or \c{<QtAlgorithms>}
+    \endtable
+
+    ### Some headers don't include each other anymore...
+\endomit
+
+    \section1 Casting and Object Types
+
+    In Qt 3, it was possible to use the \c qt_cast() function to determine
+    whether instances of QObject subclasses could be safely cast to derived
+    types of those subclasses. For example, if a QFrame instance is passed
+    to a function whose signature specifies a QWidget pointer as its argument,
+    \c qt_cast() could be used to obtain a QFrame pointer so that the
+    instance's functions can be accessed.
+
+    In Qt 4, much of this functionality is provided by the qobject_cast()
+    function, and additional functions also provide similar functionality for
+    certain non-QObject types:
+
+    \table
+    \header \o Qt 3 function \o Qt 4 function
+    \row    \o T *qt_cast<T *>(QObject *) \o \l{qobject_cast()}{T *qobject_cast<T *>(QObject *)}
+    \row    \o                            \o \l{qgraphicsitem_cast()}{T qgraphicsitem_cast<T>(QGraphicsItem *)}
+    \row    \o                            \o \l{qstyleoption_cast()}{T qstyleoption_cast<T>(QStyleOption *)}
+    \row    \o                            \o \l{qvariant_cast()}{T qvariant_cast<T>(const QVariant &)}
+    \row    \o                            \o \l{qdbus_cast()}{T qdbus_cast(const QDBusArgument &)}
+    \endtable
+
+\omit
+    \section1 Global Functions
+
+    \table
+    \header \o Qt 3 function \o Qt 4 function
+    \row \o cstrcmp() \o strcmp()
+    \row \o cstrcpy() \o strcpy()
+    \row \o cstrlen() \o strlen()
+    \row \o cstrncmp() \o strncmp()
+    \row \o qmemmove() \o memmove()
+    \endtable
+
+    qGLVersion() ###
+
+    copyBlt() ###
+    bitBlt()
+
+    #ifdef compat classes:
+        * QLayoutIterator
+        * QColorGroup
+        * QMenuItem
+
+    QWidget visibleRect property compat
+    QWidget::BackgroundOrigin compat
+\endomit
+
+    \section1 Type Names
+
+    The table below lists the classes that have been renamed in Qt 4.
+    If you compile your applications with \c QT3_SUPPORT defined, the
+    old names will be available.
+
+    Whenever you see an occurrence of the name on the left, you can
+    safely replace it with the Qt 4 equivalent in your program. The
+    \l qt3to4 tool performs the conversion automatically.
+
+    \table
+    \header \o Qt 3 class name \o Qt 4 class name
+    \input porting4-renamedclasses.qdocinc
+    \endtable
+
+    The table below lists the enums and typedefs that have been
+    renamed in Qt 4. If you compile your applications with \c
+    QT3_SUPPORT defined, the old names will be available.
+
+    Whenever you see an occurrence of the name on the left, you can
+    safely replace it with the Qt 4 equivalent in your program. The
+    \l qt3to4 tool performs the conversion
+    automatically.
+
+    \table
+    \header \o Qt 3 type name \o Qt 4 type name
+    \input porting4-renamedtypes.qdocinc
+    \endtable
+
+    \omit
+    ###
+    \row \o QButton::ToggleState \o Use QCheckBox::ToggleState instead.
+    \endomit
+
+    \section1 Enum Values
+
+    The table below lists the enum values that have been renamed in
+    Qt 4. If you compile your applications with \c QT3_SUPPORT defined,
+    the old names will be available.
+
+    Whenever you see an occurrence of the name on the left, you can
+    safely replace it with the Qt 4 equivalent in your program. The
+    \l qt3to4 tool performs the conversion automatically.
+
+    \table
+    \header \o Qt 3 enum value name \o Qt 4 enum value name
+    \input porting4-renamedenumvalues.qdocinc
+    \endtable
+
+    In addition, the following \l{Qt::WindowFlags}{window flags} have
+    been either replaced with \l{Qt::WidgetAttribute}{widget
+    attributes} or have been deprecated:
+
+    \table
+    \header \o Qt 3 type \o Qt 4 equivalent
+    \row \o Qt::WDestructiveClose \o Use QWidget::setAttribute(Qt::WA_DeleteOnClose) instead.
+    \row \o Qt::WStaticContents \o{1,2} Use QWidget::setAttribute(Qt::WA_StaticContents) instead.
+    \row \o Qt::WNorthWestGravity
+    \row \o Qt::WNoAutoErase \o{1,3} Use QWidget::setAttribute(Qt::WA_NoBackground) instead.
+    \row \o Qt::WResizeNoErase
+    \row \o Qt::WRepaintNoErase
+    \row \o Qt::WPaintClever \o Unnecessary in Qt 4.
+         \omit ### Check with Matthias \endomit
+    \row \o Qt::WMacNoSheet \o Unnecessary in Qt 4.
+         \omit ### Check with Sam \endomit
+    \endtable
+
+    In Qt 4.1, the widget flags used to determine window modality were
+    replaced by a single enum that can be used to specify the modal
+    behavior of top-level widgets:
+
+    \table
+    \header \o Qt 3 type \o Qt 4 equivalent
+    \row \o Qt::WShowModal \o Use QWidget::setWindowModality(Qt::ApplicationModal) instead.
+    \row \o Qt::WGroupLeader \o Use QWidget::setWindowModality(Qt::WindowModal)
+         for each child dialog of the group leader, but do not change the modality
+         of the group leader itself.
+    \endtable
+
+    \target properties
+    \section1 Properties
+
+    Some properties have been renamed in Qt 4, to make Qt's API more
+    consistent and more intuitive. For example, QWidget's \c caption
+    property has been renamed \c windowTitle to make it clear that it
+    refers to the title shown in the window's title bar.
+
+    In addition, the property system has been extended to allow
+    properties to be redefined in subclasses with the \l Q_PROPERTY()
+    macro, removing the need for a \c Q_OVERRIDE() macro.
+
+    The table below lists the Qt properties that have been renamed in
+    Qt 4. Occurrences of these in \e{Qt Designer} \c .ui files are
+    automatically converted to the new name by \c uic.
+
+    \table
+    \header \o Qt 3 name \o Qt 4 name
+    \row \o QButton::accel \o QButton::shortcut
+    \row \o QButton::on \o QButton::checked
+    \row \o QButton::toggleButton \o QAbstractButton::checkable
+    \row \o QDial::lineStep \o QDial::singleStep
+    \row \o QDial::maxValue \o QDial::maximum
+    \row \o QDial::minValue \o QDial::minimum
+    \row \o QDialog::modal \o QDialog::isModal
+    \row \o QLineEdit::edited \o QLineEdit::modified
+    \row \o QLineEdit::hasMarkedText \o QLineEdit::hasSelectedText
+    \row \o QLineEdit::markedText \o QLineEdit::selectedText
+    \row \o QObject::name \o QObject::objectName
+    \row \o QProgressDialog::progress \o QProgressDialog::value
+    \row \o QProgressDialog::totalSteps \o QProgressDialog::maximum
+    \row \o QProgressDialog::wasCancelled \o QProgressDialog::wasCanceled
+    \row \o QPushButton::iconSet \o QPushButton::icon
+    \row \o QScrollBar::draggingSlider \o QScrollBar::sliderDown
+    \row \o QScrollBar::lineStep \o QScrollBar::singleStep
+    \row \o QScrollBar::maxValue \o QScrollBar::maximum
+    \row \o QScrollBar::minValue \o QScrollBar::minimum
+    \row \o QSlider::lineStep \o QSlider::singleStep
+    \row \o QSlider::maxValue \o QSlider::maximum
+    \row \o QSlider::minValue \o QSlider::minimum
+    \row \o QSpinBox::lineStep \o QSpinBox::singleStep
+    \row \o QSpinBox::maxValue \o QSpinBox::maximum
+    \row \o QSpinBox::minValue \o QSpinBox::minimum
+    \row \o QTabBar::currentTab \o QTabBar::currentIndex
+    \row \o QTabWidget::currentPage \o QTabWidget::currentWidget
+    \row \o QToolButton::iconSet \o QToolButton::icon
+    \row \o QToolButton::textLabel \o QToolButton::text
+    \row \o QWidget::caption \o QWidget::windowTitle
+    \row \o QWidget::icon \o QWidget::windowIcon
+    \row \o QWidget::iconText \o QWidget::windowIconText
+    \endtable
+
+    A handful of properties in Qt 3 are no longer properties in Qt 4,
+    but the access functions still exist as part of the Qt 4 API.
+    These are not used by \e{Qt Designer}; the only case where you
+    need to worry about them is in highly dynamic applications that
+    use Qt's meta-object system to access properties. Here's the list
+    of these properties with the read and write functions that you
+    can use instead:
+
+    \table
+    \header \o Qt 3 property \o Qt 4 read function \o Qt 4 write function
+    \row \o QSqlDatabase::connectOptions \o QSqlDatabase::connectOptions() \o QSqlDatabase::setConnectOptions()
+    \row \o QSqlDatabase::databaseName \o QSqlDatabase::databaseName() \o QSqlDatabase::setDatabaseName()
+    \row \o QSqlDatabase::hostName \o QSqlDatabase::hostName() \o QSqlDatabase::setHostName()
+    \row \o QSqlDatabase::password \o QSqlDatabase::password() \o QSqlDatabase::setPassword()
+    \row \o QSqlDatabase::port \o QSqlDatabase::port() \o QSqlDatabase::setPort()
+    \row \o QSqlDatabase::userName \o QSqlDatabase::userName() \o QSqlDatabase::setUserName()
+    \endtable
+
+    Some properties have been removed from Qt 4, but the associated
+    access functions are provided if \c QT3_SUPPORT is defined to help
+    porting to Qt 4. When converting Qt 3 \c .ui files to Qt 4, \c uic
+    generates calls to the Qt 3 compatibility functions. Note that
+    this only applies to the properties of the Qt3Support library,
+    i.e. \c QT3_SUPPORT properties of the other libraries must be
+    ported manually when converting Qt 3 .ui files to Qt 4.
+
+    The table below lists these properties with the read and write
+    functions that you can use instead. The documentation for the
+    individual functions explains how to replace them with
+    non-compatibility Qt 4 functions.
+
+    \table
+    \header \o Qt 3 property \o Qt 4 read function (\c QT3_SUPPORT)\o Qt 4 write function (\c QT3_SUPPORT)
+    \row \o QMenuBar::separator \o QMenuBar::separator() \o QMenuBar::setSeparator()
+    \row \o QPushButton::menuButton \o QPushButton::isMenuButton() \o N/A
+    \row \o QTabWidget::margin \o QTabWidget::margin() \o QTabWidget::setMargin()
+    \row \o QTextEdit::textFormat \o QTextEdit::textFormat() \o QTextEdit::setTextFormat()
+    \row \o QWidget::backgroundBrush \o QWidget::backgroundBrush() \o N/A
+    \row \o QWidget::backgroundMode \o QWidget::backgroundMode() \o QWidget::setBackgroundMode()
+    \row \o QWidget::backgroundOrigin \o QWidget::backgroundOrigin() \o QWidget::setBackgroundOrigin()
+    \row \o QWidget::colorGroup \o QWidget::colorGroup() \o QWidget::setColorGroup()
+    \row \o QWidget::customWhatsThis \o QWidget::customWhatsThis() \o QWidget::setCustomWhatsThis()
+    \row \o QWidget::inputMethodEnabled \o QWidget::inputMethodEnabled() \o QWidget::setInputMethodEnabled()
+    \row \o QWidget::ownCursor \o QWidget::ownCursor() \o N/A
+    \row \o QWidget::ownFont \o QWidget::ownFont() \o N/A
+    \row \o QWidget::ownPalette \o QWidget::ownPalette() \o N/A
+    \row \o QWidget::paletteBackgroundColor \o QWidget::paletteBackgroundColor() \o QWidget::setPaletteBackgroundColor()
+    \row \o QWidget::paletteBackgroundPixmap \o QWidget::paletteBackgroundPixmap() \o QWidget::setPaletteBackgroundPixmap()
+    \row \o QWidget::paletteForegroundColor \o QWidget::paletteForegroundColor() \o QWidget::setPaletteForegroundColor()
+    \row \o QWidget::underMouse \o QWidget::underMouse() \o N/A
+    \endtable
+
+    The following Qt 3 properties and their access functions are no
+    longer available in Qt 4. In most cases, Qt 4 provides similar
+    functionality.
+
+    \table
+    \header \o Qt 3 property \o Qt 4 equivalent
+    \row \o QButton::autoRepeat \o N/A
+    \row \o QButton::autoResize \o Call QWidget:setFixedSize(QWidget::sizeHint()) whenever you change the contents.
+    \row \o QButton::exclusiveToggle \o See \l QAbstractButton::autoExclusive.
+    \row \o QButton::pixmap \o Use QAbstractButton::icon instead.
+    \row \o QButton::toggleState \o Use QCheckBox::setState() and QCheckBox::state() instead.
+    \row \o QButton::toggleType \o Use QCheckBox::setTristate() instead.
+    \row \o QComboBox::autoResize \o Call QWidget:setFixedSize(QWidget::sizeHint()) whenever you change the contents.
+    \row \o QFrame::contentsRect \o Use Q3Frame::contentsRect() instead.
+    \row \o QFrame::margin \o Use QWidget::setContentsMargins() instead.
+    \row \o QTabBar::keyboardFocusTab \o N/A
+    \row \o QToolButton::offIconSet \o Use the \l{QIcon::Off}{off component} of QAbstractButton::icon instead.
+    \row \o QToolButton::onIconSet \o Use the \l{QIcon::On}{on component} of QAbstractButton::icon instead.
+    \row \o QWidget::microFocusHint \o N/A
+    \endtable
+
+\omit
+    \section1 Inheritance Chain
+
+    ### QMenuBar, etc.
+
+    \section1 Null vs. Empty
+
+    ###
+\endomit
+
+    \section1 Explicit Sharing
+
+    Qt 4 is the first version of Qt that contains no \link
+    http://doc.trolltech.com/3.3/shclass.html explicitly shared
+    \endlink classes. All classes that were explicitly shared in Qt 3
+    are \e implicitly shared in Qt 4:
+
+    \list
+    \o QImage
+    \o QBitArray
+    \o QByteArray
+    \o Q3PointArray
+    \endlist
+
+    This means that if you took a copy of an instance of the class
+    (using operator=() or the class's copy constructor), any
+    modification to the copy would affect the original and vice
+    versa. Needless to say, this behavior is rarely desirable.
+
+    Fortunately, nearly all Qt 3 applications don't rely on explicit
+    sharing. When porting, you typically only need to remove calls to
+    detach() and/or copy(), which aren't necessary anymore.
+
+    If you deliberately rely on explicit sharing in your application,
+    you can use pointers or references to achieve the same result in
+    Qt 4.
+
+    \oldcode
+        void asciify(QByteArray array)
+        {
+            for (int i = 0; i < (int)array.size(); ++i) {
+                if ((uchar)array[i] >= 128)
+                    array[i] = '?';
+            }
+        }
+    \newcode
+        void asciify(QByteArray &array)
+        {
+            for (int i = 0; i < array.size(); ++i) {
+                if ((uchar)array[i] >= 128)
+                    array[i] = '?';
+            }
+        }
+    \endcode
+
+    (Notice the \c & in the parameter declaration.)
+
+\omit
+    \section1 Qt Designer .ui Files
+
+    ###
+\endomit
+
+    \section1 Painting and Redrawing Widgets
+
+    When implementing custom widgets in Qt 3, it was possible to use
+    QPainter to draw on a widget outside paint events. This made it
+    possible to integrate Qt applications with third party libraries
+    and tools that impose their own rendering models. For example,
+    a widget might be repainted in a slot using data obtained from
+    an external source.
+
+    In Qt 4, it is only possible to paint on a widget from within its
+    \l{QWidget::}{paintEvent()} handler function. This restriction simplifies
+    Qt's interaction with native window systems, improves the performance
+    of applications by reducing the number of redraw operations, and
+    also enables features to be implemented to improve the appearance of
+    widgets, such as a backing store.
+
+    Generally, we recommend redesigning applications to perform all
+    painting operations in \l{QWidget::}{paintEvent()} functions, deferring
+    actual painting until the next time this function is called.
+    Applications can post paint events to trigger repaints, and it may be
+    possible to examine your widget's internal state to determine which
+    part of the widget needs to be repainted.
+
+    If asynchronous repaints are used extensively by your application,
+    and it is not practical to redesign the rendering model to perform
+    all painting operations from within a widget's \l{QWidget::}{paintEvent()}
+    function, it may be necessary to consider using an intermediate painting
+    step. In this approach, one or more images can be updated asynchronously
+    and painted on the widget in the paint event. To avoid excessive
+    buffering, it may be worthwhile disabling the backing store by setting
+    the widget's Qt::WA_PaintOnScreen widget attribute.
+
+    On certain platforms, the Qt::WA_PaintOutsidePaintEvent widget attribute
+    can be set to allow a widget to be painted from outside paint events.
+
+    \note Setting widget attributes to disable key features of Qt's widget
+    rendering model may also cause other features to be disabled.
+
+    \section1 QAccel
+
+    The \c QAccel class has been renamed Q3Accel and moved to the
+    Qt3Support module. In new applications, you have three options:
+
+    \list 1
+    \o You can use QAction and set a key sequence using QAction::setShortcut().
+    \o You can use QShortcut, a class that provides similar
+       functionality to Q3Accel.
+    \o You can use QWidget::grabShortcut() and process "shortcut"
+       events by reimplementing QWidget::event().
+    \endlist
+
+    The Q3Accel class also supports multiple accelerators using the
+    same object, by calling Q3Accel::insertItem() multiple times. In
+    Qt 4, the solution is to create multiple QShortcut objects.
+
+    \section1 QAccessibleInterface
+
+    The QAccessibleInterface class has undergone some API changes in
+    Qt 4, to make it more consistent with the rest of the Qt API.
+
+    If you have classes that inherit QAccessibleInterface or one of
+    its subclasses (QAccessibleObject, QAccessibleWidget, etc.), you
+    must port them the new QAccessibleInterface API.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions}
+    for a list of QAccessibleInterface virtual member functions in
+    Qt 3 that are no longer virtual in Qt 4.
+
+    \section1 QAccessibleTitleBar
+
+    The \c QAccessibleTitleBar has been renamed Q3AccessibleTitleBar
+    and moved to the Qt3Support library.
+
+    \target qaction.section
+    \section1 QAction
+
+    The QAction class has been redesigned in Qt 4 to integrate better
+    with the rest of the menu system. It unifies the old \c QMenuItem
+    class and the old \c QAction class into one class, avoiding
+    unnecessary data duplication and the need to learn two different
+    APIs.
+
+    The old \c QAction and \c QActionGroup classes have been renamed
+    Q3Action and Q3ActionGroup and moved to Qt3Support. In addition,
+    the new QAction class has compatibility functions to ease
+    transition to Qt 4. Note that when using Q3ToolBar and
+    Q3PopupMenu, their actions must be \l {Q3Action}s.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions}
+    for a list of QAction virtual member functions in Qt 3 that are
+    no longer virtual in Qt 4.
+
+    \section1 QActionGroup
+
+    The QAction class has been completely redesigned in Qt 4 to
+    integrate better with the rest of the menu system. See the
+    \l{#qaction.section}{section on QAction} for details.
+
+    \section1 QApplication
+
+    The QApplication class has been split into two classes:
+    QCoreApplication and QApplication. The new QApplication class
+    inherits QCoreApplication and adds GUI-related functionality. In
+    practice, this has no consequences for existing Qt applications.
+
+    In addition, the following API changes were made:
+
+    \list 1
+    \o  QApplication::allWidgets() and QApplication::topLevelWidgets()
+        used to return a pointer to a QWidgetList. Now they return a
+        QWidgetList.
+
+        Also, QWidgetList has changed from being a typedef for
+        QPtrList<QWidget> to being a typedef for QList<QWidget *>.
+        See the \l{#qwidgetlist.section}{section on QWidgetList} below
+        for details.
+
+        \oldcode
+            QWidgetList *list = QApplication::topLevelWidgets();
+            QWidgetListIt it(*list);
+            QWidget *widget;
+            while ((widget = it.current())) {
+                if (widget->inherits("MainWindow"))
+                    ((MainWindow *)widget)->updateRecentFileItems();
+                ++it;
+            }
+            delete list;
+        \newcode
+            QWidgetList list = QApplication::topLevelWidgets();
+            for (int i = 0; i < list.size(); ++i) {
+                if (MainWindow *mainWin = qobject_cast<MainWindow *>(list.at(i)))
+                    mainWin->updateRecentFileItems();
+            }
+        \endcode
+    \o QApplication::setMainWidget() is no longer used. When all an application's
+       windows are closed, the application will exit normally.
+    \endlist
+
+    \section1 QAquaStyle
+
+    The \c QAquaStyle class first appeared in Qt 3.0, when the Qt for
+    Mac OS X port was first released. It emulated Apple's "Aqua" theme.
+    In Qt 3.1, QAquaStyle was obsoleted by QMacStyle, which uses Appearance
+    Manager to perform its drawing.
+
+    The \c QAquaStyle class is no longer provided in Qt 4. Use
+    QMacStyle instead.
+
+    \target qasciidict.section
+    \section1 QAsciiCache<T>
+
+    \c QAsciiCache<T> has been renamed Q3AsciiCache<T> and moved to
+    the Qt3Support library. It has been replaced by
+    QCache<QByteArray, T>.
+
+    For details, read the \l{#qcache.section}{section on QCache<T>},
+    mentally substituting QByteArray for QString.
+
+    \section1 QAsciiDict<T>
+
+    QAsciiDict<T> and QAsciiDictIterator<T> have been renamed
+    Q3AsciiDict<T> and Q3AsciiDictIterator<T> and moved to the
+    Qt3Support library. They have been replaced by the
+    more modern QHash<Key, T> and QMultiHash<Key, T> classes and
+    their associated iterator classes.
+
+    When porting old code that uses Q3AsciiDict<T> to Qt 4, there are
+    four classes that you can use:
+
+    \list
+    \o QMultiHash<QByteArray, T *>
+    \o QMultiHash<QByteArray, T>
+    \o QHash<QByteArray, T *>
+    \o QHash<QByteArray, T>
+    \endlist
+
+    For details, read the \l{#qdict.section}{section on QDict<T>},
+    mentally substituting QByteArray for QString.
+
+    \section1 QAsyncIO
+
+    The \c QAsyncIO class was used internally in Qt 2.x in
+    conjunction with QImageConsumer. It was obsoleted in Qt 3.0.
+
+    \input porting4-obsoletedmechanism.qdocinc
+
+    \section1 QBackInsertIterator
+
+    The undocumented \c QBackInsertIterator class has been removed
+    from the Qt library. If you need it in your application, feel
+    free to copy the source code from the Qt 3 \c <qtl.h> header
+    file.
+
+    \section1 QBitArray
+
+    In Qt 3, QBitArray inherited from QByteArray. In Qt 4, QBitArray
+    is a totally independent class. This makes very little difference
+    to the user, except that the new QBitArray doesn't provide any of
+    QByteArray's byte-based API anymore. These calls will result in a
+    compile-time error, except calls to QBitArray::truncate(), whose
+    parameter was a number of \e bytes in Qt 3 and a number of bits
+    in Qt 4.
+
+    QBitArray was an explicitly shared class in Qt 3. See \l{Explicit
+    Sharing} for more information.
+
+    The \c QBitVal class has been renamed QBitRef.
+
+    \section1 QButton
+
+    The \c QButton class has been replaced by QAbstractButton in Qt
+    4. Classes like QPushButton and QRadioButton inherit from
+    QAbstractButton. As a help when porting older Qt applications,
+    the Qt3Support library contains a Q3Button class
+    implemented in terms of the new QAbstractButton.
+
+    If you used the \c QButton class as a base class for your own
+    button type and want to port your code to the newer
+    QAbstractButton, you need to be aware that QAbstractButton has no
+    equivalent for the Q3Button::drawButton(QPainter *) virtual
+    function. The solution is to reimplement QWidget::paintEvent() in
+    your QAbstractButton subclass as follows:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 0
+
+    \table
+    \header \o Q3Button function \o QAbstractButton equivalent
+    \row \o Q3Button::autoResize() \o Call QWidget:setFixedSize(QWidget::sizeHint()) whenever you change the contents.
+    \row \o Q3Button::isExclusiveToggle() \o Use QAbstractButton::group() or QAbstractButton::autoExclusive() instead.
+    \row \o Q3Button::pixmap() const \o QAbstractButton::icon()
+    \row \o Q3Button::setAutoResize() \o N/A
+    \row \o Q3Button::setPixmap(const QPixmap &) \o QAbstractButton::setIcon(const QIcon &)
+    \row \o Q3Button::setState(ToggleState) \o See remark below
+    \row \o Q3Button::setToggleType(ToggleType) \o See remark below
+    \row \o Q3Button::state() \o See remark below
+    \row \o Q3Button::stateChanged(int) \o See remark below
+    \row \o Q3Button::toggleType() \o See remark below
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o In Qt 3, \c QButton had a "toggle type", which could be
+       QButton::SingleShot, QButton::Toggle, or QButton::Tristate.
+       The new QAbstractButton class doesn't support "tristate"
+       directly; this feature is implemented in QCheckBox instead.
+       The two other "toggle types" (\c QButton::SingleShot and \c
+       QButton::Toggle) are replaced by a QAbstractButton::checkable
+       property.
+    \o In Qt 3, QButton had a "toggle state", which could be \c
+       QButton::Off, \c QButton::NoChange, or \c QButton::On. In Qt
+       4, this mechanism has been moved to QCheckBox.
+    \endlist
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of \c QButton virtual member functions in Qt 3 that aren't
+    virtual in Qt 4.
+
+    See \l{#properties}{Properties} for a list of \c QButton properties
+    in Qt 3 that have changed in Qt 4.
+
+    \section1 QButtonGroup
+
+    The \c QButtonGroup class has been completely redesigned in Qt 4.
+    For compatibility, the old \c QButtonGroup class has been renamed
+    Q3ButtonGroup and has been moved to Qt3Support.
+    Likewise, the \c QHButtonGroup and \c QVButtonGroup convenience
+    subclasses have been renamed \c Q3HButtonGroup and \c Q3VButtonGroup and
+    moved to the Qt3Support library.
+
+    The old \c QButtonGroup, as well as Q3ButtonGroup, can be used in two ways:
+
+    \list 1
+    \o  The button group is the parent widget of a number of buttons,
+        i.e. the button group is the parent argument in the button
+        constructor. The buttons are assigned identifiers 0, 1, 2, etc.,
+        in the order they are created. A Q3ButtonGroup can display a frame
+        and a title because it inherits Q3GroupBox.
+    \o  The button group is an invisible widget and the contained
+        buttons have some other parent widget. In this usage, each
+        button must be manually inserted, using
+        Q3ButtonGroup::insert(), into the button group and given an
+        ID number.
+    \endlist
+
+    Unlike Q3ButtonGroup, the new QButtonGroup doesn't inherit
+    QWidget. It is very similar to a "hidden Q3ButtonGroup".
+
+    If you use a Q3ButtonGroup, Q3HButtonGroup, or Q3VButtonGroup as
+    a widget and want to port to Qt 4, you can replace it with
+    QGroupBox. In Qt 4, radio buttons with the same parent are
+    automatically part of an exclusive group, so you normally don't
+    need to do anything else. See also the
+    \l{#qgroupbox.section}{section on QGroupBox} below.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QButtonGroup virtual member functions in Qt 3 that are no
+    longer virtual in Qt 4.
+
+    \target qbytearray.section
+    \section1 QByteArray
+
+    In Qt 3, QByteArray was simply a typedef for QMemArray<char>. In
+    Qt 4, QByteArray is a class in its own right, with a higher-level
+    API in the style of QString.
+
+    Here are the main issues to be aware of when porting to Qt 4:
+
+    \list 1
+    \o  The QMemArray(int size) constructor has been replaced with
+        QByteArray(int size, char ch). The second argument specifies
+        which character should be used for initializing the array;
+        pass '\\0' if you have no specific needs.
+
+        \oldcode
+        QByteArray ba(64);
+        \newcode
+        QByteArray ba(64, '\0');
+        \endcode
+
+    \o  QMemArray::at() returned a non-const reference, whereas the
+        new QByteArray::at() returns a const value. Code like
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 1
+
+        will no longer compile. Instead, use QByteArray::operator[]:
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 2
+
+    \o  The QMemArray::contains(char) function has been renamed
+        QByteArray::count(char). In addition, there now exists a
+        QByteArray::contains(char) function that returns a boolean
+        value. Replace old calls to contains() with either count() or
+        contains(), depending on whether you care about the specific
+        number of occurrences of a character in the byte array or
+        only care about whether the array contains that character or
+        not.
+
+    \o  The new QByteArray has no assign() function. Calls to
+        QMemArray::assign(const QMemArray &) can be replaced by calls
+        to QByteArray::operator=(). Calls to QMemArray::assign(const
+        T *, uint) have no equivalent in Qt 4; if you use it, the
+        solution is either to use QByteArray::fromRawData() and to
+        call free() yourself to avoid a memory leak, or to use the
+        QByteArray(const char *, int) constructor, which will take a
+        deep copy of the data.
+
+    \o  QMemArray::bsearch() and QMemArray::sort() have no equivalent
+        in the new QByteArray class. Use \l qBinaryFind() and \l qSort()
+        if you need that functionality.
+    \endlist
+
+    QByteArray was an explicitly shared class in Qt 3. See
+    \l{Explicit Sharing} for more information.
+
+    \target qcache.section
+    \section1 QCache<T>
+
+    QCache<T> has been renamed Q3Cache<T> and moved to Qt3Support.
+    The new QCache class has a different API, and takes different
+    template parameters: QCache<Key, T>.
+
+    When porting to Qt 4, QCache<QString, T> is the obvious
+    substitute for Q3Cache<T>. The following table summarizes the API
+    differences.
+
+    \table
+    \header \o Q3Cache<T> function \o QCache<QString, T> equivalent
+    \row \o Q3Cache::Q3Cache(int maxCost, int size, bool caseSensitive) \o See remark below
+    \row \o Q3Cache::autoDelete() \o N/A
+    \row \o Q3Cache::count() \o QCache::count() or QCache::size() (equivalent)
+    \row \o Q3Cache::setAutoDelete() \o See remark below
+    \row \o Q3Cache::size() \o N/A
+    \row \o Q3Cache::statistics() \o N/A
+    \row \o Q3Cache::operator=() \o See remark below
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o  Q3Cache requires the user to allocate a specific number of
+        buckets by passing a prime number (17 by default) to the
+        constructor. In contrast, the new QCache's hash table
+        automatically grows and shrinks as needed, and the
+        constructor doesn't take a prime number.
+
+    \o  Q3Cache supportes case-insensitive lookups by passing false as
+        second argument to the constructor. This feature has no
+        equivalent in QMultiHash. Instead, call QString::toLower()
+        before you insert or lookup a key in the hash.
+
+    \o  The Q3Cache::insert() function returns a \c bool value that
+        indicates whether or not the item actually was inserted in
+        the cache. If the item wasn't inserted, it was the caller's
+        responsibility to delete the item. The new QCache::insert()
+        function returns \c void and either adds it to the cache or
+        deletes it right away. Old code like
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 3
+
+    becomes
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 4
+
+    \o  The new QCache class \e always takes ownership of the items
+        it stores (i.e. auto-delete is always on). If you use Q3Cache
+        with auto-delete turned off (the rarely useful default), you
+        cannot use QCache as a direct substitute. One unelegant trick
+        that works well in practice is to use QCache<QString, T *>
+        instead of QCache<QString, T>. In that case, QCache owns the
+        pointers, not the objects that the pointers refer to. For
+        example,
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 5
+
+        becomes
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 6
+
+        An alternative is to stick to using Q3Cache.
+    \endlist
+
+    QCacheIterator<T> has been renamed Q3CacheIterator<T> and moved
+    to the Qt3Support library. The new QCache class
+    doesn't offer any iterator types.
+
+    \section1 QCanvas
+
+    The canvas module classes have been
+    renamed and moved to the Qt3Support library.
+
+    \table
+    \header \o Qt 3 class name \o Compatibility class in Qt 4
+    \row \o \c QCanvas \o Q3Canvas
+    \row \o \c QCanvasEllipse \o Q3CanvasEllipse
+    \row \o \c QCanvasItem \o Q3CanvasItem
+    \row \o \c QCanvasItemList \o Q3CanvasItemList
+    \row \o \c QCanvasLine \o Q3CanvasLine
+    \row \o \c QCanvasPixmap \o Q3CanvasPixmap
+    \row \o \c QCanvasPixmapArray \o Q3CanvasPixmapArray
+    \row \o \c QCanvasPolygon \o Q3CanvasPolygon
+    \row \o \c QCanvasPolygonalItem \o Q3CanvasPolygonalItem
+    \row \o \c QCanvasRectangle \o Q3CanvasRectangle
+    \row \o \c QCanvasSpline \o Q3CanvasSpline
+    \row \o \c QCanvasSprite \o Q3CanvasSprite
+    \row \o \c QCanvasText \o Q3CanvasText
+    \row \o \c QCanvasView \o Q3CanvasView
+    \endtable
+
+    \l{The Graphics View Framework} replaces QCanvas. For more on porting to
+    Graphics View, see \l{Porting to Graphics View}.
+
+    \section1 QColor
+
+    In Qt 4, QColor is a value type like QPoint or QRect. Graphics
+    system-specific code has been implemented in QColormap.
+
+    The \c QColor::maxColors() function has been replaced
+    by QColormap::size().
+
+    The \c QColor::numBitPlanes() function has been replaced
+    by QColormap::depth().
+
+    The \c QColor::setNamedColor() function no longer supports
+    the named color in the same way as Qt 3. Qt 4's
+    \l{QColor::}{setNamedColor()} uses the new W3C convention
+    as stated 
+    \l{http://www.w3.org/TR/SVG/types.html#ColorKeywords}{here}.
+
+    \table
+    \header \o{4,1} Predefined Qt Colors
+    \row \o Qt::color0 \o Qt::color1 \o Qt::black \o Qt::white
+    \row \o Qt::darkGray \o Qt::gray \o Qt::lightGray \o Qt::red
+    \row \o Qt::green \o Qt::blue \o Qt::cyan \o Qt::magenta
+    \row \o Qt::yellow \o Qt::darkRed \o Qt::darkGreen \o Qt::darkBlue
+    \row \o Qt::darkCyan \o Qt::darkMagenta \o Qt::darkYellow \o Qt::transparent
+    \endtable
+
+    The predefined colors listed in the table above were static
+    QColor objects in Qt 3. In Qt 4, they are enum values of type
+    Qt::GlobalColor. Thanks to the implicit QColor(Qt::GlobalColor)
+    constructor, the enum values are automatically converted to
+    \l{QColor}s in most contexts. Occasionally, you might need a
+    cast.
+
+    \oldcode
+        QColor lightCyan = Qt::cyan.light(180);
+    \newcode
+        QColor lightCyan = QColor(Qt::cyan).light(180);
+    \endcode
+
+    \section1 QColorGroup
+
+    In Qt 3, a QPalette consisted of three QColorGroup objects. In Qt
+    4, the (rarely used) QColorGroup abstraction has been eliminated.
+    For source compatibility, a QColorGroup class is available when
+    \c QT3_SUPPORT is defined.
+
+    The new QPalette still works in terms of color groups, specified
+    through enum values (QPalette::Active, QPalette::Disabled, and
+    QPalette::Inactive). It also has the concept of a \e current
+    color group, which you can set using
+    QPalette::setCurrentColorGroup().
+
+    The QPalette object returned by QWidget::palette() returns a
+    QPalette initialized with the correct current color group for the
+    widget. This means that if you had code like
+
+    \badcode
+        painter.setBrush(colorGroup().brush(QColorGroup::Text));
+    \endcode
+
+    you can simply replace colorGroup() with palette():
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 7
+
+    \section1 QColorDrag
+
+    The \c QColorDrag class has been renamed Q3ColorDrag and moved to
+    the Qt3Support library. In Qt 4, use QMimeData
+    instead and call QMimeData::setColor() to set the color.
+
+    \section1 QComboBox
+
+    In Qt 3, the list box used to display the contents of a \c QComboBox
+    widget could be accessed by using the \c listBox() function. In Qt 4,
+    the standard list box is provided by a QListView widget, and can be
+    accessed with the \l{QComboBox::view()}{view()} function.
+
+    \omit ### \endomit
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QComboBox virtual member functions in Qt 3 that are no longer
+    virtual in Qt 4.
+
+    \section1 QCString
+
+    In Qt 3, QCString inherited from QByteArray. The main drawback
+    of this approach is that the user had the responsibility of
+    ensuring that the string is '\\0'-terminated. Another important
+    issue was that conversions between \c QCString and QByteArray often
+    gave confusing results. (See the
+    \l{http://doc.trolltech.com/qq/qq05-achtung.html#qcstringisastringofchars}{Achtung!
+    Binary and Character Data} article in \e{Qt Quarterly} for an
+    overview of the pitfalls.)
+
+    Qt 4 solves that problem by merging the QByteArray and \c QCString
+    classes into one class called QByteArray. Most functions that
+    were in \c QCString previously have been moved to QByteArray. The
+    '\\0' issue is handled by having QByteArray allocate one extra
+    byte that it always sets to '\\0'. For example:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 8
+
+    The Qt3Support library contains a class called
+    Q3CString that inherits from the new QByteArray class and that
+    extends it to provide an API that is as close to the old \c QCString
+    class as possible. Note that the following functions aren't
+    provided by Q3CString:
+
+    \list
+    \o QCString::find(const QRegExp &, int)
+    \o QCString::findRev(const QRegExp &, int)
+    \o QCString::contains(const QRegExp &)
+    \o QCString::replace(const QRegExp &, const char *)
+    \endlist
+
+    The following functions have lost their last parameter, which
+    specified whether the search was case sensitive or not:
+
+    \list
+    \o QByteArray::find(char, int)
+    \o QByteArray::find(const char *, int)
+    \o QByteArray::findRev(char, int)
+    \o QByteArray::findRev(const char *, int)
+    \o QByteArray::contains(char)
+    \o QByteArray::contains(const char *)
+    \endlist
+
+    In both cases, the solution is to convert the \c QCString to a
+    QString and use the corresponding QString functions instead.
+
+    Also be aware that \c QCString::size() (inherited from
+    QByteArray) used to return the size of the character data \e
+    including the '\\0'-terminator, whereas the new
+    QByteArray::size() is just a synonym for QByteArray::length().
+    This brings QByteArray in line with QString.
+
+    When porting to Qt 4, occurrences of \c QCString should be
+    replaced with QByteArray or QString. The following table
+    summarizes the API differences between the Q3CString
+    class and the Qt 4 QByteArray and QString classes:
+
+    \table
+    \header \o Q3CString function \o Qt 4 equivalent
+    \row \o Q3CString::Q3CString(const char *, uint) \o See remark below
+    \row \o Q3CString::Q3CString(int) \o QByteArray::QByteArray(int, char)
+    \row \o Q3CString::leftJustify() \o QString::leftJustified()
+    \row \o Q3CString::length() \o QByteArray::length() or QByteArray::size() (equivalent)
+    \row \o Q3CString::lower() \o QByteArray::toLower()
+    \row \o Q3CString::rightJustify() \o QString::rightJustified()
+    \row \o Q3CString::setExpand() \o See remark below
+    \row \o Q3CString::simplifyWhiteSpace() \o QByteArray::simplified()
+    \row \o Q3CString::sprintf() \o QString::sprintf()
+    \row \o Q3CString::stripWhiteSpace() \o QByteArray::trimmed()
+    \row \o Q3CString::toDouble() \o QString::toDouble()
+    \row \o Q3CString::toFloat() \o QString::toFloat()
+    \row \o Q3CString::toInt() \o QString::toInt()
+    \row \o Q3CString::toLong() \o QString::toLong()
+    \row \o Q3CString::toShort() \o QString::toShort()
+    \row \o Q3CString::toUInt() \o QString::toUInt()
+    \row \o Q3CString::toULong() \o QString::toULong()
+    \row \o Q3CString::toUShort() \o QString::toUShort()
+    \row \o Q3CString::upper() \o QByteArray::toUpper()
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o  Q3CString(const char *str, uint max) constructs a string of
+        length strlen(str) or \e max - 1, whichever is shorter.
+        QByteArray(const char *data, int size) constructs a byte
+        array containing exactly \e size bytes.
+
+        \oldcode
+            QCString str1("Hello", 4);           // "Hel"
+            QCString str2("Hello world!", n);
+        \newcode
+            QByteArray str1("Hello", 3);
+            QByteArray str2("Hello world!");
+            str2.truncate(n - 1);
+        \endcode
+
+    \o  Q3CString::setExpand(uint index, char ch) has no equivalent in
+        Qt 4.
+
+        \oldcode
+            QCString str("Hello world");
+            str.setExpand(16, '\n');            // "Hello world     \n"
+        \newcode
+            QByteArray str("Hello world");
+            while (str.size() < 16)
+                str += ' ';
+            str += '\n';
+        \endcode
+    \endlist
+
+    Since the old \c QCString class inherited from QByteArray,
+    everything that is said in the \l{#qbytearray.section}{QByteArray
+    section} applies for \c QCString as well.
+
+    \section1 QCustomEvent
+
+    In Qt 3, developers could create a custom event by constructing
+    a new QCustomEvent, and send relevant data to other components in
+    the application by passing a void pointer, either on construction or
+    using the setData() function. Objects could receive custom events
+    by reimplementing the \l{QObject::customEvent()}{customEvent()}
+    function, and access the stored data using the event's data()
+    function.
+
+    In Qt 4, custom events are created by subclassing
+    QEvent. Event-specific data can be stored in a way that is
+    appropriate for your application. Custom events are still
+    delivered to each object's
+    \l{QObject::customEvent()}{customEvent()} handler function, but as
+    QEvent objects rather than as deprecated QCustomEvent objects.
+
+    \section1 QDataBrowser
+
+    The \c QDataBrowser class has been renamed Q3DataBrowser and
+    moved to the Qt3Support library. In Qt 4.2, you should use the
+    QDataWidgetMapper class to create data-aware forms.
+
+    See \l{QtSql Module} for an overview of the new SQL
+    classes.
+
+    \section1 QDataPump
+
+    The \c QDataPump class was used internally in Qt 2.x in
+    conjunction with QImageConsumer. It was obsoleted in Qt 3.0.
+
+    \input porting4-obsoletedmechanism.qdocinc
+
+    \section1 QDataSink
+
+    The \c QDataSink class was used internally in Qt 2.x in conjunction
+    with QImageConsumer. It was obsoleted in Qt 3.0.
+
+    \input porting4-obsoletedmechanism.qdocinc
+
+    \section1 QDataSource
+
+    The \c QDataSource class was used internally in Qt 2.x in
+    conjunction with QImageConsumer. It was obsoleted in Qt 3.0.
+    \input porting4-obsoletedmechanism.qdocinc
+
+    \section1 QDataTable
+
+    The \c QDataTable class has been renamed Q3DataTable and moved to
+    the Qt3Support library. In Qt 4.2, you should use the
+    QDataWidgetMapper class to create data-aware forms.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QDataView
+
+    The \c QDataView class has been renamed Q3DataView and moved to
+    the Qt3Support library. In Qt 4.2, you should use the
+    QDataWidgetMapper class to create data-aware forms.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QDateEdit
+
+    The QDateEdit class in Qt 4 is a convenience class based on
+    QDateTimeEdit. The old class has been renamed Q3DateEdit and moved
+    to the Qt3Support library.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of \c QDateEdit virtual member functions in Qt 3 that are
+    no longer virtual in Qt 4.
+
+    \section1 QDateTimeEditBase
+
+    The \c QDateTimeEditBase class has been renamed
+    Q3DateTimeEditBase and moved to Qt3Support. Use QDateTimeEdit or
+    QAbstractSpinBox instead.
+
+    \section1 QDateTimeEdit
+
+    The old \c QDateTimeEdit class has been renamed
+    Q3DateTimeEditBase and moved to Qt3Support. The new QDateTimeEdit
+    in Qt 4 has been rewritten from scratch to provide a more
+    flexible and powerful API.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QDateTimeEdit virtual member functions in Qt 3 that are no
+    longer virtual in Qt 4.
+
+    \section1 QDeepCopy<T>
+
+    The \c QDeepCopy<T> class in Qt 3 provided a means of ensuring that
+    implicitly shared and explicitly shared classes referenced unique
+    data. This was necessary because the reference counting in Qt's
+    container classes was done in a thread-unsafe manner.
+
+    With Qt 4, \c QDeepCopy<T> has been renamed Q3DeepCopy<T> and
+    moved to the Qt3Support library. Removing it from
+    existing code is straightforward.
+
+    \oldcode
+        QString str1 = "I am a string";
+        QDeepCopy<QString> str2 = str1;
+        QString str3 = QDeepCopy<QString>(str2);
+    \newcode
+        QString str1 = "I am a string";
+        QString str2 = str1;
+        QString str3 = str2;
+    \endcode
+
+    \section1 QDial
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QDial virtual member functions in Qt 3 that are no longer
+    virtual in Qt 4.
+
+    See \l{#properties}{Properties} for a list of QDial properties in
+    Qt 3 that have changed in Qt 4.
+
+    \target qdict.section
+    \section1 QDict<T>
+
+    \c QDict<T> has been renamed Q3Dict<T> and moved to Qt3Support.
+    It has been replaced by the more modern QHash<Key, T> and
+    QMultiHash<Key, T> classes.
+
+    When porting old code that uses QDict<T> to Qt 4, there are four
+    classes that you can use:
+
+    \table
+    \header \o Qt 4 class \o When to use it
+    \row \o QMultiHash<QString, T *>
+
+         \o Since Q3Dict<T> is pointer-based and allows duplicate
+            keys, this is usually the most straightforward conversion.
+
+    \row \o QMultiHash<QString, T>
+
+         \o If type \c T is an \l{assignable data type}, you can use
+            \c T as the value type rather than \c{T *}. This often
+            leads to nicer code.
+
+    \row \o QHash<QString, T *>
+
+         \o{1,2} If you don't use duplicate keys, you can use QHash
+            instead of QMultiHash. QMultiHash inherits from QHash.
+
+    \row \o QHash<QString, T>
+    \endtable
+
+    The APIs of Q3Dict<T> and QMultiHash<QString, T *> are quite
+    similar. The main issue is that Q3Dict supports auto-delete
+    whereas QMultiHash doesn't.
+
+    \omit
+    (See \l{What's Wrong with
+    Auto-Delete} for an explanation of why the Qt 4 containers don't
+    offer that feature.)
+    \endomit
+
+    The following table summarizes the API differences between the
+    two classes:
+
+    \table
+    \header \o Q3Dict function \o QMultiHash equivalent
+    \row \o Q3Dict::Q3Dict(int size, bool caseSensitive) \o See remarks below
+    \row \o Q3Dict::autoDelete() \o N/A
+    \row \o Q3Dict::count() \o QMultiHash::count() or QMultiHash::size() (equivalent)
+    \row \o Q3Dict::find(const QString &) \o QMultiHash::value(const QString &)
+    \row \o Q3Dict::remove(const QString &) \o QMultiHash::take(const QString &)
+    \row \o Q3Dict::resize(uint) \o QMultiHash::reserve(int)
+    \row \o Q3Dict::setAutoDelete() \o See discussion below
+    \row \o Q3Dict::size() \o QMultiHash::capacity()
+    \row \o Q3Dict::statistics() \o N/A
+    \row \o Q3Dict::operator[](const QString &) \o See remark below
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o  Q3Dict requires the user to allocate a specific number of
+        buckets by passing a prime number (17 by default) to the
+        constructor and/or calling Q3Dict::resize() later on. In
+        contrast, QMultiHash's hash table automatically grows and
+        shrinks as needed, and the constructor doesn't take a prime
+        number.
+
+    \o  Q3Dict supportes case-insensitive lookups by passing false as
+        second argument to the constructor. This feature has no
+        equivalent in QMultiHash. Instead, call QString::toLower()
+        before you insert or lookup a key in the hash.
+
+    \o  Q3Dict::size() and QMultiHash::size() have different semantics.
+        The former returns the number of buckets in the container, whereas
+        the latter returns the number of \e items in the container.
+
+    \o  If there are multiple items with the same key,
+        Q3Dict::remove() removes only the most recently inserted item,
+        whereas QMultiHash::remove() removes all items that share a
+        particular key. To remove only the most recently inserted item,
+        call QMultiHash::take().
+
+    \o  Q3Dict has only one [] operator (Q3Dict::operator[]()),
+        providing const access to an item's value. QMultiHash also
+        has a non-const overload that can be used on the left side of
+        the assignment operator. If you use the [] operator on a
+        non-const QHash with an unexisting item, QHash will created
+        an element and initialize it to be a null pointer. For that
+        reason, Q3Dict::operator[] should be converted to
+        QMultiHash::value(), not QMultiHash::operator[].
+
+    \endlist
+
+    If you use Q3Dict's auto-delete feature (by calling
+    Q3Dict::setAutoDelete(true)), you need to do some more work. You
+    have two options: Either you call \c delete yourself whenever you
+    remove an item from the container, or you use
+    QMultiHash<QString, T> instead of QMultiHash<QString, T *> (i.e.
+    store values directly instead of pointers to values). Here, we'll
+    see when to call \c delete.
+
+    The following table summarizes the idioms that you need to watch
+    out for if you want to call \c delete yourself.
+
+    \table
+    \header \o Q3Dict idiom \o QMultiHash idiom
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 9
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 10
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 11
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 12
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 13
+
+        (also called from Q3Dict's destructor)
+
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 14
+
+        In 99% of cases, the following idiom also works:
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 15
+
+        However, it may lead to crashes if \c hash is referenced from
+        the value type's destructor, because \c hash contains
+        dangling pointers until clear() is called.
+    \endtable
+
+    Be aware that Q3Dict's destructor automatically calls clear(). If
+    you have a Q3Dict data member in a custom class and use the
+    auto-delete feature, you will need to call \c delete on all the
+    items in the container from your class destructor to avoid a
+    memory leak.
+
+    Finally, \c QDictIterator<T> (renamed Q3DictIterator<T>) must
+    also be ported. There are no fewer than four iterator classes
+    that can be used as a replacement: QHash::const_iterator,
+    QHash::iterator, QHashIterator, and QMutableHashIterator. The
+    most straightforward class to use when porting is
+    QHashIterator<QString, T *>. The following table summarizes the
+    API differences:
+
+    \table
+    \header \o Q3DictIterator functions \o Qt 4 equivalent
+    \row \o Q3DictIterator::count() \o QHash::count() or QHash::size()
+    \row \o Q3DictIterator::current() \o QHashIterator::value()
+    \row \o Q3DictIterator::currentKey() \o QHashIterator::key()
+    \row \o Q3DictIterator::isEmpty() \o QHash::isEmpty()
+    \row \o Q3DictIterator::toFirst() \o QHashIterator::toFront()
+    \row \o Q3DictIterator::operator()() \o QHashIterator::value()
+    \row \o Q3DictIterator::operator*() \o QHashIterator::value()
+    \row \o Q3DictIterator::operator++() \o See remark below
+    \endtable
+
+    Be aware that QHashIterator has a different way of iterating than
+    Q3DictIterator. A typical loop with Q3DictIterator looks like this:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 16
+
+    Here's the equivalent QHashIterator loop:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 17
+
+    See \l{Java-style iterators} for details.
+
+    \section1 QDir
+
+    The following functions used to have a boolean \c{acceptAbsPath}
+    parameter that defaulted to true:
+
+    \list
+    \i QDir::filePath()
+    \i QDir::absFilePath()
+    \i QDir::cd()
+    \i QDir::mkdir()
+    \i QDir::rmdir()
+    \i QDir::remove()
+    \i QDir::rename()
+    \i QDir::exists()
+    \endlist
+
+    In Qt 3, if \c acceptAbsPath is true, a file name starting with
+    '/' is be returned without change; if \c acceptAbsPath is false,
+    an absolute path is prepended to the file name. For example:
+
+    \table
+    \header \i Current directory   \i File name        \i \c acceptAbsPath \i File path
+    \row    \i{1,2} /home/tsmith   \i{1,2} index.html  \i true             \i /home/tsmith/index.html
+    \row                                               \i false            \i /home/tsmith/index.html
+    \row    \i{1,2} /home/tsmith   \i{1,2} /index.html \i true             \i /index.html
+    \row                                               \i false            \i /home/tsmith/index.html
+    \endtable
+
+    In Qt 4, this parameter is no longer available. If you use it
+    in your code, you can check that QDir::isRelativePath() returns
+    false instead.
+
+    \oldcode
+        QDir dir("/home/tsmith");
+        QString path = dir.filePath(fileName, false);
+    \newcode
+        QDir dir("/home/tsmith");
+        QString path;
+        if (dir.isRelativePath(fileName))
+            path = dir.filePath(fileName);
+        else
+            path = fileName;
+    \endcode
+
+    QDir::encodedEntryList() has been removed.
+
+    fileInfoList(), entryInfoList(), and drives() now return a QList<QFileInfo>
+    and not a QPtrList<QFileInfo> *. Code using these methods will not work with
+    the Qt3Support library and must be adapted instead.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QDir virtual member functions in Qt 3 that are no longer
+    virtual in Qt 4.
+
+    QDir::match() now always matches case insensitively.
+
+    QDir::homeDirPath() has been removed. Use QDir::home() instead, and
+    extract the path separately.
+
+    \section1 QDns
+
+    Qt 3 used its own implementation of the DNS protocol and provided
+    a low-level \c QDns class. Qt 4's QHostInfo class uses the system's \c
+    gethostbyname() function from a thread instead.
+
+    The old \c QDns class has been renamed Q3Dns and moved to the
+    Qt3Support library. The new QHostInfo class has a
+    radically different API: It consists mainly of two static
+    functions, one of which is blocking (QHostInfo::fromName()), the
+    other non-blocking (QHostInfo::lookupHost()). See the QHostInfo
+    class documentation for details.
+
+    \section1 QDockArea
+
+    The \c QDockArea class has been renamed Q3DockArea and moved to
+    the Qt3Support library. In Qt 4, QMainWindow handles
+    the dock and toolbar areas itself. See the QMainWindow
+    documentation for details.
+
+    \section1 QDockWindow
+
+    The old \c QDockWindow class has been renamed Q3DockWindow and
+    moved to the Qt3Support library. In Qt 4, there is a
+    new QDockWidget class with a different API. See the class
+    documentation for details.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QDockWidget virtual member functions in Qt 3 that are no
+    longer virtual in Qt 4.
+
+    \note \l{Q3DockWindow}'s
+    \l{Q3DockWindow::setHorizontallyStretchable()}{horizontallyStretchable}
+    property can be achieved in QDockWidget with
+    \l{QWidget#Size Hints and Size Policies}{size policies}.
+
+    \section1 QDragObject
+
+    The \c QDragObject class has been renamed Q3DragObject and
+    moved to the Qt3Support library. In Qt 4, it has been
+    replaced by the QMimeData class. See the class documentation for
+    details.
+
+    Note that the Q3DragObject::DragCopyOrMove drag and drop mode is
+    interpreted differently to Qt 3's QDragObject::DragCopyOrMove mode.
+    In Qt 3, a move operation was performed by default, and the user had
+    to hold down the \key{Ctrl} key to perform a copy operation.
+    In Qt 4, a copy operation is performed by default; the user has to
+    hold down the \key{Shift} key to perform a move operation.
+
+    See \l{Porting to Qt 4 - Drag and Drop} for a comparison between
+    the drag and drop APIs in Qt 3 and Qt 4.
+
+    \section1 QDropSite
+
+    The \c QDropSite class has been renamed Q3DropSite and moved to
+    the Qt3Support library.
+
+    The QDropSite class has been obsolete ever since Qt 2.0. The only
+    thing it does is call QWidget::setAcceptDrops(true).
+
+    \oldcode
+    class MyWidget : public QWidget, public QDropSite
+    {
+    public:
+        MyWidget(const QWidget *parent)
+            : QWidget(parent), QDropSite(this)
+        {
+        }
+        ...
+    }
+    \newcode
+    class MyWidget : public QWidget
+    {
+    public:
+        MyWidget(const QWidget *parent)
+            : QWidget(parent)
+        {
+            setAcceptDrops(true);
+        }
+        ...
+    }
+    \endcode
+
+    See \l{Porting to Qt 4 - Drag and Drop} for a comparison between
+    the drag and drop APIs in Qt 3 and Qt 4.
+
+    \section1 QEditorFactory
+
+    The \c QEditorFactory class has been renamed Q3EditorFactory and
+    moved to the Qt3Support library.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QEventLoop
+
+    In Qt 3, \c QEventLoop combined the Qt event loop and the event
+    dispatching. In Qt 4, these tasks are now assigned to two
+    distinct classes: QEventLoop and QAbstractEventDispatcher.
+
+    If you subclassed QEventLoop to integrate with another library's
+    event loop, you must subclass QAbstractEventDispatcher instead. See
+    the class documentation for details.
+
+    Developers using \c{QEventLoop::loopLevel()} in Qt 3 should use
+    QCoreApplication::loopLevel() instead. Note that this function is
+    marked as obsolete, but it is expected to be available for the
+    lifetime of Qt 4.
+    \omit ### mention virtual functions that aren't virtual anymore \endomit
+
+    \omit
+    \section1 QFile
+
+    The QFile::readLine(QString&, Q_ULONG) method from qt3 has been removed
+    in qt4, but this change in the QFile interface is not documented in the
+    porting documentation as of qt-4.0.0-b1.
+    \endomit
+
+    \section1 QFileDialog
+
+    The QFileDialog class in Qt 4 has been totally rewritten. It
+    provides most of the functionality of the old \c QFileDialog
+    class, but with a different API. Some functionality, such as the
+    ability to preview files, is expected to be added in a later Qt 4
+    release.
+
+    The old \c QFileDialog, \c QFileIconProvider, and \c QFilePreview
+    classes has been renamed Q3FileDialog, Q3FileIconProvider, and
+    Q3FilePreview and have been moved to Qt3Support. You can use them
+    if you need some functionality not provided yet by the new
+    QFileDialog class.
+
+    The following table lists which functions have been renamed or
+    removed in Qt 4.
+
+    \table
+    \header \o Old function \o Qt 4 equivalent
+    \row \o Q3FileDialog::addFilter(const QString &) \o See remark below
+    \row \o Q3FileDialog::addLeftWidget(QWidget *) \o N/A
+    \row \o Q3FileDialog::addRightWidget(QWidget *) \o N/A
+    \row \o Q3FileDialog::addToolButton(QAbstractButton *, bool separator) \o N/A
+    \row \o Q3FileDialog::addWidgets(QLabel *, QWidget *, QPushButton *) \o N/A
+    \row \o Q3FileDialog::dir() \o QFileDialog::directory()
+    \row \o Q3FileDialog::dirPath() \o QFileDialog::directory().path()
+    \row \o Q3FileDialog::iconProvider() \o N/A
+    \row \o Q3FileDialog::isContentsPreviewEnabled() \o N/A
+    \row \o Q3FileDialog::isInfoPreviewEnabled() \o N/A
+    \row \o Q3FileDialog::previewMode() \o N/A
+    \row \o Q3FileDialog::rereadDir() \o N/A
+    \row \o Q3FileDialog::resortDir() \o N/A
+    \row \o Q3FileDialog::selectAll(bool) \o N/A
+    \row \o Q3FileDialog::setContentsPreview(QWidget *, Q3FilePreview *) \o N/A
+    \row \o Q3FileDialog::setContentsPreviewEnabled(bool) \o N/A
+    \row \o Q3FileDialog::setDir(const QString &) \o QFileDialog::setDirectory(const QString &)
+    \row \o Q3FileDialog::setFilters(const char **) \o Q3FileDialog::setFilters(const QStringList &)
+    \row \o Q3FileDialog::setIconProvider(Q3FileIconProvider *) \o N/A
+    \row \o Q3FileDialog::setInfoPreview(QWidget *, Q3FilePreview *) \o N/A
+    \row \o Q3FileDialog::setInfoPreviewEnabled(bool) \o N/A
+    \row \o Q3FileDialog::setPreviewMode(PreviewMode) \o N/A
+    \row \o Q3FileDialog::setSelectedFilter(const QString &) \o QFileDialog::selectFilter(const QString &)
+    \row \o Q3FileDialog::setSelectedFilter(int) \o See remark below
+    \row \o Q3FileDialog::setSelection(const QString &) \o QFileDialog::selectFile(const QString &)
+    \row \o Q3FileDialog::setShowHiddenFiles(bool) \o showHidden()
+    \row \o Q3FileDialog::setUrl(const QUrlOperator &) \o N/A
+    \row \o Q3FileDialog::showHiddenFiles() \o N/A
+    \row \o Q3FileDialog::url() \o QUrl::fromLocalFile(QFileDialog::directory())
+    \header \o Old signals \o Qt 4 equivalent
+    \row \o Q3FileDialog::fileHighlighted(const QString &) \o N/A
+    \row \o Q3FileDialog::fileSelected(const QString &) \o QFileDialog::filesSelected(const QStringList &)
+    \row \o Q3FileDialog::dirEntered(const QString &) \o N/A
+    \row \o Q3FileDialog::filterSelected(const QString &) \o N/A
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o  The Q3FileDialog::addFilter(const QString &) function has no
+        direct equivalent in the new QFileDialog. Use
+        QFileDialog::setFilters() instead.
+
+        \oldcode
+        fileDialog->addFilter(tr("JPEG files (*.jpg *.jpeg)"));
+        \newcode
+        QStringList filters = fileDialog->filters();
+        filters << tr("JPEG files (*.jpg *.jpeg)");
+        fileDialog->setFilters(filters);
+        \endcode
+
+    \o  The Q3FileDialog::setSelectedFilter(int) overload has no direct
+        equivalent in the new QFileDialog. Use
+        QFileDialog::selectFilter(const QString &) instead.
+
+        \oldcode
+        fileDialog->setSelectedFilter(3);
+        \newcode
+        fileDialog->selectFilter(fileDialog->filters().at(3));
+        \endcode
+    \endlist
+
+    There are no equivalent virtual functions to the two
+    Q3FileDialog::setSelectedFilter() virtual functions in the QFileDialog
+    API. In addition, these functions have been renamed or removed, as
+    described above.
+
+    \section1 QFocusData
+
+    The QFocusData class is not available in Qt 4. Some of its
+    functionality is available via the QWidget::nextInFocusChain()
+    and QWidget::focusNextPrevChild() functions.
+
+    \section1 QFocusEvent
+
+    The setReason() function is no longer present in Qt 4. It is
+    necessary to define the reason when constructing a focus event.
+
+    \section1 QFont
+
+    \c QFont::Script has been moved to QFontDatabase::WritingSystem.
+
+    \section1 QFrame
+
+    The QFrame class has been made more lightweight in Qt 4, by
+    reducing the number of properties and virtual functions. The
+    reduction in the number of virtual functions is significant
+    because QFrame is the base class of many Qt classes.
+
+    Here's an overview of the changes:
+
+    \list
+    \o  QFrame no longer has a \c margin property (which wasn't
+        honored by Qt's layout managers anyway).
+
+    \o  QFrame no longer has a frameChanged() function, reimplement
+        QFrame::resizeEvent() instead.
+
+    \o  QFrame used to have drawFrame(QPainter *) and
+        drawContents(QPainter *) virtual functions. These are now
+        gone. In Qt 4, the frame is drawn by the QFrame::paintEvent()
+        function. If you want to change the way QFrame paints itself,
+        reimplement this function. To draw the contents of the frame,
+        reimplement QFrame:paintEvent() and call the base class
+        implementation of the function before you use the
+        \l {QWidget::}{contentsRect()} function inherited from QWidget,
+        to retrieve the rectangle to paint on.
+
+    \endlist
+
+    To help with porting, the Qt3Support library contains a Q3Frame
+    class that inherits QFrame and provides a similar API to the old
+    QFrame class. If you derived from QFrame in your application, you
+    might want to use Q3Frame as a base class as a first step in the
+    porting process, and later move on to the new QFrame class.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QFrame virtual member functions in Qt 3 that are no longer
+    virtual in Qt 4.
+
+    \section1 QFtp
+
+    QFtp no longer inherits from QNetworkProtocol. See the
+    \l{#qnetworkprotocol.section}{section on QNetworkProtocol} for
+    details.
+
+    The old \c QFtp class has been renamed Q3Ftp and moved to the
+    Qt3Support library.
+
+    \target qglayoutiterator.section
+    \section1 QGLayoutIterator
+
+    The QGLayoutIterator class no longer exists in Qt 4. This makes
+    only a difference if you implemented custom layout managers
+    (i.e., QLayout subclasses).
+
+    The new approach is much simpler: It consists in reimplementing
+    QLayout::itemAt() and QLayout::takeAt(). These functions operate
+    on indexes, eliminating the need for a layout iterator class.
+
+    \section1 QGrid
+
+    The \c QGrid class is now only available as Q3Grid in Qt 4. You
+    can achieve the same result as \c QGrid by creating a QWidget
+    with a grid layout:
+
+    \oldcode
+    QGrid *grid = new QGrid(2, Qt::Horizontal);
+    QPushButton *child1 = new QPushButton(grid);
+    QPushButton *child2 = new QPushButton(grid);
+    QPushButton *child3 = new QPushButton(grid);
+    QPushButton *child4 = new QPushButton(grid);
+    \newcode
+    QWidget *grid = new QWidget;
+    QPushButton *child1 = new QPushButton(grid);
+    QPushButton *child2 = new QPushButton(grid);
+    QPushButton *child3 = new QPushButton(grid);
+    QPushButton *child4 = new QPushButton(grid);
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(child1, 0, 0);
+    layout->addWidget(child2, 0, 1);
+    layout->addWidget(child3, 1, 0);
+    layout->addWidget(child4, 1, 1);
+    grid->setLayout(layout);
+    \endcode
+
+    \section1 QGridLayout
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QGridLayout virtual member functions in Qt 3 that are no
+    longer virtual in Qt 4.
+
+    \section1 QGridView
+
+    The \c QGridView class has been renamed Q3GridView and moved to
+    the Qt3Support library. In Qt 4, we recommend that
+    you use QTableView or QAbstractItemView for presenting tabular
+    data.
+
+    See \l{Model/View Programming} for an overview of the new item
+    view classes.
+
+    \target qgroupbox.section
+    \section1 QGroupBox
+
+    The QGroupBox class has been redesigned in Qt 4. Many of the
+    features of the old \c QGroupBox class can be obtained by using
+    the Q3GroupBox class from the Qt3Support library.
+
+    The new QGroupBox is more lightweight. It doesn't attempt to
+    duplicate functionality already provided by QGridLayout, and it
+    does not inherit from QFrame. As a result, the following members
+    have been removed:
+
+    \list
+    \o Q3GroupBox::setColumns(), Q3GroupBox::columns()
+    \o Q3GroupBox::setOrientation(), Q3GroupBox::orientation()
+    \o Q3GroupBox::setInsideMargin(), Q3GroupBox::insideMargin()
+    \o Q3GroupBox::addSpace()
+    \endlist
+
+    Naturally, the \c columns and \c orientation properties have also
+    been removed.
+
+    If you rely on some of the missing functionality in your
+    application, you can use Q3GroupBox instead of QGroupBox as a
+    help to porting.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of QGroupBox virtual member functions in Qt 3 that are no
+    longer virtual in Qt 4.
+
+    \section1 QHBox
+
+    The \c QHBox class is now only available as Q3HBox in Qt 4. You
+    can achieve the same result as \c QHBox by creating a QWidget
+    with an horizontal layout:
+
+    \oldcode
+    QHBox *hbox = new QHBox;
+    QPushButton *child1 = new QPushButton(hbox);
+    QPushButton *child2 = new QPushButton(hbox);
+    \newcode
+    QWidget *hbox = new QWidget;
+    QPushButton *child1 = new QPushButton;
+    QPushButton *child2 = new QPushButton;
+
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(child1);
+    layout->addWidget(child2);
+    hbox->setLayout(layout);
+    \endcode
+
+    Note that child widgets are not automatically placed into the widget's
+    layout; you will need to manually add each widget to the QHBoxLayout.
+
+    \section1 QHeader
+
+    The \c QHeader class has been renamed Q3Header and moved to
+    the Qt3Support library. In Qt 4, it is replaced
+    by the QHeaderView class.
+
+    See \l{Model/View Programming} for an overview of the new item
+    view classes.
+
+    \section1 QHGroupBox
+
+    The \c QHGroupBox class has been renamed Q3HGroupBox and moved to
+    the Qt3Support library.
+    Qt 4 does not provide a specific replacement class for \c QHGroupBox
+    since QGroupBox is designed to be a generic container widget. As a
+    result, you need to supply your own layout for any child widgets.
+
+    See \l{#QGroupBox} for more information about porting code that uses
+    group boxes.
+
+    \section1 QHttp
+
+    QHttp no longer inherits from QNetworkProtocol. See the See the
+    \l{#qnetworkprotocol.section}{section on QNetworkProtocol} for
+    details.
+
+    The old \c QHttp, \c QHttpHeader, \c QHttpRequestHeader, and \c
+    QHttpResponseHeader classes have been renamed Q3Http,
+    Q3HttpHeader, Q3HttpRequestHeader, and Q3HttpResponseHeader  and
+    have been moved to the Qt3Support library.
+
+    \section1 QIconFactory
+
+    The QIconFactory class is no longer part of Qt. It has been replaced by
+    the QIconEngine class.
+
+    \section1 QIconSet
+
+    The QIconSet class is no longer part of Qt. It has been replaced by
+    the QIcon class.
+
+    \section1 QIconView
+
+    The \c QIconView, \c QIconViewItem, \c QIconDrag, and \c
+    QIconDragItem classes has been renamed Q3IconView,
+    Q3IconViewItem, Q3IconDrag, and Q3IconDragItem and moved to the
+    Qt3Support library. New Qt applications should use
+    QListWidget or its base class QListView instead, and call
+    QListView::setViewMode(QListView::IconMode) to obtain an "icon
+    view" look.
+
+    See \l{Model/View Programming} for an overview of the new item
+    view classes.
+
+    \omit
+    ###
+
+    \section1 QImage
+
+    QImage::fromMimeSource(const QString &) -> qImageFromMimeSource(const QString &)
+    \endomit
+
+    \section1 QImageDrag
+
+    The \c QImageDrag class has been renamed Q3ImageDrag and moved to
+    the Qt3Support library. In Qt 4, use QMimeData
+    instead and call QMimeData::setImage() to set the image.
+
+    See \l{Porting to Qt 4 - Drag and Drop} for a comparison between
+    the drag and drop APIs in Qt 3 and Qt 4.
+
+    \section1 QImageIO
+
+    The \c QImageIO class has been split into two classes:
+    QImageReader and QImageWriter. The table below shows the
+    correspondance between the two APIs:
+
+    \table
+    \header \o Qt 3 function              \o Qt 4 equivalents
+    \row    \o QImageIO::description()    \o QImageWriter::description()
+    \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()
+    \row    \o QImageIO::image()          \o Return value of QImageReader::read()
+    \row    \o QImageIO::inputFormats()   \o QImageReader::supportedImageFormats()
+    \row    \o QImageIO::ioDevice()       \o QImageReader::device() and QImageWriter::device()
+    \row    \o QImageIO::outputFormats()  \o QImageWriter::supportedImageFormats()
+    \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::setFileName()    \o QImageReader::setFileName() and QImageWriter::setFileName()
+    \row    \o QImageIO::setFormat()      \o QImageReader::setFormat() and QImageWriter::setFormat()
+    \row    \o QImageIO::setGamma()       \o QImageWriter::setGamma()
+    \row    \o QImageIO::setIODevice()    \o QImageReader::setDevice() and QImageWriter::setDevice()
+    \row    \o QImageIO::setImage()       \o Argument to QImageWriter::write()
+    \row    \o QImageIO::setParameters()  \o N/A
+    \row    \o QImageIO::setQuality()     \o QImageWriter::setQuality()
+    \row    \o QImageIO::setStatus()      \o N/A
+    \row    \o QImageIO::status()         \o QImageReader::error() and QImageWriter::error()
+    \row    \o QImageIO::write()          \o QImageWriter::write()
+    \endtable
+
+    \section1 QIntCache<T>
+
+    QIntCache<T> has been moved to Qt3Support. It has been replaced
+    by QCache<int, T>.
+
+    For details, read the \l{#qcache.section}{section on QCache<T>},
+    mentally substituting \c int for QString.
+
+    \section1 QIntDict<T>
+
+    QIntDict<T> and QIntDictIterator<T> have been moved to
+    Qt3Support. They have been replaced by the more modern QHash<Key,
+    T> and QMultiHash<Key, T> classes and their associated iterator
+    classes.
+
+    When porting old code that uses QIntDict<T> to Qt 4, there are
+    four classes that you can use:
+
+    \list
+    \o QMultiHash<int, T *>
+    \o QMultiHash<int, T>
+    \o QHash<int, T *>
+    \o QHash<int, T>
+    \endlist
+
+    For details, read the \l{#qdict.section}{section on QDict<T>},
+    mentally substituting \c int for QString.
+
+    \target qiodevice.section
+    \section1 QIODevice
+
+    The QIODevice class's API has been simplified to make it easier
+    to subclass and to make it work more smoothly with asynchronous
+    devices such as QTcpSocket and QProcess.
+
+    The following virtual functions have changed name or signature:
+
+    \table
+    \header \o Qt 3 function \o Comment
+    \row \o QIODevice::at() const \o Renamed QIODevice::pos().
+    \row \o QIODevice::at(Offset) \o Renamed QIODevice::seek().
+    \row \o QIODevice::open(int) \o The parameter is now of type QIODevice::OpenMode.
+    \row \o QIODevice::readBlock(char *, Q_ULONG) \o QIODevice::read(char *, qint64)
+    \row \o QIODevice::writeBlock(const char *, Q_ULONG) \o QIODevice::write(const char *, qint64)
+    \endtable
+
+    \note QIODevice::open(QIODevice::OpenMode) is no longer pure virtual.
+
+    The following functions are no longer virtual or don't exist anymore:
+
+    \table
+    \row \o QIODevice::getch() \o Renamed QIODevice::getChar() and implemented in terms of QIODevice::readData().
+    \row \o QIODevice::putch(int) \o Renamed QIODevice::putChar() and implemented in terms of QIODevice::writeData().
+    \row \o QIODevice::readAll() \o Implemented in terms of QIODevice::readData().
+    \row \o QIODevice::readLine(char *, Q_ULONG) \o Implemented in terms of QIODevice::readData()
+    \row \o QIODevice::ungetch(int) \o Renamed QIODevice::ungetChar() and simulated using an internal unget buffer.
+    \endtable
+
+    The \c IO_xxx flags have been revised, and the protected setFlags()
+    function removed. Most of the flags have been
+    eliminated because errors are best handled by implementing certain
+    functions in QIODevice subclasses rather than through the base classes.
+    The file access flags, such as \c IO_ReadOnly and \c IO_WriteOnly, have
+    been moved to the QIODevice class to avoid polluting the global
+    namespace. The table below shows the correspondence between the
+    Qt 3 \c IO_xxx flags and the Qt 4 API:
+
+    \table
+    \header \o Qt 3 constant \o Qt 4 equivalent
+    \row \o IO_Direct \o Use !QIODevice::isSequential() instead (notice the \e not).
+    \row \o IO_Sequential \o Use QIODevice::isSequential() instead.
+    \row \o IO_Combined \o N/A
+    \row \o IO_TypeMask \o N/A
+    \row \o IO_Raw \o QIODevice::Unbuffered
+    \row \o IO_Async \o N/A
+    \row \o IO_ReadOnly \o QIODevice::ReadOnly
+    \row \o IO_WriteOnly \o QIODevice::WriteOnly
+    \row \o IO_ReadWrite \o QIODevice::ReadWrite
+    \row \o IO_Append \o QIODevice::Append
+    \row \o IO_Truncate \o QIODevice::Truncate
+    \row \o IO_Translate \o QIODevice::Text
+    \row \o IO_ModeMask \o N/A
+    \row \o IO_Open \o Use QIODevice::isOpen() instead.
+    \row \o IO_StateMask \o N/A
+    \row \o IO_Ok \o N/A
+    \row \o IO_ReadError \o N/A
+    \row \o IO_WriteError \o N/A
+    \row \o IO_FatalError \o N/A
+    \row \o IO_ResourceError \o N/A
+    \row \o IO_OpenError \o N/A
+    \row \o IO_ConnectError \o N/A
+    \row \o IO_AbortError \o N/A
+    \row \o IO_TimeOutError \o N/A
+    \row \o IO_UnspecifiedError \o N/A
+    \endtable
+
+    \section1 QIODeviceSource
+
+    The QIODeviceSource class was used internally in Qt 2.x in
+    conjunction with QImageConsumer. It was obsoleted in Qt 3.0.
+    \input porting4-obsoletedmechanism.qdocinc
+
+    \section1 QLabel
+
+    QLabel doesn't enable word-wrap automatically anymore when rich
+    text is used. You can enable it by calling
+    QLabel::setWordWrap() or by setting the
+    \l{QLabel::wordWrap}{wordWrap} property. The reason for this
+    change is that the old behavior was confusing to many users.
+
+    Also, QLabel no longer offers an \c autoResize property. Instead,
+    you can call QWidget::setFixedSize() on the label, with
+    QLabel::sizeHint() as the argument, whenever you change the
+    contents of the QLabel.
+
+    See also \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions}
+    for a list of QLabel virtual member functions in Qt 3 that are no
+    longer virtual in Qt 4.
+
+    \section1 QLayout
+
+    In Qt 4, margins are always handled by layouts; there is no
+    QLayout::setSupportsMargin() function anymore.
+
+    The deleteAllItems() function is now only available if
+    \c QT3_SUPPORT is defined. If you maintain a QList of layout
+    items, you can use qDeleteAll() to remove all the items in one
+    go.
+
+    In Qt 3, it was possible to change the resizing behavior for layouts
+    in top-level widgets by adjusting the layout's \c resizeMode property.
+    In Qt 4, this property has been replaced by the QLayout::sizeConstraint
+    property which provides more control over how the layout behaves when
+    resized.
+
+    See also the \l{#qlayoutiterator.section}{section on
+    QLayoutIterator} and the \l{#qglayoutiterator.section}{section on
+    QGLayoutIterator}.
+
+    \target qlayoutiterator.section
+    \section1 QLayoutIterator
+
+    The QLayoutIterator class is obsoleted in Qt 4. It is available
+    only if \c QT3_SUPPORT is defined. It can be replaced by the
+    QLayout::itemAt() and QLayout::takeAt() functions, which operate
+    on indexes.
+
+    \oldcode
+        QLayoutIterator it = layout()->iterator();
+        QLayoutItem *child;
+        while ((child = it.current()) != 0) {
+            if (child->widget() == myWidget) {
+                it.takeCurrent();
+                return;
+            ++it;
+        }
+    \newcode
+        int i = 0;
+        QLayoutItem *child;
+        while ((child = layout()->itemAt(i)) != 0) {
+            if (child->widget() == myWidget) {
+                layout()->takeAt(i);
+                return;
+            }
+            ++i;
+        }
+    \endcode
+
+    \section1 QLineEdit
+
+    See \l{#properties}{Properties} for a list of QLineEdit
+    properties in Qt 3 that have changed in Qt 4.
+
+    The default value of QLineEdit's \l{QLineEdit::dragEnabled()}{dragEnabled}
+    property was \c true in Qt 3. In Qt 4, the default value is \c false.
+
+    Note that QLineEdit in Qt 4 is no longer a subclass of QFrame.
+    If you need to visually style a line edit with a frame, we recommend
+    either using a QFrame as a container for a QLineEdit or customizing
+    the line edit with a \l{Qt Style Sheets}{style sheet}.
+
+    \section1 QListBox
+
+    The \c QListBox, \c QListBoxItem, \c QListBoxText, and \c
+    QListBoxPixmap classes have been renamed Q3ListBox,
+    Q3ListBoxItem, Q3ListBoxText, and Q3ListBoxPixmap and have been
+    moved to the Qt3Support library. New Qt applications
+    should use QListWidget or its base class QListView instead.
+
+    See \l{Model/View Programming} for an overview of the new item
+    view classes.
+
+    \section1 QListView
+
+    The \c QListView, \c QListViewItem, \c QCheckListItem, and \c
+    QListViewItemIterator classes have been renamed Q3ListView,
+    Q3ListViewItem, Q3CheckListItem, and Q3ListViewItemIterator, and
+    have been moved to the Qt3Support library. New Qt
+    applications should use one of the following four classes
+    instead: QTreeView or QTreeWidget for tree-like structures;
+    QListWidget or the new QListView class for one-dimensional lists.
+
+    See \l{Model/View Programming} for an overview of the new item
+    view classes.
+
+    \section1 QLocalFs
+
+    The \c QLocalFs class is no longer part of the public Qt API. It
+    has been renamed Q3LocalFs and moved to Qt3Support. Use QDir,
+    QFileInfo, or QFile instead.
+
+    \section1 QMainWindow
+
+    The QMainWindow class has been redesigned in Qt 4 to provide a
+    more modern look and feel and more flexibility. The API has
+    changed to reflect that. The old \c QMainWindow class has been
+    renamed Q3MainWindow and moved to Qt3Support. See the QMainWindow
+    class documentation for details.
+
+    \omit ### More detail \endomit
+
+    \target qmemarray.section
+    \section1 QMemArray<T>
+
+    QMemArray<T> has been moved to Qt3Support. It has been replaced
+    by the QVector<T> class.
+
+    The following table summarizes the API differences between the
+    two classes.
+
+    \table
+    \row \o QMemArray::assign(const QMemArray<T> &) \o QVector::operator=()
+    \row \o QMemArray::assign(const T *, uint) \o See remark below
+    \row \o QMemArray::duplicate(const QMemArray &) \o QVector::operator=()
+    \row \o QMemArray::duplicate(const T *, uint) \o See remark below
+    \row \o QMemArray::setRawData(const T *, uint) \o N/A
+    \row \o QMemArray::resetRawData(const T *, uint) \o N/A
+    \row \o QMemArray::find(const T &, uint) \o QVector::indexOf(const T &, int)
+    \row \o QMemArray::contains(const T &) \o QVector::count(const T &)
+    \row \o QMemArray::sort() \o \l qSort()
+    \row \o QMemArray::bsearch(const T &d) \o \l qBinaryFind()
+    \row \o QMemArray::at(uint) \o QVector::operator[]()
+    \row \o QMemArray::operator const T *() \o QVector::constData()
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o  QMemArray::assign(const T *, uint) and QMemArray::duplicate(const T *, uint)
+        can be replaced by QVector::resize() and qCopy().
+
+        \oldcode
+        QMemArray<QSize> array;
+        ...
+        array.assign(data, size);
+        \newcode
+        QVector<QSize> vector;
+        ...
+        vector.resize(size);
+        qCopy(data, data + size, vector.begin());
+        \endcode
+
+    \o  QMemArray is an explicitly shared class, whereas QVector is
+        implicitly shared. See \l{Explicit Sharing} for more
+        information.
+    \endlist
+
+    \section1 QMenuBar
+
+    In Qt 3, QMenuBar inherited from QFrame and QMenuData; in Qt 4, it is
+    a direct subclass of QWidget. Applications that provided customized
+    menu bars will need to take advantage of the styling features described
+    in the \l{Qt Style Sheets} document.
+
+    It is not possible to add widgets to menu bars in Qt 4.
+
+    \section1 QMenuData
+
+    In Qt 4, the QMenu class provides a menu widget that can be used in all
+    the places where menus are used in an application. Unlike \c QMenuData,
+    QMenu is designed around the concept of actions, provided by the QAction
+    class, instead of the identifiers used in Qt 3.
+
+    In Qt 3, it was possible to insert widgets directly into menus by using
+    a specific \c QMenuData::insertItem() overload. In Qt 4.2 and later,
+    the QWidgetAction class can be used to wrap widgets for use in Qt 4's
+    action-based APIs.
+
+    \section1 QMessageBox
+
+    The QMessageBox::iconPixmap() function used to return a "const
+    QPixmap *". In Qt 4, it returns a QPixmap.
+
+    \section1 QMimeSourceFactory
+
+    The \c QMimeSourceFactory has been renamed Q3MimeSourceFactory
+    and moved to the Qt3Support library. New Qt applications should
+    use Qt 4's \l{Resource System} instead.
+
+    \section1 QMovie
+
+    The QMovie API has been revised in Qt 4 to make it more
+    consistent with the other Qt classes (notably QImageReader). The
+    table below summarizes the changes.
+
+    \table
+    \header \o Qt 3 function \o Qt 4 equivalent
+    \row \o QMovie::connectResize() \o Connect to QMovie::resized()
+    \row \o QMovie::connectStatus() \o Connect to QMovie::stateChanged()
+    \row \o QMovie::connectUpdate() \o Connect to QMovie::updated()
+    \row \o QMovie::disconnectResize() \o Disconnect from QMovie::resized()
+    \row \o QMovie::disconnectStatus() \o Disconnect from QMovie::stateChanged()
+    \row \o QMovie::disconnectUpdate() \o Disconnect from QMovie::updated()
+    \row \o QMovie::finished() \o Use QMovie::state() instead
+    \row \o QMovie::frameImage() \o Use QMovie::currentImage() instead
+    \row \o QMovie::frameNumber() \o Use QMovie::currentFrameNumber() instead
+    \row \o QMovie::framePixmap() \o Use QMovie::currentPixmap() instead
+    \row \o QMovie::getValidRect() \o Use frameRect() instead
+    \row \o QMovie::isNull() \o Use QMovie::isValid() instead
+    \row \o QMovie::pause() \o Use QMovie::setPaused(true) instead
+    \row \o QMovie::paused() \o Use QMovie::state() instead
+    \row \o QMovie::pushData() \o N/A
+    \row \o QMovie::pushSpace() \o N/A
+    \row \o QMovie::restart() \o Use QMovie::jumpToFrame(0) instead
+    \row \o QMovie::running() \o Use QMovie::state() instead
+    \row \o QMovie::step() \o Use QMovie::jumpToFrame() and QMovie::setPaused() instead
+    \row \o QMovie::step() \o Use QMovie::jumpToNextFrame() instead
+    \row \o QMovie::steps() \o Use QMovie::currentFrameNumber() and QMovie::frameCount() instead
+    \row \o QMovie::unpause() \o Use QMovie::setPaused(false) instead
+    \endtable
+
+    \section1 QMultiLineEdit
+
+    The \c QMultiLineEdit class in Qt 3 was a convenience QTextEdit
+    subclass that provided an interface compatible with Qt 2's
+    QMultiLineEdit class. In Qt 4, it is called Q3MultiLineEdit, it
+    inherits Q3TextEdit, and it is part of Qt3Support. Use QTextEdit
+    in new code.
+
+    \target qnetworkprotocol.section
+    \section1 QNetworkProtocol
+
+    The QNetworkProtocol, QNetworkProtocolFactoryBase,
+    QNetworkProtocolFactory<T>, and QNetworkOperation classes are no
+    longer part of the public Qt API. They have been renamed
+    Q3NetworkProtocol, Q3NetworkProtocolFactoryBase,
+    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.
+
+    \section1 QObject
+
+    QObject::children() now returns a QObjectList instead of a
+    pointer to a QObjectList. See also the comments on QObjectList
+    below.
+
+    Use QObject::findChildren() (or qFindChildren() if you need MSVC 6
+    compatibility) instead of QObject::queryList(). For example:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 18
+
+    QObject::killTimers() has been removed because it was unsafe to
+    use in subclass. (A subclass normally doesn't know whether the
+    base class uses timers or not.)
+
+    The \c QObject::name property has been renamed
+    QObject::objectName.
+
+    \c QObject::objectTrees() has been removed. If you are primarly
+    interested in widgets, use QApplication::allWidgets() or
+    QApplication::topLevelWidgets().
+
+    \section1 QObjectDictionary
+
+    The QObjectDictionary class is a synonym for
+    QAsciiDict<QMetaObject>. See the \l{#qasciidict.section}{section
+    on QAsciiDict<T>}.
+
+    \section1 QObjectList
+
+    In Qt 3, the QObjectList class was a typedef for
+    QPtrList<QObject>. In Qt 4, it is a typedef for QList<QObject *>.
+    See the \l{#qptrlist.section}{section on QPtrList<T>}.
+
+    \section1 QPaintDevice
+
+    To reimplement painter backends one previously needed to reimplement
+    the virtual function QPaintDevice::cmd(). This function is taken out
+    and should is replaced with the function QPaintDevice::paintEngine()
+    and the abstract class QPaintEngine. QPaintEngine provides virtual
+    functions for all drawing operations that can be performed on a
+    painter backend.
+
+    bitBlt() and copyBlt() are now only compatibility functions. Use
+    QPainter::drawPixmap() instead.
+
+    \section1 QPaintDeviceMetrics
+
+    All functions that used to be provided by the \c
+    QPaintDeviceMetrics class have now been moved to QPaintDevice.
+
+    \oldcode
+        QPaintDeviceMetrics metrics(widget);
+        int deviceDepth = metrics.depth();
+    \newcode
+        int deviceDepth = widget->depth();
+    \endcode
+
+    For compatibility, the old \c QPaintDeviceMetrics class has been
+    renamed Q3PaintDeviceMetrics and moved to Qt3Support.
+
+    \section1 QPainter
+
+    The QPainter class has undergone some changes in Qt 4 because of
+    the way rectangles are drawn. In Qt 4, the result of drawing a
+    QRect with a pen width of 1 pixel is 1 pixel wider and 1 pixel
+    taller than in Qt 3.
+
+    For compatibility, we provide a Q3Painter class in Qt3Support
+    that provides the old semantics. See the Q3Painter documentation
+    for details and for the reasons why we had to make this change.
+
+    The \l{http://doc.trolltech.com/3.3/qpainter.html#CoordinateMode-enum}{QPainter::CoordinateMode}
+    enum has been removed in Qt 4. All clipping
+    operations are now defined using logical coordinates and are subject
+    to transformation operations.
+
+    The
+    \l{http://doc.trolltech.com/3.3/qpainter.html#RasterOP-enum}{QPainter::RasterOP}
+    enum has been replaced with QPainter::CompositionMode.
+
+    \section1 QPicture
+
+    In Qt 3, a QPicture could be saved in the SVG file format. In Qt
+    4, the SVG support is provided by the QtSvg module, which
+    includes classes for \e displaying the contents of SVG files.
+
+    If you would like to generate SVG files, you can use the Q3Picture
+    compatibility class or the QSvgGenerator class introduced in Qt 4.3.
+
+    \section1 QPixmap
+
+    The mask() function has been changed to return a reference to a QBitmap
+    rather than a pointer. As a result, it is no longer possible simply to
+    test for a null pointer when determining whether a pixmap has a mask.
+    Instead, you need to explicitly test whether the mask bitmap is null or
+    not.
+
+    \oldcode
+        if (pixmap.mask())
+            widget->setMask(*pixmap.mask());
+    \newcode
+        if (!pixmap.mask().isNull())
+            widget->setMask(pixmap.mask());
+    \endcode
+
+    The \c QPixmap::setOptimization() and \c QPixmap::setDefaultOptimization()
+    mechanism is no longer available in Qt 4.
+
+\omit
+    QPixmap::fromMimeSource(const QString &) -> qPixmapFromMimeSource(const QString &)
+\endomit
+
+    \section1 QPointArray
+
+    The \c QPointArray class has been renamed QPolygon in Qt 4 and
+    has undergone significant changes. In Qt 3, \c QPointArray
+    inherited from QMemArray<QPoint>. In Qt 4, QPolygon inherits from
+    QVector<QPoint>. Everything mentioned in the
+    \l{#qmemarray.section}{section on QMemArray<T>} apply for
+    QPointArray as well.
+
+    The Qt3Support library contains a Q3PointArray class
+    that inherits from QPolygon and provides a few functions that
+    existed in \c QPointArray but no longer exist in QPolygon. These
+    functions include Q3PointArray::makeArc(),
+    Q3PointArray::makeEllipse(), and Q3PointArray::cubicBezier().
+    In Qt 4, we recommend that you use QPainterPath for representing
+    arcs, ellipses, and Bezier curves, rather than QPolygon.
+
+    The QPolygon::setPoints() and QPolygon::putPoints() functions
+    return \c void in Qt 4. The corresponding Qt 3 functions returned
+    a \c bool indicating whether the array was successfully resized
+    or not. This can now be checked by checking QPolygon::size()
+    after the call.
+
+\omit
+    X11 Specific:
+
+    ::appDisplay() -> QX11Info::display()
+    QPaintDevice::x11Display() -> QX11Info::display()
+    QPaintDevice::x11AppDisplay() -> QX11Info::display()
+    QPaintDevice::x11Screen() -> QX11Info::appScreen()
+    QPaintDevice::x11AppScreen() -> ???
+    QPaintDevice::x11Depth() -> QX11Info::appDepth()
+    QPaintDevice::x11ColorMap() -> QX11Info::appColorMap()
+    QPaintDevice::x11DefaultColorMap() -> ???
+    QPaintDevice::x11Visual() -> QX11Info::appVisual()
+    QPaintDevice::x11DefaultVisual() -> ???
+
+    QPaintDevice::x11AppDpiX() -> QX11Info::appDpiX()
+    QPaintDevice::x11AppDpiY() -> QX11Info::appDpiY()
+    QPaintDevice::x11SetAppDpiX() -> QX11Info::setAppDpiX()
+    QPaintDevice::x11SetAppDpiY() -> QX11Info::setAppDpiY()
+
+    QPaintDevice::x11AppDepth() -> ???
+    QPaintDevice::x11AppCells() -> ???
+    QPaintDevice::x11AppRootWindow() -> ???
+    QPaintDevice::x11AppColorMap() -> ???
+    QPaintDevice::x11AppDefaultColorMap() -> ???
+    QPaintDevice::x11AppVisual() -> ???
+    QPaintDevice::x11AppDefaultVisual() -> ???
+
+    End of X11 Specific
+\endomit
+
+    \section1 QPopupMenu
+
+    For most purposes, QPopupMenu has been replaced by QMenu in Qt
+    4. For compatibility with older applications, Q3PopupMenu provides
+    the old API and features that are specific to pop-up menus. Note
+    that, when using Q3PopupMenu, the menu's actions must be \l
+    {Q3Action}s.
+
+    In Qt 3, it was common practice to add entries to pop-up menus using the
+    insertItem() function, maintaining identifiers for future use; for
+    example, to dynamically change menu items.
+    In Qt 4, menu entries are completely represented
+    by actions for consistency with other user interface components, such as
+    toolbar buttons. Create new menus with the QMenu class, and use the
+    overloaded QMenu::addAction() functions to insert new entries.
+    If you need to manage a set of actions created for a particular menu,
+    we suggest that you construct a QActionGroup and add them to that.
+
+    The \l{Qt Examples#Main Windows}{Main Window examples} provided
+    show how to use Qt's action system to construct menus, toolbars, and other
+    common user interface elements.
+
+    \section1 QPrinter
+
+    The QPrinter class now expects printing to be set up from a
+    QPrintDialog.
+
+    \section1 QProcess
+
+    The QProcess class has undergone major improvements in Qt 4. It
+    now inherits QIODevice, which makes it possible to combine
+    QProcess with a QTextStream or a QDataStream.
+
+    The old \c QProcess class has been renamed Q3Process and moved to
+    the Qt3Support library.
+
+    \section1 QProgressBar
+
+    The QProgressBar API has been significantly improved in Qt 4. The
+    old \c QProgressBar API is available as Q3ProgressBar in the
+    Qt3Support library.
+
+    \section1 QProgressDialog
+
+    The QProgressDialog API has been significantly improved in Qt 4.
+    The old \c QProgressDialog API is available as Q3ProgressDialog
+    in the Qt3Support library.
+
+    See \l{#properties}{Properties} for a list of QProgressDialog
+    properties in Qt 3 that have changed in Qt 4.
+
+    \section1 QPtrCollection<T>
+
+    The \c QPtrCollection<T> abstract base class has been renamed
+    Q3PtrCollection<T> moved to the Qt3Support library.
+    There is no direct equivalent in Qt 4.
+
+    \omit
+    ###
+    The QPtrCollection entry is unsatisfactory. The xref is missing
+    its list and saying "no direct equivalent" with so suggestions
+    seems feeble.
+    \endomit
+
+    See \l{Generic Containers} for a list of Qt 4 containers.
+
+    \section1 QPtrDict<T>
+
+    \c QPtrDict<T> and \c QPtrDictIterator<T> have been renamed
+    Q3PtrDict<T> and Q3PtrDictIterator<T> and have been moved to the
+    Qt3Support library. They have been replaced by the
+    more modern QHash<Key, T> and QMultiHash<Key, T> classes and
+    their associated iterator classes.
+
+    When porting old code that uses Q3PtrDict<T> to Qt 4, there are
+    four classes that you can use:
+
+    \list
+    \o QMultiHash<void *, T *>
+    \o QMultiHash<void *, T>
+    \o QHash<void *, T *>
+    \o QHash<void *, T>
+    \endlist
+
+    (You can naturally use other types than \c{void *} for the key
+    type, e.g. \c{QWidget *}.)
+
+    To port Q3PtrDict<T> to Qt 4, read the \l{#qdict.section}{section
+    on QDict<T>}, mentally substituting \c{void *} for QString.
+
+    \target qptrlist.section
+    \section1 QPtrList<T>
+
+    QPtrList<T>, QPtrListIterator<T>, and QPtrListStdIterator<T> have
+    been moved to the Qt3Support library. They have been
+    replaced by the more modern QList and QLinkedList classes and
+    their associated iterator classes.
+
+    When porting to Qt 4, you have the choice of using QList<T> or
+    QLinkedList<T> as alternatives to QValueList<T>. QList<T> has an
+    index-based API and provides very fast random access
+    (QList::operator[]), whereas QLinkedList<T> has an iterator-based
+    API.
+
+    The following table summarizes the API differences between
+    QPtrList<T> and QList<T *>:
+
+    \table
+    \header \o QPtrList function \o QList equivalent
+    \row \o QPtrList::contains(const T *) \o QList::count(T *)
+    \row \o QPtrList::containsRef(const T *) \o QList::count(T *)
+    \row \o QPtrList::find(const T *) \o See remark below
+    \row \o QPtrList::findRef(const T *) \o See remark below
+    \row \o QPtrList::getFirst() \o QList::first()
+    \row \o QPtrList::getLast() \o QList::last()
+    \row \o QPtrList::inSort(const T *) \o N/A
+    \row \o QPtrList::remove(const T *) \o QList::removeAll(T *)
+    \row \o QPtrList::remove(uint) \o QList::removeAt(int)
+    \row \o QPtrList::removeNode(QLNode *) \o N/A
+    \row \o QPtrList::removeRef(const T *) \o QList::removeAll(T *)
+    \row \o QPtrList::sort() \o See remark below
+    \row \o QPtrList::takeNode(QLNode *) \o N/A
+    \row \o QPtrList::toVector(QGVector *) \o See remark below
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o  QPtrList::toVector(QGVector *) can be replaced by
+        QVector::resize() and qCopy().
+
+        \oldcode
+        QPtrList<QWidget> list;
+        ...
+        QPtrVector<QWidget> vector;
+        list.toVector(&vector);
+        \newcode
+        QList<QWidget *> list;
+        ...
+        QVector<QWidget *> vector;
+        vector.resize(list.size());
+        qCopy(list.begin(), list.end(), vector.begin());
+        \endcode
+
+    \o  QPtrList::sort() relied on the virtual compareItems() to
+        sort items. In Qt 4, you can use \l qSort() instead and pass
+        your "compare item" function as an argument.
+
+    \o  QPtrList::find(const T *) returns an iterator, whereas
+        QList::indexOf(T *) returns an index. To convert an index
+        into an iterator, add the index to QList::begin().
+
+    \o  QPtrList::removeFirst() and QPtrList::removeLast() return a \c
+        bool that indicates whether the element was removed or not.
+        The corresponding QList functions return \c void. You can
+        achieve the same result by calling QList::isEmpty() before
+        attempting to remove an item.
+    \endlist
+
+    If you use QPtrList's auto-delete feature (by calling
+    QPtrList::setAutoDelete(true)), you need to do some more work.
+    You have two options: Either you call \c delete yourself whenever
+    you remove an item from the container, or you can use QList<T>
+    instead of QList<T *> (i.e. store values directly instead of
+    pointers to values). Here, we'll see when to call \c delete.
+
+    \omit
+    (See \l{What's Wrong with Auto-Delete} for an explanation of why
+    the Qt 4 containers don't offer that feature.)
+    \endomit
+
+    The following table summarizes the idioms that you need to watch
+    out for if you want to call \c delete yourself.
+
+    \table
+    \header \o QPtrList idiom \o QList idiom
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 19
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 20
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 21
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 22
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 23
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 24
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 25
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 26
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 27
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 28
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 29
+        (removes the current item)
+
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 30
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 31
+
+        (also called from QPtrList's destructor)
+
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 32
+
+        In 99% of cases, the following idiom also works:
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 33
+
+        However, it may lead to crashes if \c list is referenced from
+        the value type's destructor, because \c list contains
+        dangling pointers until clear() is called.
+    \endtable
+
+    Be aware that QPtrList's destructor automatically calls clear().
+    If you have a QPtrList data member in a custom class and use the
+    auto-delete feature, you will need to call \c delete on all the
+    items in the container from your class destructor to avoid a
+    memory leak.
+
+    QPtrList had the concept of a "current item", which could be used
+    for traversing the list without using an iterator. When porting
+    to Qt 4, you can use the Java-style QListIterator<T *> (or
+    QMutableListIterator<T *>) class instead. The following table
+    summarizes the API differences:
+
+    \table
+    \header \o QPtrList function \o QListIterator equivalent
+    \row \o QPtrList::at() \o N/A
+    \row \o QPtrList::current() \o QMutableListIterator::value()
+    \row \o QPtrList::currentNode() \o N/A
+    \row \o QPtrList::findNext(const T *) \o QListIterator::findNext(const T *)
+    \row \o QPtrList::findNextRef(const T *) \o QListIterator::findNext(const T *)
+    \row \o QPtrList::first() \o QPtrList::toFront()
+    \row \o QPtrList::last() \o QPtrList::toBack()
+    \row \o QPtrList::next() \o QPtrList::next()
+    \row \o QPtrList::prev() \o QPtrList::previous()
+    \row \o QPtrList::remove() \o QMutableListIterator::remove()
+    \row \o QPtrList::take() \o QMutableListIterator::remove()
+    \endtable
+
+    Be aware that QListIterator has a different way of iterating than
+    QPtrList. A typical loop with QPtrList looks like this:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 34
+
+    Here's the equivalent QListIterator loop:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 35
+
+    Finally, QPtrListIterator<T> must also be ported. There are no
+    fewer than four iterator classes that can be used as a
+    replacement: QList::const_iterator, QList::iterator,
+    QListIterator, and QMutableListIterator. The most straightforward
+    class to use when porting is QMutableListIterator<T *> (if you
+    modify the list through the iterator) or QListIterator<T *> (if
+    you don't). The following table summarizes the API differences:
+
+    \table
+    \header \o QPtrListIterator function \o Qt 4 equivalent
+    \row \o QPtrListIterator::atFirst() \o !QListIterator::hasPrevious() (notice the \c{!})
+    \row \o QPtrListIterator::atLast() \o !QListIterator::hasNext() (notice the \c{!})
+    \row \o QPtrListIterator::count() \o QList::count() or QList::size()
+    \row \o QPtrListIterator::current() \o QMutableListIterator::value()
+    \row \o QPtrListIterator::isEmpty() \o QList::isEmpty()
+    \row \o QPtrListIterator::toFirst() \o QListIterator::toFront()
+    \row \o QPtrListIterator::toLast() \o QListIterator::toBack()
+    \row \o QPtrListIterator::operator() \o QMutableListIterator::value()
+    \row \o QPtrListIterator::operator*() \o QMutableListIterator::value()
+    \endtable
+
+    Again, be aware that QListIterator has a different way of
+    iterating than QPtrList. A typical loop with QPtrList looks like
+    this:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 36
+
+    Here's the equivalent QListIterator loop:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 37
+
+    Finally, QPtrListStdIterator<T> must also be ported. This is
+    easy, because QList also provides STL-style iterators
+    (QList::iterator and QList::const_iterator).
+
+    \section1 QPtrQueue<T>
+
+    QPtrQueue has been moved to the Qt3Support library.
+    It has been replaced by the more modern QQueue class.
+
+    The following table summarizes the differences between
+    QPtrQueue<T> and QQueue<T *>:
+
+    \table
+    \header \o QPtrQueue function \o QQueue equivalent
+    \row \o QPtrQueue::autoDelete() \o See discussion below
+    \row \o QPtrQueue::count() \o QQueue::count() or QQueue::size() (equivalent)
+    \row \o QPtrQueue::current() \o QQueue::head()
+    \row \o QPtrQueue::remove() \o QQueue::dequeue()
+    \row \o QPtrQueue::setAutoDelete() \o See discussion below
+    \endtable
+
+    If you use QPtrQueue's auto-delete feature (by calling
+    QPtrQueue::setAutoDelete(true)), you need to do some more work.
+    You have two options: Either you call \c delete yourself whenever
+    you remove an item from the container, or you can use QQueue<T>
+    instead of QQueue<T *> (i.e. store values directly instead of
+    pointers to values). Here, we will show when to call \c delete.
+
+    \omit
+    (See \l{What's Wrong with Auto-Delete} for an explanation of why
+    the Qt 4 containers don't offer that feature.)
+    \endomit
+
+    \table
+    \header \o QPtrQueue idiom \o QQueue idiom
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 38
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 39
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 40
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 41
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 42
+
+        (also called from QPtrQueue's destructor)
+
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 43
+
+        In 99% of cases, the following idiom also works:
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 44
+
+        However, it may lead to crashes if \c queue is referenced
+        from the value type's destructor, because \c queue contains
+        dangling pointers until clear() is called.
+    \endtable
+
+    \section1 QPtrStack<T>
+
+    QPtrStack has been moved to the Qt3Support library.
+    It has been replaced by the more modern QStack class.
+
+    The following table summarizes the differences between
+    QPtrStack<T> and QStack<T *>:
+
+    \table
+    \header \o QPtrStack function \o QStack equivalent
+    \row \o QPtrStack::autoDelete() \o See discussion below
+    \row \o QPtrStack::count() \o QStack::count() or QStack::size() (equivalent)
+    \row \o QPtrStack::current() \o QStack::top()
+    \row \o QPtrStack::remove() \o QStack::pop()
+    \row \o QPtrStack::setAutoDelete() \o See discussion below
+    \endtable
+
+    If you use QPtrStack's auto-delete feature (by calling
+    QPtrStack::setAutoDelete(true)), you need to do some more work.
+    You have two options: Either you call \c delete yourself whenever
+    you remove an item from the container, or you can use QStack<T>
+    instead of QStack<T *> (i.e. store values directly instead of
+    pointers to values). Here, we will show when to call \c delete.
+
+    \omit
+    (See \l{What's Wrong with Auto-Delete} for an explanation of why
+    the Qt 4 containers don't offer that feature.)
+    \endomit
+
+    \table
+    \header \o QPtrStack idiom \o QStack idiom
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 45
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 46
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 47
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 48
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 49
+
+        (also called from QPtrStack's destructor)
+
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 50
+
+        In 99% of cases, the following idiom also works:
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 51
+
+        However, it may lead to crashes if \c stack is referenced
+        from the value type's destructor, because \c stack contains
+        dangling pointers until clear() is called.
+    \endtable
+
+    \section1 QPtrVector<T>
+
+    QPtrVector<T> has been moved to Qt3Support. It has been replaced
+    by the more modern QVector class.
+
+    When porting to Qt 4, you can use QVector<T *> as an alternative
+    to QPtrVector<T>. The APIs of QPtrVector<T> and QVector<T *> are
+    somewhat similar. The main issue is that QPtrVector supports
+    auto-delete whereas QVector doesn't.
+
+    \omit
+    (See \l{What's Wrong with Auto-Delete} for an explanation of why
+    the Qt 4 containers don't offer that feature.)
+    \endomit
+
+    The following table summarizes the API differences between the
+    two classes:
+
+    \table
+    \header \o QPtrVector function \o QVector equivalent
+    \row \o QPtrVector::autoDelete() \o See discussion below
+    \row \o QPtrVector::bsearch(const T *) \o \l qBinaryFind()
+    \row \o QPtrVector::contains(const T *) \o QVector::count(T *)
+    \row \o QPtrVector::containsRef(const T *) \o QVector::count(T *)
+    \row \o QPtrVector::count() \o See remark below
+    \row \o QPtrVector::insert(uint, T *) \o See remark below
+    \row \o QPtrVector::isNull() \o N/A
+    \row \o QPtrVector::remove(uint) \o See remark below
+    \row \o QPtrVector::setAutoDelete() \o See discussion below
+    \row \o QPtrVector::sort() \o \l qSort()
+    \row \o QPtrVector::take(uint) \o See remark below
+    \row \o QPtrVector::toList(QGList *) \o QList::QList(const QVector &)
+    \endtable
+
+    Remarks:
+
+    \list 1
+    \o  QPtrVector::insert(uint, T *) sets an item to store a certain
+        pointer value. This is \e not the same as QVector::insert(int, T *),
+        which creates space for the item by moving following items by
+        one position. Use \c{vect[i] = ptr} to set a QVector item to
+        a particular value.
+    \o  QPtrVector::remove(uint) sets an item to be 0. This is \e not
+        the same as QVector::removeAt(int), which entirely erases the
+        item, reducing the size of the vector. Use \c{vect[i] = 0} to
+        set a QVector item to 0.
+    \o  Likewise, QPtrVector::take(uint) sets an item to be 0 and
+        returns the previous value of the item. Again, this is easy to
+        achieve using QVector::operator[]().
+    \o  QPtrVector::count() returns the number of non-null items in
+        the vector, whereas QVector::count() (like QVector::size())
+        returns the number of items (null or non-null) in the vector.
+        Fortunately, it's not too hard to simulate QPtrVector::count().
+
+        \oldcode
+        int numValidItems = vect.count();
+        \newcode
+        int numValidItems = vect.size() - vect.count(0);
+        \endcode
+    \endlist
+
+    If you use QVector's auto-delete feature (by calling
+    QVector::setAutoDelete(true)), you need to do some more work. You
+    have two options: Either you call \c delete yourself whenever you
+    remove an item from the container, or you use QVector<T> instead
+    of QVector<T *> (i.e. store values directly instead of pointers
+    to values). Here, we'll see when to call \c delete.
+
+    The following table summarizes the idioms that you need to watch
+    out for if you want to call \c delete yourself.
+
+    \table
+    \header \o QPtrVector idiom \o QVector idiom
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 52
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 53
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 54
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 55
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 56
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 57
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 58
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 59
+    \row
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 60
+
+        (also called from QPtrVector's destructor)
+
+        \o
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 61
+
+        In 99% of cases, the following idiom also works:
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 62
+
+        However, it may lead to crashes if \c vect is referenced from
+        the value type's destructor, because \c vect contains
+        dangling pointers until clear() is called.
+    \endtable
+
+    Be aware that QPtrVector's destructor automatically calls
+    clear(). If you have a QPtrVector data member in a custom class
+    and use the auto-delete feature, you will need to call \c delete
+    on all the items in the container from your class destructor to
+    avoid a memory leak.
+
+    \section1 QPushButton
+
+    See \l{#properties}{Properties} for a list of QPushButton
+    properties in Qt 3 that have changed in Qt 4.
+
+    \section1 QRangeControl
+
+    In Qt 3, various "range control" widgets (QDial, QScrollBar,
+    QSlider, and QSpin) inherited from both QWidget and
+    \c QRangeControl.
+
+    In Qt 4, \c QRangeControl has been replaced with the new
+    QAbstractSlider and QAbstractSpinBox classes, which inherit from
+    QWidget and provides similar functionality. Apart from eliminating
+    unnecessary multiple inheritance, the new design allows
+    QAbstractSlider to provide signals, slots, and properties.
+
+    The old \c QRangeControl class has been renamed Q3RangeControl
+    and moved to the Qt3Support library, together with
+    the (undocumented) \c QSpinWidget class.
+
+    If you use \c QRangeControl as a base class in your application,
+    you can switch to use QAbstractSlider or QAbstractSpinBox instead.
+
+    \oldcode
+        class VolumeControl : public QWidget, public QRangeControl
+        {
+            ...
+        protected:
+            void valueChange() {
+                update();
+                emit valueChanged(value());
+            }
+            void rangeChange() {
+                update();
+            }
+            void stepChange() {
+                update();
+            }
+        };
+    \newcode
+        class VolumeControl : public QAbstractSlider
+        {
+            ...
+        protected:
+            void sliderChange(SliderChange change) {
+                update();
+                if (change == SliderValueChange)
+                    emit valueChanged(value());
+            }
+        };
+    \endcode
+
+    \section1 QRegExp
+
+    The search() and searchRev() functions have been renamed to indexIn()
+    and lastIndexIn() respectively.
+
+    \section1 QRegion
+
+    The following changes have been made to QRegion in Qt 4:
+
+    \list
+    \o  There is no longer any difference between a \e null region and
+        an \e empty region. Use isEmpty() in most places where you
+        would have used a null QRegion.
+    \o  QRegion::rects() used to return a QMemArray<QRect>. It now returns
+        a QVector<QRect>.
+    \endlist
+
+    \section1 QScrollBar
+
+    See \l{#properties}{Properties} for a list of QScrollBar
+    properties in Qt 3 that have changed in Qt 4.
+
+    \section1 QScrollView
+
+    The \c QScrollView class has been renamed Q3ScrollView and moved
+    to the Qt3Support library. It has been replaced by
+    the QAbstractScrollArea and QScrollArea classes.
+
+    Note that Qt 4 in general uses the QScrollArea::widget() function
+    where Qt 3 used QScrollView::viewport(). The rationale for this is
+    that it is no longer possible to draw directly on a scroll
+    area. The QScrollArea::widget() function returns the widget set on
+    the scroll area.
+
+    \c QScrollView was designed to work around the 16-bit limitation
+    on widget coordinates found on most window systems. In Qt 4, this
+    is done transparently for \e all widgets, so there is no longer a
+    need for such functionality in \c QScrollView. For that reason,
+    the new QAbstractScrollArea and QScrollArea classes are much more
+    lightweight, and concentrate on handling scroll bars.
+
+    \section1 QServerSocket
+
+    The \c QServerSocket class has been renamed Q3ServerSocket and
+    moved to the Qt3Support library. In Qt 4, it has been
+    replaced by QTcpServer.
+
+    With Q3ServerSocket, connections are accepted by reimplementing a
+    virtual function (Q3ServerSocket::newConnection()). With
+    QTcpServer, on the other hand, you don't need to subclass.
+    Instead, simply connect to the QTcpServer::newConnection()
+    signal.
+
+    \section1 QSettings
+
+    The QSettings class has been rewritten to be more robust and to
+    respect existing standards (e.g., the INI file format). The API
+    has also been extensively revised. The old API is still provided
+    when Qt 3 support is enabled.
+
+    Since the format and location of settings have changed between Qt
+    3 and Qt 4, the Qt 4 version of your application won't recognize
+    settings written using Qt 3.
+
+    \section1 QShared
+
+    The \c QShared class has been obsoleted by the more powerful
+    QSharedData and QSharedDataPointer as a means of creating custom
+    implicitly shared classes. It has been renamed Q3Shared moved to
+    the Qt3Support library.
+
+    An easy way of porting to Qt 4 is to include this class into your
+    project and to use it instead of \c QShared:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 63
+
+    If possible, we recommend that you use QSharedData and
+    QSharedDataPointer instead. They provide thread-safe reference
+    counting and handle all the reference counting behind the scenes,
+    eliminating the risks of forgetting to increment or decrement the
+    reference count.
+
+    \section1 QSignal
+
+    The QSignal class has been renamed to Q3Signal and moved to the
+    Qt3Support library. The preferred approach is to create your own
+    QObject subclass with a signal that has the desired signature.
+    Alternatively, you can call QMetaObject::invokeMethod() if you
+    want to invoke a slot.
+
+    \section1 QSimpleRichText
+
+    QSimpleRichText has been obsoleted by QTextDocument. It has
+    bene renamed Q3SimpleRichText and moved to the Qt3Support
+    library.
+
+    Previously, you would do the following with Q3SimpleRichText:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 63a
+
+    However, with QTextDocument, you use the following code instead:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 63b
+
+    See \l{Rich Text Processing} for an overview of the Qt 4 rich
+    text classes.
+
+    \section1 QSlider
+
+    The QSlider::sliderStart() and QSlider::sliderRect() functions
+    have been removed.
+
+    The slider's rect can now be retrieved using the code snippet below:
+
+    \snippet doc/src/snippets/code/doc_src_porting4.qdoc 63c
+
+    In addition, the direction of a vertical QSlider has changed,
+    i.e. the bottom is now the minimum, and the top the maximum. You
+    can use the QAbstractSlider::invertedAppearance property to
+    control this behavior.
+
+    See \l{#properties}{Properties} for a list of QSlider properties
+    in Qt 3 that have changed in Qt 4.
+
+    \section1 QSocket
+
+    The \c QSocket class has been renamed Q3Socket and moved to the
+    Qt3Support library. In Qt 4, it has been replaced by
+    the QTcpSocket class, which inherits most of its functionality
+    from QAbstractSocket.
+
+    \section1 QSocketDevice
+
+    The \c QSocketDevice class has been renamed Q3SocketDevice and
+    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.
+
+    \o If you use Q3SocketDevice for UDP, you can now use QUdpSocket instead.
+
+    \o If you use Q3SocketDevice for other uses, Qt 4 offers no
+    alternative right now. However, there is a \c QAbstractSocketEngine
+    internal class that offers a low-level socket API similar to
+    Q3SocketDevice. Should the need for such functionality arise in
+    Qt 4 applications, we will consider making this class public in a
+    future release.
+    \endlist
+
+    \section1 QSortedList
+
+    The QSortedList<T> class has been deprecated since Qt 3.0. In Qt
+    4, it has been moved to the Qt3Support library.
+
+    In new code, we recommend that you use QList<T> instead and use
+    \l qSort() to sort the items.
+
+    \section1 QSplitter
+
+    The function setResizeMode() has been moved into Qt3Support. Set
+    the stretch factor in the widget's size policy to get equivalent
+    functionality.
+
+    The obsolete function drawSplitter() has been removed. Use
+    QStyle::drawPrimitive() to acheive similar functionality.
+
+    \section1 QSpinBox
+
+    See \l{#properties}{Properties} for a list of QSpinBox properties
+    in Qt 3 that have changed in Qt 4.
+
+    \section1 QSqlCursor
+
+    The \c QSqlCursor class has been renamed Q3SqlCursor and moved to
+    the Qt3Support library. In Qt 4, you can use
+    QSqlQuery, QSqlQueryModel, or QSqlTableModel, depending on
+    whether you want a low-level or a high-level interface for
+    accessing databases.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QSqlDatabase
+
+    QSqlDatabase is now a smart pointer that is passed around by
+    value. Simply replace all QSqlDatabase pointers by QSqlDatabase
+    objects.
+
+    \section1 QSqlEditorFactory
+
+    The \c QSqlEditorFactory class has been renamed
+    Q3SqlEditorFactory and moved to Qt3Support.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QSqlError
+
+    The enum \c{Type} was renamed to \c{ErrorType}, The values were renamed as well:
+
+    \list
+    \o None - use NoError instead
+    \o Connection - use ConnectionError instead
+    \o Statement - use StatementError instead
+    \o Transaction - use TransactionError instead
+    \o Unknown - use UnknownError instead
+    \endlist
+
+    \section1 QSqlFieldInfo
+
+    The QSqlFieldInfo class has been moved to Qt3Support. Its
+    functionality is now provided by the QSqlField class.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QSqlForm
+
+    The \c QSqlForm class has been renamed Q3SqlForm and moved to the
+    Qt3Support library.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QSqlPropertyMap
+
+    The \c QSqlPropertyMap class has been renamed Q3SqlPropertyMap
+    moved to the Qt3Support library.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QSqlQuery
+
+    QSqlQuery::prev() was renamed to QSqlQuery::previous().
+    QSqlQuery::prev() remains, but it just calls previous().
+    QSqlQuery no longer has any virtual methods, i.e., exec(),
+    value(), seek(), next(), prev(), first(), last(), and the
+    destructor are no longer virtual.
+
+    \section1 QSqlRecord
+
+    QSqlRecord behaves like a vector now, QSqlRecord::insert() will
+    actually insert a new field instead of replacing the existing
+    one.
+
+    \section1 QSqlRecordInfo
+
+    The QSqlRecordInfo class has been moved to Qt3Support. Its
+    functionality is now provided by the QSqlRecord class.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QSqlSelectCursor
+
+    The \c QSqlSelectCursor class has been renamed Q3SqlSelectCursor
+    and moved to the Qt3Support library.
+
+    See \l{QtSql Module} for an overview of the new SQL classes.
+
+    \section1 QStoredDrag
+
+    The \c QStoredDrag class has been renamed Q3StoredDrag and moved
+    to the Qt3Support library. In Qt 4, use QMimeData
+    instead and call QMimeData::setData() to set the data.
+
+    See \l{Porting to Qt 4 - Drag and Drop} for a comparison between
+    the drag and drop APIs in Qt 3 and Qt 4.
+
+    \section1 QStr(I)List
+
+    The QStrList and QStrIList convenience classes have been
+    deprecated since Qt 2.0. In Qt 4, they have been moved to the
+    Qt3Support library. If you used any of these, we
+    recommend that you use QStringList or QList<QByteArray> instead.
+
+    \section1 QStr(I)Vec
+
+    The QStrVec and QStrIVec convenience classes have been deprecated
+    since Qt 2.0. In Qt 4, they have been moved to Qt3Support. If you
+    used any of these, we recommend that you use QStringList or
+    QList<QByteArray> instead.
+
+    \section1 QString
+
+    Here are the main issues to be aware of when porting QString to
+    Qt 4:
+
+    \list 1
+    \o  The QString::QString(QChar) constructor performed implicit
+        conversion in Qt 3. Now, you will need a cast to convert a
+        QChar to a QString.
+
+    \o  The QString::QString(const QByteArray &) constructor used to
+        stop at the first '\\0' it encountered, for compatibility
+        with Qt 1. This quirk has now been fixed; in Qt 4, the
+        resulting QString always has the same length as the
+        QByteArray that was passed to the constructor.
+
+    \o  The QString::null static constant has been deprecated in Qt
+        4. For compatibility, Qt 4 provides a QString::null symbol
+        that behaves more or less the same as the old constant. The
+        new idiom is to write QString() instead of QString::null, or
+        to call clear().
+
+        \oldcode
+            str1 = QString::null;
+            if (str2 == QString::null)
+                do_something(QString::null);
+        \newcode
+            str1.clear();
+            if (str2.isNull())
+                do_something(QString());
+        \endcode
+
+        In new code, we recommend that you don't rely on the
+        distinction between a null string and a (non-null) empty
+        string. See \l{Distinction Between Null and Empty Strings}
+        for details.
+
+    \o  QString::latin1() and QString::ascii() have been replaced
+        with QString::toLatin1() and QString::toAscii(), which return
+        a QByteArray instead of a (non-reentrant) \c{const char *}.
+        For consistency, QString::utf8() and QString::local8Bit(),
+        which already returned a QByteArray (actually a \c QCString),
+        have been renamed QString::toUtf8() and
+        QString::toLocal8Bit().
+
+        To obtain a \c{const char *} pointer to ASCII or Latin-1 data,
+        use QString::toAscii() or QString::toLatin1() to obtain a
+        QByteArray containing the data, then call QByteArray::constData()
+        to access the character data directly. Note that the pointer
+        returned by this function is only valid for the lifetime of the
+        byte array; you should avoid taking a pointer to the data
+        contained in temporary objects.
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 64
+
+        In the above example, the \c goodData pointer is valid for the lifetime
+        of the \c asciiData byte array. If you need to keep a copy of the data
+        in a non-Qt data structure, use standard C memory allocation and string
+        copying functions to do so \e before destroying the byte array.
+
+    \o  QString::at() returned a non-const reference, whereas the
+        new QString::at() returns a const value. Code like
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 65
+
+        will no longer compile. Instead, use QString::operator[]:
+
+        \snippet doc/src/snippets/code/doc_src_porting4.qdoc 66
+
+    \o  The QString::contains(\e x) function (where \e x is a
+        character or a string) has been renamed QString::count(\e x).
+        In addition, there now exists a set of QString::contains()
+        functions that returns a boolean value. Replace old calls to
+        contains() with either count() or contains(), depending on
+        whether you care about the specific number of occurrences of
+        a character in the string or only care about whether the
+        string contains that character or not.
+
+    \o  Many functions in QString had a \c bool parameter that
+        specified case sensitivity. In Qt 4, in the interest of code
+        readability and maintainability, the \c bool parameters have
+        been replaced by the Qt::CaseSensitivity enum, which can take
+        the values Qt::CaseSensitive and Qt::CaseInsensitive.
+
+        \oldcode
+            if (url.startsWith("http:", false))
+                ...
+        \newcode
+            if (url.startsWith("http:", Qt::CaseInsensitive))
+                ...
+        \endcode
+
+    \o  The QString::setExpand(uint, QChar) function, which already
+        was obsolete in Qt 3, is no longer available. Use
+        QString::operator[] instead.
+
+        \oldcode
+            str.setExpand(32, '$');
+        \newcode
+            str[32] = '$';
+        \endcode
+
+    \o  The \c QT_NO_ASCII_CAST and \c QT_NO_CAST_ASCII macros have
+        been renamed \c QT_NO_CAST_TO_ASCII and \c
+        QT_NO_CAST_FROM_ASCII, respectively.
+
+    \o  The QString::data() used to return the same as
+        QString::ascii(). It now returns a pointer to the Unicode
+        data stored in the QString object. Call QString::ascii() if
+        you want the old behavior.
+
+    \o  QString::arg() now converts two-digit place markers, allowing
+        up to 99 place markers to be used in any given string.
+
+    \o  Comparisons between QStrings and \c NULL in order to determine
+        whether strings are empty are no longer allowed.
+        Use \l{QString::}{isEmpty()} instead.
+
+    \endlist
+
+    \section1 QStringList
+
+    QStringList now inherits from QList<QString> and can no longer be
+    converted to a QValueList<QString>. Since QValueList inherits QList a
+    cast will work as expected.
+
+    This change implies some API incompatibilities for QStringList.
+    For example, at() returns the string, not an iterator. See the
+    \l{#qvaluelist.section}{section on QValueList} for details.
+
+    The static QStringList::split() function for splitting strings into
+    lists of smaller strings has been replaced by QString::split(),
+    which returns a QStringList.
+
+    \section1 QStyle
+
+    The QStyle API has been overhauled and improved. Most of the information on
+    why this change was done is described in \l{The Qt 4 Style API}{the QStyle overview}.
+
+    Since QStyle is mostly used internally by Qt's widgets and styles and since
+    it is not essential to the good functioning of an application, there is no
+    compatibility path. This means that we have changed many enums and
+    functions and the qt3to4 porting tool will not change much in your qstyle
+    code. To ease the pain, we list some of the major changes here.
+
+    QStyleOption has taken on a more central role and is no longer an optional
+    argument, please see the QStyleOption documentation for more information.
+
+    The QStyle::StyleFlags have been renamed QStyle::StateFlags and are now prefixed State_
+    instead of Style_, in addition the Style_ButtonDefault flag has moved to
+    QStyleOptionButton.
+
+    The QStyle::PrimitiveElement enumeration has undergone extensive change.
+    Some of the enums were moved to QStyle::ControlElement, some were removed
+    and all were renamed. This renaming is not done by the qt3to4 porting tool,
+    so you must do it yourself. The table below shows how things look
+    now.
+
+    \table
+    \header \o Old name \o New name \o Remark
+    \row \o \c PE_ButtonCommand             \o QStyle::PE_PanelButtonCommand
+    \row \o \c PE_ButtonDefault             \o QStyle::PE_FrameDefaultButton
+    \row \o \c PE_ButtonBevel               \o QStyle::PE_PanelButtonBevel
+    \row \o \c PE_ButtonTool                \o QStyle::PE_PanelButtonTool
+    \row \o \c PE_ButtonDropDown            \o QStyle::PE_IndicatorButtonDropDown
+    \row \o \c PE_FocusRect                 \o QStyle::PE_FrameFocusRect
+    \row \o \c PE_ArrowUp                   \o QStyle::PE_IndicatorArrowUp
+    \row \o \c PE_ArrowDown                 \o QStyle::PE_IndicatorArrowDown
+    \row \o \c PE_ArrowRight                \o QStyle::PE_IndicatorArrowRight
+    \row \o \c PE_ArrowLeft                 \o QStyle::PE_IndicatorArrowLeft
+    \row \o \c PE_SpinBoxUp                 \o QStyle::PE_IndicatorSpinUp
+    \row \o \c PE_SpinBoxDown               \o QStyle::PE_IndicatorSpinDown
+    \row \o \c PE_SpinBoxPlus               \o QStyle::PE_IndicatorSpinPlus
+    \row \o \c PE_SpinBoxMinus              \o QStyle::PE_IndicatorSpinMinus
+    \row \o \c PE_SpinBoxSlider             \o QStyle::CE_SpinBoxSlider \o uses QStyle::drawControl()
+    \row \o \c PE_Indicator                 \o QStyle::PE_IndicatorCheckBox
+    \row \o \c PE_IndicatorMask             \o N/A \o use QStyle::styleHint() to retrieve mask
+    \row \o \c PE_ExclusiveIndicator        \o QStyle::PE_IndicatorRadioButton
+    \row \o \c PE_ExclusiveIndicatorMask    \o N/A \o use QStyle::styleHint() to retrieve mask
+    \row \o \c PE_DockWindowHandle          \o QStyle::PE_IndicatorToolBarHandle
+    \row \o \c PE_DockWindowSeparator       \o QStyle::PE_Q3DockWindowSeparator
+    \row \o \c PE_DockWindowResizeHandle    \o QStyle::PE_IndicatorDockWindowResizeHandle
+    \row \o \c PE_DockWindowTitle           \o QStyle::CE_DockWindowTitle \o uses QStyle::drawControl()
+    \row \o \c PE_Splitter                  \o QStyle::CE_Splitter \o uses QStyle::drawControl()
+    \row \o \c PE_Panel                     \o QStyle::PE_Frame
+    \row \o \c PE_PanelMenu                 \o QStyle::PE_FrameMenu
+    \row \o \c PE_PanelMenuBar              \o QStyle::PE_PanelMenuBar
+    \row \o \c PE_PanelDockWindow           \o QStyle::PE_FrameDockWindow
+    \row \o \c PE_TabBarBase                \o QStyle::PE_FrameTabBarBase
+    \row \o \c PE_HeaderSection             \o QStyle::CE_HeaderSection \o uses QStyle::drawControl()
+    \row \o \c PE_HeaderArrow               \o QStyle::PE_IndicatorHeaderArrow
+    \row \o \c PE_StatusBarSection          \o QStyle::PE_FrameStatusBar
+    \row \o \c PE_Separator                 \o QStyle::PE_Q3Separator
+    \row \o \c PE_SizeGrip                  \o QStyle::CE_SizeGrip \o uses QStyle::drawControl()
+    \row \o \c PE_CheckMark                 \o QStyle::PE_IndicatorMenuCheckMark
+    \row \o \c PE_ScrollBarAddLine          \o QStyle::CE_ScrollBarAddLine \o uses QStyle::drawControl()
+    \row \o \c PE_ScrollBarSubLine          \o QStyle::CE_ScrollBarSubLine \o uses QStyle::drawControl()
+    \row \o \c PE_ScrollBarAddPage          \o QStyle::CE_ScrollBarAddPage \o uses QStyle::drawControl()
+    \row \o \c PE_ScrollBarSubPage          \o QStyle::CE_ScrollBarSubPage \o uses QStyle::drawControl()
+    \row \o \c PE_ScrollBarSlider           \o QStyle::CE_ScrollBarSlider  \o uses QStyle::drawControl()
+    \row \o \c PE_ScrollBarFirst            \o QStyle::CE_ScrollBarFirst   \o uses QStyle::drawControl()
+    \row \o \c PE_ScrollBarLast             \o QStyle::CE_ScrollBarLast    \o uses QStyle::drawControl()
+    \row \o \c PE_ProgressBarChunk          \o QStyle::PE_IndicatorProgressChunk
+    \row \o \c PE_PanelLineEdit             \o QStyle::PE_FrameLineEdit
+    \row \o \c PE_PanelTabWidget            \o QStyle::PE_FrameTabWidget
+    \row \o \c PE_WindowFrame               \o QStyle::PE_FrameWindow
+    \row \o \c PE_CheckListController       \o QStyle::PE_Q3CheckListController
+    \row \o \c PE_CheckListIndicator        \o QStyle::PE_Q3CheckListIndicator
+    \row \o \c PE_CheckListExclusiveIndicato\o QStyle::PE_Q3CheckListExclusiveIndicator
+    \row \o \c PE_PanelGroupBox             \o QStyle::PE_FrameGroupBox
+    \row \o \c PE_TreeBranch                \o QStyle::PE_IndicatorBranch
+    \row \o \c PE_RubberBand                \o QStyle::CE_RubberBand \o uses QStyle::drawControl()
+    \row \o \c PE_PanelToolBar              \o QStyle::PE_PanelToolBar
+    \row \o \c PE_ToolBarHandle             \o QStyle::PE_IndicatorToolBarHandle
+    \row \o \c PE_ToolBarSeparator          \o QStyle::PE_IndicatorToolBarSeparator
+    \endtable
+
+    The QStyle::drawControlMask() and QStyle::drawComplexControlMask()
+    functions have been removed. They are replaced with a style hint.
+
+    The QStyle::drawItem() overloads that took both a pixmap and a string have
+    been removed. Use QStyle::drawItemText() and QStyle::drawItemPixmap() directly.
+
+    The QStyle::itemRect() overload that took both a pixmap and a string is also removed, use
+    either QStyle::itemTextRect() or QStyle::itemPixmapRect() instead.
+
+    \section1 QStyleSheet
+
+    The QStyleSheet and QStyleSheetItem classes have been renamed
+    Q3StyleSheet and Q3StyleSheetItem, and have been moved to the
+    Qt3Support library.
+
+    See \l{Rich Text Processing} for an overview of the Qt 4 rich
+    text classes, and \l{Qt Style Sheets} for a description of
+    CSS-like style sheet support in Qt 4.2 and above.
+
+    \section1 QSyntaxHighlighter
+
+    The \c QSyntaxHighlighter class from Qt 3 has been renamed
+    Q3SyntaxHighlighter and moved to the Qt3Support library. Since Qt
+    4.1, it has been replaced by a new QSyntaxHighlighter class based
+    on Qt 4's new rich text engine.
+
+    \section1 QTabBar
+
+    See \l{#properties}{Properties} for a list of QTabBar properties
+    in Qt 3 that have changed in Qt 4.
+
+    \section1 QTabDialog
+
+    The \c QTabDialog class is no longer part of the public Qt API.
+    It has been renamed Q3TabDialog and moved to Qt3Support. In Qt 4
+    applications, you can easily obtain the same result by combining
+    a QTabWidget with a QDialog and provide \l{QPushButton}s
+    yourself.
+
+    See also the \l{dialogs/tabdialog} example, which shows how to
+    implement tab dialogs in Qt 4.
+
+    \section1 QTabWidget
+
+    See \l{#properties}{Properties} for a list of QTabWidget
+    properties in Qt 3 that have changed in Qt 4.
+
+    \section1 QTable
+
+    The \c QTable, \c QTableItem, \c QComboTableItem, \c
+    QCheckTableItem, and \c QTableSelection classes have been renamed
+    Q3Table, Q3TableItem, Q3ComboTableItem, Q3CheckTableItem, and
+    Q3TableSelection and moved to the Qt3Support library.
+    New Qt applications should use the new QTableWidget or QTableView
+    class instead.
+
+    Some of these classes behave differently with respect to the way
+    they handle \c NULL pointers. For example, Q3TableItem::setPixmap()
+    no longer accepts \c NULL or 0 to indicate that the item should
+    contain a null pixmap; in this case, a null pixmap should be
+    constructed and passed explicitly to the function.
+
+    See \l{Model/View Programming} for an overview of the new item
+    view classes.
+
+    \section1 QTextCodec
+
+    The loadCharmap() and loadCharmapFromFile() functions are no longer
+    available in Qt 4. You need to create your own codec if you want to
+    create a codec based on a POSIX2 charmap definition.
+
+    \section1 QTextDrag
+
+    The \c QTextDrag class has been renamed Q3TextDrag and moved to
+    the Qt3Support library. In Qt 4, use QMimeData
+    instead and call QMimeData::setText() to set the data.
+
+    See \l{Porting to Qt 4 - Drag and Drop} for a comparison between
+    the drag and drop APIs in Qt 3 and Qt 4.
+
+    \section1 QTextEdit
+
+    The old QTextEdit and QTextBrowser classes have been renamed
+    Q3TextEdit and Q3TextBrowser, and have been moved to Qt3Support.
+    The new QTextEdit and QTextBrowser have a somewhat different API.
+
+    The \c QTextEdit::setWrapPolicy() function has been renamed to \l{QTextEdit::setWordWrapMode()}{setWordWrapMode()} and the
+    \c QTextEdit::setWrapColumnOrWidth() function has been renamed to \l{QTextEdit::setLineWrapColumnOrWidth()}
+    {setLineWrapColumnOrWidth()}. The Q3TextEdit::setWrapPolicy() and Q3TextEdit::setWrapColumnOrWidth() still provide this
+    functionality in the Q3TextEdit class.
+
+
+    See \l{Rich Text Processing} for an overview of the Qt 4 rich
+    text classes.
+
+    \section1 QTextIStream
+
+    The QTextIStream convenience class is no longer provided in Qt 4. Use
+    QTextStream directly instead.
+
+    \section1 QTextOStream
+
+    The QTextOStream convenience class is no longer provided in Qt 4. Use
+    QTextStream directly instead.
+
+    \section1 QTextOStreamIterator
+
+    The undocumented \c QTextOStreamIterator class has been removed
+    from the Qt library. If you need it in your application, feel
+    free to copy the source code from the Qt 3 \c <qtl.h> header
+    file.
+
+    \section1 QTextStream
+
+    QTextStream has undergone a number of API and implementation enhancements,
+    and some of the changes affect QTextStream's behavior:
+
+    \list
+    \o QTextStream now uses buffered writing, which means that you need to
+       call QTextStream::flush(), or use the streaming manipulators \c endl or
+       \c flush if you need QTextStream to flush its write buffer. The stream is
+       flushed automatically if QTextStream is deleted or when the device is
+       closed.
+    \o QTextStream now uses buffered reading, so if you read a line from the
+       stream, QTextStream will read as much as it can from the device to
+       fill up its internal read buffer. This speeds up reading significantly,
+       but Qt 3 code that mixed QTextStream access and direct device access
+       may need to be updated.
+    \o While QTextStream in Qt 3 always translated end-of-line characters from
+       Windows style ("\\r\\n") to Unix style ("\\n") on Windows, QTextStream in
+       Qt 4 only does this on devices opened with the \c{QIODevice::Text} mode
+       (formerly \c{IO_Translate}).
+    \endlist
+
+    Note that when using a QTextStream on a QFile in Qt 4, calling
+    QIODevice::reset() on the QFile will not have the expected result
+    because QTextStream now buffers the file. Use the
+    QTextStream::seek() function instead.
+
+    \section1 QTextView
+
+    The \c QTextView class has been renamed Q3TextView and moved to the
+    Qt3Support library.
+
+    \section1 QTimeEdit
+
+    The QTimeEdit class in Qt 4 is a convenience class based on
+    QDateTimeEdit. The old class has been renamed Q3TimeEdit and moved
+    to the Qt3Support library.
+
+    See \l{Porting to Qt 4 - Virtual Functions}{Virtual Functions} for
+    a list of \c QTimeEdit virtual member functions in Qt 3 that are no
+    longer virtual in Qt 4.
+
+    \section1 QTimer
+
+    Windows restricts the granularity of timers, but starting with Qt 4,
+    we emulate a finer time resolution. On Windows XP we use the
+    multimedia timer API, which gives us 1 millisecond resolution for
+    QTimer.
+
+    Note that other versions of Windows have a lower timer resolution,
+    and that code relying on underlying system timer restrictions
+    encounters no such limitations using Qt 4 (e.g., setting an
+    interval of 0 millisecond results in Qt occupying all of the
+    processor time when no GUI events need processing).
+
+    \section1 QToolBar
+
+    The old \c QToolBar class, which worked with the old \c
+    QMainWindow and \c QDockArea classes and inherited from \c
+    QDockWindow, has been renamed Q3ToolBar and moved to
+    Qt3Support. Note that, when using Q3ToolBar, the toolbar's actions
+    must be \l {Q3Action}s.
+
+    Use the new QToolBar class in new applications.
+
+    \note \l{Q3ToolBar}'s
+    \l{Q3DockWindow::setHorizontallyStretchable()}{horizontallyStretchable}
+    property can be achieved in QToolBar with
+    \l{QWidget#Size Hints and Size Policies}{size policies}.
+
+    \section1 QToolButton
+
+    See \l{#properties}{Properties} for a list of QToolButton properties
+    in Qt 3 that have changed in Qt 4.
+
+    Note that many of the properties that could previously be set in
+    the constructor must now be set separately.
+
+    \section1 QToolTip
+
+    The QToolTip::setGloballyEnabled() function no longer exists.
+    Tooltips can be disabled by \l{QObject::installEventFilter()}{installing
+    an event filter} on qApp (the unique QApplication object) to block events
+    of type QEvent::ToolTip.
+
+    \section1 QUriDrag
+
+    The \c QUriDrag class has been renamed Q3UriDrag and moved to the
+    Qt3Support library. In Qt 4, use QMimeData instead
+    and call QMimeData::setUrl() to set the URL.
+
+    See \l{Porting to Qt 4 - Drag and Drop} for a comparison between
+    the drag and drop APIs in Qt 3 and Qt 4.
+
+    \section1 QUrl
+
+    The QUrl class has been rewritten from scratch in Qt 4 to be more
+    standard-compliant. The old QUrl class has been renamed Q3Url and
+    moved to the Qt3Support library.
+
+    The new QUrl class provides an extensive list of compatibility
+    functions to ease porting from Q3Url to QUrl. A few functions
+    require you to change your code:
+
+    \list
+    \o Q3Url::Q3Url(const Q3Url &, const QString &, bool) can be
+       simulated by combining the URLs manually (using
+       QString::operator+(), for example).
+    \o Q3Url::setEncodedPathAndQuery(const QString &) is replaced by
+       QUrl::setPath() and QUrl::setEncodedQuery().
+    \o Q3Url::encodedPathAndQuery() is replaced by QUrl::path() and
+       QUrl::encodedQuery().
+    \o Q3Url::isLocalFile() can be simulated by checking that
+       QUrl::protocol() is "file".
+    \o Q3Url::toString(bool, bool) is replaced by
+       QUrl::toString(int), where the \c int parameter specifies a
+       combination of \l{QUrl::FormattingOptions}{formatting
+       options}.
+    \endlist
+
+    \section1 QUrlOperator
+
+    The \c QUrlOperator class is no longer part of the public Qt API.
+    It has been renamed Q3UrlOperator and moved to Qt3Support.
+
+    From Qt 4.4, the Network Access API provides a subset of the features
+    provided by \c QUrlOperator that are mostly intended for use with
+    applications that use the HTTP and FTP protocols. See the
+    QNetworkRequest, QNetworkReply, and QNetworkAccessManager documentation
+    for further details.
+
+    \target qvaluelist.section
+    \section1 QValueList<T>
+
+    The QValueList<T> class has been replaced by QList<T> and
+    QLinkedList<T> in Qt 4. As a help when porting older Qt
+    applications, the Qt3Support library contains a
+    QValueList<T> class implemented in terms of the new
+    QLinkedList<T>. Similarly, it contains QValueListIterator<T> and
+    QValueListConstIterator<T> classes implemented in terms of
+    QLinkedList<T>::iterator and QLinkedList<T>::const_iterator.
+
+    When porting to Qt 4, you have the choice of using QList<T> or
+    QLinkedList<T> as alternatives to QValueList<T>. QList<T> has an
+    index-based API and provides very fast random access
+    (QList::operator[]), whereas QLinkedList<T> has an iterator-based
+    API.
+
+    Here's a list of problem functions:
+
+    \list
+    \o  QValueList(const std::list<T> &) doesn't exist in QList or
+        QLinkedList. You can simulate it by calling
+        \l{QLinkedList::append()}{append()} in a loop.
+
+    \o  QValueList::insert(iterator, size_type, const T& x) doesn't
+        exist in QList or QLinkedList. Call
+        \l{QLinkedList::insert()}{insert()} repeatedly instead.
+
+    \o  QValueList::fromLast() doesn't exist in QList or QLinkedList. Use
+        QValueList::end() instead.
+
+        \oldcode
+        for (QValueList<T>::iterator i = list.fromLast(); i != list.begin(); --i)
+            do_something(*i);
+        \newcode
+        QLinkedList<T>::iterator i = list.end();
+        while (i != list.begin()) {
+            --i; // decrement i before using it
+            do_something(*i);
+        }
+        \endcode
+
+    \o  QValueList::append() and QValueList::prepend() return an
+        iterator to the inserted item. QList's and QLinkedList's
+        corresponding functions don't, but it's not a problem because
+        QValueList::prepend() always returns begin() and append()
+        always returns QValueList::end() - 1.
+
+    \o  QValueList::at(\e i) return an iterator to the item at index
+        \e i. This corresponds to QList::begin() + \e i.
+
+    \o  QValueList::contains(const T &) corresponds to
+        QList::count(const T &) and QLinkedList::count(const T &).
+    \endlist
+
+    \section1 QValueVector<T>
+
+    The QValueVector<T> class has been replaced by QVector<T> in Qt
+    4. As a help when porting older Qt applications, the Qt3Support
+    library contains a Q3ValueVector<T> class implemented in terms of
+    the new QVector<T>.
+
+    When porting from QValueVector<T> to QVector<T>, you might run
+    into the following incompatibilities:
+
+    \list
+    \o QValueVector(const std::vector<T> &) doesn't exist in QVector.
+       You can simulate it by calling QVector::append()} in a loop.
+    \o QValueVector::resize(int, const T &) doesn't exist in QVector.
+       If you want the new items to be initialized with a particular
+       value, use QVector::insert() instead.
+    \o QValueVector::at() on a non-const vector returns a non-const
+       reference. This corresponds to QVector::operator[]().
+    \o Both QValueVector::at() functions have an \e ok parameter of
+       type \c{bool *} that is set to true if the index is within
+       bounds. This functionality doesn't exist in QVector; instead,
+       check the index against QVector::size() yourself.
+    \endlist
+
+    See \l{Generic Containers} for an overview of the Qt 4 container
+    classes.
+
+    \section1 QVariant
+
+    Some changes to the rest of the Qt library have
+    implications on QVariant:
+
+    \list 1
+    \o The \c QVariant::ColorGroup enum value is defined only
+       if \c QT3_SUPPORT is defined.
+    \o The \c QVariant::IconSet enum value has been renamed
+       QVariant::Icon.
+    \o The \c QVariant::CString enum value is now a synonym for
+       QVariant::ByteArray.
+    \endlist
+
+    Also, the QVariant(bool, int) constructor has been replaced by QVariant(bool).
+    Old code like QVariant(true, 0) should be replaced with QVariant(true); otherwise,
+    the QVariant(int, void *) overload might accidentally be triggered.
+
+    Many of QVariant's convenience functions in Qt 3, such as toColor() and
+    toKeySequence(), have been removed to enable QVariant to be part of the
+    QtCore module. QVariant is still able to hold values of these types.
+
+    Types which are not supported by any of the QVariant constructors can be
+    stored as variants with the QVariant::fromValue() function. Types with no
+    suitable convenience function for unpacking can be retrieved with the
+    QVariant::value() function or passed directly to classes that implement
+    the QVariant() operator.
+
+    \table
+    \header \o Qt 3 function \o Qt 4 function
+    \input porting4-removedvariantfunctions.qdocinc
+    \endtable
+
+    See the QVariant::Type enum for a list of types supported by QVariant.
+
+    \section1 QVBox
+
+    The \c QVBox class is now only available as Q3VBox in Qt 4. You
+    can achieve the same result as \c QVBox by creating a QWidget
+    with a vertical layout:
+
+    \oldcode
+    QVBox *vbox = new QVBox;
+    QPushButton *child1 = new QPushButton(vbox);
+    QPushButton *child2 = new QPushButton(vbox);
+    \newcode
+    QWidget *vbox = new QWidget;
+    QPushButton *child1 = new QPushButton;
+    QPushButton *child2 = new QPushButton;
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(child1);
+    layout->addWidget(child2);
+    vbox->setLayout(layout);
+    \endcode
+
+    Note that child widgets are not automatically placed into the widget's
+    layout; you will need to manually add each widget to the QVBoxLayout.
+
+    \section1 QVGroupBox
+
+    The \c QVGroupBox class has been renamed Q3VGroupBox and moved to
+    the Qt3Support library.
+    Qt 4 does not provide a specific replacement class for \c QVGroupBox
+    since QGroupBox is designed to be a generic container widget. As a
+    result, you need to supply your own layout for any child widgets.
+
+    See \l{#QGroupBox} for more information about porting code that uses
+    group boxes.
+
+    \section1 QWhatsThis
+
+    The QWhatsThis class has been redesigned in Qt 4. The old \c
+    QWhatsThis class is available as Q3WhatsThis in Qt3Support.
+
+    \section1 QWidget
+
+    Widget background painting has been greatly improved, supporting
+    flicker-free updates and making it possible to have
+    semi-transparent widgets. This renders the following background
+    handling functions obsolete:
+
+    \list
+    \o QWidget::repaint(bool noErase) - the \c noErase boolean parameter is gone
+    \o QWidget::setBackgroundMode(BackgroundMode m)
+    \o QWidget::backgroundBrush() const
+    \o QWidget::setBackgroundPixmap(const QPixmap &pm)
+    \o QWidget::backgroundPixmap() const
+    \o QWidget::setBackgroundColor(const QColor &c)
+    \o QWidget::backgroundColor() const
+    \o QWidget::foregroundColor() const
+    \o QWidget::eraseColor() const
+    \o QWidget::setEraseColor(const QColor &c)
+    \o QWidget::erasePixmap() const
+    \o QWidget::setErasePixmap(const QPixmap &p)
+    \o QWidget::paletteForegroundColor()
+    \o QWidget::setPaletteForegroundColor(const QColor &c)
+    \o QWidget::paletteBackgroundColor()
+    \o QWidget::setPaletteBackgroundColor(const QColor &c)
+    \o QWidget::paletteBackgroundPixmap() const
+    \o QWidget::setPaletteBackgroundPixmap(const QPixmap &p)
+    \o QWidget::erase()
+    \o QWidget::erase(const QRect &r)
+    \o QWidget::setBackgroundOrigin( BackgroundOrigin )
+    \o QWidget::BackgroundOrigin backgroundOrigin() const
+    \o QWidget::backgroundOffset()
+    \endlist
+
+    Sample code on how to do obtain similar behavior from Qt 4, previously
+    handled by some of the above functions can be found in the
+    \l{http://doc.trolltech.com/qwidget-qt3.html}{Qt 3 Support Members for QWidget}
+    page.
+
+    A widget now receives change events in its QWidget::changeEvent()
+    handler. This makes the following virtual change handlers obsolete:
+
+    \list
+    \o QWidget::styleChange - use QEvent::StyleChange
+    \o QWidget::enabledChange - use QEvent::EnabledChange
+    \o QWidget::paletteChange - use QEvent::PaletteChange
+    \o QWidget::fontChange - use QEvent::FontChange
+    \o QWidget::windowActivationChange - use QEvent::ActivationChange
+    \o QWidget::languageChange - use QEvent::LanguageChange
+    \endlist
+
+    The following functions were slots, but are no more:
+    \list
+    \o QWidget::clearFocus()
+    \o QWidget::setMouseTracking()
+    \o QWidget::stackUnder(QWidget*)
+    \o QWidget::move(int x, int y)
+    \o QWidget::move(const QPoint &)
+    \o QWidget::resize(int w, int h)
+    \o QWidget::resize(const QSize &)
+    \o QWidget::setGeometry(int x, int y, int w, int h)
+    \o QWidget::setGeometry(const QRect &)
+    \o QWidget::adjustSize()
+    \o QWidget::update(int x, int y, int w, int h)
+    \o QWidget::update(const QRect&)
+    \o QWidget::repaint(bool erase)
+    \o QWidget::repaint(int x, int y, int w, int h, bool erase)
+    \o QWidget::repaint(const QRect &, bool erase)
+    \o QWidget::repaint(const QRegion &, bool erase)
+    \o QWidget::setCaption(const QString &)
+    \o QWidget::setIcon(const QPixmap &)
+    \o QWidget::setIconText(const QString &)
+    \endlist
+
+    The following functions were incorrectly marked as virtual:
+
+    \list
+    \o QWidget::close(bool alsoDelete)
+    \o QWidget::create(WId, bool, bool)
+    \o QWidget::destroy(bool)
+    \o QWidget::move(int x, int y)
+    \o QWidget::reparent(QWidget *parent, WFlags, const QPoint &, bool)
+    \o QWidget::resize(int w, int h)
+    \o QWidget::setAcceptDrops(bool on)
+    \o QWidget::setActiveWindow()
+    \o QWidget::setAutoMask(bool)
+    \o QWidget::setBackgroundColor(const QColor &)
+    \o QWidget::setBackgroundMode(BackgroundMode)
+    \o QWidget::setBackgroundOrigin(BackgroundOrigin)
+    \o QWidget::setBackgroundPixmap(const QPixmap &)
+    \o QWidget::setCaption(const QString &)
+    \o QWidget::setCursor(const QCursor &)
+    \o QWidget::setEnabled(bool)
+    \o QWidget::setEraseColor(const QColor &)
+    \o QWidget::setErasePixmap(const QPixmap &)
+    \o QWidget::setFocus()
+    \o QWidget::setFocusPolicy(FocusPolicy)
+    \o QWidget::setFocusProxy(QWidget *)
+    \o QWidget::setFont(const QFont &)
+    \o QWidget::setGeometry(const QRect &)
+    \o QWidget::setGeometry(int x, int y, int w, int h)
+    \o QWidget::setIcon(const QPixmap &)
+    \o QWidget::setIconText(const QString &)
+    \o QWidget::setKeyCompression(bool)
+    \o QWidget::setMask(const QBitmap &)
+    \o QWidget::setMask(const QRegion &)
+    \o QWidget::setMaximumSize(int maxw, int maxh)
+    \o QWidget::setMicroFocusHint(int x, int y, int w, int h, bool, QFont *f)
+    \o QWidget::setMinimumSize(int minw, int minh)
+    \o QWidget::setMouseTracking(bool enable)
+    \o QWidget::setPalette(const QPalette &)
+    \o QWidget::setPaletteBackgroundColor(const QColor &)
+    \o QWidget::setPaletteBackgroundPixmap(const QPixmap &)
+    \o QWidget::setSizeIncrement(int w, int h)
+    \o QWidget::setSizePolicy(QSizePolicy)
+    \o QWidget::setUpdatesEnabled(bool enable)
+    \o QWidget::setWState(uint)
+    \o QWidget::show()
+    \o QWidget::showFullScreen()
+    \o QWidget::showMaximized()
+    \o QWidget::showMinimized()
+    \o QWidget::showNormal()
+    \o QWidget::sizePolicy()
+    \o QWidget::unsetCursor()
+    \endlist
+
+    The internal clearWState() function was removed. Use
+    QWidget::setAttribute() instead.
+
+    setWFlags() was renamed QWidget::setWindowFlags().
+
+    clearWFlags() has no direct replacement. You can use
+    QWidget::setAttribute() instead. For example,
+    \c{setAttribute(..., false)} to clear an attribute. More information
+    is available \l{http://doc.trolltech.com/qwidget.html#setAttribute}{here}.
+
+    testWFlags() was renamed to \l{QWidget::testAttribute()}{testAttribute()}.
+
+    See \l{#properties}{Properties} for a list of QWidget properties
+    in Qt 3 that have changed in Qt 4.
+
+    \section1 QWidgetFactory
+
+    The \c QWidgetFactory class has been replaced by QFormBuilder in Qt 4.
+
+    \section1 QWidgetIntDict
+
+    The QWidgetIntDict class was a synonym for QIntDict<QWidget>. It
+    is no longer available in Qt 4. If you link against Qt3Support,
+    you can use Q3IntDict<QWidget> instead; otherwise, see the
+    \l{#qdict.section}{section on QDict<T>}.
+
+    \target qwidgetlist.section
+    \section1 QWidgetList
+
+    In Qt 3, the QWidgetList class was a typedef for
+    QPtrList<QWidget>. In Qt 4, it is a typedef for QList<QWidget *>.
+    See the \l{#qptrlist.section}{section on QPtrList<T>}.
+
+    \section1 QWidgetPlugin
+
+    The QWidgetPlugin class is no longer available in Qt 4. To create
+    custom widget plugins, subclass QDesignerCustomWidgetInterface to
+    provide information about the custom widget, and build a plugin in
+    the way described in the \l{designer/customwidgetplugin}{Custom
+    Widget Plugin} example.
+
+    \section1 QWidgetStack
+
+    The QWidgetStack class is no longer part of the Qt public API. It
+    has been renamed Q3WidgetStack and moved to Qt3Support. In Qt 4
+    applications, you can use QStackedWidget instead to obtain the
+    same results.
+
+    \section1 QWizard
+
+    The \c QWizard class was reintroduced in Qt 4.3. See the
+    \l{Trivial Wizard Example}, \l{License Wizard Example} and
+    \l{Class Wizard Example} for more details.
+
+    \section1 QWorkspace
+
+    The \c QWorkspace in Qt 4 class requires explicit adding of MDI
+    windows with QWorkspace::addWindow().
+*/
+
+/*!
+    \page porting4-virtual-functions.html
+    \title Porting to Qt 4 - Virtual Functions
+    \contentspage {Porting Guides}{Contents}
+    \previouspage Porting to Qt 4
+    \nextpage Porting to Qt 4 - Drag and Drop
+    \ingroup porting
+    \brief An overview of changes to virtual functions in Qt 4.
+
+    \section1 Virtual Functions
+
+    Virtual functions that changed their signature in Qt 4:
+
+    \table
+    \header \o Qt 3 function signature \o Qt 4 function signature
+    \input porting4-modifiedvirtual.qdocinc
+    \endtable
+
+    Virtual functions that are not virtual in Qt 4:
+
+    \table
+    \header \o Qt 3 function \o Comment
+    \input porting4-removedvirtual.qdocinc
+    \endtable
+*/