Commit f81e67c6 authored by Stephen Kelly's avatar Stephen Kelly
Browse files

Help: Update Qt4 documentation.

Remove independent doc listing for Qt4ConfigurationSettings, Qt4Macros
and UseQt4. These are implementation details.

Recommend the use of IMPORTED targets.

Remove references to the UseQt4 file, which is obsolete in light of
the IMPORTED targets.

Add documentation for automatic tool invocation and options.

Remove reference to variables which should not be needed in modern
implementations.
parent c4e5e17f
......@@ -214,8 +214,6 @@ All Modules
/module/InstallRequiredSystemLibraries
/module/MacroAddFileDependencies
/module/ProcessorCount
/module/Qt4ConfigDependentSettings
/module/Qt4Macros
/module/SelectLibraryConfigurations
/module/SquishTestScript
/module/TestBigEndian
......@@ -229,7 +227,6 @@ All Modules
/module/UseJava
/module/UseJavaSymlinks
/module/UsePkgConfig
/module/UseQt4
/module/UseSWIG
/module/UsewxWidgets
/module/Use_wxWindows
......
.. cmake-module:: ../../Modules/Qt4ConfigDependentSettings.cmake
.. cmake-module:: ../../Modules/Qt4Macros.cmake
.. cmake-module:: ../../Modules/UseQt4.cmake
#.rst:
# FindQt4
# -------
# *******
#
# Find Qt 4
# Finding and Using Qt4
# =====================
#
# This module can be used to find Qt4. The most important issue is that
# the Qt4 qmake is available via the system path. This qmake is then
# used to detect basically everything else. This module defines a
# number of key variables and macros. The variable QT_USE_FILE is set
# which is the path to a CMake file that can be included to compile Qt 4
# applications and libraries. It sets up the compilation environment
# for include directories, preprocessor defines and populates a
# QT_LIBRARIES variable.
# number of :prop_tgt:`IMPORTED` targets, macros and variables.
#
# Typical usage could be something like:
#
# ::
# .. code-block:: cmake
#
# find_package(Qt4 4.4.3 REQUIRED QtCore QtGui QtXml)
# include(${QT_USE_FILE})
# set(CMAKE_AUTOMOC ON)
# set(CMAKE_INCLUDE_CURRENT_DIR ON)
# find_package(Qt4 4.4.3 REQUIRED QtGui QtXml)
# add_executable(myexe main.cpp)
# target_link_libraries(myexe ${QT_LIBRARIES})
#
#
#
# The minimum required version can be specified using the standard
# find_package()-syntax (see example above). For compatibility with
# older versions of FindQt4.cmake it is also possible to set the
# variable QT_MIN_VERSION to the minimum required version of Qt4 before
# the find_package(Qt4) command. If both are used, the version used in
# the find_package() command overrides the one from QT_MIN_VERSION.
#
# When using the components argument, QT_USE_QT* variables are
# automatically set for the QT_USE_FILE to pick up. If one wishes to
# manually set them, the available ones to set include:
#
# ::
#
# QT_DONT_USE_QTCORE
# QT_DONT_USE_QTGUI
# QT_USE_QT3SUPPORT
# QT_USE_QTASSISTANT
# QT_USE_QAXCONTAINER
# QT_USE_QAXSERVER
# QT_USE_QTDESIGNER
# QT_USE_QTMOTIF
# QT_USE_QTMAIN
# QT_USE_QTMULTIMEDIA
# QT_USE_QTNETWORK
# QT_USE_QTNSPLUGIN
# QT_USE_QTOPENGL
# QT_USE_QTSQL
# QT_USE_QTXML
# QT_USE_QTSVG
# QT_USE_QTTEST
# QT_USE_QTUITOOLS
# QT_USE_QTDBUS
# QT_USE_QTSCRIPT
# QT_USE_QTASSISTANTCLIENT
# QT_USE_QTHELP
# QT_USE_QTWEBKIT
# QT_USE_QTXMLPATTERNS
# QT_USE_PHONON
# QT_USE_QTSCRIPTTOOLS
# QT_USE_QTDECLARATIVE
#
#
#
# ::
#
# QT_USE_IMPORTED_TARGETS
# If this variable is set to TRUE, FindQt4.cmake will create imported
# library targets for the various Qt libraries and set the
# library variables like QT_QTCORE_LIBRARY to point at these imported
# targets instead of the library file on disk. This provides much better
# handling of the release and debug versions of the Qt libraries and is
# also always backwards compatible, except for the case that dependencies
# of libraries are exported, these will then also list the names of the
# imported targets as dependency and not the file location on disk. This
# is much more flexible, but requires that FindQt4.cmake is executed before
# such an exported dependency file is processed.
#
#
#
# ::
#
# Note that if using IMPORTED targets, the qtmain.lib static library is
# automatically linked on Windows. To disable that globally, set the
# QT4_NO_LINK_QTMAIN variable before finding Qt4. To disable that for a
# particular executable, set the QT4_NO_LINK_QTMAIN target property to
# True on the executable.
#
#
#
# ::
#
# QT_INCLUDE_DIRS_NO_SYSTEM
# If this variable is set to TRUE, the Qt include directories
# in the QT_USE_FILE will NOT have the SYSTEM keyword set.
#
#
#
# There are also some files that need processing by some Qt tools such
# as moc and uic. Listed below are macros that may be used to process
# those files.
# target_link_libraries(myexe Qt4::QtGui Qt4::QtXml)
#
# .. note::
#
# When using :prop_tgt:`IMPORTED` targets, the qtmain.lib static library is
# automatically linked on Windows. To disable that globally, set the
# ``QT4_NO_LINK_QTMAIN`` variable before finding Qt4. To disable that
# for a particular executable, set the ``QT4_NO_LINK_QTMAIN`` target
# property to ``TRUE`` on the executable.
#
# Qt Build Tools
# ==============
#
# Qt relies on some bundled tools for code generation, such as ``moc`` for
# meta-object code generation,``uic`` for widget layout and population,
# and ``rcc`` for virtual filesystem content generation. These tools may be
# automatically invoked by :manual:`cmake(1)` if the appropriate conditions
# are met.
#
# The tools are executed as part of a synthesized custom target generated by
# CMake. Target dependencies may be added to that custom target by adding them
# to the :prop_tgt:`AUTOGEN_TARGET_DEPENDS` target property.
#
# AUTOMOC
# '''''''
#
# The :prop_tgt:`AUTOMOC` target property controls whether :manual:`cmake(1)`
# inspects the C++ files in the target to determine if they require ``moc`` to
# be run, and to create rules to execute ``moc`` at the appropriate time.
#
# If a ``Q_OBJECT`` or ``Q_GADGET`` macro is found in a header file, ``moc``
# will be run on the file. The result will be put into a file named according
# to ``moc_<basename>.cpp``. If the macro is found in a C++ implementation
# file, the moc output will be put into a file named according to
# ``<basename>.moc``, following the Qt conventions. The ``moc file`` may be
# included by the user in the C++ implementation file with a preprocessor
# ``#include``. If it is not so included, it will be added to a separate file
# which is compiled into the target.
#
# Generated ``moc_*.cpp`` and ``*.moc`` files are placed in the build directory
# so it is convenient to set the :variable:`CMAKE_INCLUDE_CURRENT_DIR`
# variable. The :prop_tgt:`AUTOMOC` target property may be pre-set for all
# following targets by setting the :variable:`CMAKE_AUTOMOC` variable. The
# :prop_tgt:`AUTOMOC_MOC_OPTIONS` target property may be populated to set
# options to pass to ``moc``. The :variable:`CMAKE_AUTOMOC_MOC_OPTIONS`
# variable may be populated to pre-set the options for all following targets.
#
# AUTOUIC
# '''''''
#
# The :prop_tgt:`AUTOUIC` target property controls whether :manual:`cmake(1)`
# inspects the C++ files in the target to determine if they require ``uic`` to
# be run, and to create rules to execute ``uic`` at the appropriate time.
#
# If a preprocessor ``#include`` directive is found which matches
# ``ui_<basename>.h``, and a ``<basename>.ui`` file exists, then ``uic`` will
# be executed to generate the appropriate file.
#
# Generated ``ui_*.h`` files are placed in the build directory so it is
# convenient to set the :variable:`CMAKE_INCLUDE_CURRENT_DIR` variable. The
# :prop_tgt:`AUTOUIC` target property may be pre-set for all following targets
# by setting the :variable:`CMAKE_AUTOUIC` variable. The
# :prop_tgt:`AUTOUIC_OPTIONS` target property may be populated to set options
# to pass to ``uic``. The :variable:`CMAKE_AUTOUIC_OPTIONS` variable may be
# populated to pre-set the options for all following targets. The
# :prop_sf:`AUTOUIC_OPTIONS` source file property may be set on the
# ``<basename>.ui`` file to set particular options for the file. This
# overrides options from the :prop_tgt:`AUTOUIC_OPTIONS` target property.
#
# AUTORCC
# '''''''
#
# The :prop_tgt:`AUTORCC` target property controls whether :manual:`cmake(1)`
# creates rules to execute ``rcc`` at the appropriate time on source files
# which have the suffix ``.qrc``.
#
# .. code-block:: cmake
#
# add_executable(myexe main.cpp resource_file.qrc)
#
# The :prop_tgt:`AUTORCC` target property may be pre-set for all following targets
# by setting the :variable:`CMAKE_AUTORCC` variable. The
# :prop_tgt:`AUTORCC_OPTIONS` target property may be populated to set options
# to pass to ``rcc``. The :variable:`CMAKE_AUTORCC_OPTIONS` variable may be
# populated to pre-set the options for all following targets. The
# :prop_sf:`AUTORCC_OPTIONS` source file property may be set on the
# ``<name>.qrc`` file to set particular options for the file. This
# overrides options from the :prop_tgt:`AUTORCC_OPTIONS` target property.
#
#
# Qt Macros
# =========
#
# In some cases it can be necessary or useful to invoke the Qt build tools in a
# more-manual way. Several macros are available to add targets for such uses.
#
# ::
#
......@@ -116,7 +125,6 @@
# those found when executing "moc -help".
#
#
#
# ::
#
# macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
......@@ -125,7 +133,6 @@
# when executing "uic -help"
#
#
#
# ::
#
# macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
......@@ -134,7 +141,6 @@
# when executing "rcc -help"
#
#
#
# ::
#
# macro QT4_GENERATE_MOC(inputfile outputfile [TARGET tgt])
......@@ -146,32 +152,6 @@
# the <tgt> are passed to moc.
#
#
#
# ::
#
# macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... [TARGET tgt])
# The qt4_automoc macro is obsolete. Use the CMAKE_AUTOMOC feature instead.
# This macro is still experimental.
# It can be used to have moc automatically handled.
# So if you have the files foo.h and foo.cpp, and in foo.h a
# a class uses the Q_OBJECT macro, moc has to run on it. If you don't
# want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
# #include "foo.moc"
# in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
# scan all listed files at cmake-time for such included moc files and if it finds
# them cause a rule to be generated to run moc at build time on the
# accompanying header file foo.h.
# If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.
# If the <tgt> is specified, the INTERFACE_INCLUDE_DIRECTORIES and
# INTERFACE_COMPILE_DEFINITIONS from the <tgt> are passed to moc.
#
#
# ::
#
# You should have a look on the AUTOMOC property for targets to achieve the same results.
#
#
#
# ::
#
# macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
......@@ -179,33 +159,16 @@
# given basename from the given interface xml file and add it to
# the list of sources.
#
#
#
# ::
#
# You can pass additional parameters to the qdbusxml2cpp call by setting
# properties on the input file:
#
#
#
# ::
#
# INCLUDE the given file will be included in the generate interface header
#
#
#
# ::
#
# CLASSNAME the generated class is named accordingly
#
#
#
# ::
#
# NO_NAMESPACE the generated class is not wrapped in a namespace
#
#
#
# ::
#
# macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
......@@ -213,14 +176,9 @@
# for all listed interface xml files.
# The basename will be automatically determined from the name of the xml file.
#
#
#
# ::
#
# The source file properties described for QT4_ADD_DBUS_INTERFACE also apply here.
#
#
#
# ::
#
# macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])
......@@ -233,7 +191,6 @@
# adaptor itself.
#
#
#
# ::
#
# macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
......@@ -244,7 +201,6 @@
# Options may be given to qdbuscpp2xml, such as those found when executing "qdbuscpp2xml --help"
#
#
#
# ::
#
# macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ...
......@@ -263,7 +219,6 @@
# they get updated/generated.
#
#
#
# ::
#
# macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
......@@ -274,11 +229,28 @@
# must exist and are not updated in any way.
#
#
# ::
#
# macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... [TARGET tgt])
# The qt4_automoc macro is obsolete. Use the CMAKE_AUTOMOC feature instead.
# This macro is still experimental.
# It can be used to have moc automatically handled.
# So if you have the files foo.h and foo.cpp, and in foo.h a
# a class uses the Q_OBJECT macro, moc has to run on it. If you don't
# want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
# #include "foo.moc"
# in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
# scan all listed files at cmake-time for such included moc files and if it finds
# them cause a rule to be generated to run moc at build time on the
# accompanying header file foo.h.
# If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.
# If the <tgt> is specified, the INTERFACE_INCLUDE_DIRECTORIES and
# INTERFACE_COMPILE_DEFINITIONS from the <tgt> are passed to moc.
#
# function QT4_USE_MODULES( target [link_type] modules...)
#
# ::
#
# function QT4_USE_MODULES( target [link_type] modules...)
# This function is obsolete. Use target_link_libraries with IMPORTED targets instead.
# Make <target> use the <modules> from Qt. Using a Qt module means
# to link to the library, add the relevant include directories for the module,
......@@ -291,227 +263,100 @@
# to the target_link_libraries call.
#
#
#
#
#
# ::
# IMPORTED Targets
# ================
#
# A particular Qt library may be used by using the corresponding
# :prop_tgt:`IMPORTED` target with the :command:`target_link_libraries`
# command:
#
# .. code-block:: cmake
#
# target_link_libraries(myexe Qt4::QtGui Qt4::QtXml)
#
# Using a target in this way causes :cmake(1)` to use the appropriate include
# directories and compile definitions for the target when compiling ``myexe``.
#
# Targets are aware of their dependencies, so for example it is not necessary
# to list ``Qt4::QtCore`` if another Qt library is listed, and it is not
# necessary to list ``Qt4::QtGui`` if ``Qt4::QtDeclarative`` is listed.
# Targets may be tested for existence in the usual way with the
# :command:`if(TARGET)` command.
#
# The Qt toolkit may contain both debug and release libraries.
# :manual:`cmake(1)` will choose the appropriate version based on the build
# configuration.
#
# ``Qt4::QtCore``
# The QtCore target
# ``Qt4::QtGui``
# The QtGui target
# ``Qt4::Qt3Support``
# The Qt3Support target
# ``Qt4::QtAssistant``
# The QtAssistant target
# ``Qt4::QtAssistantClient``
# The QtAssistantClient target
# ``Qt4::QAxContainer``
# The QAxContainer target (Windows only)
# ``Qt4::QAxServer``
# The QAxServer target (Windows only)
# ``Qt4::QtDBus``
# The QtDBus target
# ``Qt4::QtDesigner``
# The QtDesigner target
# ``Qt4::QtDesignerComponents``
# The QtDesignerComponents target
# ``Qt4::QtHelp``
# The QtHelp target
# ``Qt4::QtMotif``
# The QtMotif target
# ``Qt4::QtMultimedia``
# The QtMultimedia target
# ``Qt4::QtNetwork``
# The QtNetwork target
# ``Qt4::QtNsPLugin``
# The QtNsPLugin target
# ``Qt4::QtOpenGL``
# The QtOpenGL target
# ``Qt4::QtScript``
# The QtScript target
# ``Qt4::QtScriptTools``
# The QtScriptTools target
# ``Qt4::QtSql``
# The QtSql target
# ``Qt4::QtSvg``
# The QtSvg target
# ``Qt4::QtTest``
# The QtTest target
# ``Qt4::QtUiTools``
# The QtUiTools target
# ``Qt4::QtWebKit``
# The QtWebKit target
# ``Qt4::QtXml``
# The QtXml target
# ``Qt4::QtXmlPatterns``
# The QtXmlPatterns target
# ``Qt4::phonon``
# The phonon target
#
# Result Variables
# ================
#
# Below is a detailed list of variables that FindQt4.cmake sets.
# QT_FOUND If false, don't try to use Qt.
# Qt4_FOUND If false, don't try to use Qt 4.
# QT4_FOUND If false, don't try to use Qt 4. This variable is for compatibility only.
#
#
#
# ::
#
# QT_VERSION_MAJOR The major version of Qt found.
# QT_VERSION_MINOR The minor version of Qt found.
# QT_VERSION_PATCH The patch version of Qt found.
#
#
#
# ::
#
# QT_EDITION Set to the edition of Qt (i.e. DesktopLight)
# QT_EDITION_DESKTOPLIGHT True if QT_EDITION == DesktopLight
# QT_QTCORE_FOUND True if QtCore was found.
# QT_QTGUI_FOUND True if QtGui was found.
# QT_QT3SUPPORT_FOUND True if Qt3Support was found.
# QT_QTASSISTANT_FOUND True if QtAssistant was found.
# QT_QTASSISTANTCLIENT_FOUND True if QtAssistantClient was found.
# QT_QAXCONTAINER_FOUND True if QAxContainer was found (Windows only).
# QT_QAXSERVER_FOUND True if QAxServer was found (Windows only).
# QT_QTDBUS_FOUND True if QtDBus was found.
# QT_QTDESIGNER_FOUND True if QtDesigner was found.
# QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.
# QT_QTHELP_FOUND True if QtHelp was found.
# QT_QTMOTIF_FOUND True if QtMotif was found.
# QT_QTMULTIMEDIA_FOUND True if QtMultimedia was found (since Qt 4.6.0).
# QT_QTNETWORK_FOUND True if QtNetwork was found.
# QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found.
# QT_QTOPENGL_FOUND True if QtOpenGL was found.
# QT_QTSQL_FOUND True if QtSql was found.
# QT_QTSVG_FOUND True if QtSvg was found.
# QT_QTSCRIPT_FOUND True if QtScript was found.
# QT_QTSCRIPTTOOLS_FOUND True if QtScriptTools was found.
# QT_QTTEST_FOUND True if QtTest was found.
# QT_QTUITOOLS_FOUND True if QtUiTools was found.
# QT_QTWEBKIT_FOUND True if QtWebKit was found.
# QT_QTXML_FOUND True if QtXml was found.
# QT_QTXMLPATTERNS_FOUND True if QtXmlPatterns was found.
# QT_PHONON_FOUND True if phonon was found.
# QT_QTDECLARATIVE_FOUND True if QtDeclarative was found.
#
#
#
# ::
#
# QT_MAC_USE_COCOA For Mac OS X, its whether Cocoa or Carbon is used.
# In general, this should not be used, but its useful
# when having platform specific code.
#
#
#
# ::
#
# QT_DEFINITIONS Definitions to use when compiling code that uses Qt.
# You do not need to use this if you include QT_USE_FILE.
# The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
# to fit your current build type. Those are not contained
# in QT_DEFINITIONS.
#
#
#
# ::
#
# QT_INCLUDES List of paths to all include directories of
# Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
# always in this variable even if NOTFOUND,
# all other INCLUDE_DIRS are
# only added if they are found.
# You do not need to use this if you include QT_USE_FILE.
#
#
#
#
#
# ::
#
# Include directories for the Qt modules are listed here.
# You do not need to use these variables if you include QT_USE_FILE.
#
#
#
# ::
#
# QT_INCLUDE_DIR Path to "include" of Qt4
# QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support"
# QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant"
# QT_QTASSISTANTCLIENT_INCLUDE_DIR Path to "include/QtAssistant"
# QT_QAXCONTAINER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
# QT_QAXSERVER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
# QT_QTCORE_INCLUDE_DIR Path to "include/QtCore"
# QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus"
# QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner"
# QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner"
# QT_QTGUI_INCLUDE_DIR Path to "include/QtGui"
# QT_QTHELP_INCLUDE_DIR Path to "include/QtHelp"
# QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif"
# QT_QTMULTIMEDIA_INCLUDE_DIR Path to "include/QtMultimedia"
# QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork"
# QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin"
# QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL"
# QT_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript"
# QT_QTSQL_INCLUDE_DIR Path to "include/QtSql"
# QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg"
# QT_QTTEST_INCLUDE_DIR Path to "include/QtTest"
# QT_QTWEBKIT_INCLUDE_DIR Path to "include/QtWebKit"
# QT_QTXML_INCLUDE_DIR Path to "include/QtXml"
# QT_QTXMLPATTERNS_INCLUDE_DIR Path to "include/QtXmlPatterns"
# QT_PHONON_INCLUDE_DIR Path to "include/phonon"
# QT_QTSCRIPTTOOLS_INCLUDE_DIR Path to "include/QtScriptTools"
# QT_QTDECLARATIVE_INCLUDE_DIR Path to "include/QtDeclarative"
#
#
#
# ::
#
# QT_BINARY_DIR Path to "bin" of Qt4
# QT_LIBRARY_DIR Path to "lib" of Qt4
# QT_PLUGINS_DIR Path to "plugins" for Qt4
# QT_TRANSLATIONS_DIR Path to "translations" of Qt4
# QT_IMPORTS_DIR Path to "imports" of Qt4
# QT_DOC_DIR Path to "doc" of Qt4
# QT_MKSPECS_DIR Path to "mkspecs" of Qt4
#
#
#
#
#
# The Qt toolkit may contain both debug and release libraries. In that
# case, the following library variables will contain both. You do not
# need to use these variables if you include QT_USE_FILE, and use
# QT_LIBRARIES.
#
# ::
#
# QT_QT3SUPPORT_LIBRARY The Qt3Support library
# QT_QTASSISTANT_LIBRARY The QtAssistant library
# QT_QTASSISTANTCLIENT_LIBRARY The QtAssistantClient library
# QT_QAXCONTAINER_LIBRARY The QAxContainer library (Windows only)
# QT_QAXSERVER_LIBRARY The QAxServer library (Windows only)
# QT_QTCORE_LIBRARY The QtCore library
# QT_QTDBUS_LIBRARY The QtDBus library
# QT_QTDESIGNER_LIBRARY The QtDesigner library
# QT_QTDESIGNERCOMPONENTS_LIBRARY The QtDesignerComponents library
# QT_QTGUI_LIBRARY The QtGui library
# QT_QTHELP_LIBRARY The QtHelp library
# QT_QTMOTIF_LIBRARY The QtMotif library
# QT_QTMULTIMEDIA_LIBRARY The QtMultimedia library
# QT_QTNETWORK_LIBRARY The QtNetwork library
# QT_QTNSPLUGIN_LIBRARY The QtNsPLugin library
# QT_QTOPENGL_LIBRARY The QtOpenGL library
# QT_QTSCRIPT_LIBRARY The QtScript library
# QT_QTSQL_LIBRARY The QtSql library
# QT_QTSVG_LIBRARY The QtSvg library
# QT_QTTEST_LIBRARY The QtTest library
# QT_QTUITOOLS_LIBRARY The QtUiTools library
# QT_QTWEBKIT_LIBRARY The QtWebKit library
# QT_QTXML_LIBRARY The QtXml library
# QT_QTXMLPATTERNS_LIBRARY The QtXmlPatterns library
# QT_QTMAIN_LIBRARY The qtmain library for Windows
# QT_PHONON_LIBRARY The phonon library
# QT_QTSCRIPTTOOLS_LIBRARY The QtScriptTools library
#
#
#