# Change History

This section contains a list of all major changes from release to release starting from the most recent. The text in the square brackets after the release date shows the repository tag corresponding to this release.

More detailed changes can be found in the file os2-doc\ChangeLog.

## Release Candidate 5 (2005-11-12) [`rc05`]

Important Note. The Qt DLL built by this release is binary incompatible with the previous release. All applications must be relinked against the new version of the library.

### kernel

`QCursor` is fully implemented, including creating custom pointer shapes from bitmaps.

`QT_NO_PROPERTIES` macro is not defined any more, so `QObject`'s properties functionality is now available.

Implemented OS/2 PM Clipboard support (`QMime` and `QClipboard` classes); `QT_NO_CLIPBOARD` macro is no more defined by default.

Implemented `QPixmap::xForm()`; `QT_NO_PIXMAP_TRANSFORMATION` is no more defined by default.

Implemented font transformations according to `QPainter` view and world matrices (this still has some issues because both native TTF and FreeType2 font rendering engines are bogus when applying complex world transformations such as rotation).

Added the `QMovie` class; `QT_NO_MOVIE` is no more defined by default.

Enabled translation (internationalization) services, including `QTranslator` and `QTranslatorMessage` classes, plus `lupdate.exe` and `lrelease.exe` command line tools. `QT_NO_TRANSLATION` is no more defined.

### dialogs

OS/2 and eComStation are now mentioned in the `QMessageBox::aboutQt()` dialog.

### workspace

Added the `workspace` module (`QWorkspace` class). The limitation of the current implementation is that child windows don't have sysmenu/min/max/close buttons and cannot be closed/maximized/minimized using the titlebar.

### other changes

New examples: `action`, `application`, `cursor`, `drawlines`, `i18n`, `mdi`, `network/archivesearch`, `network/ftpclient`, `network/infoprotocol`, `network/remotecontrol`, `picture`, `qfd`, `qmag`, `qtl`, `qwerty`, `rot13`, `showimg`, `textedit`, `tictac`, `toplevel` and `xform`.

Various fixes (`QTextEdit` in `LogText` mode, `QPopupMenu` with multiple columns, using pixel sizes to select fonts), see `os2-doc\ChangeLog` for more info.

Added two new qmake project variables to the `GNUMake` backend: `DEF_FILE_TEMPLATE` and `DEF_FILE_MAP` (see here for more info). `mkspecs/os2-g++/qmake.conf` recognizes these variables and (with the help of the supplied `emxexpw.cmd` script) uses them as follows:

- If `DEF_FILE_TEMPLATE` is defined, it is expected to point to an existing `.def` file template used when creating a `.def` file for the DLL. In this template, all occurences of the `${name}` macro are replaced with the name of the DLL and the first occurence of the `${exports}` macro is replaced with the list of exported symbols. If `DEF_FILE_TEMPLATE` is not defined, the default template is used (`INITINSTANCE` `TERMINSTANCE`, `DATA` `MULTIPLE` `NONSHARED`).
- If `DEF_FILE_MAP` is defined, it must point to an existing file (it may be empty for the first time). Specifying a map file tells the `.def` file generator to export all public symbols by ordinals only (to reduce the DLL size and speed up access to exported symbols). This map file is used to store ordinals assigned to exported symbols (to guarantee these assignments are persistent from build to build, which in turn helps to support binary DLL compatibility). For more details about the format of the map file, please refer to the `envexpw.cmd` script. If `DEF_FILE_MAP` is not defined, all symbols are exported by name.

The Qt library, when built as a DLL, makes usage of the above `DEF_FILE_*` variables. This makes it possible to maintain binary compatibility between newer and older releases whenever it is technically possible (i.e. no new data members in Qt classes etc.).

The `configure.cmd` script has been rewritten from scratch. It is now fully interactive and is capable of searching for suitable versions of the compiler, linker and the make tool in the locations specified by the user.

## Release Candidate 4 (2004-10-02) [`rc04`]

This release contains few fixes (`\os2-doc\ChangeLog` for full list) as well as the following new functionality.

### kernel

Added zlib, jpeg, png, mng support (controlled via `\configure.cmd`), async I/O classes (defined in `asyncio.h`).

Added basic MIME support (`QMimeSource` class), no PM DDE <-> open MIME conversion yet (`QMimeSource` is just necessary for some other classes). Added basic DND support (`QDragObject`, `QImageDrag`, `QTextDrag`, `QStoredDrag`, `QUriDrag`), but no real drag & drop yet (`QT_NO_DRAGANDDROP` is still defined, but some classes need `QDragObject` and others to make the correct usage of `QMimeSource`).

`QRegion` now supports creating regions from `QBitmap`s (`QRegion(const QBitmap &)` constructor).

### widgets

New classes: `QWidgetPlugin` (necessary for some other new classes), `QTextBrowser`; `QDateTimeEditor`, `QDial`, `QSplashScreen`, `QWhatsThis`.

Implemented animation effects support, (see `QApplicaition::setEffectEnabled()`, `isEffectEnabled()` methods), this means that the `widgets` module is now completely implemented.

### network

Implemented network module (classes `QDns`, `QFtp`, `QHostAddress`, `QHttp`, `QServerSocket`, `QSocket`, `QSocketDevice`, `QSocketNotifier`) with the following limitations: no IPv6 support (`QT_NO_IPV6` is defined), no synchronous lookups (i.e. defining `Q_DNS_SYNCHRONOUS` in `qdns.h` is useless), `QSocketDevice::blocking()` always returns `TRUE` (it seems that there's no way to determine the current blocking state of an arbitrary socket).

Note: the socket notification (`QSocketNotifier`) functionality is not available when Qt is compiled without threading support (this also means that `QDns` class will not function properly, as well as many other network applications that rely on the socket notification mechanism provided by Qt); in a single-threaded version of Qt such methods as `QEventLoop::registerSocketNotifier()` simply do nothing, and notification signals are never emitted.

### other changes

The `configure.cmd` script has been moved from the `\bin` subdirectory to the root directory of the project.

Added new examples: `scrollview`, `helpviewer`; `network\clientserver`, `network\httpd`, `network\mail`, `network\networkprotocol`; all xml examples (the `xml` subdirectory). Note that the `helpviewer` example shows nothing after invocation (because Qt docs are not contained in the repository), point it to the existing html file to see the results.

#### GNUMake backend for qmake

A new makefile generator (backend) for qmake has been created, `GNUMAKE`. It is now used in Qt/OS2 along with the GCC compiler and the GNU Make utility to generate makefiles from `qmake`'s project files (instead of a bit buggy MINGWMAKE backend). See here for more information about the GNUMAKE backend.

#### new linker

The linker used along with the GCC compiler has been changed. The previously used IBM ILINK 5.0 has some very unpleasant bugs that do not allow to build the DLL version (see below) of the Qt library. It is now necessary to use the linker from the distribution of IBM Visual Age C/C++ version 3.08. The copies of your `gcc322.cmd` and `qt.cmd` scripts should be updated with the new ones from the `\os2-misc` subdirectory (don't forget to correct path variables inside the scripts). Read also here about the steps necessary to compile the Qt Library.

Note that ILINK 3.08 creates executables and DLLs that are slightly bigger in size comparing to ones produced by ILINK 5.0. The freeware tool lxlite can be used to reduce the size of executables and DLLs, if desired.

#### DLL version of Qt

The Qt library can now be compiled as the DLL. The `DLL` variable has been added to the `\configure.cmd` script to control the type of the Qt library to compile. Set it to `1` to compile Qt as the the DLL and to `0` to compile it as the static library. After building the Qt DLL using `configure.cmd`, all Qt programs built using qmake wil be linked against this DLL. By default, `configure.cmd` compiles Qt as the release DLL with all available features turned on (excluding the `gif` support, due to its license limitations).

#### uic tool

The user interface compiler (`uic`) utility has been added to the project. As for now, It is primarily necessary to process the `IMAGES` qmake's project variable used to embed a collection of images to the executable, but can be also used to compile the user interface (`.ui`) files as well. However, there's still no QDesigner for OS/2, so `.ui` files can be created and edited only manually (with one limitation -- widget properties for setting the cursor shape are not supported by the current version of `uic` due to the currently incomplete `QCursor` class implementation).

## Release Candidate 3 (2004-06-23) [`rc03`]

This release contains some fixes (see `\os2-doc\ChangeLog`) as well as the following new functionality.

### kernel

Qt applications now use the PM Scheme Palette font settings to setup default fonts for widgets. This can be disabled by calling `QApplication::setDesktopSettingsAware(FALSE)`.

### widgets

The `QWidget::reparent()` method has been implemented. Things like tear-off menus (see the `menu` example) and toolbars (the `action\toggleaction` example) seem to work well.

### other changes

New examples: `menu`, `rangecontrols`, `listbox`, `tabdialog`, `wizard`, `life`, `hello`, `gridview`, `forever`, `fonts`, `addressbook`, `splitter`, `layout`, `customlayout`, `themes`, `scribble`, `action\toggleaction`, `thread\prodcons`, `thread\semaphores`. Note that the `themes` example using the Norwegian Wood theme doesn't handle the button roundness because non-rectangular widgets are not currently supported by Qt/OS2.

The `RELEASE` variable has been added to the `bin\configure.cmd` script to control the type of the Qt library to be compiled. Set it to `1` to compile the release version and to `0` to compile the debug version.

## Release Candidate 2 (2004-06-16) [`rc02`]

This release is mostly a bugfix. See `\os2-doc\ChangeLog` for the detailed info about all fixes applied. Also, the following functionality has been added.

### kernel

Qt applications now use the PM Scheme Palette color settings to setup the default palette for widgets. This can be disabled by calling `QApplication::setDesktopSettingsAware(FALSE)`.

Mouse wheel handling (`QEvent::Wheel`) now works, the wheel can be used in all widgets that support it. System settings for the mouse wheel (standard or AMouse) are currently ignored, because Qt handles things such as the number of lines to scroll per whell rotation on its own, and doesn't offer a setting to tell it to be aware of system settings.

The optimization setting for pixmaps with masks is now meaningful: `NoOptim`/`MemoryOptim` optimizes for memory, `NormalOptim`/`BestOptim` -- for speed. Memory optimization causes QPixmap not to store a special precomposed image for every pixmap but recreate it every time the pixmap is drawn.

Rich text support for widgets has been enabled and seems to work well. This includes `QStyleSheet` and `QSimpleRichText` classes. Widgets that support it (for example, QMessageBox) now display rich text strings correctly.

### widgets

New widgets: `QGridView`, `QSpinBox`, `QSyntaxHighlighter`, `QTextEdit`, `QTextView`.

### dialogs

Two new dialogs: `QColorDialog` and `QFontDialog`.

### other changes

New examples: `lineedits`, `listboxcombo`, `listviews`, `progressbar`.

## Release Candidate 1 (2004-06-04) [`rc01`]

This release candidate brings Qt/OS2 functioality to a level where it can be used to create simipe "general-purpose" applications: many commonly used widgets are done. Some (mostly cosmetic) shortcomings are still present (for example, images do not support transparency yet) -- this will be fixed in next releases.

### kernel

The modal widget functionality has been implemented (including `Qt::WShowModal` widget flag). `QEvent::WindowBlocked` and `WindowUnblocked` are now sent to widgets when they are blocked/unblocked by modal widgets. Unlike on Qt/Win32, these events are sent to all top-level widgets, not only to the direct parent of the modal widget being shown/hidden.

The popup widget functionality has been done (`Qt::WType_Popup` widget flag). It has no significant differences comparing to Qt/Win32; in particular, popup widgets do not grab mouse move events addressed to widgets from other applications, except when a mouse button is pressed down while moving (as this can be seen in the `popup` example). It should be noted here, that `QWidget::grabMouse()` in OS/2 does grab such events, which differs from Qt/Win32 where this function has the same effect as in popups.

New classes: `QLocalFs`, `QUrl`, `QUrlOperator`, `QUrlInfo`, `QNetworkProtocol`. These classes do not bring the network support to Qt/OS2 -- they are network helper classes that also required by some common widgets, such as `QFileDialog`.

### dialogs

The dialogs module has been started: `QDialog`, `QMessageBox`, `QProgressDialog` and `QFileDialog` are now present. `QFileDialog` is a pure Qt widget, native OS/2 PM file dialogs are not yet supported.

### widgets

New widgets:

- `QPopupMenu` and `QMenuBar` (including `QMenuData`);
- `QLineEdit`, `QValidator`;
- `QProgressBar`, `QStatusBar`;
- `QMainWindow`;
- `QComboBox`;
- `QDockArea`, `QDockWindow`;
- `QListBox`, `QListView`, `QHeader`;
- `QScrollBar`, `QScrollView`;
- `QSplitter`;
- `QTitleBar`;
- `QToolBar`; `QToolButton`;
- `QToolTip`;
- `QWidgetStack`.

New methods:

- `QApplication::cursorFlashTime()` and `setCursorFlashTime()`;
- `QApplication::doubleClickInterval()` and `setDoubleClickInterval()`;
- `QWidget::scroll()`.

### other changes

New examples: `popup`, `progress`, `buttongroups`, `checklists`, `tooltip`.

## Beta 2 (2004-05-27) [`b02`]

### kernel

Mouse and keyboard event handling has been implemented. The following new types of events are now handled by Qt/OS2 and delivered to widgets:

- mouse events (`QEvent::MouseButtonPress`, `MouseButtonRelease`, `MouseButtonDblClick`, `MouseMove`);
- mouse enter/leave events (`QEvent::Enter`, `Leave`);
- show/hide/close events (`QEvent::Show`, `Hide`, `Close`);
- focus events (`QEvent::FocusIn`, `FocusOut`);
- window activation change events (`QEvent::WindowActivate`, `WindowDeactivate`);
- context menu event (`QEvent::ContextMenu`);
- keyboard events (`QEvent::keyPress`, `keyRelease`).

Also, the following has been added:

- `QApplication`: `setGlobalMouseTracking()`.
- `QWidget`:
  - `mapToGlobal()`, `mapFromGlobal()`.
  - `setMinimumSize()` and `setMaximumSize()` now make sense (although system recommended minimum top-level window size is still obeyed, for compatibility with Qt/Win32).
- `QPainter`: `drawRoundRect()`, `drawCubicBezier()`. All `QPainter` methods are now implemented.
- `QAccel` and `QKeySequence` classes.

#### Keyboard handling

DBCS keyboard input is not tested, and most likely will not work correctly in Qt/OS2.

#### System menu

The system menu of the top-level widget (if it is present) can be activated by pressing the `ALT`+`<space>` keyboard combination. Pressing single `ALT` doesn't show it, this is done for compatibility with other Qt versions. Also, frame size/position accelerators (`ALT`+`F7` etc.) have been disabled for the same reason. They are still present in the menu item text, but it will be fixed in the next release.

### widgets

The `widgets` module implementation has been started. The following classes are currently available and seem to function well: `QButton`, `QButtonGroup`, `QLabel`, `QFrame`, `QPushButton`, `QCheckButton`, `QRadioButton`, `QLCDNumber`, QRangeControl, `QSlider`.

Also, layout management has been completely compiled in and partially tested, including classes: `QBoxLayout`, `QButtonGroup`, `QGLayoutIterator`, `QGrid`, `QGridLayout`, `QGroupBox`, `QHBox`, `QHBoxLayout`, `QHButtonGroup`, `QHGroupBox`, `QLayout`, `QLayoutItem`, `QLayoutIterator`, `QSizePolicy`, `QSpacerItem`, `QVBox`, `QVBoxLayout`, `QVButtonGroup`, `QVGroupBox`, `QWidgetItem`.

### other changes

The Qt/OS2 distribution now contains the Qt tutorial and examples from the original Qt 3.3.1 distribution that can be compiled without any modifications and run well under OS/2. This doesn't mean though that they are fully functional (comparing to other platforms) -- some functionality (such as the non-rectangular window in the aclock example) is still missing in Qt/OS2, but these examples can at least properly handle such situations (usually doing nothing or keeping some kind of "default" behavior when the missing functionality is requested).

The Qt tutorial can be completely compiled on OS/2 and works fine, as well as `aclock` and `dclock` examples. The compilation of tutorial applications and examples is done automatically by the `configure.cmd` script.

## Beta 1 (2004-05-18) [`b01`]

### kernel

Big work is done to implement the font support (`QFont`, `QFontInfo`, `QFontMetrics`, `QFontDatabase` classes). This in particular means that all kernel module visualization functionality (primitives, images, fonts) is now done. The current font implementation has the following limitations:

- DBCS fonts will most likely not work correctly (a serious work is required to support such scripts as arabic, herbew, japanese), so true unicode is not fully supported. Also this means that it's not possible to draw glyphs from different scripts at the same time, only glyphs from the current character set (usually system default) are available to draw, `QFont::Script` values are totally ignored.
- Foundries in family names are ignored (the same behavior is on Qt/Win32).
- Printer output is not yet supported (this also relates to all other kernel parts).
- `QFontMetrics`: `minRightBearing()` and `minLeftBearing()` return zero at the present.
- Text drawing and font measuring operations are not subject of any coordinate space transformations except the simple translation transformation.
- No font style simulation (bold and italic) is done, only true styles of the fonts installed in the system are available.
- `QFontDatabase`: due to a bug in `GpiQueryFontAction()` API the Qt font database is not sensible to font changes (installing/removing fonts from the system) during the application lifetime. This means that the application should be restarted in order to pick up such changes.

Also, the following has been added:

- `QPainter`: `drawText()` (+ font getter/setter methods), `drawEllipse()`, `drawArc()`, `drawPie()`, `drawChord()`, `drawPolyLine()`, `drawLineSegments()`, `drawWinFocusRect()`.
- `QWidget`: `drawText()` (+ font getter/setter methods).
- `QIconSet` and `QPicture` are now available.

### styles

The styles module (`QStyle`, `QStyleFactory` etc.) has been enabled for compilation. Currently, OS/2 version of Qt uses the "Windows" (`QWindowsStyle`) style for widgets by default (though, this cannot be seen in this beta -- no widgets that use styles are completely ready at this moment).

### other changes

- The CVS repository changelog has been added to the distribution (it can be found in the `\os2-doc` directory). This changelog contains more detailed project change history.
- The link to GNU Make (here) is now updated to refer to the latest version (it was outdated in `a02`).

## Alpha 2 (2004-05-07) [`a02`]

This alpha is intended to test the basic GUI functionality: widget creation, starting the main event loop, painting widgets and drawing on pixmaps (graphic primitives, colors, images).

### tools

The `tools` module is completely done (some of recent classes are `QMutex`, `QSemaphore`, `QWaitCondition`, `QThread`, `QThreadStorage`).

#### QThread::wait (time)

Since OS/2 doesn't support specifying a maximum time to wait for a thread to end other than infininty we use a loop containing of wait intervals until the thread has ended or the maximum time specified by the caller has expired, which brings the granularity of 1 second (the length of the wait interval) to this process.

### codecs

The `codecs` module (`QTextCodec` class) seems to be done (excluding `QHerbewCodec`, that depends on `QTextEngine`)

### moc

The meta object compiler (`moc`) added to the project, compiled and seems to work well.

### kernel

The `kernel` module is done on about 75 percent. Here are the most imortant classes that have been implemented (with a very brief description of implemented and disabled features -- the most of this will be changed later):

- `QApplication`: no handling of fonts (`QFont` and stuff), sessions, clipboard (`QClipboard`), drag&drop and styles (`QStyle`) yet, event handling is still limited (only `QPaintEvent`, `QResizeEvent` and `QMoveEvent` plus some others).
- `QEventLoop`: no `QSocketNotifier` functionality, no simple timers for plugins (that do not require the message queue)
- `QPaintDevice`: no alpha blending, no printer (`QPrinter`) support
- `QPaintDeviceMetrics`
- `QColor` (fully, including the palette support)
- `QPixmap`: alpha pixmaps, no pixmap transformations (xForm())
- `QBitmap`
- `QImage`
- `QRegion` (no y coordinate flipping yet, regions from ellipses and polygons are created as bounding rectangle regions, no regions from bitmaps, ready for limited usage only)
- `QPainter`: everything related to fonts, text drawing and rich text classes is currently disabled
- `QBrush`, `QPen`
- `QWidget`: everything related to fonts and cursors is currently disabled; no mask support (`setMask()`); no icon support (`setIcon()`); only few events at the moment (`paintEvent()`, `resizeEvent()`, `moveEvent()`)
- `QDesktopWidget`
- `QLayout` and stuff
- `QTimer`
- `QPalette`
- `QVariant` (`QFont`, `QIconSet` and `QKeySequense` are not yet handled)

There is no support for MNG, PNG and JPEG formats at the moment, it will be compiled in later.

There is no zlib integration yet, will also be done later.

### other changes

Compilation tools are updated (Innotek GCC and GNU Make). The process of building Qt is changed (in particular, it is now built as the static library). This is described here.

The `aclock` example from the Qt-Win32 distribution now compiles and runs well (except that there is no full mouse support and no transparent mode). Instructions are at the same place as above.

## Alpha 1 (2004-04-09) [`a01`]

The aim of this first step is to organize and test the compilation environment to make sure it is suitable for further development. Also it gives us many of non-visual widely used Qt classes from the `tools` module compiled for OS/2 as well as the OS/2 version of the `qmake` utility which uses these classes.

Currently the following most important public Qt classes are available (this list is not complete): `QLibrary`, `QSettings`, `QDir`, `QFile`, `QFileInfo`, `QLocale` `QDate`, `QTime`, `QDateTime`, `QString`, `QChar`, `QCString` plus various container and iterator classes.

#### QSettings

`QSettings` class is implemented using the Open32 registry API available in recent OS/2 versions (REGISTRY.DLL). This registry is very similar to the Windows one so this class should behave nearly the same as on Windows.

#### QFileInfo

The `QFileInfo` class is implemented in the following way:

- `isSymLink()` always returns `FALSE`
- `readLink()` always returns `QString::null`
- `owner()` = `group()` = `QString:null`
- `ownerID()` = `groupID()` = `-2`
- `permission()` always returns `TRUE` except the situation when the `permissionSpec` argument is `Write*` and the file is read-only

#### QString

Since everything is currently compiled with the `QT_NO_TEXTCODEC` flag set `QString` will return question (`?`) marks for all unicode symbos with codes greater than `0x00FF`. However, non-Unicode string data taken from the OS (for example in file operations) will be simply converted to unicode by expanding every non-unicode byte to a unicode word, meaning that the conversion from Unicode back to single byte (for example, during the output to the console) will preserve nationals. This is the standard behavior of Qt and it is not critical for most console mode applications as long as `QString`s are not presistently stored in the unicode form and the system local character set is not changed.

#### qmake

The current OS/2 version of qmake uses the MINGW makefile generator mode. Resulting makefiles produced by `qmake` from Qt project files seem to be processed well by GNU Make, however the following known limitations currently apply:

- object files are always created with the `.o` extension (although they are actually OMF files).
- dll files cannot be correctly linked without manual correction of the makefile because MINGW generator always adds the hard-encoded option `-Wl,--out-implib,libXXX.a` to a call to the linker to tell it to generate the import library, but this option is not compatible with Innotek GCC.
- MINGW generator assigns a dot to OBJECTS_DIR and MOC_DIR when they are not specified which causes GNU Make to produce warning messages.

These limitations will be eliminated in the future, probably by implementing a separate makefile generator class.

qmake for OS/2 understands the new command line option `-os2` that tells it to use OS/2 semantics when generating makefiles, and the new scope specifier `os2` in Qt project files to isolate OS/2-specific project parts.

The qmake specification for OS/2 and GCC is named `os2-g++` and after setting the `QMAKESPEC` variable accordingly it is available for use.

Please also refer here to get info about how to compile and run qmake.