/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE: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 Technology Preview License Agreement accompanying
** this package.
**
** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
    \page porting4-overview.html
    \title Moving from Qt 3 to Qt 4
    \ingroup porting
    \brief Porting advice for authors of new and existing Qt 3 applications.

    This document describes which parts of Qt should be used when
    writing an application with Qt 3, so that it can be upgraded to
    use Qt 4 later with a minimum of effort. However, the advice may
    also be useful to developers who are porting existing applications
    from Qt 3 to Qt 4.

    For a detailed overview
    of the porting process for existing Qt 3 applications, see the
    \l{Porting to Qt 4} document.

    \tableofcontents

    Since Qt 4 provides important new functionality at the cost of
    some compatibility with Qt 3, it is useful for developers of
    Qt 3-based applications to learn how to take advantage of
    Qt 3's API now while preparing for future changes that will be
    needed when upgrading to Qt 4.

    Certain advanced Qt 3 features were moved to the Qt 3 support
    library (\l{Qt3Support}) in Qt 4.0, and have been gradually
    replaced in subsequent releases of Qt 4.

    Making Qt 3 applications as portable to Qt 4 as possible
    enables a smooth transition between versions of Qt in the
    long term, and allows for a stable development process
    throughout.

    \section1 Qt 3 Features to Avoid

    Although we are proud of the level of stability we have achieved
    with Qt, it is important to realise that, for Qt 4 to be a
    substantial improvement over Qt 3, certain features have
    been revised to make the framework more maintainable for us
    and more usable for developers. It is therefore useful to
    know which features of Qt 3 should be avoided to help save
    time during a later porting effort to Qt 4. Note that it is
    still possible to use many of the following classes and
    features through the use of the \l{Qt3Support} module.

    \section2 Painting Outside Paint Events

    In Qt 3, under certain circumstances, it was possible to use
    QPainter to draw on a given custom widget outside its
    \l{QWidget::}{paintEvent()} reimplementation. In Qt 4, in most
    situations, painting must occur within a widget's paint event
    handler.

    On X11, it is possible to set the \l{Qt::WA_PaintOutsidePaintEvent}
    attribute on widgets to keep existing code, but we recommend
    restricting the use of painting code to within paint event handlers
    where possible.

    More information about this change can be found in the
    \l{Porting to Qt 4#Painting and Redrawing Widgets}{Painting and Redrawing Widgets}
    section of the \l{Porting to Qt 4} document.

    \section2 Qt Designer

    The version of Qt Designer supplied with Qt 3 provided
    extensive code editing and project management features
    (control over \c{.ui.h} and \c{.pro} files), and encouraged
    users to design main window applications from within the
    Qt Designer environment.

    The version of Qt Designer supplied with Qt 4 is intended
    to be integrated with other software development tools (such
    as integrated development environments), and does not
    support these project-level features.

    We recommend using one of the
    \l{Using a Designer UI File in Your Application}{form subclassing approaches}
    with forms created using Qt Designer. This avoids the need
    to use \c{.ui.h} files and special purpose code editors.

    Existing Qt 3 forms created using Qt Designer can be gradually
    ported to Qt 4 by following the advice in the
    \l{Porting UI Files to Qt 4} guide. However, some extra effort
    will be required to move application logic from \c{.ui.h} files
    into the main body of a Qt 4 application.

    \section2 Menu Items (QMenuItem)

    The old-style construction of menus by creating individual
    menu items has been superseded in Qt 4 by the use of
    generic actions which can be used in menus, toolbars, and
    as keyboard shortcuts.

    Qt 3 also supports this action-based approach, so, by using
    QAction throughout your application, less work will be
    required to adapt your application to Qt 4.

    \section2 Pointer-Based Classes (QPtr*)

    Qt 3 provides a group of pointer-based classes (\c QPtrList,
    \c QPtrDict, \c QPtrVector, etc.) that help manage collections
    of pointers to objects (usually QObject subclasses) in an
    application. In addition, the value-based collection classes
    (\c QValueList, \c QValueDict, \c QValueVector, etc.) provide
    a way to store standard value types which cannot be easily stored
    in pointer-based collections.

    Qt 4 introduces a single set of collection classes which
    does not require developers to pay as much attention to
    memory allocation and object ownership issues. As a result,
    Qt 3's pointer-based classes have no direct equivalent
    classes in Qt 4.

    To ease migration, use Qt 3's value-based classes to store
    most objects, including pointers; for example, use
    \c QValueVector<QWidget *> rather than
    \c QPtrVector<QWidget *>. These can be replaced by
    Qt 4's QVector, QLinkedList, and QList later.

    \section2 Other Collection Classes (QStrList, Q*Dict)

    Some collection classes in Qt 3 have been deprecated in
    favor of easier to use, higher level alternatives. These
    include the dictionary classes (\c QAsciiDict, \c QDict,
    \c QIntDict, \c QPtrDict) and \c QStrList.

    \c QStrList can usually replaced by the higher level QStringList
    class in Qt 3; this is also available in Qt 4. It is
    recommended that you use the QMap class instead of the \c QDict
    classes. In Qt 4, QMap is also complemented by the QHash
    class.

    \section2 Memory Arrays (QMemArray)

    In Qt 3, the \c QMemArray class is used as a simple array
    container for simple data types. This class is deprecated in
    Qt 4 in favor of the QVector and QVarLengthVector classes
    which provide more powerful and consistent array objects.

    Qt 3's closest equivalent class to Qt 4's QVector is the
    \c QValueVector class. For many purposes, this can be used
    instead of \c QMemArray.

    \section2 URL Operations (QUrlOperator)

    The URL operator in Qt 3 provides an abstract way to
    handle files via HTTP, FTP, and on the local file system.
    However, Qt 4 only provides this functionality through the
    use of the Q3UrlOperator.

    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.

    It is also possible to perform operations on remote files through
    the QNetworkAccessManager and QFtp classes, and on local files
    with the QFile class.

    \section2 SQL Cursors (QSqlCursor)

    In Qt 3, one of the preferred methods of working with SQL
    is to use a cursor to manipulate the contents of a database.
    In Qt 4, the preferred method of working with SQL is to use
    the model/view architecture (QSqlQueryModel and QSqlTableModel)
    and, as a result, the cursor interface is only supplied in the
    Q3SqlCursor class.

    The easiest way to ensure continuity between Qt 3 and Qt 4
    is to use QSqlQuery rather than \c QSqlCursor,
    and migrate to QSqlQueryModel later.

    \section2 Domain Name Service (QDns)

    The QDns class in Qt 4 provides a much simpler interface
    than the QDns class in Qt 3, and is mainly used for host
    name resolution.
    As a result, many of the more complex features of Qt 3's
    QDns class are only available through Qt 4's Q3Dns
    compatibility class.

    To resolve host names with Qt 3, it is recommended that you
    use the higher level interface of QSocket rather than QDns.
    The equivalent functionality is available in Qt 4 in the
    QAbstractSocket and QHostInfo classes.

    \section2 Wizard Dialogs (QWizard)

    Qt 3 provides support for "wizard" dialogs in the form of
    the \c QWizard class. Prior to Qt 4.3, this class was made
    available as Q3Wizard, and provides the same interface for
    creating relatively complex wizards.

    In Qt 4.3 and later, a revised QWizard class can be used to
    create this kind of dialog, but existing Qt 3 wizard
    implementations may need to be redesigned to work with the
    new QWizard API.

    \section2 Abstract Grid Views (QGridView)

    Before the introduction of the Qt 3 \c QTable class,
    \c QGridView was the recommended way to create tables of
    custom items.
    With the introduction of \c QTable, the \c QGridView class was
    effectively obsoleted, and the \c QTable class should now be
    used to display tabular information in your Qt 3 application.
    This approach allows you to use QTableWidget as a replacement
    when later porting your application to Qt 4.

    \section2 Specialized Scrolling Views

    In Qt 3, the \c QScrollView class provides a viewport that can
    be used to display part of a larger widget, and will
    optionally provide scroll bars for navigation purposes.
    In Qt 4, this functionality is superseded by classes such as
    QScrollArea, which provides a more intuitive interface for
    developers to use.
    \c QScrollView is available in Qt 4 as the Q3ScrollView class.

    In Qt 3, it is recommended that \c QScrollView should be
    used with child widgets rather than subclassed. However, it
    should be noted that this approach may not be appropriate if
    you need to use extremely large scrolling areas in your
    application, since Qt 3 widgets cannot be wider or taller
    than 32767 pixels.

    \section1 Significantly Changed Features

    Some Qt 3 features have changed significantly for Qt 4. 
    and the recommended way of using them has therefore changed
    significantly, too. This is most notably true for the drag 
    and drop API. 

    Additionally, some of the more specialized features in Qt 3 are
    often used to help customize widgets and add extra polish to an
    application.
    Although these improvements make applications more presentable to
    users, many of them are unnecessary with Qt 4, and may create
    additional porting work.

    \section2 Drag and Drop

    Qt 4 introduces a simpler and more intuitive implementation
    of drag and drop between widgets, and with other applications.
    As a result, there is no simple approach that can be used to
    make drag and drop in a Qt 3 application easier to port to
    Qt 4.

    \section2 Extensive Customization of Item Views

    Each of the classes that are used to display list, tree,
    and table items in Qt 3 can be subclassed for the purposes
    of customizing their appearance. The item view framework
    in Qt 4 is implemented according to a different paradigm
    (model/view) which does not allow items to be customized
    using this method.

    Although Qt 4 provides compatibility classes (Q3ListBoxItem,
    Q3ListViewItem, and Q3TableItem) that can be used in the same
    way as their Qt 3 counterparts, these cannot be used within
    the standard model/view framework. It is recommended that,
    to minimize porting effort, extensive customization of item
    classes should be avoided in Qt 3, if at all possible.

    \section2 Double Buffering

    Qt 3 applications often use double buffering for reducing
    flicker when painting custom widgets. This approach is
    unnecessary with Qt 4 because double buffering is
    automatically performed by the paint engine.

    It still makes sense to use double buffering in
    Qt 4 in certain contexts. For example, in
    Chapter 5 of \l{GUI Programming with Qt 3}, double buffering
    was presented as a speed optimization and not just as a means
    of reducing flicker.

    \section2 Data-Aware Forms

    The \c QDataTable, \c QDataBrowser, and \c QDataView classes
    in Qt 3 allow integration between widgets and SQL-based
    databases.

    In Qt 4.1 and earlier, the preferred way to create a data-aware
    widget is to connect an generic item view (such as a table view)
    to a SQL model. In Qt 4.2 and later, the QDataWidgetMapper class
    can be used to map data to widgets in a form-based user interface.

    New applications written with Qt 3 should use QSqlQuery in
    preference to an approach based on the old-style data-aware
    widgets.
    This offers a choice of porting strategies when later migrating
    the application to Qt 4: You can either continue to use
    QSqlQuery or take the opportunity to use the model/view
    classes to handle database integration.

    \section2 Dock Windows and Areas

    In Qt 4, the way that dock windows are constructed and used
    in main window applications differs significantly to the
    pattern of use provided by Qt 3. As a result, the introduction
    of a simpler and cleaner API means that Qt 3 applications that
    make extensive use of dock window areas will require careful
    examination when they are ported to Qt 4.

    We recommend that the QMainWindow class be used in preference
    to the Q3MainWindow compatibility class when an existing Qt 3
    main window application is ported to Qt 4. Therefore, we
    recommend that specialized use of dock window areas should
    be avoided when writing a Qt 3 application with Qt 4 in mind.

    \section2 Custom Styles

    The style system used to provide consistent themes for Qt's
    standard widgets has been revised for Qt 4. As a result,
    custom styles for Qt 3 require some porting work to be done
    before they can be used with Qt 4. To ease the porting process,
    we recommend that you avoid implementing custom widget styles
    for Qt 3 applications unless it is absolutely necessary for
    your users.

    In Qt 4.2 and later, \l{Qt Style Sheets} can be used to
    implement many common modifications to existing styles, and
    this may be sufficient for Qt 3 applications.

    \section2 Events
    In Qt 3, QCloseEvents were not accepted by default. In Qt 4,
    the event handler QWidget::closeEvent() receives QCloseEvents,
    and accepts them by default closing the application. To avoid 
    this, please reimplement QWidget::closeEvent().  
*/
