source: trunk/README.OS2@ 814

This is Qt version 4.6.2 for OS/2 and eCS.

This document contains a brief information on the OS/2 version of the Qt
library. Please read it carefully before starting your work. You may also
visit the project page at

  http://svn.netlabs.org/qt4/wiki

to get more information and the latest news and also to report bugs.

To get a brief list of OS/2-specific changes from release to release
please see the CHANGES.OS2 file included in this distribution.

Please note that this version is binary incompatible with previous versions of
Qt 4 for OS/2! This is not a behavior of the original Qt library (where versions
with the same major number are usually binary compatible), but it is due to the
fact that we continue to add missing features to the OS/2 version ot Qt and this
cannot be done witout breaking the binary compatibility. On practice, this means
that you need to recompile your applications with the new version of the Qt
library in order to make them work with it.



REQUIREMENTS

In order to compile the Qt library and Qt-based applications, you will need
the following tools:

  - One of the OS/2 Warp 4, OS/2 Warp 4.5 or eComStation operating systems.

  - GCC compiler version 4.4.2 for OS/2, patched OpenWatcom linker and
    GNU Make 3.81beta1 or above. The GCC compiler must be set up to use the
    OpenWatcom linker for linking.

    If you do not have a working GCC environment with the above requirements, it
    is recommended to download a ready-to-use GCC 4.2.2 distribution from here:

      ftp://ftp.netlabs.org/pub/qt4/gcc-4_4_2-complete-20091205.zip

    This distribution includes all tools necessary to compile and build the Qt
    library from the source code. Just follow the installation instructions
    contained in the README file inside this ZIP archive to set up the GCC
    environment.

    Please note that starting from Qt 4.6.2, support for GCC 3.3.5 and earlier
    versions of the compiler has been dropped and the Qt library will most
    likely not build if you use one of these compilers. Later versions prior to
    GCC 4.4.2 may work but they are not tested and not supported.

There is also a set of optional tools which are necessary to enable the selected
features of the Qt library. If these tools are missing, the Qt configuration
script (discussed in section "COMPILING QT" below) will automatically disable
the corresponding feature:

  - LxLite 1.3.3 or above (not tested) to enable the compression of Qt DLLs and
    application executables (which saves hard disk space and application startup
    time). If you use a recent version of eComStation (e.g. 2.0 rc6) you will
    already have LxLite installed. Otherwise, you may take it from here:

      http://www.os2site.com/sw/util/archiver/lxlt133.zip

  - CUPS 1.3.11 or later to support printing in Qt. The CUPS libraries are
    available at:

      http://download.smedley.info/cups-1.3.11-os2-20090807.zip

    Linking against eCUPS also requires pthread.lib:

      http://web.os2power.com/download/lib/pthread-20100217-os2.zip

  - OpenSSL 0.9.8o or later to support OpenSSL in Qt. The OpenSSL libraries are
    available at:

      http://bauxite.sakura.ne.jp/tmp/os2/openssl-1.0.0a-os2knix-20100706-runtime.zip
      http://bauxite.sakura.ne.jp/tmp/os2/openssl-1.0.0a-os2knix-20100706-dev.zip

  - MySQL 5.1 or later for the MySQL Qt plugin. The MySQL libraries are
    available at:

      http://download.smedley.info/mysql-5.1.51-os2-20101001.zip

    Note that you will also need the above OpenSSL libraries and pthread.lib to
    be able to use this MySQL build.

  - PostgersSQL 9.0.1 or later to support the PostgresSQL Qt plugin. The
    PostgresSQL libraries are available at:

      http://download.smedley.info/postgresql-9.0.1-os2-20101012.zip

    Note that you will also need libc064x.dll for this PostgresSQL build and a
    patched PostgresSQL library that fixes one critical bug (this will not be
    necessary for the next PostgresSQL build as it will incorporate the fix):

      http://download.smedley.info/libc064x.zip
      http://download.smedley.info/libpq.zip

    Note that you will also need the above OpenSSL libraries and pthread.lib to
    be able to use this PostgresSQL build.



SETTING UP THE ENVIRONMENT

First of all, make sure that your GCC environment is set up and meets the
specified requirements. To perform a quick check, you may run the following
command:

  gcc --version && make --version && wl /version

If the setup is done properly, it will print the versions of the key tools
to the console.

The next step is to set up the Qt environment. If you installed the Qt
development libraries from the WPI archive (refer to section "USING OFFICIAL
BINARY QT ARCHIVES" below for more details about existing WPI archives), you
will only need to run the supplied "QtEnv.cmd" script which will do all the
setup job for you. The script is located in the directory where you installed
the developmnent libraries (or in the WPS folder created by the WPI installer).
Execute this script in a command line session to make it ready for building
Qt 4 applications (for example, using the "qmake" command follwed by "make"
for applications based on qmake project files which most of them are). If you
go that way, you may skip the rest of this section and proceed directly to
section "USING OFFICIAL BINARY QT ARCHIVES" below.

If you use the full source code ZIP distribution of the Qt library or work
directly with the Qt SVN tree, you will need to set up the environment yourself
by performing the following steps:

  - Add the "bin" subdirectory of the directory where you unpacked the Qt4
    source tree to PATH and BEGINLIBPATH, like this:

      set PATH=D:\Coding\Qt4\bin;%PATH%
      set BEGINLIBPATH=D:\Coding\Qt4\bin;%BEGINLIBPATH%

  - Add the system DLLs to the GCC library path with the following command:

      set LIBRARY_PATH=C:\OS2\DLL;C:\MPTN\DLL;%LIBRARY_PATH%

    where C: is your boot drive.

  - Make sure CMD.EXE is your command line processor (the generated makefiles
    will rely on its 'copy', 'if' and other commands). If you have a Unix shell
    (SH.EXE) in your environment, you may need to force GNU make to use CMD.EXE
    by executing the followingn command:

       set MAKESHELL=C:\OS2\CMD.EXE

    where C: is your boot drive.

Note that the QTDIR environment variable used in previous Qt versions is not
used in Qt4 anymore. Therefore, there is no need to set this variable
explicitly.

There is also no need to set the QMAKESPEC variable explicitly. If it is absent,
qmake will use the specification stored in the <Qt4_Home>/mkspecs/default
directory, which on OS/2 always refers to the "os2-g++" specification, the only
one supported at the present time.

NOTE:

    It is especially important to make sure that there are no traces of any
    other Watcom or OpenWatcom installation in the environment where you build
    Qt as it will interfere with the patched OpenWatcom linker we use. This
    basically means removing all environment variables containing "WATCOM" in
    their names and also removing references to all those Watcom installations
    from PATH.



SETTING UP OPTIONAL TOOLS

The following list describes the steps necessary to set up the optional tools
that the Qt library depends on:

  - Unzip the CUPS libraries to some directory and set the following environment
    variables to tell the Qt configure script its location:

      set CUPS_INCLUDEPATH=<path_to_CUPS>\include
      set CUPS_LIBS=-L<path_to_CUPS>\lib -llibcups.a -L<path_to_pthread> -lpthread.lib

  - Unzip the OpenSSL libraries to some directory and set the following
    environment variables to tell the Qt configure script its location:

      set OPENSSL_INCLUDEPATH=<path_to_OpenSSL>\include
      set OPENSSL_LIBS=

    Note that you will also need to place OpenSSL DLLs to BEGINLIBPATH (if they
    are not already in your LIBPATH) so that Qt applications can find them at
    runtime:

      set BEGINLIBPATH=<path_to_OpenSSL>\dll;%BEGINLIBPATH%

  - Unzip the MySQL archive to some directory and set the following environment
    variables to tell the Qt configure script the library location:

      set MYSQL_INCLUDEPATH=<path_to_MySQL>\include'
      set MYSQL_LIBS=-L<path_to_MySQL>\lib -lmysqlclient_r -L<path_to_OpenSSL>\lib -llibssl -llibcrypto -L<path_to_pthread> -lpthread

  - Unzip the PostgresSQL archive to some directory and set the following
    environment variables to tell the Qt configure script the library location:

      set PSQL_INCLUDEPATH=<path_to_PostgresSQL>\include'
      set PSQL_LIBS=-L<path_to_PostgresSQL>\lib -llibpq -L<path_to_OpenSSL>\lib -llibssl -llibcrypto -L<path_to_pthread> -lpthread



COMPILING QT

You should skip this section if you installed the Qt development libraries using
the WPI archive (that already contains compiled release versions of the
libraries) and proceed directly to the next section.

When the environment is set up, go to the directory where you unpacked the
Qt4 source tree and type:

  configure.cmd

This will set up the Qt library (by creating necessary configuration and include
files and a bunch of Makefiles for variuos components) and build the qmake tool.

The next step is to type:

  make

This will compile and link the Qt library. Note that by default both the release
and the debug version of the library are built (please be patient, it may take
quite some time depending on your hardware). The release and debug libraries can
co-exist in the same source tree and may be used in parallel: all the debug DLLs
get a 'd' letter in their name preceeding the Qt major version number and use
separate directories for object files.

To save time, you may build the release and the debug versions of the Qt library
separately by typing 'make release' or 'make debug' accordingly instead of just
'make'.

Once the library is successfully built, you may try to compile the demos and
examples by visiting the individual example subdirectories in the source tree
and typing 'qmake' followed by one of 'make', 'make release' or 'make debug'
in that subdirectory.

NOTE:

     This version of Qt for OS/2 includes the Extended system tray plugin for
     XCenter/eCenter which is necessary to enable Qt support for the special
     notification area on the XCenter/eCenter panel (called the "system tray")
     which is used by many long-running applications to display their status.
     In order to activate this support, you need to install this plugin to your
     XCenter or eCenter. The plugin is built during the normal Qt build process
     and can be found in the file \plugins\xcenter\xsystray.dll in the Qt source
     tree. In order to install the plugin, do the following:

     a. Copy xsystray.dll to <XWorkplace installation folder>\plugins\xcenter\
        (on eComStation, this will be C:\ecs\system\ewps\plugins\xcenter\ where
        C: is your boot drive).

     b. Restart WPS.

     c. Add the "Extended system tray" widget to the XCenter/eCenter panel using
        the XCenter context menu ('Create new widget').

     Note that if you upgrade from the previous version of the plugin then
     please unlock xsystray.dll in the target folder using the UNLOCK.EXE
     utility (which you can find in the LxLite package, for example) before
     performing step a., otherwise the copy operation will fail.

IMPORTANT NOTE:

     Please take into account that the Qt library you build on your own as
     described above is NOT intended for wide distribution with Qt applications
     you port or create. Such private Qt builds help you develop Qt applications
     (because you can easily debug your program and parts of the Qt framework at
     the source level) but being widely distributed they will create a so-called
     DLL hell when a program running on a user computer crashes because it picks
     up a wrong build of the Qt library. This will happen because even a single
     change to Qt configuration options may make your build binary incompatible
     with another build. And even if you convince the user to isolate different
     DLLs (using LIBPATHSTRICT and BEGINLIBPATH) it will create another major
     problem: two different Qt applications will load two different copies of Qt
     into memory which will create an unnecessary overhead by doubling the
     amount of used system resources.

     In order to nicely solve this problem, netlabs.org provides the official
     binary builds of the Qt library distributed as WPI archives which are
     described in the next section.



USING OFFICIAL BINARY QT ARCHIVES

For your convenience, netlabs.org provides the following binary distributions
of the Qt library (where X_Y_Z is the Qt version number) distributed as WPI
archives:

  qt-lib-X_Y_Z.wpi   - Runtime DLLs and binaries ("lib" archive)
  qt-dev-X_Y_Z.wpi   - Development libraries, tools and headers ("dev" archive)

These archives are called the official binary archives of the Qt library for
OS/2. An official binary archive contains the most complete Qt build that
enables all features of the Qt library and includes all standard Qt plugins
implemented for the OS/2 platform at the time of the release.

The "lib" archive contains the release versions of DLLs (and may contain a few
helper binaries) necessary to run applications created using the Qt framework.
This package is usually installed by end users together with Qt applications
they want to use.

The "dev" archive contains pre-built release versions of import libraries and
a complete set of C++ include headers of the Qt framework. This package is used
by developers and porters of Qt applications to build release versions of the
applications that are binary compatibie with the Qt runtime provided by the
official "lib" archive described above. Using the "dev" package requires the
same environment as described in section "SETTING UP THE ENVIRONMET" above.

Please note again that the "dev" archive is intended to make a final release
build of the Qt application which you do when you decide to ship a new version
to the end users -- makes sure that the deployed application will share the same
Qt runtime with other Qt applications. However, for daily work it is highly
recommended that you build the debug version of the Qt library yourself (using
the full source code ZIP archive or directly from SVN) as described in section
"COMPILING QT").

Besides the "lib" and the "dev" archives, the following official archives exist
that you may also find useful:

  qt-examples-X_Y_Z.wpi  - Demo and example sources ("examples")

The "examples" archive contains the source code and compiled binaries of the
demo and example applications shipped with Qt. They serve as a good
demonstration of the Qt library features and it is recommended to look at them.
The binaries are compiled using the official "lib" archive. Please note that
some demos and examples may miss from the arcvhice since not all features have
been implemented in the OS/2 version of Qt yet.

NOTE:

     All .DLL and .EXE files of the official binary build contain a DESCRIPTION
     string with the vendor field set to "netlabs.org" (by contrast, all custom
     Qt builds will set the vendor field to what the USER environment variable
     contains or to "anonymous" if USER is not set). Please note that you must
     NOT set vendor to "netlabs.org" when creating your own builds of the Qt
     library because it will make it difficult to identify various distributions
     and track possible problems with the builds.



QMAKE CONFIG OPTIONS

The following CONFIG options of the qmake tool have a special meaning in OS/2:

  windows           Turns on generation of PM (WINDOWAPI) executables. By
                    default, this option is set for release builds that link
                    to the Qt GUI library.

  console           Turns on generation of text mode (WINDOWCOMPAT) executables.
                    By default, this option is set when setting the "windows"
                    option is not appropriate (see above).

In addition, qmake recognizes the following OS/2-specific CONFIG options:

  map               Turns on generation of the .map files for executables and
                    DLLs. This option is set by default.

  exepack           Turns on compression for executables and DLLs. The option is
                    turned on by default for release builds if configure.cmd
                    finds a compression tool (LxLite) in PATH.

  highmem           Turns on high memory usage for dynamically allocated memory
                    in DLLs and executables. When this option is set, a special
                    compiler flag (-Zhigh-mem for GCC) is used to enable high
                    memory support in the C library (LIBC). This option is set
                    by default so that all Qt DLLs and Qt applications built
                    with qmake are enabled for high memory. Note that high
                    memory support must be enabled for all LIBC-based DLLs
                    linked to the executable as well as for the executable
                    itself: high memory usage will be disabled if one of them
                    votes against it.

  export_all        Cause the linker to export all public symbols in a generated
                    DLL. By default (when this option is absent), only the
                    symbols marked with the __declspec(dllexport) compiler
                    directive in the source files.



PRINTING SUPPORT

Starting with version 4.6.2, Qt for OS/2 supports printing through the CUPS
framework (provided that this support is enabled when building Qt, see the
respective sections in the beginning of this document). The OS/2 implementation
of the CUPS framework is provided by the eCUPS package available at
http://svn.netlabs.org/ecups/.

The Qt Runtime detects the presence of eCUPS in the system on the fly and talks
to the CUPS daemon directly, bypassing the standard OS/2 printing subsystem.
This means that in order to print from Qt applications, you don't need to create
and configure printer objects using the standard OS/2 system printer setup
procedure -- you only need to install eCUPS and configure your printers in
there. Please refer to the eCUPS user manual to obtain the detailed instructions
on how to configure CUPS printers.



ENVIRONMENT VARIABLES

The Qt library recognizes a number of OS/2-specific environment variables that
affect its functionality at runtime. The table below lists these variables and
their meaning:

  QT_PM_NO_DIVE             If set, Qt will not use DIVE (direct interface video
                            extensions) for painting widgets even if DIVE (which
                            provides a much faster painting speed than the
                            regular GPI approach) is available. Currently, this
                            is the default setting if the Panorama video driver
                            is detected because its DIVE implementation contains
                            a number of bugs.

  QT_PM_DIVE=<mode>         Enables using DIVE for painting widgets. <mode> is
                            one of:

                              - FB (direct framebuffer access, which is the
                                fastest mode but causes the curruption of the
                                screen under the software mouse pointer due to
                                the limitation of DIVE). If this mode is not
                                available, BLIT will be used (see below).

                              - FBSWM (the same FB but hides the mouse pointer
                                before painting which introduces mouse flicker
                                and may be a bit slower than the raw FB).

                              - BLIT (slower than both FB and FBSWM but prevents
                                screen corruption under the mouse pointer and
                                does not produce the mouse pointer flicker
                                effect).

                            This variable is ignored if QT_PM_NO_DIVE is set. If
                            neither this nor the QT_PM_NO_DIVE variable is set,
                            the FBSWM mode is used by default (unless the
                            current video driver is Panorama, see above).

  QT_PM_NO_SOUND_SHARE      If set, Qt will open the audio device in exclusive
                            only one sound may be played on the computer at a
                            time. This mode is recommended for some sound cards
                            when using the Uniaud audio driver as it is known to
                            have problems with simultaneous playback. In current
                            Qt builds, this is the default behavior if neither
                            this nor the QT_PM_SOUND_SHARE variable is set.

  QT_PM_SOUND_SHARE         The opposite to the above. If set, Qt will open the
                            audio device in shared mode. This variable is
                            ignored if QT_PM_NO_SOUND_SHARE is set.

  QT_PM_NO_REGISTRY         If set, Qt will not use the Open32 registry to store
                            application settings with QSettings. Instead, plain
                            text INI files will be used for both NativeFormat
                            and IniFormat. Due to a number of problems in the
                            Open32 registry implementation (that may easily lead
                            to registry corruption), this is the default
                            behavior if neither this nor the QT_PM_REGISTRY
                            variable is set.

  QT_PM_REGISTRY            The opposite to the above. If set, Qt will use the
                            Open32 registry to store application settings. This
                            variable is ignored if QT_PM_NO_REGISTRY is set.

  QT_PM_NO_SYSTEM_LOCALE    If set, Qt will ignore the regional settings from
                            the system locale object found in the Country
                            Palette located in the System Setup folder and will
                            take them from the internal Qt locale database
                            according to the current country and language
                            settings. Due to the fact that this internal Qt
                            database usually has a better representation of the
                            regional settings, this is the default behavior if
                            neither this nor the QT_PM_SYSTEM_LOCALE variable is
                            set.

  QT_PM_SYSTEM_LOCALE       The opposite to the above. If set, Qt will use the
                            regional settings as found in the default locale
                            object set the Country Palette.  This variable is
                            ignored if QT_PM_NO_SYSTEM_LOCALE is set.

  LANG                      This variable can be used to override the default
                            country and language used in the Qt application both
                            for regional settings and for translations. The
                            format of the value is "ll_CC" where <ll> is the
                            two-letter ISO language code and <CC> is the two-
                            letter ISO country code. Note that if this variable
                            is not set, Qt will derive the language and country
                            from the system country code specified in the
                            COUNTRY statement of CONFIG.SYS.



COMMAND LINE OPTIONS

Any Qt executable recognizes a number of command line options that may change
the behavior of the Qt application. Here are the most interesting ones:

  -style <name>             Changes the default Qt widget style (theme) to a
                            style with the given name. The buiil-in styles which
                            are always available in the official build include:
                            "windows" (currently, the default on OS/2), "motif",
                            "cde", "plastique" and "cleanlooks". Other styles
                            may be also provided by the style plugins.

  -graphicssystem <name>    Changes the graphics system used to paint widgets.
                            On OS/2, only two values are supported: "native"
                            (the default one) and "raster". The "native" system
                            uses DIVE (direct interface video extensions) when
                            it is available. If DIVE is not available or if it
                            is disabled (see the QT_PM_NO_DIVE environment
                            variable description for details), the "raster"
                            system will be automatically selected as a fallback.



CURRENT LIMITATIONS

  1. configure.cmd is does not build demos and examples by default (to save
     time). They may be built by hand, as described above.

  2. configure.cmd does not understand any command line options yet. If you want
     to customize your build of the Qt library (which is normally not
     recommended and not supported), you may try to modify configure.cmd itself.

  3. OS/2 bitmap fonts are not supported. Use TTF or Type1 (PFB) fonts with Qt.

  4. No native PM style, but Qt will use fonts and colors from the current
     OS/2 theme. Hint: if your default OS/2 font is "WarpSans", install the
     "Workplace Sans" TTF font from Alex Taylor to get more native look & feel.
     It is recommended to install version 0.7 of the Normal face and version 0.3
     of the Bold face which you can find here:

       http://users.socis.ca/~ataylo00/creative/fonts/workplace/

  5. QProcess: when starting PM applications from text-mode applications, the
     returned PID is a PID of the intermediate cmd.exe process, not the target
     application.

  6. The following classes are not available due to their rare usage or low
     importance on the OS/2 platform: QSharedMemory, QSystemSemaphore,
     QInputContext. On the source level, a number of macros is defined to
     reflect this, respectively: QT_NO_SYSTEMSEMAPHORE, QT_NO_SHAREDMEMORY,
     QT_NO_IM. Normally, Qt applications use these macros in the form of
     "#fndef QT_NO_SOMEFEATURE" to isolate the relevant parts of the code that
     uses these classes so that the application still builds when the
     corresponding feature is missing.

  7. No qt3support module. This functionality is rarely necessary in mature
     real life Qt applications and has low priority. In the code, it is
     reflected by the absense of the QT3_SUPPORT macro.

  8. The following features are missing (either because of the lack of the
     required support from the system side or because of the rare usage):

     - IPV6 support in the network module (QT_NO_IPV6 is defined).
     - OpenSSL support in the network module (QT_NO_OPENSSL is defined).
     - phonon module (QT_NO_PHONON is defined).
     - multimedia module (QT_NO_MULTIMEDIA is defined).
     - OpenGL module (QT_NO_OPENGL is defined).
     - declarative module (QT_NO_DECLARATIVE is defined).
     - tablet support (QT_NO_TABLET is defined).

  See the project roadmap for more information on the current progress and
  future plans:

    http://svn.netlabs.org/qt4/roadmap

  Feel free to request new features and report bugs using the project bug
  tracker abaialble at:

    http://svn.netlabs.org/qt4/report



CREDITS

Dmitry A. Kuminov (development)
Silvan Scherrer (management)

netlabs.org (hosting & support)

Nokia Corporation (original Qt library)

We also want to THANK all individuals and organizations who made the donations
to this project and helped to make it happen. Please visit

  http://qt.netlabs.org/en/site/index.xml

to get the full list of sponsors and to find information on how you can support
the project.


Qt is a trademark of Nokia Corporation and/or its subsidiary(-ies).
OS/2 and OS/2 Warp are trademarks of the IBM Corporation and/or its subsidiary(-ies).
eComStation is a trademark of Serenity Systems International and/or its subsidiary(-ies).
Etc.