File: changes.doc

package info (click to toggle)
qt-x11-free 3:3.3.8b-7
  • links: PTS, VCS
  • area: main
  • in suites: squeeze
  • size: 82,260 kB
  • ctags: 72,611
  • sloc: cpp: 456,781; ansic: 129,082; sh: 11,455; yacc: 2,947; xml: 766; makefile: 566; perl: 495; lex: 458; sql: 29; lisp: 13
file content (453 lines) | stat: -rw-r--r-- 20,304 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
/****************************************************************************
**
** Change documentation
**
** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
**
** This file is part of the Qt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free Qt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.QPL
** included in the packaging of this file.  Licensees holding valid Qt
** Commercial licenses may use this file in accordance with the Qt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/

/*!
\page keyfeatures30.html

\title Key Features in Qt 3.0

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.

\omit
Other major new features include a component architecture allowing you
to build cross platform components, 'plugins' with Qt. 
\endomit
Other major new features include a plugin architecture. 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
(\l{QDockArea}/\l{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.


\section1 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.


\section2 Database support

One of the major new features in Qt 3.0 is the \link sql.html SQL
module\endlink that provides multiplatform 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.

\omit
\section2 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.
\endomit
\section2 Plugins

The QLibrary class provides a platform independent wrapper for runtime
loading of shared libraries. 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. 

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

See the \link plugins-howto.html plugins documentation\endlink.


\section2 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 new QTextEdit engine is highly optimized for proccesing
and displaying large documents quickly and efficiently. 


\section2 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.


\section2 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.


\section2 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, QRegExp, 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.


\section2 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.


\section2 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.


\section2 Accessibility

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.


\section2 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.


\section2 SVG support

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


\section2 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 Mac OS X, Windows 98, and 2000 is supported, as well
as the traditional multi-screen and the newer Xinerama multihead setups on
X11.


\section2 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).


\section2 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.


\section2 QHttp

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


\section2 Compatibility with the Standard Template Library (STL)

Support for the C++ Standard Template Library has been added to the
\link qt-template-lib.html Qt Template Library (QTL)\endlink.  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()).


\section1 Qt Designer

\link designer-manual.book Qt Designer\endlink 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.


\section1 Qt Linguist

\link linguist-manual.book Qt Linguist\endlink 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:

\list
  \i 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).
  \i Provide translations for the source texts in the *.ts file using
     Qt Linguist.
  \i Run lrelease to obtain a light-weight message file (a *.qm file)
     from the *.ts file, which provides very fast lookup for released
     applications.
\endlist

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.


\section1 Qt Assistant

Thanks to the positive feedback we received about the help system
built into \link designer-manual.book Qt Designer\endlink, we decided
to offer this part as a separate application called \link
assistant.book Qt Assistant\endlink. 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.


\section1 qmake

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

*/