Fixing warnings in QScopedPointer test case

[qt-netbsd.git] / dist / changes-3.0.0-beta1

Qt 3.0 adds a lot of new features and improvements over the Qt 2.x
series. Some internals have undergone major redesign and new classes
and methods have been added.

We have tried to keep the API of Qt 3.0 as compatible as possible with
the Qt 2.x series. For most applications only minor changes will be
needed to compile and run them successfully using Qt 3.0.

One of the major new features that has been added in the 3.0 release
is a module allowing you to easily work with databases. The API is
platform independent and database neutral. This module is seamlessly
integrated into Qt Designer, greatly simplifying the process of
building database applications and using data aware widgets.

Other major new features include a component architecture allowing you
to build cross platform components, 'plugins' with Qt. You can use
your own and third party plugins your own applications. The Unicode
support of Qt 2.x has been greatly enhanced, it now includes full
support for scripts written from right to left (e.g. Arabic and
Hebrew) and also provides improved support for Asian languages.

Many new classes have been added to the Qt Library. Amongst them are
classes that provide a docking architecture (QDockArea/QDockWindow), a
powerful rich text editor (QTextEdit), a class to store and access
application settings (QSettings) and a class to create and communicate
with processes (QProcess).

Apart from the changes in the library itself a lot has been done to
make the development of Qt applications with Qt 3.0 even easier than
before. Two new applications have been added: Qt Linguist is a tool to
help you translate your application into different languages; Qt
Assistant is an easy to use help browser for the Qt documentation that
supports bookmarks and can search by keyword.

Another change concerns the Qt build system, which has been reworked
to make it a lot easier to port Qt to new platforms. You can use this
platform independent build system for your own applications.


The Qt Library
========================================

A large number of new features has been added to Qt 3.0. The following
list gives an overview of the most important new and changed aspects
of the Qt library. A full list of every new method follows the
overview.


Database support
----------------

One of the major new features in Qt 3.0 is the SQL module that
provides cross-platform access to SQL databases, making database
application programming with Qt seamless and portable. The API, built
with standard SQL, is database-neutral and software development is
independent of the underlying database.

A collection of tightly focused C++ classes are provided to give the
programmer direct access to SQL databases. Developers can send raw SQL
to the database server or have the Qt SQL classes generate SQL queries
automatically.  Drivers for Oracle, PostgreSQL, MySQL and ODBC are
available and writing new drivers is straightforward.

Tying the results of SQL queries to GUI components is fully supported
by Qt's SQL widgets. These classes include a tabular data widget
(for spreadsheet-like data presentation with in-place editing), a
form-based data browser (which provides data navigation and edit
functions) and a form-based data viewer (which provides read-only
forms). This framework can be extended by using custom field editors,
allowing for example, a data table to use custom widgets for in-place
editing. The SQL module fully supports Qt's signal/slots mechanism,
making it easy for developers to include their own data validation and
auditing code.

Qt Designer fully supports Qt's SQL module. All SQL widgets can be
laid out within Qt Designer, and relationships can be established
between controls visually. Many interactions can be defined purely in
terms of Qt's signals/slots mechanism directly in Qt Designer.


Component model - plugins
-------------------------

The QLibrary class provides a platform independent wrapper for runtime
loading of shared libraries. Access to the shared libraries uses a
COM-like interface. QPluginManager makes it trivial to implement
plugin support in applications. The Qt library is able to load
additional styles, database drivers and text codecs from plugins which
implement the relevant interfaces, e.g. QStyleFactoryInterface,
QSqlDriverInterface or QTextCodecInterface. It is possible to remove
unused components from the Qt library, and easy to extend any
application with 3rd party styles, database drivers or text codecs.

Qt Designer supports custom widgets in plugins, and will use the
widgets both when designing and previewing forms.

QComponentFactory makes it easy to register any kind of component in a
global database (e.g. the Windows Registry) and to use any registered
component.


Rich text engine and editor
---------------------------

The rich text engine originally introduced in Qt 2.0 has been further
optimized and extended to support editing. It allows editing formatted
text with different fonts, colors, paragraph styles, tables and
images. The editor supports different word wrap modes, command-based
undo/redo, multiple selections, drag and drop, and many other
features.  The engine is highly optimized for proccesing and displaying
large documents quickly and efficiently.


Unicode
-------

Apart from the rich text engine, another new feature of Qt 3.0 that
relates to text handling is the greatly improved Unicode support. Qt
3.0 includes an implementation of the bidirectional algorithm (BiDi)
as defined in the Unicode standard and a shaping engine for Arabic,
which gives full native language support to Arabic and Hebrew speaking
people. At the same time the support for Asian languages has been
greatly enhanced.

The support is almost transparent for the developer using Qt to
develop their applications. This means that developers who developed
applications using Qt 2.x will automatically gain the full support for
these languages when switching to Qt 3.0. Developers can rely on their
application to work for people using writing systems different from
Latin1, without having to worry about the complexities involved with
these scripts, as Qt takes care of this automatically.


Docked and Floating Windows
---------------------------

Qt 3.0 introduces the concept of Dock Windows and Dock Areas. Dock
windows are widgets, that can be attached to, and detached from, dock
areas. The commonest kind of dock window is a tool bar. Any number of
dock windows may be placed in a dock area. A main window can have dock
areas, for example, QMainWindow provides four dock areas (top, left,
bottom, right) by default. The user can freely move dock windows and
place them at a convenient place in a dock area, or drag them out of
the application and have them float freely as top level windows in
their own right. Dock windows can also be minimized or hidden.

For developers, dock windows behave just like ordinary widgets. QToolbar
for example is now a specialized subclass of a dock window.  The API
of QMainWindow and QToolBar is source compatible with Qt 2.x, so
existing code which uses these classes will continue to work.


Regular Expressions
-------------------

Qt has always provided regular expression support, but that support
was pretty much limited to what was required in common GUI control
elements such as file dialogs. Qt 3.0 introduces a new regular
expression engine that supports most of Perl's regex features and is
Unicode based. The most useful additions are support for parentheses
(capturing and non-capturing) and backreferences.


Storing application settings
----------------------------

Most programs will need to store some settings between runs, for
example, user selected fonts, colors and other preferences, or a list
of recently used files.  The new QSettings class provides a platform
independent way to achieve this goal. The API makes it easy to store
and retrieve most of the basic data types used in Qt (such as basic
C++ types, strings, lists, colors, etc). The class uses the registry
on the Windows platform and traditional resource files on Unix.


Creating and controlling other processes
----------------------------------------

QProcess is a class that allows you to start other programs from
within a Qt application in a platform independent manner. It gives you
full control over the started program, for example you can redirect
the input and output of console applications.


Accessibility (not part of the beta1 release)
---------------------------------------------

Accessibility means making software usable and accessible to a wide
range of users, including those with disabilities. In Qt 3.0, most
widgets provide accessibility information for assistive tools that can
be used by a wide range of disabled users. Qt standard widgets like
buttons or range controls are fully supported. Support for complex
widgets, like e.g. QListView, is in development. Existing applications
that make use of standard widgets will become accessible just by using
Qt 3.0.

Qt uses the Active Accessibility infrastructure on Windows, and needs
the MSAA SDK, which is part of most platform SDKs. With improving
standardization of accessibility on other platforms, Qt will support
assistive technologies on other systems, too.

The accessibility API in Qt is not yet stable, which is why we decided
not to make it a part of the beta1 release.


XML Improvements
----------------

The XML framework introduced in Qt 2.2 has been vastly improved. Qt
2.2 already supported level 1 of the Document Object Model (DOM), a
W3C standard for accessing and modifying XML documents.  Qt 3.0 has
added support for DOM Level 2 and XML namespaces.

The XML parser has been extended to allow incremental parsing of XML
documents. This allows you to start parsing the document directly
after the first parts of the data have arrived, and to continue
whenever new data is available.  This is especially useful if the XML
document is read from a slow source, e.g. over the network, as it
allows the application to start working on the data at a very early
stage.


SVG support
-----------

SVG is a W3C standard for "Scalable Vector Graphics". Qt 3.0's SVG
support means that QPicture can optionally generate and import static
SVG documents. All the SVG features that have an equivalent in
QPainter are supported.


Multihead support
-----------------

Many professional applications, such as DTP and CAD software, are able
to display data on two or more monitors. In Qt 3.0 the QDesktopWidget
class provides the application with runtime information about the
number and geometry of the desktops on the different monitors and such
allows applications to efficiently use a multi-monitor setup.

The virtual desktop of Windows 98 and 2000 is supported, as well as
the traditional multi-screen and the newer Xinerama multihead setups
on X11.


X11 specific enhancements
-------------------------

Qt 3.0 now complies with the NET WM Specification, recently adopted
by KDE 2.0.  This allows easy integration and proper execution with
desktop environments that support the NET WM specification.

The font handling on X11 has undergone major changes.  QFont no longer
has a one-to-one relation with window system fonts.  QFont is now a
logical font that can load multiple window system fonts to simplify
Unicode text display.  This completely removes the burden of
changing/setting fonts for a specific locale/language from the
programmer.  For end-users, any font can be used in any locale.  For
example, a user in Norway will be able to see Korean text without
having to set their locale to Korean.

Qt 3.0 also supports the new render extension recently added to
XFree86. This adds support for anti aliased text and pixmaps with
alpha channel (semi transparency) on the systems that support the
rendering extension (at the moment XFree 4.0.3 and later).


Printing
--------

Printing support has been enhanced on all platforms. The QPrinter
class now supports setting a virtual resolution for the painting
process. This makes WYSIWYG printing trivial, and also allows you to
take full advantage of the high resolution of a printer when painting
on it.

The postscript driver built into Qt and used on Unix has been greatly
enhanced. It supports the embedding of true/open type and type1 fonts
into the document, and can correctly handle and display Unicode.
Support for fonts built into the printer has been enhanced and Qt now
knows about the most common printer fonts used for Asian languages.


QHttp
-----

This class provides a simple interface for HTTP downloads and uploads.


Compatibility with the Standard Template Library (STL)
------------------------------------------------------

Support for the C++ Standard Template Library has been added to the Qt
Template Library (QTL).  The QTL classes now contain appropriate copy
constructors and typedefs so that they can be freely mixed with other
STL containers and algorithms.  In addition, new member functions have
been added to QTL template classes which correspond to STL-style
naming conventions (e.g., push_back()).


Qt Designer
========================================

Qt Designer was a pure dialog editor in Qt 2.2 but has now been
extended to provide the full functionality of a GUI design tool.

This includes the ability to lay out main windows with menus and
toolbars. Actions can be edited within Qt Designer and then plugged
into toolbars and menu bars via drag and drop. Splitters can now be
used in a way similar to layouts to group widgets horizontally or
vertically.

In Qt 2.2, many of the dialogs created by Qt Designer had to be
subclassed to implement functionality beyond the predefined signal and
slot connections. Whilst the subclassing approach is still fully supported,
Qt Designer now offers an alternative: a plugin for editing 
slots. The editor offers features such as syntax highlighting,
completion, parentheses matching and incremental search.

The functionality of Qt Designer can now be extended via plugins.
Using Qt Designer's interface or by implementing one of the provided
interfaces in a plugin, a two way communication between plugin and Qt
Designer can be established. This functionality is used to implement
plugins for custom widgets, so that they can be used as real widgets
inside the designer.

Basic support for project management has been added. This allows you
to read and edit *.pro files, add and remove files to/from the project
and do some global operations on the project. You can now open the
project file and have one-click access to all the *.ui forms in the
project.

In addition to generating code via uic, Qt Designer now supports the
dynamic creation of widgets directly from XML user interface
description files (*.ui files) at runtime. This eliminates the need of
recompiling your application when the GUI changes, and could be used
to enable your customers to do their own customizations. Technically,
the feature is provided by a new class, QWidgetFactory in the
QResource library.


Qt Linguist
========================================

Qt Linguist is a GUI utility to support translating the user-visible
text in applications written with Qt. It comes with two command-line
tools: lupdate and lrelease.

Translation of a Qt application is a three-step process:

  1) Run lupdate to extract user-visible text from the C++ source
     code of the Qt application, resulting in a translation source file
     (a *.ts file).
  2) Provide translations for the source texts in the *.ts file using
     Qt Linguist.
  3) Run lrelease to obtain a light-weight message file (a *.qm file)
     from the *.ts file, which provides very fast lookup for released
     applications.

Qt Linguist is a tool suitable for use by translators. Each
user-visible (source) text is characterized by the text itself, a
context (usually the name of the C++ class containing the text), and
an optional comment to help the translator. The C++ class name will
usually be the name of the relevant dialog, and the comment will often
contain instructions that describe how to navigate to the relevant
dialog.

You can create phrase books for Qt Linguist to provide common
translations to help ensure consistency and to speed up the
translation process. Whenever a translator navigates to a new text to
translate, Qt Linguist uses an intelligent algorithm to provide a list
of possible translations: the list is composed of relevant text from
any open phrase books and also from identical or similar text that has
already been translated.

Once a translation is complete it can be marked as "done"; such
translations are included in the *.qm file. Text that has not been
"done" is included in the *.qm file in its original form. Although Qt
Linguist is a GUI application with dock windows and mouse control,
toolbars, etc., it has a full set of keyboard shortcuts to make
translation as fast and efficient as possible.

When the Qt application that you're developing evolves (e.g. from
version 1.0 to version 1.1), the utility lupdate merges the source
texts from the new version with the previous translation source file,
reusing existing translations. In some typical cases, lupdate may
suggest translations. These translations are marked as unfinished, so
you can easily find and check them.


Qt Assistant
========================================

Due to the positive feedback we received about the help system built
into Qt Designer, we decided to offer this part as a separate
application called Qt Assistant. Qt Assistant can be used to browse
the Qt class documentation as well as the manuals for Qt Designer and
Qt Linguist. It offers index searching, a contents overview, bookmarks
history and incremental search. Qt Assistant is used by both Qt
Designer and Qt Linguist for browsing their help documentation.


QMake
========================================

To ease portability we now provide the qmake utility to replace tmake.
QMake is a C++ version of tmake which offers additional functionallity
that is difficult to reproduce in tmake. Qt uses qmake in its
build system and we have released it as free software.


Qt Functions
========================================

QAction
-------

All new functions:
        void addedTo( QWidget *actionWidget, QWidget *container );
        void addedTo( int index, QPopupMenu *menu );

QActionGroup
------------

New mode "uses drop down", where members are shown in a separate
subwidget such as a combobox or a submenu (enable with
setUsesDropDown(TRUE) )

All new functions:
        void add(QAction*);
        void addSeparator();
        void addedTo( QWidget *actionWidget, QWidget *container, QAction *a );
        void addedTo( int index, QPopupMenu *menu, QAction *a );
        void setUsesDropDown( bool enable );
        bool usesDropDown() const;


QApplication
------------

Added the setStyle(const QString&) overload that takes the name of the
style as its argument. This loads a style plugin via a QStyleFactory.

desktop() now returns a QDesktopWidget that provides access to
multi-head information. Prior to 3.0, it returned a normal QWidget.

New functions to define the library search path for plugins
(setLibraryPaths, ...).

New functions to define reverse layout for bidirectional languages
(setReverseLayout, ...).

All new functions:
        bool hasPendingEvents()

        void setLibraryPaths(const QStringList &);
        QStringList libraryPaths();
        void addLibraryPath(const QString &);
        void removeLibraryPath(const QString &);

        void setReverseLayout( bool b );
        bool reverseLayout();
        int horizontalAlignment( int align );



QClipboard
----------

On systems that support it, for example X11, QClipboard now
differentiates between the primary selection and the data in the clipboard.

All new functions:
        bool supportsSelection() const;
        bool ownsClipboard() const;
        void setSelectionMode(bool enable);
        bool selectionModeEnabled() const;
New signals:
        void selectionChanged()
        


QCursor
-------

Now inherits Qt namespace. Enum values like ArrowCursor,
UpArrowCursor, CrossCursor etc. are now part of that namespace.


QDataStream
-----------

Added missing operators for Q_LONG and Q_ULONG


QDateTime / QDate / QTime
-------------------------

More sophisticated toString() function that takes a DateFormat, where
DateFormat can be either TextDate (the default), ISODate (ISO 8601) or
LocalDate (locale dependent).

All new functions:
        QDate addMonths( int months ) const;
        QDate addYears( int years ) const;
        QDate fromString( const QString& s, Qt::DateFormat f = Qt::TextDate );
        static QString shortMonthName( int month );
        static QString longMonthName( int month );
        static QString shortDayName( int weekday );
        static QString longDayName( int weekday );
        static void setShortMonthNames( const QStringList& names );
        static void setLongMonthNames( const QStringList& names );
        static void setShortDayNames( const QStringList& names );
        static void setLongDayNames( const QStringList& names );

QDialog
-------

Merged with QSemiModal. Calling show() on a modal dialog will return
immediately, not enter a local event loop. Showing a modal dialog in
its own event loop is achieved using exec().

exec() is now a public slot.

Usability: For widgets supporting What's This help, QDialog
automatically offers a context menu containing a "What's This?" entry.


QEvent
------

Mouse events are now propagated up to the toplevel widget if no widget
accepts them and no event filter filters them out. In previous Qt
versions, only key events were propagated.

All events carry a flag 'spontaneous' to determine whether the even
came from the outside or was generated by code within the
applications. Previously, only show and hide events had this flag.

Enter/Leave event generation has been fixed. Previously, a widget
received a leave event when the mouse pointer entered one of its
children. This was both unnatural and contradictive to the
documentation.

QWheelevent now carries an orientation to differentiate between
horizontal and vertical wheels.

QFocusEvent: new reason 'Backtab' (previously only 'Tab' was
available). This makes it possible to discover from what direction on
the tab-focus chain the widget was entered.

New events: QContextMenuEvent, QIMEvent


QFile
-----

Ported from int to Q_LONG to prepare for large file sizes on 64 bit
systems.

Filter handling made more flexible.


QFileDialog
-----------

All new Functions:
        void setSelectedFilter( const QString& );
        void setSelectedFilter( int );
New signals:
        void filesSelected( const QStringList& );
        void filterSelected( const QString& );

If you try to specify an invalid file when using getOpenFileName(s), an error message
will appear and the file will not be accepted.  In 2.x, this function behaved differently
because users were using getOpenFileName(s) as a Save File Dialog; you should use
getSaveFileName() when you require a Save File Dialog.  


QCanvas Module
--------------

        New classes:
                QCanvasSpline - a multi-bezier spline

        QCanvasItemList
                void update();

        QCanvas:
                QRect rect() const;
                void setUnchanged( const QRect& area );
                void drawArea(const QRect&, QPainter* p, bool double_buffer);
                void drawViewArea( QCanvasView* view, QPainter* p, const QRect& r, bool dbuf );
                QRect changeBounds(const QRect& inarea);

        QCanvasView:
                const QWMatrix &worldMatrix() const;
                const QWMatrix &inverseWorldMatrix() const;
                void setWorldMatrix( const QWMatrix & );
        QCanvasSprite:
                int leftEdge() const;
                int topEdge() const;
                int rightEdge() const;
                int bottomEdge() const;
                int leftEdge(int nx) const;
                int topEdge(int ny) const;
                int rightEdge(int nx) const;
                int bottomEdge(int ny) const;

QCanvasSprite can now be set to animate its frames without the need to
subclass.


QFont, QFontDatabase, QFontInfo, QFontMetrics
---------------------------------------------

The QFont::CharSet enum has been removed and replaced with the
QFont::Script enum. With this change, a QFont is not associated with a
specific character set. Instead, QFont uses Unicode Scripts for
loading fonts.  On platforms where most fonts do not use the Unicode
encoding (currently only X11), multiple locale and character-set
dependent fonts can be loaded for the individual Unicode Scripts.

Another new feature of QFont is a much more flexible substitution
mechanism. Each family can have a list of appropriate substitutes. The
font substitution feature allows you to specify a list of substitute
fonts. Substitute fonts are used when a font cannot be loaded, or if
the specified font doesn't have a particular character (X11 only).

For example (on X11), you select the font Lucida, which doesn't have
Korean characters. For Korean text, you want to use the Mincho font
family. By adding Mincho to the list, any Korean characters not found
in Lucida will be used from Mincho. Because the font substitutions are
lists, you can also select multiple families, such as Song Ti (for use
with Chinese text).

QFontInfo and QFontMetrics had small API changes related to the
disappearance of QFont::CharSet.  In terms of functionality, the
behavior of these classes is unchanged.

QFontDatabase had several API cleanups related to the disappearance of
QFont::CharSet.  Most QFontDatabase member functions take one less
argument, yet compatibility functions still exist to keep old source
code working.

Family and style names returned from QFontDatabase are now processed
and formatted in a way that is suitable for display to users.  Family
and foundry names are capitalized and foundry names are enclosed in
square brackets after the family name.  For example, the Helvetica
font family might have 3 different foundries: Adobe, Cronyx and
Phaisarn. In 2.x, QFontDatabase listed them like this:

        adobe-helvetica
        cronyx-helvetica
        phaisarn-helvetica

Starting with 3.0, QFontDatabase lists them like this:

        Helvetica [Adobe]
        Helvetica [Cronyx]
        Helvetica [Phaisarn]


QFrame
------

Two new frame shapes for more sophisticated style features:
MenuBarPanel and ToolBarPanel.


QGrid
-----

The member type

    enum Direction { Horizontal, Vertical };

has been eliminated, as it is redundant: use Qt::Orientation instead.
Old code referring to QGrid::Horizontal or QGrid::Vertical will still
work, as QGrid counts Qt among its ancestors.


QGroupBox
---------

More functionality of the built-in layout is exposed:

        int insideMargin() const;
        int insideSpacing() const;
        void setInsideMargin( int m );
        void setInsideSpacing( int s );


QHeader
-------

New property: bool stretching

New functions:
        bool isStretchEnabled( int section );
        void setStretchEnabled( bool b, int section );
        

QIconSet
--------

In addition to the mode - which can be either Normal, Disabled or
Active - QIconSet now supports different pixmaps for a state, i.e. On
or Off. The functions pixmap() and setPixmap() have been extended
accordingly.

The default constructor no longer initializes the iconset to
contain a null pixmap. QIconSet::isNull() returns TRUE for un-
initialized iconsets, and pixmap() still returns a null pixmap for
pixmaps that couldn't be generated.


QIconView
---------

Extended findItem() to support ComparisonFlags. Support for
soft-hyphens when doing word wrap.

New signal:
        contextMenuRequested( QIconViewItem*, const QPoint& pos);


QIconViewItem
-------------

Added support for explicit rtti.

New function:
        int rtti() const;



QListBox
--------

Extended findItem() to support ComparisonFlags.

New signal:
        void contextMenu( QListBoxItem *, const QPoint & );


QListBoxItem
------------

Added support for explicit rtti.

New function:
        int rtti() const;



QListView
---------

It was never really hard to implement drag and drop with QListView,
but since many applications demand this functionality today, we
decided to add it to the listview itself.

In addition, in-place editing and per-item tooltips have been added.
Extended findItem() to support ComparisonFlags

New properties:
        bool showToolTips
        ResizeMode resizeMode

New signals:
        contextMenuRequested( QIconViewItem*, const QPoint& pos);
        void dropped( QDropEvent *e );
        void itemRenamed( QListViewItem *item, int col, const QString & );
        void itemRenamed( QListViewItem *item, int col  );

New functions:
        void setResizeMode( ResizeMode m );
        ResizeMode resizeMode() const;
        QDragObject *dragObject();
        void startDrag();
        void startRename();


QListViewItem
-------------

Added support for explicit rtti.

New functions:
        void setDragEnabled( bool allow );
        void setDropEnabled( bool allow );
        bool dragEnabled() const;
        bool dropEnabled() const;
        bool acceptDrop( const QMimeSource *mime ) const;
        void setVisible( bool b );
        bool isVisible() const;
        void setRenameEnabled( int col, bool b );
        bool renameEnabled( int col ) const;
        void startRename( int col );
        void setEnabled( bool b );
        bool isEnabled() const;
        int rtti() const;

        void dropped( QDropEvent *e );
        void dragEntered();
        void dragLeft();
        void okRename( int col );
        void cancelRename( int col );


QLabel
------

In addition to text, rich text, pixmaps and movies, QLabel can now
display QPicture vector graphics.

New functions:

        QPicture *picture() const;
        void setPicture( const QPicture & );


QLineEdit
---------

New property: bool dragEnabled

New signal:
        contextMenuRequested( QIconViewItem*, const QPoint& pos);

New functions:
        void cursorForward( bool mark, int steps = 1 );
        void cursorBackward( bool mark, int steps = 1 );
        void cursorWordForward( bool mark );
        void cursorWordBackward( bool mark );
        bool dragEnabled();
        void setDragEnabled( bool b );


QMainWindow
-----------

Added a dock window architecture. Previous versions of QMainWindow
could only deal with toolbars, now they handle generalized dock
windows. QToolBar inherits QDockWindow.


New property:
        bool dockWindowsMovable;

New signals:
        void dockWindowPositionChanged( QDockWindow * );

New functions:
        void setDockEnabled( Dock dock, bool enable );
        bool isDockEnabled( Dock dock ) const;
        bool isDockEnabled( QDockArea *area ) const;
        void setDockEnabled( QDockWindow *tb, Dock dock, bool enable );
        bool isDockEnabled( QDockWindow *tb, Dock dock ) const;
        bool isDockEnabled( QDockWindow *tb, QDockArea *area ) const;

        void addDockWindow( QDockWindow *, Dock = Top, bool newLine = FALSE );
        void addDockWindow( QDockWindow *, const QString &label, Dock = Top, bool newLine = FALSE );
        void moveDockWindow( QDockWindow *, Dock = Top );
        void moveDockWindow( QDockWindow *, Dock, bool nl, int index, int extraOffset = -1 );
        void removeDockWindow( QDockWindow * );

        QDockArea *dockingArea( const QPoint &p );
        QDockArea *leftDock() const;
        QDockArea *rightDock() const;
        QDockArea *topDock() const;
        QDockArea *bottomDock() const;
        
        bool isCustomizable() const;
        bool appropriate( QDockWindow *dw ) const;
        QPopupMenu *createDockWindowMenu( DockWindows dockWindows = AllDockWindows ) const;

        bool showDockMenu( const QPoint &globalPos );


QMetaObject
-----------

###TODO


QMimeSourceFactory
------------------

New static functions:
        QMimeSourceFactory* takeDefaultFactory();
        static void addFactory( QMimeSourceFactory *f );


QNetworkProtocol
----------------

Spelling fix in Error::ErrListChildren enum.


QRegExp
-------

QRegExp now has a more complete regular expression engine similar to
Perl's, with full Unicode and backreference support.

New functions:
        bool minimal() const;
        void setMinimal( bool minimal );
        bool exactMatch( const QString& str );
        bool exactMatch( const QString& str ) const;
        int search( const QString& str, int start = 0 );
        int search( const QString& str, int start = 0 ) const;
        int searchRev( const QString& str, int start = -1 );
        int searchRev( const QString& str, int start = -1 ) const;
        int matchedLength();
        QStringList capturedTexts();
        QString cap( int nth = 0 );
        int pos( int nth = 0 );


QSessionManager
---------------

Renamed the misnamed setProperty() overloads to setManagerProperty()
to resolve the conflict with the now virtual QObject::setProperty().


QString
-------

New functions:
        bool endsWith( const QString & );
        int similarityWith( const QString & );

### TODO

QStyle
------

### TODO

QTabBar
-------

The extended QTabWidget support in Qt Designer made two more
functions handy to have:
        QTab * tabAt( int ) const;
        int indexOf( int ) const;



QToolBar
--------

Inherits QDockWindow now, previously only QWidget.


QToolButton
-----------

New property:
        QIconSet iconSet

New functions:
        QIconSet iconSet() const;
        virtual void setIconSet( const QIconSet & );

QWidget
-------

New functions:

    const QColor & eraseColor() const;
    virtual void setEraseColor( const QColor & );
    const QPixmap * erasePixmap() const;
    virtual void setErasePixmap( const QPixmap & );



QWizard
-------

New property: QString titleFont

New functions:
        QFont titleFont() const;
        void setTitleFont( const QFont & );
        int indexOf( QWidget* ) const;


QWMatrix
--------

New function:
        bool isIdentity() const;
        

QGL Module
----------

QGLWidget
New functions:
        QGLFormat requestedFormat() const;
        QImage grabFrameBuffer( bool withAlpha = FALSE );


QWorkspace Module
-----------------

A new property scrollBarsEnabled makes it possible to add on-demand
scrollbars to the workspace. We define this property in Qt Designer to
make designing forms larger than the available space on the desktop
more comfortable.

New property:
        bool scrollBarsEnabled


QXML Module
-----------
Many new functions have been added:
        QDomImplementation
                QDomDocumentType createDocumentType( const QString& qName, const QString& publicId, const QString& systemId );
                QDomDocument createDocument( const QString& nsURI, const QString& qName, const QDomDocumentType& doctype );
        QDomNode
                QDomNode insertBefore( const QDomNode& newChild, const QDomNode& refChild );
                QDomNode insertAfter( const QDomNode& newChild, const QDomNode& refChild );
                QDomNode replaceChild( const QDomNode& newChild, const QDomNode& oldChild );
                QDomNode removeChild( const QDomNode& oldChild );
                QDomNode appendChild( const QDomNode& newChild );
                bool hasChildNodes() const;
                QDomNode cloneNode( bool deep = TRUE ) const;
                void normalize();
                bool isSupported( const QString& feature, const QString& version ) const;
                QString namespaceURI() const;
                QString localName() const;
                bool hasAttributes() const;
        QDomDocument
                bool setContent( const QCString& text, bool namespaceProcessing=FALSE );
                bool setContent( const QByteArray& text, bool namespaceProcessing=FALSE );
                bool setContent( const QString& text, bool namespaceProcessing=FALSE );
                bool setContent( QIODevice* dev, bool namespaceProcessing=FALSE );
        QDomNamedNodeMap
                QDomNode namedItemNS( const QString& nsURI, const QString& localName ) const;
                QDomNode setNamedItemNS( const QDomNode& newNode );
                QDomNode removeNamedItemNS( const QString& nsURI, const QString& localName );

        QDomElement
                QString attributeNS( const QString nsURI, const QString& localName, const QString& defValue ) const;
                void setAttributeNS( const QString nsURI, const QString& qName, const QString& value );
                void setAttributeNS( const QString nsURI, const QString& qName, int value );
                void setAttributeNS( const QString nsURI, const QString& qName, uint value );
                void setAttributeNS( const QString nsURI, const QString& qName, double value );
                void removeAttributeNS( const QString& nsURI, const QString& localName );
                QDomAttr attributeNodeNS( const QString& nsURI, const QString& localName );
                QDomAttr setAttributeNodeNS( const QDomAttr& newAttr );
                QDomNodeList elementsByTagNameNS( const QString& nsURI, const QString& localName ) const;
                bool hasAttributeNS( const QString& nsURI, const QString& localName ) const;

        
        QXmlAttributes
                void clear();
                void append( const QString &qName, const QString &uri, const QString &localPart, const QString &value );

        QXmlInputSource:
                void setData( const QByteArray& dat );
                void fetchData();
                QString data();
                QChar next();
                void reset();
                QString fromRawData( const QByteArray &data, bool beginning = FALSE );

        QXmlSimpleReader:
                bool parse( const QXmlInputSource& input, bool incremental );
                bool parseContinue();

        QXmlEntityResolver:
                bool startEntity( const QString& name );
                bool endEntity( const QString& name );

        

New classes
-----------

QAquaStyle (only on MacOS X)
QCleanupHandler
QComponentFactory
QComponentFactoryInterface
QComponentServerInterface
QContextMenuEvent
QDesktopWidget
QDockArea
QDockWindow
QErrorMessage
QFeatureListInterface
QHttp [network]
QInterfaceListInterface
QInterfacePtr
QIMEvent
QLibrary
QLibraryInterface
QStyleFactory
QStyleInterface
QTextCodecInterface
QUnknownInterface
QUuid
QRegExpValidator
QTextEdit


Renamed Classes
---------------

QArray has been renamed QMemArray
QCollection has been renamed QPtrCollection
QList has been renamed QPtrList
QListIterator has been renamed QPtrListIterator
QQueue has been renamed QPtrQueue
QStack has been renamed QPtrStack
QVector has been renamed QPtrVector

The include file names have changed accordingly (e.g., <qmemarray.h>).


New Modules
-----------

SQL
        QDataBrowser
        QDataTable
        QDataView
        QDateTimeEdit
        QEditFactory


Obsolete classes
----------------

        QSemiModal, use QDialog instead.
        QMultiLineEdit, use QTextEdit instead.
        QTableView, use QScrollView or QTable instead.
        QAsyncIO, QDataSink, QDataSource, QDataPump and QIODeviceSource


Obsolete functions
------------------
        QActionGroup::insert( QAction * ),  use QActionGroup::add( QAction* ) instead.
        QApplication::setWinStyleHighlightColor( const QColor &c ), use setPalette() instead
        QApplication::winStyleHighlightColor(), use palette() instead
        QDir::encodedEntryList( int filterSpec, int sortSpec ), use QDir::entryList() instead
        QDir::encodedEntryList( const QString &nameFilter, int filterSpec, int sortSpec ), use QDir::entryList() instead
        QMainWindow::addToolBar( QDockWindow *, Dock = Top, bool newLine = FALSE );
        QMainWindow::addToolBar( QDockWindow *, const QString &label,  Dock = Top, bool newLine = FALSE );
        QMainWindow::moveToolBar( QDockWindow *, Dock = Top );
        QMainWindow::moveToolBar( QDockWindow *, Dock, bool nl, int index, int extraOffset = -1 );
        QMainWindow::removeToolBar( QDockWindow * );
        QMainWindow::toolBarsMovable() const;
        QMainWindow::toolBars( Dock dock ) const;
        QMainWindow::lineUpToolBars( bool keepNewLines = FALSE );
        QRegExp::match( const QString& str, int index = 0, int *len = 0,
                        bool indexIsStart = TRUE );
        QToolButton::setOnIconSet( const QIconSet & )
        QToolButton::setOffIconSet( const QIconSet & )
        QToolButton::onIconSet() const
        QToolButton::offIconSet() const
        QToolButton::setIconSet( const QIconSet & set, bool on )
        QToolButton::iconSet( bool on ) const
        QXmlInputSource::QXmlInputSource( QFile& file ), use QXmlInputSource( QIODevice *dev ) instead.
        QXmlInputSource::QXmlInputSource( QTextStream& stream ), use QXmlInputSource( QIODevice *dev ) instead.

Removed functions:
        QWidget::setFontPropagation
        QWidget::setPalettePropagation
        QMenuBar::setActItem
        QMenuBar::setWindowsAltMode
        QCheckListItem::paintBranches
        QString::visual
        QString::basicDirection
        QRegExp::find( const QString& str, int index ) const; - has been renamed QRegExp::search()
        QFont::charSet() const, not needed anymore
        QFont::setCharSet( QFont::CharSet ), not needed anymore
        QPushButton::upButton(), not relevant anymore
        QPushButton::downButton(), not relevant anymore
        QSpinBox::upButton(), not relevant anymore
        QSpinBox::downButton(), not relevant anymore


Removed preprocessor directives
-------------------------------

        qcstring.h no longer contains the following defines:

                #define strlen qstrlen
                #define strcpy qstrcpy
                #define strcmp qstrcmp
                #define strncmp qstrncmp
                #define stricmp qstricmp
                #define strnicmp qstrnicmp

        These directives were meant to automagically replace calls to the
        above listed standard C functions with the equivalent Qt wrappers.
        The latter pre-check the input parameters for null pointers as those
        might cause crashes on some platforms.

        Although convenient, this trick turned out to sometimes conflict with
        third-party code, or, simply be nullified by standard system and
        library headers depending on version and include order.

        The name of some debugging macro variables has been changed.

                DEBUG becomes QT_DEBUG
                NO_DEBUG becomes QT_NO_DEBUG
                NO_CHECK becomes QT_NO_CHECK
                CHECK_STATE becomes QT_CHECK_STATE
                CHECK_RANGE becomes QT_CHECK_RANGE
                CHECK_NULL becomes QT_CHECK_NULL
                CHECK_MATH becomes QT_CHECK_MATH

        The name of some other debugging macro functions has also been changed
        but source compatibility should not be affected if the macro variable
        QT_CLEAN_NAMESPACE is not defined:

                ASSERT becomes Q_ASSERT
                CHECK_PTR becomes Q_CHECK_PTR

        For the record these undocumented macro variables that are not part of
        the API have been changed:

                _OS_*_ becomes Q_OS_*
                _WS_*_ becomes Q_WS_*
                _CC_*_ becomes Q_CC_*


[Qt 3.0]