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.