summaryrefslogtreecommitdiffstats
path: root/doc/src/porting4.qdoc
diff options
context:
space:
mode:
Diffstat (limited to 'doc/src/porting4.qdoc')
-rw-r--r--doc/src/porting4.qdoc4215
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
+*/