| 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] |
| |