cmake/modules/FindQt4.cmake

   1 # - Find QT 4
   2 # This module can be used to find Qt4.
   3 # The most important issue is that the Qt4 qmake is available via the system path.
   4 # This qmake is then used to detect basically everything else.
   5 # This module defines a number of key variables and macros.
   6 # The variable QT_USE_FILE is set which is the path to a CMake file that can be included
   7 # to compile Qt 4 applications and libraries.  It sets up the compilation
   8 # environment for include directories, preprocessor defines and populates a
   9 # QT_LIBRARIES variable.
  10 #
  11 # Typical usage could be something like:
  12 #   find_package(Qt4 4.4.3 COMPONENTS QtCore QtGui QtXml REQUIRED )
  13 #   include(${QT_USE_FILE})
  14 #   add_executable(myexe main.cpp)
  15 #   target_link_libraries(myexe ${QT_LIBRARIES})
  16 #
  17 # The minimum required version can be specified using the standard find_package()-syntax
  18 # (see example above).
  19 # For compatibility with older versions of FindQt4.cmake it is also possible to
  20 # set the variable QT_MIN_VERSION to the minimum required version of Qt4 before the
  21 # find_package(Qt4) command.
  22 # If both are used, the version used in the find_package() command overrides the
  23 # one from QT_MIN_VERSION.
  24 #
  25 # When using the components argument, QT_USE_QT* variables are automatically set
  26 # for the QT_USE_FILE to pick up.  If one wishes to manually set them, the
  27 # available ones to set include:
  28 #                    QT_DONT_USE_QTCORE
  29 #                    QT_DONT_USE_QTGUI
  30 #                    QT_USE_QT3SUPPORT
  31 #                    QT_USE_QTASSISTANT
  32 #                    QT_USE_QAXCONTAINER
  33 #                    QT_USE_QAXSERVER
  34 #                    QT_USE_QTDESIGNER
  35 #                    QT_USE_QTMOTIF
  36 #                    QT_USE_QTMAIN
  37 #                    QT_USE_QTMULTIMEDIA
  38 #                    QT_USE_QTNETWORK
  39 #                    QT_USE_QTNSPLUGIN
  40 #                    QT_USE_QTOPENGL
  41 #                    QT_USE_QTSQL
  42 #                    QT_USE_QTXML
  43 #                    QT_USE_QTSVG
  44 #                    QT_USE_QTTEST
  45 #                    QT_USE_QTUITOOLS
  46 #                    QT_USE_QTDBUS
  47 #                    QT_USE_QTSCRIPT
  48 #                    QT_USE_QTASSISTANTCLIENT
  49 #                    QT_USE_QTHELP
  50 #                    QT_USE_QTWEBKIT
  51 #                    QT_USE_QTXMLPATTERNS
  52 #                    QT_USE_PHONON
  53 #                    QT_USE_QTSCRIPTTOOLS
  54 #
  55 # There are also some files that need processing by some Qt tools such as moc
  56 # and uic.  Listed below are macros that may be used to process those files.
  57 #
  58 #  macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
  59 #        create moc code from a list of files containing Qt class with
  60 #        the Q_OBJECT declaration.  Per-direcotry preprocessor definitions
  61 #        are also added.  Options may be given to moc, such as those found
  62 #        when executing "moc -help".
  63 #
  64 #  macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
  65 #        create code from a list of Qt designer ui files.
  66 #        Options may be given to uic, such as those found
  67 #        when executing "uic -help"
  68 #
  69 #  macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
  70 #        create code from a list of Qt resource files.
  71 #        Options may be given to rcc, such as those found
  72 #        when executing "rcc -help"
  73 #
  74 #  macro QT4_GENERATE_MOC(inputfile outputfile )
  75 #        creates a rule to run moc on infile and create outfile.
  76 #        Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
  77 #        because you need a custom filename for the moc file or something similar.
  78 #
  79 #  macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... )
  80 #        This macro is still experimental.
  81 #        It can be used to have moc automatically handled.
  82 #        So if you have the files foo.h and foo.cpp, and in foo.h a
  83 #        a class uses the Q_OBJECT macro, moc has to run on it. If you don't
  84 #        want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
  85 #        #include "foo.moc"
  86 #        in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
  87 #        scan all listed files at cmake-time for such included moc files and if it finds
  88 #        them cause a rule to be generated to run moc at build time on the
  89 #        accompanying header file foo.h.
  90 #        If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.
  91 #
  92 #  macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
  93 #        create a the interface header and implementation files with the
  94 #        given basename from the given interface xml file and add it to
  95 #        the list of sources.
  96 #        To disable generating a namespace header, set the source file property
  97 #        NO_NAMESPACE to TRUE on the interface file.
  98 #        To include a header in the interface header, set the source file property
  99 #        INCLUDE to the name of the header.
 100 #        To specify a class name to use, set the source file property CLASSNAME
 101 #        to the name of the class.
 102 #
 103 #  macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
 104 #        create the interface header and implementation files
 105 #        for all listed interface xml files
 106 #        the name will be automatically determined from the name of the xml file
 107 #        To disable generating namespace headers, set the source file property
 108 #        NO_NAMESPACE to TRUE for these inputfiles.
 109 #        To include a header in the interface header, set the source file property
 110 #        INCLUDE to the name of the header.
 111 #        To specify a class name to use, set the source file property CLASSNAME
 112 #        to the name of the class.
 113 #
 114 #  macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])
 115 #        create a dbus adaptor (header and implementation file) from the xml file
 116 #        describing the interface, and add it to the list of sources. The adaptor
 117 #        forwards the calls to a parent class, defined in parentheader and named
 118 #        parentclassname. The name of the generated files will be
 119 #        <basename>adaptor.{cpp,h} where basename defaults to the basename of the xml file.
 120 #        If <classname> is provided, then it will be used as the classname of the
 121 #        adaptor itself.
 122 #
 123 #  macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
 124 #        generate the xml interface file from the given header.
 125 #        If the optional argument interfacename is omitted, the name of the
 126 #        interface file is constructed from the basename of the header with
 127 #        the suffix .xml appended.
 128 #        Options may be given to qdbuscpp2xml, such as those found when executing "qdbuscpp2xml --help"
 129 #
 130 #  macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ...
 131 #                                ts_files ... OPTIONS ...)
 132 #        out: qm_files
 133 #        in:  directories sources ts_files
 134 #        options: flags to pass to lupdate, such as -extensions to specify
 135 #        extensions for a directory scan.
 136 #        generates commands to create .ts (vie lupdate) and .qm
 137 #        (via lrelease) - files from directories and/or sources. The ts files are
 138 #        created and/or updated in the source tree (unless given with full paths).
 139 #        The qm files are generated in the build tree.
 140 #        Updating the translations can be done by adding the qm_files
 141 #        to the source list of your library/executable, so they are
 142 #        always updated, or by adding a custom target to control when
 143 #        they get updated/generated.
 144 #
 145 #  macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
 146 #        out: qm_files
 147 #        in:  ts_files
 148 #        generates commands to create .qm from .ts - files. The generated
 149 #        filenames can be found in qm_files. The ts_files
 150 #        must exists and are not updated in any way.
 151 #
 152 #
 153 #  Below is a detailed list of variables that FindQt4.cmake sets.
 154 #  QT_FOUND         If false, don't try to use Qt.
 155 #  QT4_FOUND        If false, don't try to use Qt 4.
 156 #
 157 #  QT_VERSION_MAJOR The major version of Qt found.
 158 #  QT_VERSION_MINOR The minor version of Qt found.
 159 #  QT_VERSION_PATCH The patch version of Qt found.
 160 #
 161 #  QT_EDITION               Set to the edition of Qt (i.e. DesktopLight)
 162 #  QT_EDITION_DESKTOPLIGHT  True if QT_EDITION == DesktopLight
 163 #  QT_QTCORE_FOUND          True if QtCore was found.
 164 #  QT_QTGUI_FOUND           True if QtGui was found.
 165 #  QT_QT3SUPPORT_FOUND      True if Qt3Support was found.
 166 #  QT_QTASSISTANT_FOUND     True if QtAssistant was found.
 167 #  QT_QTASSISTANTCLIENT_FOUND  True if QtAssistantClient was found.
 168 #  QT_QAXCONTAINER_FOUND    True if QAxContainer was found (Windows only).
 169 #  QT_QAXSERVER_FOUND       True if QAxServer was found (Windows only).
 170 #  QT_QTDBUS_FOUND          True if QtDBus was found.
 171 #  QT_QTDESIGNER_FOUND      True if QtDesigner was found.
 172 #  QT_QTDESIGNERCOMPONENTS  True if QtDesignerComponents was found.
 173 #  QT_QTHELP_FOUND          True if QtHelp was found.
 174 #  QT_QTMOTIF_FOUND         True if QtMotif was found.
 175 #  QT_QTMULTIMEDIA_FOUND    True if QtMultimedia was found (since Qt 4.6.0).
 176 #  QT_QTNETWORK_FOUND       True if QtNetwork was found.
 177 #  QT_QTNSPLUGIN_FOUND      True if QtNsPlugin was found.
 178 #  QT_QTOPENGL_FOUND        True if QtOpenGL was found.
 179 #  QT_QTSQL_FOUND           True if QtSql was found.
 180 #  QT_QTSVG_FOUND           True if QtSvg was found.
 181 #  QT_QTSCRIPT_FOUND        True if QtScript was found.
 182 #  QT_QTSCRIPTTOOLS_FOUND   True if QtScriptTools was found.
 183 #  QT_QTTEST_FOUND          True if QtTest was found.
 184 #  QT_QTUITOOLS_FOUND       True if QtUiTools was found.
 185 #  QT_QTWEBKIT_FOUND        True if QtWebKit was found.
 186 #  QT_QTXML_FOUND           True if QtXml was found.
 187 #  QT_QTXMLPATTERNS_FOUND   True if QtXmlPatterns was found.
 188 #  QT_PHONON_FOUND          True if phonon was found.
 189 #
 190 #  QT_MAC_USE_COCOA    For Mac OS X, its whether Cocoa or Carbon is used.
 191 #                      In general, this should not be used, but its useful
 192 #                      when having platform specific code.
 193 #
 194 #  QT_DEFINITIONS   Definitions to use when compiling code that uses Qt.
 195 #                   You do not need to use this if you include QT_USE_FILE.
 196 #                   The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
 197 #                   to fit your current build type.  Those are not contained
 198 #                   in QT_DEFINITIONS.
 199 #
 200 #  QT_INCLUDES      List of paths to all include directories of
 201 #                   Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
 202 #                   always in this variable even if NOTFOUND,
 203 #                   all other INCLUDE_DIRS are
 204 #                   only added if they are found.
 205 #                   You do not need to use this if you include QT_USE_FILE.
 206 #
 207 #
 208 #  Include directories for the Qt modules are listed here.
 209 #  You do not need to use these variables if you include QT_USE_FILE.
 210 #
 211 #  QT_INCLUDE_DIR              Path to "include" of Qt4
 212 #  QT_QT_INCLUDE_DIR           Path to "include/Qt"
 213 #  QT_QT3SUPPORT_INCLUDE_DIR   Path to "include/Qt3Support"
 214 #  QT_QTASSISTANT_INCLUDE_DIR  Path to "include/QtAssistant"
 215 #  QT_QTASSISTANTCLIENT_INCLUDE_DIR       Path to "include/QtAssistant"
 216 #  QT_QAXCONTAINER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
 217 #  QT_QAXSERVER_INCLUDE_DIR    Path to "include/ActiveQt" (Windows only)
 218 #  QT_QTCORE_INCLUDE_DIR       Path to "include/QtCore"
 219 #  QT_QTDBUS_INCLUDE_DIR       Path to "include/QtDBus"
 220 #  QT_QTDESIGNER_INCLUDE_DIR   Path to "include/QtDesigner"
 221 #  QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR   Path to "include/QtDesigner"
 222 #  QT_QTGUI_INCLUDE_DIR        Path to "include/QtGui"
 223 #  QT_QTHELP_INCLUDE_DIR       Path to "include/QtHelp"
 224 #  QT_QTMOTIF_INCLUDE_DIR      Path to "include/QtMotif"
 225 #  QT_QTMULTIMEDIA_INCLUDE_DIR Path to "include/QtMultimedia"
 226 #  QT_QTNETWORK_INCLUDE_DIR    Path to "include/QtNetwork"
 227 #  QT_QTNSPLUGIN_INCLUDE_DIR   Path to "include/QtNsPlugin"
 228 #  QT_QTOPENGL_INCLUDE_DIR     Path to "include/QtOpenGL"
 229 #  QT_QTSCRIPT_INCLUDE_DIR     Path to "include/QtScript"
 230 #  QT_QTSQL_INCLUDE_DIR        Path to "include/QtSql"
 231 #  QT_QTSVG_INCLUDE_DIR        Path to "include/QtSvg"
 232 #  QT_QTTEST_INCLUDE_DIR       Path to "include/QtTest"
 233 #  QT_QTWEBKIT_INCLUDE_DIR     Path to "include/QtWebKit"
 234 #  QT_QTXML_INCLUDE_DIR        Path to "include/QtXml"
 235 #  QT_QTXMLPATTERNS_INCLUDE_DIR  Path to "include/QtXmlPatterns"
 236 #  QT_PHONON_INCLUDE_DIR       Path to "include/phonon"
 237 #  QT_QTSCRIPTTOOLS_INCLUDE_DIR       Path to "include/QtScriptTools"
 238 #
 239 #  QT_BINARY_DIR               Path to "bin" of Qt4
 240 #  QT_LIBRARY_DIR              Path to "lib" of Qt4
 241 #  QT_PLUGINS_DIR              Path to "plugins" for Qt4
 242 #  QT_TRANSLATIONS_DIR         Path to "translations" of Qt4
 243 #  QT_DOC_DIR                  Path to "doc" of Qt4
 244 #  QT_MKSPECS_DIR              Path to "mkspecs" of Qt4
 245 #
 246 #
 247 # For every library of Qt, a QT_QTFOO_LIBRARY variable is defined, with the full path to the library.
 248 #
 249 # So there are the following variables:
 250 # The Qt3Support library:     QT_QT3SUPPORT_LIBRARY
 251 #
 252 # The QtAssistant library:    QT_QTASSISTANT_LIBRARY
 253 #
 254 # The QtAssistantClient library:  QT_QTASSISTANTCLIENT_LIBRARY
 255 #
 256 # The QAxServer library:      QT_QAXSERVER_LIBRARY
 257 #
 258 # The QAxContainer library:   QT_QAXCONTAINER_LIBRARY
 259 #
 260 # The QtCore library:         QT_QTCORE_LIBRARY
 261 #
 262 # The QtDBus library:         QT_QTDBUS_LIBRARY
 263 #
 264 # The QtDesigner library:     QT_QTDESIGNER_LIBRARY
 265 #
 266 # The QtDesignerComponents library:     QT_QTDESIGNERCOMPONENTS_LIBRARY
 267 #
 268 # The QtGui library:          QT_QTGUI_LIBRARY
 269 #
 270 # The QtHelp library:         QT_QTHELP_LIBRARY
 271 #
 272 # The QtMotif library:        QT_QTMOTIF_LIBRARY
 273 #
 274 # The QtMultimedia library:   QT_QTMULTIMEDIA_LIBRARY
 275 #
 276 # The QtNetwork library:      QT_QTNETWORK_LIBRARY
 277 #
 278 # The QtNsPLugin library:     QT_QTNSPLUGIN_LIBRARY
 279 #
 280 # The QtOpenGL library:       QT_QTOPENGL_LIBRARY
 281 #
 282 # The QtScript library:       QT_QTSCRIPT_LIBRARY
 283 #
 284 # The QtScriptTools library:      QT_QTSCRIPTTOOLS_LIBRARY
 285 #
 286 # The QtSql library:          QT_QTSQL_LIBRARY
 287 #
 288 # The QtSvg library:          QT_QTSVG_LIBRARY
 289 #
 290 # The QtTest library:         QT_QTTEST_LIBRARY
 291 #
 292 # The QtUiTools library:      QT_QTUITOOLS_LIBRARY
 293 #
 294 # The QtWebKit library:       QT_QTWEBKIT_LIBRARY
 295 #
 296 # The QtXml library:          QT_QTXML_LIBRARY
 297 #
 298 # The QtXmlPatterns library:  QT_QTXMLPATTERNS_LIBRARY
 299 #
 300 # The qtmain library for Windows QT_QTMAIN_LIBRARY
 301 #
 302 # The Phonon library:             QT_PHONON_LIBRARY
 303 #
 304 # also defined, but NOT for general use are
 305 #  QT_MOC_EXECUTABLE                   Where to find the moc tool.
 306 #  QT_UIC_EXECUTABLE                   Where to find the uic tool.
 307 #  QT_UIC3_EXECUTABLE                  Where to find the uic3 tool.
 308 #  QT_RCC_EXECUTABLE                   Where to find the rcc tool
 309 #  QT_DBUSCPP2XML_EXECUTABLE           Where to find the qdbuscpp2xml tool.
 310 #  QT_DBUSXML2CPP_EXECUTABLE           Where to find the qdbusxml2cpp tool.
 311 #  QT_LUPDATE_EXECUTABLE               Where to find the lupdate tool.
 312 #  QT_LRELEASE_EXECUTABLE              Where to find the lrelease tool.
 313 #  QT_LCONVERT_EXECUTABLE              Where to find the lconvert tool.
 314 #  QT_QCOLLECTIONGENERATOR_EXECUTABLE  Where to find the qcollectiongenerator tool.
 315 #  QT_DESIGNER_EXECUTABLE              Where to find the Qt designer tool.
 316 #  QT_LINGUIST_EXECUTABLE              Where to find the Qt linguist tool.
 317 #
 318 #
 319 # These are around for backwards compatibility
 320 # they will be set
 321 #  QT_WRAP_CPP  Set true if QT_MOC_EXECUTABLE is found
 322 #  QT_WRAP_UI   Set true if QT_UIC_EXECUTABLE is found
 323 #
 324 # These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)
 325 #  QT_MT_REQUIRED         Qt4 is now always multithreaded
 326 #
 327 # These variables are set to "" Because Qt structure changed
 328 # (They make no sense in Qt4)
 329 #  QT_QT_LIBRARY        Qt-Library is now split
 330
 331 # Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
 332 # See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 333
 334 # Use FIND_PACKAGE( Qt4 COMPONENTS ... ) to enable modules
 335 IF( Qt4_FIND_COMPONENTS )
 336   FOREACH( component ${Qt4_FIND_COMPONENTS} )
 337     STRING( TOUPPER ${component} _COMPONENT )
 338     SET( QT_USE_${_COMPONENT} 1 )
 339   ENDFOREACH( component )
 340
 341   # To make sure we don't use QtCore or QtGui when not in COMPONENTS
 342   IF(NOT QT_USE_QTCORE)
 343     SET( QT_DONT_USE_QTCORE 1 )
 344   ENDIF(NOT QT_USE_QTCORE)
 345
 346   IF(NOT QT_USE_QTGUI)
 347     SET( QT_DONT_USE_QTGUI 1 )
 348   ENDIF(NOT QT_USE_QTGUI)
 349
 350 ENDIF( Qt4_FIND_COMPONENTS )
 351
 352 # If Qt3 has already been found, fail.
 353 IF(QT_QT_LIBRARY)
 354   IF(Qt4_FIND_REQUIRED)
 355     MESSAGE( FATAL_ERROR "Qt3 and Qt4 cannot be used together in one project.  If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
 356   ELSE(Qt4_FIND_REQUIRED)
 357     IF(NOT Qt4_FIND_QUIETLY)
 358       MESSAGE( STATUS    "Qt3 and Qt4 cannot be used together in one project.  If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
 359     ENDIF(NOT Qt4_FIND_QUIETLY)
 360     RETURN()
 361   ENDIF(Qt4_FIND_REQUIRED)
 362 ENDIF(QT_QT_LIBRARY)
 363
 364
 365 IF (QT4_QMAKE_FOUND)
 366    # Check already done in this cmake run, nothing more to do
 367    RETURN()
 368 ENDIF (QT4_QMAKE_FOUND)
 369
 370 # check that QT_NO_DEBUG is defined for release configurations
 371 MACRO(QT_CHECK_FLAG_EXISTS FLAG VAR DOC)
 372   IF(NOT ${VAR} MATCHES "${FLAG}")
 373     SET(${VAR} "${${VAR}} ${FLAG}"
 374       CACHE STRING "Flags used by the compiler during ${DOC} builds." FORCE)
 375   ENDIF(NOT ${VAR} MATCHES "${FLAG}")
 376 ENDMACRO(QT_CHECK_FLAG_EXISTS FLAG VAR)
 377
 378 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO "Release with Debug Info")
 379 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELEASE "release")
 380 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL "release minsize")
 381
 382 INCLUDE(MacroPushRequiredVars)
 383 INCLUDE(CheckSymbolExists)
 384 INCLUDE(MacroAddFileDependencies)
 385
 386 SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
 387
 388 SET( QT_DEFINITIONS "")
 389
 390 SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)
 391
 392 #  macro for asking qmake to process pro files
 393 MACRO(QT_QUERY_QMAKE outvar invar)
 394   IF(QT_QMAKE_EXECUTABLE)
 395     FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro
 396          "message(CMAKE_MESSAGE<$$${invar}>)")
 397
 398     # Invoke qmake with the tmp.pro program to get the desired
 399     # information.  Use the same variable for both stdout and stderr
 400     # to make sure we get the output on all platforms.
 401     EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}
 402       WORKING_DIRECTORY
 403       ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake
 404       OUTPUT_VARIABLE _qmake_query_output
 405       RESULT_VARIABLE _qmake_result
 406       ERROR_VARIABLE _qmake_query_output )
 407
 408     FILE(REMOVE_RECURSE
 409          "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake")
 410
 411     IF(_qmake_result)
 412       MESSAGE(WARNING " querying qmake for ${invar}.  qmake reported:\n${_qmake_query_output}")
 413     ELSE(_qmake_result)
 414       STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}")
 415     ENDIF(_qmake_result)
 416
 417   ENDIF(QT_QMAKE_EXECUTABLE)
 418 ENDMACRO(QT_QUERY_QMAKE)
 419
 420 GET_FILENAME_COMPONENT(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME)
 421 # check for qmake
 422 # Debian uses qmake-qt4
 423 # macports' Qt uses qmake-mac
 424 FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 qmake-mac PATHS
 425   "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
 426   "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
 427   "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]/bin"
 428   $ENV{QTDIR}/bin
 429 )
 430
 431 IF (QT_QMAKE_EXECUTABLE)
 432
 433   IF(QT_QMAKE_EXECUTABLE_LAST)
 434     STRING(COMPARE NOTEQUAL "${QT_QMAKE_EXECUTABLE_LAST}" "${QT_QMAKE_EXECUTABLE}" QT_QMAKE_CHANGED)
 435   ENDIF(QT_QMAKE_EXECUTABLE_LAST)
 436
 437   SET(QT_QMAKE_EXECUTABLE_LAST "${QT_QMAKE_EXECUTABLE}" CACHE INTERNAL "" FORCE)
 438
 439   SET(QT4_QMAKE_FOUND FALSE)
 440
 441   EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
 442
 443   # check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
 444   IF("${QTVERSION}" MATCHES "Unknown")
 445     SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
 446     FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS
 447       "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
 448       "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
 449       $ENV{QTDIR}/bin
 450       )
 451     IF(QT_QMAKE_EXECUTABLE)
 452       EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
 453         ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
 454     ENDIF(QT_QMAKE_EXECUTABLE)
 455   ENDIF("${QTVERSION}" MATCHES "Unknown")
 456
 457   # check that we found the Qt4 qmake, Qt3 qmake output won't match here
 458   STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")
 459   IF (qt_version_tmp)
 460
 461     # we need at least version 4.0.0
 462     IF (NOT QT_MIN_VERSION)
 463       SET(QT_MIN_VERSION "4.0.0")
 464     ENDIF (NOT QT_MIN_VERSION)
 465
 466     #now parse the parts of the user given version string into variables
 467     STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}")
 468     IF (NOT req_qt_major_vers)
 469       MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"")
 470     ENDIF (NOT req_qt_major_vers)
 471
 472     # now parse the parts of the user given version string into variables
 473     STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}")
 474     STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}")
 475     STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}")
 476
 477     # Suppport finding at least a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 )
 478     # This implementation is a hack to avoid duplicating code and make sure we stay
 479     # source-compatible with CMake 2.6.x
 480     IF( Qt4_FIND_VERSION )
 481       SET( QT_MIN_VERSION ${Qt4_FIND_VERSION} )
 482       SET( req_qt_major_vers ${Qt4_FIND_VERSION_MAJOR} )
 483       SET( req_qt_minor_vers ${Qt4_FIND_VERSION_MINOR} )
 484       SET( req_qt_patch_vers ${Qt4_FIND_VERSION_PATCH} )
 485     ENDIF( Qt4_FIND_VERSION )
 486
 487     IF (NOT req_qt_major_vers EQUAL 4)
 488       MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")
 489     ENDIF (NOT req_qt_major_vers EQUAL 4)
 490
 491     # and now the version string given by qmake
 492     STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" QT_VERSION_MAJOR "${QTVERSION}")
 493     STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" QT_VERSION_MINOR "${QTVERSION}")
 494     STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" QT_VERSION_PATCH "${QTVERSION}")
 495
 496     # compute an overall version number which can be compared at once
 497     MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")
 498     MATH(EXPR found_vers "${QT_VERSION_MAJOR}*10000 + ${QT_VERSION_MINOR}*100 + ${QT_VERSION_PATCH}")
 499
 500     # Support finding *exactly* a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 EXACT )
 501     IF( Qt4_FIND_VERSION_EXACT )
 502       IF(found_vers EQUAL req_vers)
 503         SET( QT4_QMAKE_FOUND TRUE )
 504       ELSE(found_vers EQUAL req_vers)
 505         SET( QT4_QMAKE_FOUND FALSE )
 506         IF (found_vers LESS req_vers)
 507           SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
 508         ELSE (found_vers LESS req_vers)
 509           SET(QT4_INSTALLED_VERSION_TOO_NEW TRUE)
 510         ENDIF (found_vers LESS req_vers)
 511       ENDIF(found_vers EQUAL req_vers)
 512     ELSE( Qt4_FIND_VERSION_EXACT )
 513       IF (found_vers LESS req_vers)
 514         SET(QT4_QMAKE_FOUND FALSE)
 515         SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
 516       ELSE (found_vers LESS req_vers)
 517         SET(QT4_QMAKE_FOUND TRUE)
 518       ENDIF (found_vers LESS req_vers)
 519     ENDIF( Qt4_FIND_VERSION_EXACT )
 520   ENDIF (qt_version_tmp)
 521
 522 ENDIF (QT_QMAKE_EXECUTABLE)
 523
 524 IF (QT4_QMAKE_FOUND)
 525
 526   if (WIN32)
 527     # get qt install dir
 528     get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )
 529     get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )
 530   endif (WIN32)
 531
 532   # ask qmake for the library dir
 533   # Set QT_LIBRARY_DIR
 534   IF (NOT QT_LIBRARY_DIR OR QT_QMAKE_CHANGED)
 535     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 536       ARGS "-query QT_INSTALL_LIBS"
 537       OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP )
 538     # make sure we have / and not \ as qmake gives on windows
 539     FILE(TO_CMAKE_PATH "${QT_LIBRARY_DIR_TMP}" QT_LIBRARY_DIR_TMP)
 540     IF(EXISTS "${QT_LIBRARY_DIR_TMP}")
 541       SET(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir" FORCE)
 542     ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}")
 543       MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT_LIBRARY_DIR_TMP}")
 544       MESSAGE("Warning: ${QT_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.")
 545     ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}")
 546   ENDIF(NOT QT_LIBRARY_DIR OR QT_QMAKE_CHANGED)
 547
 548   IF (APPLE)
 549     IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 550       SET(QT_USE_FRAMEWORKS ON
 551         CACHE BOOL "Set to ON if Qt build uses frameworks." FORCE)
 552     ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 553       SET(QT_USE_FRAMEWORKS OFF
 554         CACHE BOOL "Set to ON if Qt build uses frameworks." FORCE)
 555     ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 556
 557     MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)
 558   ENDIF (APPLE)
 559
 560   # ask qmake for the binary dir
 561   IF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR  OR  QT_QMAKE_CHANGED)
 562      EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
 563        ARGS "-query QT_INSTALL_BINS"
 564        OUTPUT_VARIABLE qt_bins )
 565      # make sure we have / and not \ as qmake gives on windows
 566      FILE(TO_CMAKE_PATH "${qt_bins}" qt_bins)
 567      SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "" FORCE)
 568   ENDIF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR  OR  QT_QMAKE_CHANGED)
 569
 570   # ask qmake for the include dir
 571   IF (QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR  OR  QT_QMAKE_CHANGED)
 572       EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 573         ARGS "-query QT_INSTALL_HEADERS"
 574         OUTPUT_VARIABLE qt_headers )
 575       # make sure we have / and not \ as qmake gives on windows
 576       FILE(TO_CMAKE_PATH "${qt_headers}" qt_headers)
 577       SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "" FORCE)
 578   ENDIF (QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR  OR  QT_QMAKE_CHANGED)
 579
 580
 581   # ask qmake for the documentation directory
 582   IF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR  OR  QT_QMAKE_CHANGED)
 583     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 584       ARGS "-query QT_INSTALL_DOCS"
 585       OUTPUT_VARIABLE qt_doc_dir )
 586     # make sure we have / and not \ as qmake gives on windows
 587     FILE(TO_CMAKE_PATH "${qt_doc_dir}" qt_doc_dir)
 588     SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs" FORCE)
 589   ENDIF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR  OR  QT_QMAKE_CHANGED)
 590
 591   # ask qmake for the mkspecs directory
 592   IF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR  OR  QT_QMAKE_CHANGED)
 593     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 594       ARGS "-query QMAKE_MKSPECS"
 595       OUTPUT_VARIABLE qt_mkspecs_dirs )
 596     # do not replace : on windows as it might be a drive letter
 597     # and windows should already use ; as a separator
 598     IF(UNIX)
 599       STRING(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}")
 600     ENDIF(UNIX)
 601     SET(QT_MKSPECS_DIR NOTFOUND)
 602     FIND_PATH(QT_MKSPECS_DIR qconfig.pri PATHS ${qt_mkspecs_dirs}
 603       DOC "The location of the Qt mkspecs containing qconfig.pri"
 604       NO_DEFAULT_PATH )
 605   ENDIF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR  OR  QT_QMAKE_CHANGED)
 606
 607   # ask qmake for the plugins directory
 608   IF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR  OR  QT_QMAKE_CHANGED)
 609     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 610       ARGS "-query QT_INSTALL_PLUGINS"
 611       OUTPUT_VARIABLE qt_plugins_dir )
 612     # make sure we have / and not \ as qmake gives on windows
 613     FILE(TO_CMAKE_PATH "${qt_plugins_dir}" qt_plugins_dir)
 614     SET(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins" FORCE)
 615   ENDIF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR  OR  QT_QMAKE_CHANGED)
 616
 617   # ask qmake for the translations directory
 618   IF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR  OR  QT_QMAKE_CHANGED)
 619     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 620       ARGS "-query QT_INSTALL_TRANSLATIONS"
 621       OUTPUT_VARIABLE qt_translations_dir )
 622     # make sure we have / and not \ as qmake gives on windows
 623     FILE(TO_CMAKE_PATH "${qt_translations_dir}" qt_translations_dir)
 624     SET(QT_TRANSLATIONS_DIR ${qt_translations_dir} CACHE PATH "The location of the Qt translations" FORCE)
 625   ENDIF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR  OR  QT_QMAKE_CHANGED)
 626
 627   # Make variables changeble to the advanced user
 628   MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_DOC_DIR QT_MKSPECS_DIR
 629                     QT_PLUGINS_DIR QT_TRANSLATIONS_DIR)
 630
 631
 632   #############################################
 633   #
 634   # Find out what window system we're using
 635   #
 636   #############################################
 637   # Save required includes and required_flags variables
 638   MACRO_PUSH_REQUIRED_VARS()
 639   # Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES
 640   SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_HEADERS_DIR}")
 641   # On Mac OS X when Qt has framework support, also add the framework path
 642   IF( QT_USE_FRAMEWORKS )
 643     SET(CMAKE_REQUIRED_FLAGS "-F${QT_LIBRARY_DIR} ")
 644   ENDIF( QT_USE_FRAMEWORKS )
 645   # Check for Window system symbols (note: only one should end up being set)
 646   CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)
 647   CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)
 648   CHECK_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)
 649   CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)
 650   IF(Q_WS_MAC)
 651     IF(QT_QMAKE_CHANGED)
 652       SET(QT_MAC_USE_COCOA "" CACHE BOOL "Use Cocoa on Mac" FORCE)
 653     ENDIF(QT_QMAKE_CHANGED)
 654     CHECK_SYMBOL_EXISTS(QT_MAC_USE_COCOA "QtCore/qconfig.h" QT_MAC_USE_COCOA)
 655   ENDIF(Q_WS_MAC)
 656
 657   IF (QT_QTCOPY_REQUIRED)
 658      CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)
 659      IF (NOT QT_IS_QTCOPY)
 660         MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found")
 661      ENDIF (NOT QT_IS_QTCOPY)
 662   ENDIF (QT_QTCOPY_REQUIRED)
 663
 664   # Restore CMAKE_REQUIRED_INCLUDES+CMAKE_REQUIRED_FLAGS variables
 665   MACRO_POP_REQUIRED_VARS()
 666   #
 667   #############################################
 668
 669
 670
 671   ########################################
 672   #
 673   #       Setting the INCLUDE-Variables
 674   #
 675   ########################################
 676
 677   SET(QT_MODULES QtCore QtGui Qt3Support QtSvg QtScript QtTest QtUiTools
 678                  QtHelp QtWebKit QtXmlPatterns QtNetwork QtMultimedia
 679                  QtNsPlugin QtOpenGL QtSql QtXml QtDesigner QtDBus QtScriptTools)
 680
 681   IF(Q_WS_X11)
 682     SET(QT_MODULES ${QT_MODULES} QtMotif)
 683   ENDIF(Q_WS_X11)
 684
 685   IF(QT_QMAKE_CHANGED)
 686     FOREACH(QT_MODULE ${QT_MODULES})
 687       STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
 688       SET(QT_${_upper_qt_module}_INCLUDE_DIR NOTFOUND)
 689       SET(QT_${_upper_qt_module}_LIBRARY_RELEASE NOTFOUND)
 690       SET(QT_${_upper_qt_module}_LIBRARY_DEBUG NOTFOUND)
 691     ENDFOREACH(QT_MODULE)
 692     SET(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR NOTFOUND)
 693     SET(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NOTFOUND)
 694     SET(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NOTFOUND)
 695     SET(QT_QTASSISTANTCLIENT_INCLUDE_DIR NOTFOUND)
 696     SET(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NOTFOUND)
 697     SET(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG NOTFOUND)
 698     SET(QT_QTASSISTANT_INCLUDE_DIR NOTFOUND)
 699     SET(QT_QTASSISTANT_LIBRARY_RELEASE NOTFOUND)
 700     SET(QT_QTASSISTANT_LIBRARY_DEBUG NOTFOUND)
 701     SET(QT_QTCLUCENE_LIBRARY_RELEASE NOTFOUND)
 702     SET(QT_QTCLUCENE_LIBRARY_DEBUG NOTFOUND)
 703     SET(QT_QAXCONTAINER_INCLUDE_DIR NOTFOUND)
 704     SET(QT_QAXCONTAINER_LIBRARY_RELEASE NOTFOUND)
 705     SET(QT_QAXCONTAINER_LIBRARY_DEBUG NOTFOUND)
 706     SET(QT_QAXSERVER_INCLUDE_DIR NOTFOUND)
 707     SET(QT_QAXSERVER_LIBRARY_RELEASE NOTFOUND)
 708     SET(QT_QAXSERVER_LIBRARY_DEBUG NOTFOUND)
 709     IF(WIN32)
 710       SET(QT_QTMAIN_LIBRARY_DEBUG NOTFOUND)
 711       SET(QT_QTMAIN_LIBRARY_RELEASE NOTFOUND)
 712     ENDIF(WIN32)
 713     SET(QT_PHONON_INCLUDE_DIR NOTFOUND)
 714   ENDIF(QT_QMAKE_CHANGED)
 715
 716   FOREACH(QT_MODULE ${QT_MODULES})
 717     STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
 718     FIND_PATH(QT_${_upper_qt_module}_INCLUDE_DIR ${QT_MODULE}
 719               PATHS
 720               ${QT_HEADERS_DIR}/${QT_MODULE}
 721               ${QT_LIBRARY_DIR}/${QT_MODULE}.framework/Headers
 722               NO_DEFAULT_PATH
 723       )
 724   ENDFOREACH(QT_MODULE)
 725
 726   IF(WIN32)
 727     SET(QT_MODULES ${QT_MODULES} QAxContainer QAxServer)
 728     # Set QT_AXCONTAINER_INCLUDE_DIR and QT_AXSERVER_INCLUDE_DIR
 729     FIND_PATH(QT_QAXCONTAINER_INCLUDE_DIR ActiveQt
 730       PATHS
 731       ${QT_HEADERS_DIR}/ActiveQt
 732       NO_DEFAULT_PATH
 733       )
 734     FIND_PATH(QT_QAXSERVER_INCLUDE_DIR ActiveQt
 735       PATHS
 736       ${QT_HEADERS_DIR}/ActiveQt
 737       NO_DEFAULT_PATH
 738       )
 739   ENDIF(WIN32)
 740
 741   # Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR
 742   FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents
 743     PATHS
 744     ${QT_HEADERS_DIR}/QtDesigner
 745     ${QT_LIBRARY_DIR}/QtDesigner.framework/Headers
 746     NO_DEFAULT_PATH
 747     )
 748
 749   # Set QT_QTASSISTANT_INCLUDE_DIR
 750   FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant
 751     PATHS
 752     ${QT_HEADERS_DIR}/QtAssistant
 753     ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
 754     NO_DEFAULT_PATH
 755     )
 756
 757   # Set QT_QTASSISTANTCLIENT_INCLUDE_DIR
 758   FIND_PATH(QT_QTASSISTANTCLIENT_INCLUDE_DIR QAssistantClient
 759     PATHS
 760     ${QT_HEADERS_DIR}/QtAssistant
 761     ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
 762     NO_DEFAULT_PATH
 763     )
 764
 765   # Set QT_QT_INCLUDE_DIR
 766   FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h
 767     PATHS
 768     ${QT_HEADERS_DIR}/Qt
 769     ${QT_LIBRARY_DIR}/QtCore.framework/Headers
 770     NO_DEFAULT_PATH
 771     )
 772
 773   # Set QT_PHONON_INCLUDE_DIR
 774   # Qt >= 4.5.3 (or kde-qt-4.5.2 which has the fix too) : Phonon/ClassName is inside include/phonon
 775   # With previous versions of Qt, this could not work; upgrade Qt or use a standalone phonon
 776   FIND_PATH(QT_PHONON_INCLUDE_DIR Phonon
 777     PATHS
 778     ${QT_HEADERS_DIR}/phonon
 779     NO_DEFAULT_PATH
 780     )
 781   SET(QT_MODULES ${QT_MODULES} phonon)
 782
 783   # Set QT_INCLUDE_DIR by removine "/QtCore" in the string ${QT_QTCORE_INCLUDE_DIR}
 784   IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
 785     IF (QT_USE_FRAMEWORKS)
 786       SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR})
 787     ELSE (QT_USE_FRAMEWORKS)
 788       STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT_QTCORE_INCLUDE_DIR})
 789       SET( QT_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "")
 790     ENDIF (QT_USE_FRAMEWORKS)
 791   ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
 792
 793   IF( NOT QT_INCLUDE_DIR)
 794     IF(Qt4_FIND_REQUIRED)
 795       MESSAGE( FATAL_ERROR "Could NOT find QtCore header")
 796     ENDIF(Qt4_FIND_REQUIRED)
 797   ENDIF( NOT QT_INCLUDE_DIR)
 798
 799   # Make variables changeble to the advanced user
 800   MARK_AS_ADVANCED( QT_INCLUDE_DIR QT_QT_INCLUDE_DIR)
 801
 802   # Set QT_INCLUDES
 803   SET( QT_INCLUDES ${QT_QT_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ${QT_INCLUDE_DIR} )
 804
 805
 806   #######################################
 807   #
 808   #       Qt configuration
 809   #
 810   #######################################
 811   IF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
 812     FILE(READ ${QT_MKSPECS_DIR}/qconfig.pri _qconfig_FILE_contents)
 813     STRING(REGEX MATCH "QT_CONFIG[^\n]+" QT_QCONFIG "${_qconfig_FILE_contents}")
 814     STRING(REGEX MATCH "CONFIG[^\n]+" QT_CONFIG "${_qconfig_FILE_contents}")
 815     STRING(REGEX MATCH "EDITION[^\n]+" QT_EDITION "${_qconfig_FILE_contents}")
 816     STRING(REGEX MATCH "QT_LIBINFIX[^\n]+" _qconfig_qt_libinfix "${_qconfig_FILE_contents}")
 817     STRING(REGEX REPLACE "QT_LIBINFIX *= *([^\n]*)" "\\1" QT_LIBINFIX "${_qconfig_qt_libinfix}")
 818   ENDIF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
 819   IF("${QT_EDITION}" MATCHES "DesktopLight")
 820     SET(QT_EDITION_DESKTOPLIGHT 1)
 821   ENDIF("${QT_EDITION}" MATCHES "DesktopLight")
 822
 823   ########################################
 824   #
 825   #       Setting the LIBRARY-Variables
 826   #
 827   ########################################
 828
 829   # find the libraries
 830   FOREACH(QT_MODULE ${QT_MODULES})
 831     STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
 832     FIND_LIBRARY(QT_${_upper_qt_module}_LIBRARY_RELEASE
 833                  NAMES ${QT_MODULE}${QT_LIBINFIX} ${QT_MODULE}${QT_LIBINFIX}4
 834                  PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH
 835         )
 836     FIND_LIBRARY(QT_${_upper_qt_module}_LIBRARY_DEBUG
 837                  NAMES ${QT_MODULE}${QT_LIBINFIX}_debug ${QT_MODULE}${QT_LIBINFIX}d ${QT_MODULE}${QT_LIBINFIX}d4
 838                  PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH
 839         )
 840   ENDFOREACH(QT_MODULE)
 841
 842   # QtUiTools not with other frameworks with binary installation (in /usr/lib)
 843   IF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE)
 844     FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
 845   ENDIF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE)
 846
 847   IF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
 848
 849     # try dropping a hint if trying to use Visual Studio with Qt built by mingw
 850     IF(QT_LIBRARY_DIR AND MSVC)
 851       IF(EXISTS ${QT_LIBRARY_DIR}/libqtmain.a)
 852         MESSAGE( FATAL_ERROR "It appears you're trying to use Visual Studio with Qt built by mingw")
 853       ENDIF(EXISTS ${QT_LIBRARY_DIR}/libqtmain.a)
 854     ENDIF(QT_LIBRARY_DIR AND MSVC)
 855
 856     IF(Qt4_FIND_REQUIRED)
 857       MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
 858     ENDIF(Qt4_FIND_REQUIRED)
 859   ENDIF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
 860
 861   # Set QT_QTDESIGNERCOMPONENTS_LIBRARY
 862   FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents${QT_LIBINFIX} QtDesignerComponents${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR}        NO_DEFAULT_PATH)
 863   FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG   NAMES QtDesignerComponents${QT_LIBINFIX}_debug QtDesignerComponents${QT_LIBINFIX}d QtDesignerComponents${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 864
 865   # Set QT_QTMAIN_LIBRARY
 866   IF(WIN32)
 867     FIND_LIBRARY(QT_QTMAIN_LIBRARY_RELEASE NAMES qtmain${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR}
 868       NO_DEFAULT_PATH)
 869     FIND_LIBRARY(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmain${QT_LIBINFIX}d PATHS ${QT_LIBRARY_DIR}
 870       NO_DEFAULT_PATH)
 871   ENDIF(WIN32)
 872
 873   # Set QT_QTASSISTANTCLIENT_LIBRARY
 874   FIND_LIBRARY(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR}        NO_DEFAULT_PATH)
 875   FIND_LIBRARY(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG   NAMES QtAssistantClient${QT_LIBINFIX}_debug QtAssistantClient${QT_LIBINFIX}d QtAssistantClient${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 876
 877   # Set QT_QTASSISTANT_LIBRARY
 878   FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 QtAssistant${QT_LIBINFIX} QtAssistant${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR}        NO_DEFAULT_PATH)
 879   FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_DEBUG   NAMES QtAssistantClient${QT_LIBINFIX}_debug QtAssistantClient${QT_LIBINFIX}d QtAssistantClient${QT_LIBINFIX}d4 QtAssistant${QT_LIBINFIX}_debug QtAssistant${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 880
 881   # Set QT_QTHELP_LIBRARY
 882   FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} QtCLucene${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR}        NO_DEFAULT_PATH)
 883   FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_DEBUG   NAMES QtCLucene${QT_LIBINFIX}_debug QtCLucene${QT_LIBINFIX}d QtCLucene${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 884   # QtCLucene not with other frameworks with binary installation (in /usr/lib)
 885   IF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE)
 886     FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
 887   ENDIF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE)
 888
 889   ############################################
 890   #
 891   # Check the existence of the libraries.
 892   #
 893   ############################################
 894
 895   MACRO (_QT4_ADJUST_LIB_VARS basename)
 896 #    message(STATUS "Adjusting ${basename}, release: -${QT_${basename}_LIBRARY_RELEASE}- debug: -${QT_${basename}_LIBRARY_DEBUG}-")
 897     IF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
 898       ADD_LIBRARY(Qt4__${basename} SHARED IMPORTED )
 899
 900       IF(WIN32)
 901         SET(_QT4_LIBRARY_PROPERTY_NAME IMPLIB)
 902       ELSE(WIN32)
 903         SET(_QT4_LIBRARY_PROPERTY_NAME LOCATION)
 904       ENDIF(WIN32)
 905
 906
 907       IF (QT_${basename}_LIBRARY_RELEASE)
 908         SET_PROPERTY(TARGET Qt4__${basename} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
 909         SET_PROPERTY(TARGET Qt4__${basename}        PROPERTY IMPORTED_${_QT4_LIBRARY_PROPERTY_NAME}_RELEASE "${QT_${basename}_LIBRARY_RELEASE}" )
 910 #        message(STATUS "Setting IMPORTED_LOCATION_RELEASE to -${QT_${basename}_LIBRARY_RELEASE}-")
 911       ENDIF (QT_${basename}_LIBRARY_RELEASE)
 912
 913       IF (QT_${basename}_LIBRARY_DEBUG)
 914         SET_PROPERTY(TARGET Qt4__${basename} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
 915         SET_PROPERTY(TARGET Qt4__${basename}        PROPERTY IMPORTED_${_QT4_LIBRARY_PROPERTY_NAME}_DEBUG "${QT_${basename}_LIBRARY_DEBUG}" )
 916
 917 #       message(STATUS "Setting IMPORTED_LOCATION_DEBUG to -${QT_${basename}_LIBRARY_DEBUG}-")
 918
 919         SET_PROPERTY(TARGET Qt4__${basename} PROPERTY MAP_IMPORTED_CONFIG_PROFILE DEBUG)
 920         SET_PROPERTY(TARGET Qt4__${basename} PROPERTY MAP_IMPORTED_CONFIG_DEBUGFULL DEBUG)
 921       ENDIF (QT_${basename}_LIBRARY_DEBUG)
 922
 923       SET(QT_${basename}_LIBRARY       Qt4__${basename} )
 924       SET(QT_${basename}_LIBRARIES     Qt4__${basename} )
 925
 926       IF (QT_${basename}_LIBRARY)
 927         SET(QT_${basename}_FOUND 1)
 928       ENDIF (QT_${basename}_LIBRARY)
 929
 930     ENDIF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
 931
 932     IF (QT_${basename}_INCLUDE_DIR)
 933       #add the include directory to QT_INCLUDES
 934       SET(QT_INCLUDES "${QT_${basename}_INCLUDE_DIR}" ${QT_INCLUDES})
 935     ENDIF (QT_${basename}_INCLUDE_DIR)
 936
 937     # Make variables changeble to the advanced user
 938     MARK_AS_ADVANCED(QT_${basename}_LIBRARY QT_${basename}_LIBRARY_RELEASE QT_${basename}_LIBRARY_DEBUG QT_${basename}_INCLUDE_DIR)
 939   ENDMACRO (_QT4_ADJUST_LIB_VARS)
 940
 941
 942   # Set QT_xyz_LIBRARY variable and add
 943   # library include path to QT_INCLUDES
 944   _QT4_ADJUST_LIB_VARS(QTCORE)
 945   _QT4_ADJUST_LIB_VARS(QTGUI)
 946   _QT4_ADJUST_LIB_VARS(QT3SUPPORT)
 947   _QT4_ADJUST_LIB_VARS(QTASSISTANT)
 948   _QT4_ADJUST_LIB_VARS(QTASSISTANTCLIENT)
 949   _QT4_ADJUST_LIB_VARS(QTCLUCENE)
 950   _QT4_ADJUST_LIB_VARS(QTDBUS)
 951   _QT4_ADJUST_LIB_VARS(QTDESIGNER)
 952   _QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS)
 953   _QT4_ADJUST_LIB_VARS(QTHELP)
 954   _QT4_ADJUST_LIB_VARS(QTMULTIMEDIA)
 955   _QT4_ADJUST_LIB_VARS(QTNETWORK)
 956   _QT4_ADJUST_LIB_VARS(QTNSPLUGIN)
 957   _QT4_ADJUST_LIB_VARS(QTOPENGL)
 958   _QT4_ADJUST_LIB_VARS(QTSCRIPT)
 959   _QT4_ADJUST_LIB_VARS(QTSCRIPTTOOLS)
 960   _QT4_ADJUST_LIB_VARS(QTSQL)
 961   _QT4_ADJUST_LIB_VARS(QTSVG)
 962   _QT4_ADJUST_LIB_VARS(QTTEST)
 963   _QT4_ADJUST_LIB_VARS(QTUITOOLS)
 964   _QT4_ADJUST_LIB_VARS(QTWEBKIT)
 965   _QT4_ADJUST_LIB_VARS(QTXML)
 966   _QT4_ADJUST_LIB_VARS(QTXMLPATTERNS)
 967   _QT4_ADJUST_LIB_VARS(PHONON)
 968
 969   # platform dependent libraries
 970   IF(Q_WS_X11)
 971     _QT4_ADJUST_LIB_VARS(QTMOTIF)
 972   ENDIF(Q_WS_X11)
 973   IF(WIN32)
 974     _QT4_ADJUST_LIB_VARS(QTMAIN)
 975     _QT4_ADJUST_LIB_VARS(QAXSERVER)
 976     _QT4_ADJUST_LIB_VARS(QAXCONTAINER)
 977   ENDIF(WIN32)
 978
 979   # If Qt is installed as a framework, we need to add QT_QTCORE_LIBRARY here (which
 980   # is the framework directory in that case), since this will make the cmake include_directories()
 981   # command recognize that we need the framework flag with the respective directory (-F)
 982   IF(QT_USE_FRAMEWORKS)
 983     SET(QT_INCLUDES       ${QT_INCLUDES} ${QT_QTCORE_LIBRARY} )
 984     SET(QT_INCLUDE_DIR ${QT_INCLUDE_DIR} ${QT_QTCORE_LIBRARY} )
 985   ENDIF(QT_USE_FRAMEWORKS)
 986
 987
 988
 989   #######################################
 990   #
 991   #       Check the executables of Qt
 992   #          ( moc, uic, rcc )
 993   #
 994   #######################################
 995
 996
 997   IF(QT_QMAKE_CHANGED)
 998     SET(QT_UIC_EXECUTABLE NOTFOUND)
 999     SET(QT_MOC_EXECUTABLE NOTFOUND)
1000     SET(QT_UIC3_EXECUTABLE NOTFOUND)
1001     SET(QT_RCC_EXECUTABLE NOTFOUND)
1002     SET(QT_DBUSCPP2XML_EXECUTABLE NOTFOUND)
1003     SET(QT_DBUSXML2CPP_EXECUTABLE NOTFOUND)
1004     SET(QT_LUPDATE_EXECUTABLE NOTFOUND)
1005     SET(QT_LRELEASE_EXECUTABLE NOTFOUND)
1006     SET(QT_QCOLLECTIONGENERATOR_EXECUTABLE NOTFOUND)
1007     SET(QT_DESIGNER_EXECUTABLE NOTFOUND)
1008     SET(QT_LINGUIST_EXECUTABLE NOTFOUND)
1009   ENDIF(QT_QMAKE_CHANGED)
1010
1011   FIND_PROGRAM(QT_MOC_EXECUTABLE
1012     NAMES moc-qt4 moc
1013     PATHS ${QT_BINARY_DIR}
1014     NO_DEFAULT_PATH
1015     )
1016
1017   FIND_PROGRAM(QT_UIC_EXECUTABLE
1018     NAMES uic-qt4 uic
1019     PATHS ${QT_BINARY_DIR}
1020     NO_DEFAULT_PATH
1021     )
1022
1023   FIND_PROGRAM(QT_UIC3_EXECUTABLE
1024     NAMES uic3
1025     PATHS ${QT_BINARY_DIR}
1026     NO_DEFAULT_PATH
1027     )
1028
1029   FIND_PROGRAM(QT_RCC_EXECUTABLE
1030     NAMES rcc
1031     PATHS ${QT_BINARY_DIR}
1032     NO_DEFAULT_PATH
1033     )
1034
1035   FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE
1036     NAMES qdbuscpp2xml
1037     PATHS ${QT_BINARY_DIR}
1038     NO_DEFAULT_PATH
1039     )
1040
1041   FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE
1042     NAMES qdbusxml2cpp
1043     PATHS ${QT_BINARY_DIR}
1044     NO_DEFAULT_PATH
1045     )
1046
1047   FIND_PROGRAM(QT_LUPDATE_EXECUTABLE
1048     NAMES lupdate-qt4 lupdate
1049     PATHS ${QT_BINARY_DIR}
1050     NO_DEFAULT_PATH
1051     )
1052
1053   FIND_PROGRAM(QT_LRELEASE_EXECUTABLE
1054     NAMES lrelease-qt4 lrelease
1055     PATHS ${QT_BINARY_DIR}
1056     NO_DEFAULT_PATH
1057     )
1058
1059   FIND_PROGRAM(QT_LCONVERT_EXECUTABLE
1060     NAMES lconvert-qt4 lconvert
1061     PATHS ${QT_BINARY_DIR}
1062     NO_DEFAULT_PATH
1063     )
1064
1065   FIND_PROGRAM(QT_QCOLLECTIONGENERATOR_EXECUTABLE
1066     NAMES qcollectiongenerator-qt4 qcollectiongenerator
1067     PATHS ${QT_BINARY_DIR}
1068     NO_DEFAULT_PATH
1069     )
1070
1071   FIND_PROGRAM(QT_DESIGNER_EXECUTABLE
1072     NAMES designer-qt4 designer
1073     PATHS ${QT_BINARY_DIR}
1074     NO_DEFAULT_PATH
1075     )
1076
1077   FIND_PROGRAM(QT_LINGUIST_EXECUTABLE
1078     NAMES linguist-qt4 linguist
1079     PATHS ${QT_BINARY_DIR}
1080     NO_DEFAULT_PATH
1081     )
1082
1083   IF (QT_MOC_EXECUTABLE)
1084      SET(QT_WRAP_CPP "YES")
1085   ENDIF (QT_MOC_EXECUTABLE)
1086
1087   IF (QT_UIC_EXECUTABLE)
1088      SET(QT_WRAP_UI "YES")
1089   ENDIF (QT_UIC_EXECUTABLE)
1090
1091
1092
1093   MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE
1094     QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE
1095     QT_LUPDATE_EXECUTABLE QT_LRELEASE_EXECUTABLE QT_QCOLLECTIONGENERATOR_EXECUTABLE
1096     QT_DESIGNER_EXECUTABLE QT_LINGUIST_EXECUTABLE)
1097
1098
1099   # get the directory of the current file, used later on in the file
1100   GET_FILENAME_COMPONENT( _qt4_current_dir  "${CMAKE_CURRENT_LIST_FILE}" PATH)
1101
1102   ######################################
1103   #
1104   #       Macros for building Qt files
1105   #
1106   ######################################
1107
1108   INCLUDE("${_qt4_current_dir}/Qt4Macros.cmake")
1109
1110
1111   ######################################
1112   #
1113   #       decide if Qt got found
1114   #
1115   ######################################
1116
1117   # if the includes,libraries,moc,uic and rcc are found then we have it
1118   IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1119       QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1120     SET( QT4_FOUND "YES" )
1121     IF( NOT Qt4_FIND_QUIETLY)
1122       MESSAGE(STATUS "Found Qt-Version ${QTVERSION} (using ${QT_QMAKE_EXECUTABLE})")
1123     ENDIF( NOT Qt4_FIND_QUIETLY)
1124   ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1125         QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1126     SET( QT4_FOUND "NO")
1127     SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1128     IF( Qt4_FIND_REQUIRED)
1129       IF ( NOT QT_LIBRARY_DIR )
1130         MESSAGE(STATUS "Qt libraries NOT found!")
1131       ENDIF(NOT QT_LIBRARY_DIR )
1132       IF ( NOT QT_INCLUDE_DIR )
1133         MESSAGE(STATUS "Qt includes NOT found!")
1134       ENDIF( NOT QT_INCLUDE_DIR )
1135       IF ( NOT QT_MOC_EXECUTABLE )
1136         MESSAGE(STATUS "Qt's moc NOT found!")
1137       ENDIF( NOT QT_MOC_EXECUTABLE )
1138       IF ( NOT QT_UIC_EXECUTABLE )
1139         MESSAGE(STATUS "Qt's uic NOT found!")
1140       ENDIF( NOT QT_UIC_EXECUTABLE )
1141       IF ( NOT QT_RCC_EXECUTABLE )
1142         MESSAGE(STATUS "Qt's rcc NOT found!")
1143       ENDIF( NOT QT_RCC_EXECUTABLE )
1144       MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")
1145     ENDIF( Qt4_FIND_REQUIRED)
1146   ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1147          QT_UIC_EXECUTABLE AND  QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1148
1149   SET(QT_FOUND ${QT4_FOUND})
1150
1151
1152   ###############################################
1153   #
1154   #       configuration/system dependent settings
1155   #
1156   ###############################################
1157
1158   INCLUDE("${_qt4_current_dir}/Qt4ConfigDependentSettings.cmake")
1159
1160
1161   #######################################
1162   #
1163   #       compatibility settings
1164   #
1165   #######################################
1166   # Backwards compatibility for CMake1.4 and 1.2
1167   SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
1168   SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
1169
1170   SET( QT_QT_LIBRARY "")
1171
1172 ELSE(QT4_QMAKE_FOUND)
1173
1174    SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1175
1176    # The code below is overly complex to make sure we do not break compatibility with CMake 2.6.x
1177    # For CMake 2.8, it should be simplified by getting rid of QT4_INSTALLED_VERSION_TOO_OLD and
1178    # QT4_INSTALLED_VERSION_TOO_NEW
1179    IF(Qt4_FIND_REQUIRED)
1180       IF(QT4_INSTALLED_VERSION_TOO_OLD)
1181     IF( Qt4_FIND_VERSION_EXACT )
1182       MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, version ${QT_MIN_VERSION} is required")
1183     ELSE( Qt4_FIND_VERSION_EXACT )
1184       MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1185     ENDIF( Qt4_FIND_VERSION_EXACT )
1186       ELSE(QT4_INSTALLED_VERSION_TOO_OLD)
1187       IF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1188       MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too new, version ${QT_MIN_VERSION} is required")
1189     ELSE( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1190       MESSAGE( FATAL_ERROR "Qt qmake not found!")
1191     ENDIF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1192       ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)
1193    ELSE(Qt4_FIND_REQUIRED)
1194       IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1195          MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1196       ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1197    ENDIF(Qt4_FIND_REQUIRED)
1198
1199 ENDIF (QT4_QMAKE_FOUND)
1200