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.

5 files changed, 212 insertions, 373 deletions

diff --git a/Help/manual/cmake-modules.7.rst b/Help/manual/cmake-modules.7.rst
index 3f819d6..7a06be6 100644
--- a/Help/manual/cmake-modules.7.rst
+++ b/Help/manual/cmake-modules.7.rst
@@ -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
diff --git a/Help/module/Qt4ConfigDependentSettings.rst b/Help/module/Qt4ConfigDependentSettings.rst
deleted file mode 100644
index 7002f53..0000000
--- a/Help/module/Qt4ConfigDependentSettings.rst
+++ /dev/null
@@ -1 +0,0 @@
-.. cmake-module:: ../../Modules/Qt4ConfigDependentSettings.cmake
diff --git a/Help/module/Qt4Macros.rst b/Help/module/Qt4Macros.rst
deleted file mode 100644
index 6448d53..0000000
--- a/Help/module/Qt4Macros.rst
+++ /dev/null
@@ -1 +0,0 @@
-.. cmake-module:: ../../Modules/Qt4Macros.cmake
diff --git a/Help/module/UseQt4.rst b/Help/module/UseQt4.rst
deleted file mode 100644
index c2f2ea8..0000000
--- a/Help/module/UseQt4.rst
+++ /dev/null
@@ -1 +0,0 @@
-.. cmake-module:: ../../Modules/UseQt4.cmake
diff --git a/Modules/FindQt4.cmake b/Modules/FindQt4.cmake
index 9be4270..0bf2b99 100644
--- a/Modules/FindQt4.cmake
+++ b/Modules/FindQt4.cmake
@@ -1,109 +1,118 @@
 #.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
-#
-#
-#
-# The QtDeclarative library: QT_QTDECLARATIVE_LIBRARY
-#
-# also defined, but NOT for general use are
-#
-# ::
-#
-#   QT_MOC_EXECUTABLE                   Where to find the moc tool.
-#   QT_UIC_EXECUTABLE                   Where to find the uic tool.
-#   QT_UIC3_EXECUTABLE                  Where to find the uic3 tool.
-#   QT_RCC_EXECUTABLE                   Where to find the rcc tool
-#   QT_DBUSCPP2XML_EXECUTABLE           Where to find the qdbuscpp2xml tool.
-#   QT_DBUSXML2CPP_EXECUTABLE           Where to find the qdbusxml2cpp tool.
-#   QT_LUPDATE_EXECUTABLE               Where to find the lupdate tool.
-#   QT_LRELEASE_EXECUTABLE              Where to find the lrelease tool.
-#   QT_QCOLLECTIONGENERATOR_EXECUTABLE  Where to find the qcollectiongenerator tool.
-#   QT_DESIGNER_EXECUTABLE              Where to find the Qt designer tool.
-#   QT_LINGUIST_EXECUTABLE              Where to find the Qt linguist tool.
-#
-#
-#
-#
-#
-# These are around for backwards compatibility they will be set
-#
-# ::
-#
-#   QT_WRAP_CPP  Set true if QT_MOC_EXECUTABLE is found
-#   QT_WRAP_UI   Set true if QT_UIC_EXECUTABLE is found
-#
-#
-#
-# These variables do _NOT_ have any effect anymore (compared to
-# FindQt.cmake)
-#
-# ::
-#
-#   QT_MT_REQUIRED         Qt4 is now always multithreaded
-#
-#
-#
-# These variables are set to "" Because Qt structure changed (They make
-# no sense in Qt4)
-#
-# ::
 #
-#   QT_QT_LIBRARY        Qt-Library is now split
+# ``Qt4_FOUND``
+#  If false, don't try to use Qt 4.
+# ``QT_FOUND``
+#  If false, don't try to use Qt. This variable is for compatibility only.
+# ``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.
 
 #=============================================================================
 # Copyright 2005-2009 Kitware, Inc.