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 # First is QT_USE_FILE which is the path to a CMake file that can be included
   7 # to compile Qt 4 applications and libraries.  By default, the QtCore and QtGui
   8 # libraries are loaded. This behavior can be changed by setting one or more
   9 # of the following variables to true before doing INCLUDE(${QT_USE_FILE}):
  10 #                    QT_DONT_USE_QTCORE
  11 #                    QT_DONT_USE_QTGUI
  12 #                    QT_USE_QT3SUPPORT
  13 #                    QT_USE_QTASSISTANT
  14 #                    QT_USE_QTDESIGNER
  15 #                    QT_USE_QTMOTIF
  16 #                    QT_USE_QTMAIN
  17 #                    QT_USE_QTNETWORK
  18 #                    QT_USE_QTNSPLUGIN
  19 #                    QT_USE_QTOPENGL
  20 #                    QT_USE_QTSQL
  21 #                    QT_USE_QTXML
  22 #                    QT_USE_QTSVG
  23 #                    QT_USE_QTTEST
  24 #                    QT_USE_QTUITOOLS
  25 #                    QT_USE_QTDBUS
  26 #                    QT_USE_QTSCRIPT
  27 #                    QT_USE_QTASSISTANTCLIENT
  28 #                    QT_USE_QTHELP
  29 #                    QT_USE_QTWEBKIT
  30 #                    QT_USE_QTXMLPATTERNS
  31 #                    QT_USE_PHONON
  32 #
  33 # The file pointed to by QT_USE_FILE will set up your compile environment
  34 # by adding include directories, preprocessor defines, and populate a
  35 # QT_LIBRARIES variable containing all the Qt libraries and their dependencies.
  36 # Add the QT_LIBRARIES variable to your TARGET_LINK_LIBRARIES.
  37 #
  38 # Typical usage could be something like:
  39 #   FIND_PACKAGE(Qt4)
  40 #   SET(QT_USE_QTXML 1)
  41 #   INCLUDE(${QT_USE_FILE})
  42 #   ADD_EXECUTABLE(myexe main.cpp)
  43 #   TARGET_LINK_LIBRARIES(myexe ${QT_LIBRARIES})
  44 #
  45 #
  46 # There are also some files that need processing by some Qt tools such as moc
  47 # and uic.  Listed below are macros that may be used to process those files.
  48 #
  49 #  macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
  50 #        create moc code from a list of files containing Qt class with
  51 #        the Q_OBJECT declaration.  Options may be given to moc, such as those found
  52 #        when executing "moc -help"
  53 #
  54 #  macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
  55 #        create code from a list of Qt designer ui files.
  56 #        Options may be given to uic, such as those found
  57 #        when executing "uic -help"
  58 #
  59 #  macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
  60 #        create code from a list of Qt resource files.
  61 #        Options may be given to rcc, such as those found
  62 #        when executing "rcc -help"
  63 #
  64 #  macro QT4_GENERATE_MOC(inputfile outputfile )
  65 #        creates a rule to run moc on infile and create outfile.
  66 #        Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
  67 #        because you need a custom filename for the moc file or something similar.
  68 #
  69 #  macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... )
  70 #        This macro is still experimental.
  71 #        It can be used to have moc automatically handled.
  72 #        So if you have the files foo.h and foo.cpp, and in foo.h a
  73 #        a class uses the Q_OBJECT macro, moc has to run on it. If you don't
  74 #        want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
  75 #        #include "foo.moc"
  76 #        in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
  77 #        scan all listed files at cmake-time for such included moc files and if it finds
  78 #        them cause a rule to be generated to run moc at build time on the
  79 #        accompanying header file foo.h.
  80 #        If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.
  81 #
  82 #  macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
  83 #        create a the interface header and implementation files with the
  84 #        given basename from the given interface xml file and add it to
  85 #        the list of sources.
  86 #        To disable generating a namespace header, set the source file property
  87 #        NO_NAMESPACE to TRUE on the interface file.
  88 #
  89 #  macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
  90 #        create the interface header and implementation files
  91 #        for all listed interface xml files
  92 #        the name will be automatically determined from the name of the xml file
  93 #        To disable generating namespace headers, set the source file property
  94 #        NO_NAMESPACE to TRUE for these inputfiles.
  95 #
  96 #  macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])
  97 #        create a dbus adaptor (header and implementation file) from the xml file
  98 #        describing the interface, and add it to the list of sources. The adaptor
  99 #        forwards the calls to a parent class, defined in parentheader and named
 100 #        parentclassname. The name of the generated files will be
 101 #        <basename>adaptor.{cpp,h} where basename defaults to the basename of the xml file.
 102 #        If <classname> is provided, then it will be used as the classname of the
 103 #        adaptor itself.
 104 #
 105 #  macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
 106 #        generate the xml interface file from the given header.
 107 #        If the optional argument interfacename is omitted, the name of the
 108 #        interface file is constructed from the basename of the header with
 109 #        the suffix .xml appended.
 110 #        Options may be given to qdbuscpp2xml, such as those found when executing "qdbuscpp2xml --help"
 111 #
 112 #  QT_FOUND         If false, don't try to use Qt.
 113 #  QT4_FOUND        If false, don't try to use Qt 4.
 114 #
 115 #  QT_QTCORE_FOUND        True if QtCore was found.
 116 #  QT_QTGUI_FOUND         True if QtGui was found.
 117 #  QT_QT3SUPPORT_FOUND    True if Qt3Support was found.
 118 #  QT_QTASSISTANT_FOUND   True if QtAssistant was found.
 119 #  QT_QTDBUS_FOUND        True if QtDBus was found.
 120 #  QT_QTDESIGNER_FOUND    True if QtDesigner was found.
 121 #  QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.
 122 #  QT_QTMOTIF_FOUND       True if QtMotif was found.
 123 #  QT_QTNETWORK_FOUND     True if QtNetwork was found.
 124 #  QT_QTNSPLUGIN_FOUND    True if QtNsPlugin was found.
 125 #  QT_QTOPENGL_FOUND      True if QtOpenGL was found.
 126 #  QT_QTSQL_FOUND         True if QtSql was found.
 127 #  QT_QTXML_FOUND         True if QtXml was found.
 128 #  QT_QTSVG_FOUND         True if QtSvg was found.
 129 #  QT_QTSCRIPT_FOUND      True if QtScript was found.
 130 #  QT_QTTEST_FOUND        True if QtTest was found.
 131 #  QT_QTUITOOLS_FOUND     True if QtUiTools was found.
 132 #  QT_QTASSISTANTCLIENT_FOUND         True if QtAssistantClient was found.
 133 #  QT_QTHELP_FOUND      True if QtHelp was found.
 134 #  QT_QTWEBKIT_FOUND        True if QtWebKit was found.
 135 #  QT_QTXMLPATTERNS_FOUND   True if QtXmlPatterns was found.
 136 #  QT_PHONON_FOUND          True if phonon was found.
 137 #
 138 #
 139 #  QT_DEFINITIONS   Definitions to use when compiling code that uses Qt.
 140 #                   You do not need to use this if you include QT_USE_FILE.
 141 #                   The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
 142 #                   to fit your current build type.  Those are not contained
 143 #                   in QT_DEFINITIONS.
 144 #
 145 #  QT_INCLUDES      List of paths to all include directories of
 146 #                   Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
 147 #                   always in this variable even if NOTFOUND,
 148 #                   all other INCLUDE_DIRS are
 149 #                   only added if they are found.
 150 #                   You do not need to use this if you include QT_USE_FILE.
 151 #
 152 #
 153 #  Include directories for the Qt modules are listed here.
 154 #  You do not need to use these variables if you include QT_USE_FILE.
 155 #
 156 #  QT_INCLUDE_DIR              Path to "include" of Qt4
 157 #  QT_QT_INCLUDE_DIR           Path to "include/Qt"
 158 #  QT_QT3SUPPORT_INCLUDE_DIR   Path to "include/Qt3Support"
 159 #  QT_QTASSISTANT_INCLUDE_DIR  Path to "include/QtAssistant"
 160 #  QT_QTCORE_INCLUDE_DIR       Path to "include/QtCore"
 161 #  QT_QTDESIGNER_INCLUDE_DIR   Path to "include/QtDesigner"
 162 #  QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR   Path to "include/QtDesigner"
 163 #  QT_QTDBUS_INCLUDE_DIR       Path to "include/QtDBus"
 164 #  QT_QTGUI_INCLUDE_DIR        Path to "include/QtGui"
 165 #  QT_QTMOTIF_INCLUDE_DIR      Path to "include/QtMotif"
 166 #  QT_QTNETWORK_INCLUDE_DIR    Path to "include/QtNetwork"
 167 #  QT_QTNSPLUGIN_INCLUDE_DIR   Path to "include/QtNsPlugin"
 168 #  QT_QTOPENGL_INCLUDE_DIR     Path to "include/QtOpenGL"
 169 #  QT_QTSQL_INCLUDE_DIR        Path to "include/QtSql"
 170 #  QT_QTXML_INCLUDE_DIR        Path to "include/QtXml"
 171 #  QT_QTSVG_INCLUDE_DIR        Path to "include/QtSvg"
 172 #  QT_QTSCRIPT_INCLUDE_DIR     Path to "include/QtScript"
 173 #  QT_QTTEST_INCLUDE_DIR       Path to "include/QtTest"
 174 #  QT_QTASSISTANTCLIENT_INCLUDE_DIR       Path to "include/QtAssistant"
 175 #  QT_QTHELP_INCLUDE_DIR       Path to "include/QtHelp"
 176 #  QT_QTWEBKIT_INCLUDE_DIR     Path to "include/QtWebKit"
 177 #  QT_QTXMLPATTERNS_INCLUDE_DIR  Path to "include/QtXmlPatterns"
 178 #  QT_PHONON_INCLUDE_DIR       Path to "include/phonon"
 179 #
 180 #  QT_LIBRARY_DIR              Path to "lib" of Qt4
 181 #
 182 #  QT_PLUGINS_DIR              Path to "plugins" for Qt4
 183 #
 184 # For every library of Qt, a QT_QTFOO_LIBRARY variable is defined, with the full path to the library.
 185 #
 186 # So there are the following variables:
 187 # The Qt3Support library:     QT_QT3SUPPORT_LIBRARY
 188 #
 189 # The QtAssistant library:    QT_QTASSISTANT_LIBRARY
 190 #
 191 # The QtCore library:         QT_QTCORE_LIBRARY
 192 #
 193 # The QtDBus library:         QT_QTDBUS_LIBRARY
 194 #
 195 # The QtDesigner library:     QT_QTDESIGNER_LIBRARY
 196 #
 197 # The QtDesignerComponents library:     QT_QTDESIGNERCOMPONENTS_LIBRARY
 198 #
 199 # The QtGui library:          QT_QTGUI_LIBRARY
 200 #
 201 # The QtMotif library:        QT_QTMOTIF_LIBRARY
 202 #
 203 # The QtNetwork library:      QT_QTNETWORK_LIBRARY
 204 #
 205 # The QtNsPLugin library:     QT_QTNSPLUGIN_LIBRARY
 206 #
 207 # The QtOpenGL library:       QT_QTOPENGL_LIBRARY
 208 #
 209 # The QtSql library:          QT_QTSQL_LIBRARY
 210 #
 211 # The QtXml library:          QT_QTXML_LIBRARY
 212 #
 213 # The QtSvg library:          QT_QTSVG_LIBRARY
 214 #
 215 # The QtScript library:       QT_QTSCRIPT_LIBRARY
 216 #
 217 # The QtTest library:         QT_QTTEST_LIBRARY
 218 #
 219 # The qtmain library for Windows QT_QTMAIN_LIBRARY
 220 #
 221 # The QtUiTools library:      QT_QTUITOOLS_LIBRARY
 222
 223 #
 224 # The QtAssistantClient library:  QT_QTASSISTANTCLIENT_LIBRARY
 225 #
 226 # The QtHelp library:             QT_QTHELP_LIBRARY
 227 #
 228 # The QtWebKit library:           QT_QTWEBKIT_LIBRARY
 229 #
 230 # The QtXmlPatterns library:      QT_QTXMLPATTERNS_LIBRARY
 231 #
 232 # The Phonon library:             QT_PHONON_LIBRARY
 233
 234
 235
 236 #
 237 # also defined, but NOT for general use are
 238 #  QT_MOC_EXECUTABLE          Where to find the moc tool.
 239 #  QT_UIC_EXECUTABLE          Where to find the uic tool.
 240 #  QT_UIC3_EXECUTABLE         Where to find the uic3 tool.
 241 #  QT_RCC_EXECUTABLE          Where to find the rcc tool
 242 #  QT_DBUSCPP2XML_EXECUTABLE  Where to find the qdbuscpp2xml tool.
 243 #  QT_DBUSXML2CPP_EXECUTABLE  Where to find the qdbusxml2cpp tool.
 244 #  QT_LUPDATE_EXECUTABLE      Where to find the lupdate tool.
 245 #  QT_LRELEASE_EXECUTABLE     Where to find the lrelease tool.
 246 #
 247 #  QT_DOC_DIR                 Path to "doc" of Qt4
 248 #  QT_MKSPECS_DIR             Path to "mkspecs" of Qt4
 249 #  QT_TRANSLATIONS_DIR        Path to "translations" of Qt4
 250 #
 251 #
 252 # These are around for backwards compatibility
 253 # they will be set
 254 #  QT_WRAP_CPP  Set true if QT_MOC_EXECUTABLE is found
 255 #  QT_WRAP_UI   Set true if QT_UIC_EXECUTABLE is found
 256 #
 257 # These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)
 258 #  QT_MT_REQUIRED         Qt4 is now always multithreaded
 259 #
 260 # These variables are set to "" Because Qt structure changed
 261 # (They make no sense in Qt4)
 262 #  QT_QT_LIBRARY        Qt-Library is now split
 263
 264 # Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
 265 # See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 266
 267 if (QT4_QMAKE_FOUND)
 268    # Check already done in this cmake run, nothing more to do
 269
 270 else (QT4_QMAKE_FOUND)
 271
 272 # check that QT_NO_DEBUG is defined for release configurations
 273 MACRO(QT_CHECK_FLAG_EXISTS FLAG VAR DOC)
 274   IF(NOT ${VAR} MATCHES "${FLAG}")
 275     SET(${VAR} "${${VAR}} ${FLAG}"
 276       CACHE STRING "Flags used by the compiler during ${DOC} builds." FORCE)
 277   ENDIF(NOT ${VAR} MATCHES "${FLAG}")
 278 ENDMACRO(QT_CHECK_FLAG_EXISTS FLAG VAR)
 279 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO "Release with Debug Info")
 280 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELEASE "release")
 281 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL "release minsize")
 282
 283 INCLUDE(CheckSymbolExists)
 284 INCLUDE(MacroAddFileDependencies)
 285 INCLUDE(MacroPushRequiredVars)
 286
 287 SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
 288
 289 SET( QT_DEFINITIONS "")
 290
 291 IF (WIN32 AND NOT STATIC)
 292   SET(QT_DEFINITIONS -DQT_DLL)
 293 ENDIF(WIN32 AND NOT STATIC)
 294
 295 SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)
 296
 297 #  macro for asking qmake to process pro files
 298 MACRO(QT_QUERY_QMAKE outvar invar)
 299   FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro
 300     "message(CMAKE_MESSAGE<$$${invar}>)")
 301
 302   # Invoke qmake with the tmp.pro program to get the desired
 303   # information.  Use the same variable for both stdout and stderr
 304   # to make sure we get the output on all platforms.
 305   EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}
 306     WORKING_DIRECTORY
 307     ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake
 308     OUTPUT_VARIABLE _qmake_query_output
 309     RESULT_VARIABLE _qmake_result
 310     ERROR_VARIABLE _qmake_query_output )
 311
 312   FILE(REMOVE_RECURSE
 313     "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake")
 314
 315   IF(_qmake_result)
 316     MESSAGE(WARNING " querying qmake for ${invar}.  qmake reported:\n${_qmake_query_output}")
 317   ELSE(_qmake_result)
 318     STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}")
 319   ENDIF(_qmake_result)
 320
 321 ENDMACRO(QT_QUERY_QMAKE)
 322
 323 GET_FILENAME_COMPONENT(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME)
 324 # check for qmake
 325 FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 PATHS
 326   "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
 327   "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
 328   "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]/bin"
 329   $ENV{QTDIR}/bin
 330 )
 331
 332 IF (QT_QMAKE_EXECUTABLE)
 333
 334   SET(QT4_QMAKE_FOUND FALSE)
 335
 336   EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
 337
 338   # check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
 339   IF("${QTVERSION}" MATCHES "Unknown")
 340     SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
 341     FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS
 342       "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
 343       "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
 344       $ENV{QTDIR}/bin
 345       )
 346     IF(QT_QMAKE_EXECUTABLE)
 347       EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
 348         ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
 349     ENDIF(QT_QMAKE_EXECUTABLE)
 350   ENDIF("${QTVERSION}" MATCHES "Unknown")
 351
 352   # check that we found the Qt4 qmake, Qt3 qmake output won't match here
 353   STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")
 354   IF (qt_version_tmp)
 355
 356     # we need at least version 4.0.0
 357     IF (NOT QT_MIN_VERSION)
 358       SET(QT_MIN_VERSION "4.0.0")
 359     ENDIF (NOT QT_MIN_VERSION)
 360
 361     #now parse the parts of the user given version string into variables
 362     STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}")
 363     IF (NOT req_qt_major_vers)
 364       MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"")
 365     ENDIF (NOT req_qt_major_vers)
 366
 367     # now parse the parts of the user given version string into variables
 368     STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}")
 369     STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}")
 370     STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}")
 371
 372     IF (NOT req_qt_major_vers EQUAL 4)
 373       MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")
 374     ENDIF (NOT req_qt_major_vers EQUAL 4)
 375
 376     # and now the version string given by qmake
 377     STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" found_qt_major_vers "${QTVERSION}")
 378     STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" found_qt_minor_vers "${QTVERSION}")
 379     STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" found_qt_patch_vers "${QTVERSION}")
 380
 381     # compute an overall version number which can be compared at once
 382     MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")
 383     MATH(EXPR found_vers "${found_qt_major_vers}*10000 + ${found_qt_minor_vers}*100 + ${found_qt_patch_vers}")
 384
 385     IF (found_vers LESS req_vers)
 386       SET(QT4_QMAKE_FOUND FALSE)
 387       SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
 388     ELSE (found_vers LESS req_vers)
 389       SET(QT4_QMAKE_FOUND TRUE)
 390     ENDIF (found_vers LESS req_vers)
 391   ENDIF (qt_version_tmp)
 392
 393 ENDIF (QT_QMAKE_EXECUTABLE)
 394
 395 IF (QT4_QMAKE_FOUND)
 396
 397   if (WIN32)
 398     # get qt install dir
 399     get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )
 400     get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )
 401   endif (WIN32)
 402
 403   # ask qmake for the library dir
 404   # Set QT_LIBRARY_DIR
 405   IF (NOT QT_LIBRARY_DIR)
 406     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 407       ARGS "-query QT_INSTALL_LIBS"
 408       OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP )
 409     # make sure we have / and not \ as qmake gives on windows
 410     FILE(TO_CMAKE_PATH "${QT_LIBRARY_DIR_TMP}" QT_LIBRARY_DIR_TMP)
 411     IF(EXISTS "${QT_LIBRARY_DIR_TMP}")
 412       SET(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir")
 413     ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}")
 414       MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT_LIBRARY_DIR_TMP}")
 415       MESSAGE("Warning: ${QT_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.")
 416     ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}")
 417   ENDIF(NOT QT_LIBRARY_DIR)
 418
 419   IF (APPLE)
 420     IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 421       SET(QT_USE_FRAMEWORKS ON
 422         CACHE BOOL "Set to ON if Qt build uses frameworks.")
 423     ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 424       SET(QT_USE_FRAMEWORKS OFF
 425         CACHE BOOL "Set to ON if Qt build uses frameworks.")
 426     ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 427
 428     MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)
 429   ENDIF (APPLE)
 430
 431   # ask qmake for the binary dir
 432   IF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR)
 433      EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
 434        ARGS "-query QT_INSTALL_BINS"
 435        OUTPUT_VARIABLE qt_bins )
 436      # make sure we have / and not \ as qmake gives on windows
 437      FILE(TO_CMAKE_PATH "${qt_bins}" qt_bins)
 438      SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "")
 439   ENDIF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR)
 440
 441   # ask qmake for the include dir
 442   IF (QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR)
 443       EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 444         ARGS "-query QT_INSTALL_HEADERS"
 445         OUTPUT_VARIABLE qt_headers )
 446       # make sure we have / and not \ as qmake gives on windows
 447       FILE(TO_CMAKE_PATH "${qt_headers}" qt_headers)
 448       SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "")
 449   ENDIF(QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR)
 450
 451
 452   # ask qmake for the documentation directory
 453   IF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR)
 454     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 455       ARGS "-query QT_INSTALL_DOCS"
 456       OUTPUT_VARIABLE qt_doc_dir )
 457     # make sure we have / and not \ as qmake gives on windows
 458     FILE(TO_CMAKE_PATH "${qt_doc_dir}" qt_doc_dir)
 459     SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs")
 460   ENDIF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR)
 461
 462   # ask qmake for the mkspecs directory
 463   IF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR)
 464     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 465       ARGS "-query QMAKE_MKSPECS"
 466       OUTPUT_VARIABLE qt_mkspecs_dirs )
 467     # do not replace : on windows as it might be a drive letter
 468     # and windows should already use ; as a separator
 469     IF(UNIX)
 470       STRING(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}")
 471     ENDIF(UNIX)
 472     FIND_PATH(QT_MKSPECS_DIR qconfig.pri PATHS ${qt_mkspecs_dirs}
 473       DOC "The location of the Qt mkspecs containing qconfig.pri"
 474       NO_DEFAULT_PATH )
 475   ENDIF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR)
 476
 477   # ask qmake for the plugins directory
 478   IF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR)
 479     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 480       ARGS "-query QT_INSTALL_PLUGINS"
 481       OUTPUT_VARIABLE qt_plugins_dir )
 482     # make sure we have / and not \ as qmake gives on windows
 483     FILE(TO_CMAKE_PATH "${qt_plugins_dir}" qt_plugins_dir)
 484     SET(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins")
 485   ENDIF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR)
 486
 487   # ask qmake for the translations directory
 488   IF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR)
 489     EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
 490       ARGS "-query QT_INSTALL_TRANSLATIONS"
 491       OUTPUT_VARIABLE qt_translations_dir )
 492     # make sure we have / and not \ as qmake gives on windows
 493     FILE(TO_CMAKE_PATH "${qt_translations_dir}" qt_translations_dir)
 494     SET(QT_TRANSLATIONS_DIR ${qt_translations_dir} CACHE PATH "The location of the Qt translations")
 495   ENDIF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR)
 496
 497   ########################################
 498   #
 499   #       Setting the INCLUDE-Variables
 500   #
 501   ########################################
 502
 503   FIND_PATH(QT_QTCORE_INCLUDE_DIR QtGlobal
 504     ${QT_HEADERS_DIR}/QtCore
 505     ${QT_LIBRARY_DIR}/QtCore.framework/Headers
 506     NO_DEFAULT_PATH
 507     )
 508
 509   # Set QT_INCLUDE_DIR by removine "/QtCore" in the string ${QT_QTCORE_INCLUDE_DIR}
 510   IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
 511     IF (QT_USE_FRAMEWORKS)
 512       SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR})
 513     ELSE (QT_USE_FRAMEWORKS)
 514       STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT_QTCORE_INCLUDE_DIR})
 515       SET( QT_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "")
 516     ENDIF (QT_USE_FRAMEWORKS)
 517   ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
 518
 519   IF( NOT QT_INCLUDE_DIR)
 520     IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
 521       MESSAGE( FATAL_ERROR "Could NOT find QtGlobal header")
 522     ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
 523   ENDIF( NOT QT_INCLUDE_DIR)
 524
 525   #############################################
 526   #
 527   # Find out what window system we're using
 528   #
 529   #############################################
 530   # Save required includes and required_flags variables
 531   macro_push_required_vars()
 532   # Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES
 533   SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_INCLUDE_DIR}")
 534   # On Mac OS X when Qt has framework support, also add the framework path
 535   IF( QT_USE_FRAMEWORKS )
 536     SET(CMAKE_REQUIRED_FLAGS "-F${QT_LIBRARY_DIR} ")
 537   ENDIF( QT_USE_FRAMEWORKS )
 538   # Check for Window system symbols (note: only one should end up being set)
 539   CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)
 540   CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)
 541   CHECK_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)
 542   CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)
 543
 544   IF (QT_QTCOPY_REQUIRED)
 545      CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)
 546      IF (NOT QT_IS_QTCOPY)
 547         MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found")
 548      ENDIF (NOT QT_IS_QTCOPY)
 549   ENDIF (QT_QTCOPY_REQUIRED)
 550
 551   # Restore CMAKE_REQUIRED_INCLUDES+CMAKE_REQUIRED_FLAGS variables
 552   macro_pop_required_vars()
 553   #
 554   #############################################
 555
 556   IF (QT_USE_FRAMEWORKS)
 557     SET(QT_DEFINITIONS ${QT_DEFINITIONS} -F${QT_LIBRARY_DIR} -L${QT_LIBRARY_DIR} )
 558   ENDIF (QT_USE_FRAMEWORKS)
 559
 560   # Set QT_QT3SUPPORT_INCLUDE_DIR
 561   FIND_PATH(QT_QT3SUPPORT_INCLUDE_DIR Qt3Support
 562     PATHS
 563     ${QT_INCLUDE_DIR}/Qt3Support
 564     ${QT_LIBRARY_DIR}/Qt3Support.framework/Headers
 565     NO_DEFAULT_PATH
 566     )
 567
 568   # Set QT_QT_INCLUDE_DIR
 569   FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h
 570     PATHS
 571     ${QT_INCLUDE_DIR}/Qt
 572     ${QT_LIBRARY_DIR}/QtCore.framework/Headers
 573     NO_DEFAULT_PATH
 574     )
 575
 576   # Set QT_QTGUI_INCLUDE_DIR
 577   FIND_PATH(QT_QTGUI_INCLUDE_DIR QtGui
 578     PATHS
 579     ${QT_INCLUDE_DIR}/QtGui
 580     ${QT_LIBRARY_DIR}/QtGui.framework/Headers
 581     NO_DEFAULT_PATH
 582     )
 583
 584   # Set QT_QTSVG_INCLUDE_DIR
 585   FIND_PATH(QT_QTSVG_INCLUDE_DIR QtSvg
 586     PATHS
 587     ${QT_INCLUDE_DIR}/QtSvg
 588     ${QT_LIBRARY_DIR}/QtSvg.framework/Headers
 589     NO_DEFAULT_PATH
 590     )
 591
 592   # Set QT_QTSCRIPT_INCLUDE_DIR
 593   FIND_PATH(QT_QTSCRIPT_INCLUDE_DIR QtScript
 594     PATHS
 595     ${QT_INCLUDE_DIR}/QtScript
 596     ${QT_LIBRARY_DIR}/QtScript.framework/Headers
 597     NO_DEFAULT_PATH
 598     )
 599
 600   # Set QT_QTTEST_INCLUDE_DIR
 601   FIND_PATH(QT_QTTEST_INCLUDE_DIR QtTest
 602     PATHS
 603     ${QT_INCLUDE_DIR}/QtTest
 604     ${QT_LIBRARY_DIR}/QtTest.framework/Headers
 605     NO_DEFAULT_PATH
 606     )
 607
 608   # Set QT_QTUITOOLS_INCLUDE_DIR
 609   FIND_PATH(QT_QTUITOOLS_INCLUDE_DIR QtUiTools
 610     PATHS
 611     ${QT_INCLUDE_DIR}/QtUiTools
 612     ${QT_LIBRARY_DIR}/QtUiTools.framework/Headers
 613     NO_DEFAULT_PATH
 614     )
 615
 616   # Set QT_QTMOTIF_INCLUDE_DIR
 617   IF(Q_WS_X11)
 618     FIND_PATH(QT_QTMOTIF_INCLUDE_DIR QtMotif
 619       PATHS
 620       ${QT_INCLUDE_DIR}/QtMotif
 621       NO_DEFAULT_PATH )
 622   ENDIF(Q_WS_X11)
 623
 624   # Set QT_QTNETWORK_INCLUDE_DIR
 625   FIND_PATH(QT_QTNETWORK_INCLUDE_DIR QtNetwork
 626     PATHS
 627     ${QT_INCLUDE_DIR}/QtNetwork
 628     ${QT_LIBRARY_DIR}/QtNetwork.framework/Headers
 629     NO_DEFAULT_PATH
 630     )
 631
 632   # Set QT_QTNSPLUGIN_INCLUDE_DIR
 633   FIND_PATH(QT_QTNSPLUGIN_INCLUDE_DIR QtNsPlugin
 634     PATHS
 635     ${QT_INCLUDE_DIR}/QtNsPlugin
 636     ${QT_LIBRARY_DIR}/QtNsPlugin.framework/Headers
 637     NO_DEFAULT_PATH
 638     )
 639
 640   # Set QT_QTOPENGL_INCLUDE_DIR
 641   FIND_PATH(QT_QTOPENGL_INCLUDE_DIR QtOpenGL
 642     PATHS
 643     ${QT_INCLUDE_DIR}/QtOpenGL
 644     ${QT_LIBRARY_DIR}/QtOpenGL.framework/Headers
 645     NO_DEFAULT_PATH
 646     )
 647
 648   # Set QT_QTSQL_INCLUDE_DIR
 649   FIND_PATH(QT_QTSQL_INCLUDE_DIR QtSql
 650     PATHS
 651     ${QT_INCLUDE_DIR}/QtSql
 652     ${QT_LIBRARY_DIR}/QtSql.framework/Headers
 653     NO_DEFAULT_PATH
 654     )
 655
 656   # Set QT_QTXML_INCLUDE_DIR
 657   FIND_PATH(QT_QTXML_INCLUDE_DIR QtXml
 658     PATHS
 659     ${QT_INCLUDE_DIR}/QtXml
 660     ${QT_LIBRARY_DIR}/QtXml.framework/Headers
 661     NO_DEFAULT_PATH
 662     )
 663
 664   # Set QT_QTASSISTANT_INCLUDE_DIR
 665   FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant
 666     PATHS
 667     ${QT_INCLUDE_DIR}/QtAssistant
 668     ${QT_HEADERS_DIR}/QtAssistant
 669     ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
 670     NO_DEFAULT_PATH
 671     )
 672
 673   # Set QT_QTDESIGNER_INCLUDE_DIR
 674   FIND_PATH(QT_QTDESIGNER_INCLUDE_DIR QDesignerComponents
 675     PATHS
 676     ${QT_INCLUDE_DIR}/QtDesigner
 677     ${QT_HEADERS_DIR}/QtDesigner
 678     ${QT_LIBRARY_DIR}/QtDesigner.framework/Headers
 679     NO_DEFAULT_PATH
 680     )
 681
 682   # Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR
 683   FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents
 684     PATHS
 685     ${QT_INCLUDE_DIR}/QtDesigner
 686     ${QT_HEADERS_DIR}/QtDesigner
 687     NO_DEFAULT_PATH
 688     )
 689
 690   # Set QT_QTDBUS_INCLUDE_DIR
 691   FIND_PATH(QT_QTDBUS_INCLUDE_DIR QtDBus
 692     PATHS
 693     ${QT_INCLUDE_DIR}/QtDBus
 694     ${QT_HEADERS_DIR}/QtDBus
 695     ${QT_LIBRARY_DIR}/QtDBus.framework/Headers
 696     NO_DEFAULT_PATH
 697     )
 698
 699   # Set QT_QTASSISTANTCLIENT_INCLUDE_DIR
 700   FIND_PATH(QT_QTASSISTANTCLIENT_INCLUDE_DIR QAssistantClient
 701     PATHS
 702     ${QT_INCLUDE_DIR}/QtAssistant
 703     ${QT_HEADERS_DIR}/QtAssistant
 704     NO_DEFAULT_PATH
 705     )
 706
 707   # Set QT_QTHELP_INCLUDE_DIR
 708   FIND_PATH(QT_QTHELP_INCLUDE_DIR QtHelp
 709     PATHS
 710     ${QT_INCLUDE_DIR}/QtHelp
 711     ${QT_HEADERS_DIR}/QtHelp
 712     NO_DEFAULT_PATH
 713     )
 714
 715   # Set QT_QTWEBKIT_INCLUDE_DIR
 716   FIND_PATH(QT_QTWEBKIT_INCLUDE_DIR QtWebKit
 717     PATHS
 718     ${QT_INCLUDE_DIR}/QtWebKit
 719     ${QT_HEADERS_DIR}/QtWebKit
 720     NO_DEFAULT_PATH
 721     )
 722
 723   # Set QT_QTXMLPATTERNS_INCLUDE_DIR
 724   FIND_PATH(QT_QTXMLPATTERNS_INCLUDE_DIR QtXmlPatterns
 725     PATHS
 726     ${QT_INCLUDE_DIR}/QtXmlPatterns
 727     ${QT_HEADERS_DIR}/QtXmlPatterns
 728     NO_DEFAULT_PATH
 729     )
 730
 731   # Set QT_PHONON_INCLUDE_DIR
 732   FIND_PATH(QT_PHONON_INCLUDE_DIR phonon
 733     PATHS
 734     ${QT_INCLUDE_DIR}/phonon
 735     NO_DEFAULT_PATH
 736     )
 737
 738   # Make variables changeble to the advanced user
 739   MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_INCLUDE_DIR QT_QT_INCLUDE_DIR QT_DOC_DIR QT_MKSPECS_DIR QT_PLUGINS_DIR)
 740
 741   # Set QT_INCLUDES
 742   SET( QT_INCLUDES ${QT_QT_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ${QT_INCLUDE_DIR} )
 743
 744   ########################################
 745   #
 746   #       Setting the LIBRARY-Variables
 747   #
 748   ########################################
 749
 750   IF (QT_USE_FRAMEWORKS)
 751     # If FIND_LIBRARY found libraries in Apple frameworks, we would NOT have
 752     # to jump through these hoops.
 753     IF(EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 754       SET(QT_QTCORE_FOUND TRUE)
 755       SET(QT_QTCORE_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtCore" CACHE STRING "The QtCore library.")
 756     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 757       SET(QT_QTCORE_FOUND FALSE)
 758     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
 759
 760     IF(EXISTS ${QT_LIBRARY_DIR}/QtGui.framework)
 761       SET(QT_QTGUI_FOUND TRUE)
 762       SET(QT_QTGUI_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtGui" CACHE STRING "The QtGui library.")
 763     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtGui.framework)
 764       SET(QT_QTGUI_FOUND FALSE)
 765     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtGui.framework)
 766
 767     IF(EXISTS ${QT_LIBRARY_DIR}/Qt3Support.framework)
 768       SET(QT_QT3SUPPORT_FOUND TRUE)
 769       SET(QT_QT3SUPPORT_LIBRARY "-F${QT_LIBRARY_DIR} -framework Qt3Support" CACHE STRING "The Qt3Support library.")
 770     ELSE(EXISTS ${QT_LIBRARY_DIR}/Qt3Support.framework)
 771       SET(QT_QT3SUPPORT_FOUND FALSE)
 772     ENDIF(EXISTS ${QT_LIBRARY_DIR}/Qt3Support.framework)
 773
 774     IF(EXISTS ${QT_LIBRARY_DIR}/QtNetwork.framework)
 775       SET(QT_QTNETWORK_FOUND TRUE)
 776       SET(QT_QTNETWORK_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtNetwork" CACHE STRING "The QtNetwork library.")
 777     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtNetwork.framework)
 778       SET(QT_QTNETWORK_FOUND FALSE)
 779     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtNetwork.framework)
 780
 781     IF(EXISTS ${QT_LIBRARY_DIR}/QtOpenGL.framework)
 782       SET(QT_QTOPENGL_FOUND TRUE)
 783       SET(QT_QTOPENGL_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtOpenGL" CACHE STRING "The QtOpenGL library.")
 784     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtOpenGL.framework)
 785       SET(QT_QTOPENGL_FOUND FALSE)
 786     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtOpenGL.framework)
 787
 788     IF(EXISTS ${QT_LIBRARY_DIR}/QtSql.framework)
 789       SET(QT_QTSQL_FOUND TRUE)
 790       SET(QT_QTSQL_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtSql" CACHE STRING "The QtSql library.")
 791     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtSql.framework)
 792       SET(QT_QTSQL_FOUND FALSE)
 793     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtSql.framework)
 794
 795     IF(EXISTS ${QT_LIBRARY_DIR}/QtXml.framework)
 796       SET(QT_QTXML_FOUND TRUE)
 797       SET(QT_QTXML_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtXml" CACHE STRING "The QtXml library.")
 798     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtXml.framework)
 799       SET(QT_QTXML_FOUND FALSE)
 800     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtXml.framework)
 801
 802     IF(EXISTS ${QT_LIBRARY_DIR}/QtSvg.framework)
 803       SET(QT_QTSVG_FOUND TRUE)
 804       SET(QT_QTSVG_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtSvg" CACHE STRING "The QtSvg library.")
 805     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtSvg.framework)
 806       SET(QT_QTSVG_FOUND FALSE)
 807     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtSvg.framework)
 808
 809     IF(EXISTS ${QT_LIBRARY_DIR}/QtDBus.framework)
 810       SET(QT_QTDBUS_FOUND TRUE)
 811       SET(QT_QTDBUS_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtDBus" CACHE STRING "The QtDBus library.")
 812     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtDBus.framework)
 813       SET(QT_QTDBUS_FOUND FALSE)
 814     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtDBus.framework)
 815
 816     IF(EXISTS ${QT_LIBRARY_DIR}/QtTest.framework)
 817       SET(QT_QTTEST_FOUND TRUE)
 818       SET(QT_QTTEST_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtTest" CACHE STRING "The QtTest library.")
 819     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtTest.framework)
 820       SET(QT_QTTEST_FOUND FALSE)
 821     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtTest.framework)
 822
 823     IF(EXISTS ${QT_LIBRARY_DIR}/QtAssistantClient.framework)
 824       SET(QT_QTASSISTANTCLIENT_FOUND TRUE)
 825       SET(QT_QTASSISTANTCLIENT_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtAssistantClient" CACHE STRING "The QtAssistantClient library.")
 826     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtAssistantClient.framework)
 827       SET(QT_QTASSISTANTCLIENT_FOUND FALSE)
 828     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtAssistantClient.framework)
 829
 830     IF(EXISTS ${QT_LIBRARY_DIR}/QtWebKit.framework)
 831       SET(QT_QTWEBKIT_FOUND TRUE)
 832       SET(QT_QTWEBKIT_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtWebKit" CACHE STRING "The QtWebKit library.")
 833     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtWebKit.framework)
 834       SET(QT_QTWEBKIT_FOUND FALSE)
 835     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtWebKit.framework)
 836
 837     IF(EXISTS ${QT_LIBRARY_DIR}/QtXmlPatterns.framework)
 838       SET(QT_QTXMLPATTERNS_FOUND TRUE)
 839       SET(QT_QTXMLPATTERNS_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtXmlPatterns" CACHE STRING "The QtXmlPatterns library.")
 840     ELSE(EXISTS ${QT_LIBRARY_DIR}/QtXmlPatterns.framework)
 841       SET(QT_QTXMLPATTERNS_FOUND FALSE)
 842     ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtXmlPatterns.framework)
 843
 844
 845     # WTF?  why don't we have frameworks?  :P
 846     # Set QT_QTUITOOLS_LIBRARY
 847     FIND_LIBRARY(QT_QTUITOOLS_LIBRARY NAMES QtUiTools QtUiTools4 PATHS ${QT_LIBRARY_DIR} )
 848     # Set QT_QTSCRIPT_LIBRARY
 849     FIND_LIBRARY(QT_QTSCRIPT_LIBRARY NAMES QtScript QtScript4    PATHS ${QT_LIBRARY_DIR} )
 850
 851   ELSE (QT_USE_FRAMEWORKS)
 852
 853     # Set QT_QTCORE_LIBRARY by searching for a lib with "QtCore."  as part of the filename
 854     FIND_LIBRARY(QT_QTCORE_LIBRARY NAMES QtCore QtCore4 QtCored4 QtCore_debug         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH )
 855
 856     # Set QT_QT3SUPPORT_LIBRARY
 857     FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY NAMES Qt3Support Qt3Support_debug Qt3Support4 Qt3Supportd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 858
 859     # Set QT_QTGUI_LIBRARY
 860     FIND_LIBRARY(QT_QTGUI_LIBRARY NAMES QtGui QtGui_debug QtGui_debug QtGui4 QtGuid4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 861
 862     # Set QT_QTMOTIF_LIBRARY
 863     IF(Q_WS_X11)
 864       FIND_LIBRARY(QT_QTMOTIF_LIBRARY NAMES QtMotif  QtMotif_debug PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 865     ENDIF(Q_WS_X11)
 866
 867     # Set QT_QTNETWORK_LIBRARY
 868     FIND_LIBRARY(QT_QTNETWORK_LIBRARY NAMES QtNetwork QtNetwork_debug QtNetwork4 QtNetworkd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 869
 870     # Set QT_QTNSPLUGIN_LIBRARY
 871     FIND_LIBRARY(QT_QTNSPLUGIN_LIBRARY NAMES QtNsPlugin QtNsPlugin_debug PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 872
 873     # Set QT_QTOPENGL_LIBRARY
 874     FIND_LIBRARY(QT_QTOPENGL_LIBRARY NAMES QtOpenGL QtOpenGL_debug QtOpenGL4 QtOpenGLd4    PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 875
 876     # Set QT_QTSQL_LIBRARY
 877     FIND_LIBRARY(QT_QTSQL_LIBRARY NAMES QtSql QtSql_debug QtSql4 QtSqld4       PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 878
 879     # Set QT_QTXML_LIBRARY
 880     FIND_LIBRARY(QT_QTXML_LIBRARY NAMES QtXml QtXml_debug QtXml4 QtXmld4       PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 881
 882     # Set QT_QTSVG_LIBRARY
 883     FIND_LIBRARY(QT_QTSVG_LIBRARY NAMES QtSvg QtSvg_debug QtSvg4 QtSvgd4       PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 884
 885     # Set QT_QTSCRIPT_LIBRARY
 886     FIND_LIBRARY(QT_QTSCRIPT_LIBRARY NAMES QtScript QtScript_debug QtScript4 QtScriptd4   PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 887
 888     # Set QT_QTUITOOLS_LIBRARY
 889     FIND_LIBRARY(QT_QTUITOOLS_LIBRARY NAMES QtUiTools QtUiTools_debug QtUiTools4 QtUiToolsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 890
 891     # Set QT_QTTEST_LIBRARY
 892     FIND_LIBRARY(QT_QTTEST_LIBRARY NAMES QtTest QtTest_debug QtTest4 QtTestd4          PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 893
 894     FIND_LIBRARY(QT_QTDBUS_LIBRARY NAMES QtDBus QtDBus_debug QtDBus4 QtDBusd4         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 895
 896     FIND_LIBRARY(QT_QTASSISTANTCLIENT_LIBRARY NAMES QtAssistantClient QtAssistantClient_debug QtAssistantClient4 QtAssistantClientd4         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 897
 898     FIND_LIBRARY(QT_QTHELP_LIBRARY NAMES QtHelp QtHelp_debug QtHelp4 QtHelpd4         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 899
 900     FIND_LIBRARY(QT_QTWEBKIT_LIBRARY NAMES QtWebKit QtWebKit_debug QtWebKit4 QtWebKitd4         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 901
 902     FIND_LIBRARY(QT_QTXMLPATTERNS_LIBRARY NAMES QtXmlPatterns QtXmlPatterns_debug QtXmlPatterns4 QtXmlPatternsd4         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 903
 904     FIND_LIBRARY(QT_PHONON_LIBRARY NAMES phonon phonon4 phonon_debug phonond4    PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 905
 906
 907     IF(MSVC)
 908       FIND_LIBRARY(QT_QTCORE_LIBRARY_RELEASE    NAMES QtCore4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 909       FIND_LIBRARY(QT_QTCORE_LIBRARY_DEBUG      NAMES QtCored4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 910       FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY_RELEASE NAMES Qt3Support4        PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 911       FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY_DEBUG  NAMES Qt3Supportd4        PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 912       FIND_LIBRARY(QT_QTGUI_LIBRARY_RELEASE     NAMES QtGui4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 913       FIND_LIBRARY(QT_QTGUI_LIBRARY_DEBUG       NAMES QtGuid4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 914       FIND_LIBRARY(QT_QTNETWORK_LIBRARY_RELEASE NAMES QtNetwork4         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 915       FIND_LIBRARY(QT_QTNETWORK_LIBRARY_DEBUG   NAMES QtNetworkd4         PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 916       FIND_LIBRARY(QT_QTOPENGL_LIBRARY_RELEASE  NAMES QtOpenGL4          PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 917       FIND_LIBRARY(QT_QTOPENGL_LIBRARY_DEBUG    NAMES QtOpenGLd4          PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 918       FIND_LIBRARY(QT_QTSQL_LIBRARY_RELEASE     NAMES QtSql4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 919       FIND_LIBRARY(QT_QTSQL_LIBRARY_DEBUG       NAMES QtSqld4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 920       FIND_LIBRARY(QT_QTXML_LIBRARY_RELEASE     NAMES QtXml4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 921       FIND_LIBRARY(QT_QTXML_LIBRARY_DEBUG       NAMES QtXmld4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 922       FIND_LIBRARY(QT_QTSVG_LIBRARY_RELEASE     NAMES QtSvg4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 923       FIND_LIBRARY(QT_QTSVG_LIBRARY_DEBUG       NAMES QtSvgd4             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 924       FIND_LIBRARY(QT_QTSCRIPT_LIBRARY_RELEASE  NAMES QtScript4          PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 925       FIND_LIBRARY(QT_QTSCRIPT_LIBRARY_DEBUG    NAMES QtScriptd4          PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 926       FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools QtUiTools4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 927       FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_DEBUG   NAMES QtUiToolsd QtUiToolsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 928       FIND_LIBRARY(QT_QTTEST_LIBRARY_RELEASE    NAMES QtTest4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 929       FIND_LIBRARY(QT_QTTEST_LIBRARY_DEBUG      NAMES QtTestd4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 930       FIND_LIBRARY(QT_QTDBUS_LIBRARY_RELEASE    NAMES QtDBus4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 931       FIND_LIBRARY(QT_QTDBUS_LIBRARY_DEBUG      NAMES QtDBusd4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 932       FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_RELEASE NAMES QtAssistantClient4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 933       FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_DEBUG NAMES QtAssistantClientd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 934       FIND_LIBRARY(QT_QTDESIGNER_LIBRARY_RELEASE NAMES QtDesigner4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 935       FIND_LIBRARY(QT_QTDESIGNER_LIBRARY_DEBUG  NAMES QtDesignerd4            PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 936       FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 937       FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NAMES QtDesignerComponentsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 938       FIND_LIBRARY(QT_QTMAIN_LIBRARY_RELEASE    NAMES qtmain             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 939       FIND_LIBRARY(QT_QTMAIN_LIBRARY_DEBUG      NAMES qtmaind             PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 940     ENDIF(MSVC)
 941   ENDIF (QT_USE_FRAMEWORKS)
 942
 943   IF( NOT QT_QTCORE_LIBRARY )
 944     IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
 945       MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
 946     ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
 947   ENDIF( NOT QT_QTCORE_LIBRARY )
 948
 949   # Set QT_QTASSISTANT_LIBRARY
 950   FIND_LIBRARY(QT_QTASSISTANT_LIBRARY NAMES QtAssistantClient QtAssistantClient4 QtAssistant QtAssistant4 QtAssistantd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 951
 952   # Set QT_QTDESIGNER_LIBRARY
 953   FIND_LIBRARY(QT_QTDESIGNER_LIBRARY NAMES QtDesigner QtDesigner_debug QtDesigner4 QtDesignerd4 PATHS ${QT_LIBRARY_DIR}        NO_DEFAULT_PATH)
 954
 955   # Set QT_QTDESIGNERCOMPONENTS_LIBRARY
 956   FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY NAMES QtDesignerComponents QtDesignerComponents_debug QtDesignerComponents4 QtDesignerComponentsd4 PATHS ${QT_LIBRARY_DIR}        NO_DEFAULT_PATH)
 957
 958   # Set QT_QTMAIN_LIBRARY
 959   IF(WIN32)
 960     FIND_LIBRARY(QT_QTMAIN_LIBRARY NAMES qtmain qtmaind PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
 961   ENDIF(WIN32)
 962
 963   ############################################
 964   #
 965   # Check the existence of the libraries.
 966   #
 967   ############################################
 968
 969   MACRO (_QT4_ADJUST_LIB_VARS basename)
 970     IF (QT_${basename}_LIBRARY OR QT_${basename}_LIBRARY_DEBUG)
 971
 972       IF(MSVC)
 973         # Both set
 974         IF (QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)
 975           SET(QT_${basename}_LIBRARY optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})
 976         ENDIF (QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)
 977
 978         # Only debug was found
 979         IF (NOT QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)
 980           SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_DEBUG})
 981         ENDIF (NOT QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)
 982
 983         # Only release was found
 984         IF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)
 985           SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE})
 986         ENDIF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)
 987
 988         # Hmm, is this used anywhere ? Yes, in UseQt4.cmake. We are currently incompatible :-(
 989         SET(QT_${basename}_LIBRARIES optimized ${QT_${basename}_LIBRARY} debug ${QT_${basename}_LIBRARY_DEBUG})
 990
 991       ENDIF(MSVC)
 992
 993       SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY} CACHE FILEPATH "The Qt ${basename} library")
 994
 995       IF (QT_${basename}_LIBRARY)
 996         SET(QT_${basename}_FOUND 1)
 997       ENDIF (QT_${basename}_LIBRARY)
 998
 999     ENDIF (QT_${basename}_LIBRARY OR QT_${basename}_LIBRARY_DEBUG)
1000
1001     IF (QT_${basename}_INCLUDE_DIR)
1002       #add the include directory to QT_INCLUDES
1003       SET(QT_INCLUDES "${QT_${basename}_INCLUDE_DIR}" ${QT_INCLUDES})
1004     ENDIF (QT_${basename}_INCLUDE_DIR)
1005
1006     # Make variables changeble to the advanced user
1007     MARK_AS_ADVANCED(QT_${basename}_LIBRARY QT_${basename}_INCLUDE_DIR)
1008   ENDMACRO (_QT4_ADJUST_LIB_VARS)
1009
1010
1011   # Set QT_xyz_LIBRARY variable and add
1012   # library include path to QT_INCLUDES
1013   _QT4_ADJUST_LIB_VARS(QTCORE)
1014   _QT4_ADJUST_LIB_VARS(QTGUI)
1015   _QT4_ADJUST_LIB_VARS(QT3SUPPORT)
1016   _QT4_ADJUST_LIB_VARS(QTASSISTANT)
1017   _QT4_ADJUST_LIB_VARS(QTDESIGNER)
1018   _QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS)
1019   _QT4_ADJUST_LIB_VARS(QTNETWORK)
1020   _QT4_ADJUST_LIB_VARS(QTNSPLUGIN)
1021   _QT4_ADJUST_LIB_VARS(QTOPENGL)
1022   _QT4_ADJUST_LIB_VARS(QTSQL)
1023   _QT4_ADJUST_LIB_VARS(QTXML)
1024   _QT4_ADJUST_LIB_VARS(QTSVG)
1025   _QT4_ADJUST_LIB_VARS(QTSCRIPT)
1026   _QT4_ADJUST_LIB_VARS(QTUITOOLS)
1027   _QT4_ADJUST_LIB_VARS(QTTEST)
1028   _QT4_ADJUST_LIB_VARS(QTDBUS)
1029   _QT4_ADJUST_LIB_VARS(QTASSISTANTCLIENT)
1030   _QT4_ADJUST_LIB_VARS(QTHELP)
1031   _QT4_ADJUST_LIB_VARS(QTWEBKIT)
1032   _QT4_ADJUST_LIB_VARS(QTXMLPATTERNS)
1033   _QT4_ADJUST_LIB_VARS(PHONON)
1034
1035   # platform dependent libraries
1036   IF(Q_WS_X11)
1037     _QT4_ADJUST_LIB_VARS(QTMOTIF)
1038   ENDIF(Q_WS_X11)
1039   IF(WIN32)
1040     _QT4_ADJUST_LIB_VARS(QTMAIN)
1041   ENDIF(WIN32)
1042
1043
1044   #######################################
1045   #
1046   #       Check the executables of Qt
1047   #          ( moc, uic, rcc )
1048   #
1049   #######################################
1050
1051
1052   # find moc and uic using qmake
1053   QT_QUERY_QMAKE(QT_MOC_EXECUTABLE_INTERNAL "QMAKE_MOC")
1054   QT_QUERY_QMAKE(QT_UIC_EXECUTABLE_INTERNAL "QMAKE_UIC")
1055
1056   # make sure we have / and not \ as qmake gives on windows
1057   FILE(TO_CMAKE_PATH
1058     "${QT_MOC_EXECUTABLE_INTERNAL}" QT_MOC_EXECUTABLE_INTERNAL)
1059   # make sure we have / and not \ as qmake gives on windows
1060   FILE(TO_CMAKE_PATH
1061     "${QT_UIC_EXECUTABLE_INTERNAL}" QT_UIC_EXECUTABLE_INTERNAL)
1062
1063   SET(QT_MOC_EXECUTABLE
1064     ${QT_MOC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The moc executable")
1065   SET(QT_UIC_EXECUTABLE
1066     ${QT_UIC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The uic executable")
1067
1068   FIND_PROGRAM(QT_UIC3_EXECUTABLE
1069     NAMES uic3
1070     PATHS ${QT_BINARY_DIR}
1071     NO_DEFAULT_PATH
1072     )
1073
1074   FIND_PROGRAM(QT_RCC_EXECUTABLE
1075     NAMES rcc
1076     PATHS ${QT_BINARY_DIR}
1077     NO_DEFAULT_PATH
1078     )
1079
1080   FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE
1081     NAMES qdbuscpp2xml
1082     PATHS ${QT_BINARY_DIR}
1083     NO_DEFAULT_PATH
1084     )
1085
1086   FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE
1087     NAMES qdbusxml2cpp
1088     PATHS ${QT_BINARY_DIR}
1089     NO_DEFAULT_PATH
1090     )
1091
1092   FIND_PROGRAM(QT_LUPDATE_EXECUTABLE
1093     NAMES lupdate-qt4 lupdate
1094     PATHS ${QT_BINARY_DIR}
1095     NO_DEFAULT_PATH
1096     )
1097
1098   FIND_PROGRAM(QT_LRELEASE_EXECUTABLE
1099     NAMES lrelease-qt4 lrelease
1100     PATHS ${QT_BINARY_DIR}
1101     NO_DEFAULT_PATH
1102     )
1103
1104   IF (QT_MOC_EXECUTABLE)
1105      SET(QT_WRAP_CPP "YES")
1106   ENDIF (QT_MOC_EXECUTABLE)
1107
1108   IF (QT_UIC_EXECUTABLE)
1109      SET(QT_WRAP_UI "YES")
1110   ENDIF (QT_UIC_EXECUTABLE)
1111
1112
1113
1114   MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE
1115     QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE
1116     QT_LUPDATE_EXECUTABLE QT_LRELEASE_EXECUTABLE)
1117
1118   ######################################
1119   #
1120   #       Macros for building Qt files
1121   #
1122   ######################################
1123
1124   MACRO (QT4_EXTRACT_OPTIONS _qt4_files _qt4_options)
1125     SET(${_qt4_files})
1126     SET(${_qt4_options})
1127     SET(_QT4_DOING_OPTIONS FALSE)
1128     FOREACH(_currentArg ${ARGN})
1129       IF ("${_currentArg}" STREQUAL "OPTIONS")
1130         SET(_QT4_DOING_OPTIONS TRUE)
1131       ELSE ("${_currentArg}" STREQUAL "OPTIONS")
1132         IF(_QT4_DOING_OPTIONS)
1133           LIST(APPEND ${_qt4_options} "${_currentArg}")
1134         ELSE(_QT4_DOING_OPTIONS)
1135           LIST(APPEND ${_qt4_files} "${_currentArg}")
1136         ENDIF(_QT4_DOING_OPTIONS)
1137       ENDIF ("${_currentArg}" STREQUAL "OPTIONS")
1138     ENDFOREACH(_currentArg)
1139   ENDMACRO (QT4_EXTRACT_OPTIONS)
1140
1141   MACRO (QT4_GET_MOC_INC_DIRS _moc_INC_DIRS)
1142      SET(${_moc_INC_DIRS})
1143      GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)
1144
1145      FOREACH(_current ${_inc_DIRS})
1146         SET(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-I" ${_current})
1147      ENDFOREACH(_current ${_inc_DIRS})
1148
1149      # if Qt is installed only as framework, add -F /library/Frameworks to the moc arguments
1150      # otherwise moc can't find the headers in the framework include dirs
1151      IF(APPLE  AND  "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
1152         SET(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-F/Library/Frameworks")
1153      ENDIF(APPLE  AND  "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
1154
1155   ENDMACRO(QT4_GET_MOC_INC_DIRS)
1156
1157   MACRO (QT4_GENERATE_MOC infile outfile )
1158   # get include dirs
1159      # QT4_GET_MOC_INC_DIRS(moc_includes) # Not needed...
1160      # QT4_GET_MOC_DEFINES(moc_defines)   # Now supplied via ${MOC_DEFINES}
1161
1162      GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE)
1163
1164      IF (MSVC_IDE)
1165         SET (_moc_parameter_file ${outfile}_parameters)
1166         SET (_moc_param "${moc_includes} \n-o${outfile} \n${abs_infile}")
1167         STRING(REGEX REPLACE ";-I;" "\\n-I" _moc_param "${_moc_param}")
1168         FILE (WRITE ${_moc_parameter_file} "${_moc_param}")
1169         ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1170           COMMAND ${QT_MOC_EXECUTABLE}
1171           ARGS @"${_moc_parameter_file}"
1172           DEPENDS ${abs_infile})
1173      ELSE (MSVC_IDE)
1174         ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1175            COMMAND ${QT_MOC_EXECUTABLE}
1176            ARGS ${moc_includes} ${MOC_DEFINES} -o ${outfile} ${abs_infile}
1177            DEPENDS ${abs_infile})
1178      ENDIF (MSVC_IDE)
1179
1180      SET_SOURCE_FILES_PROPERTIES(${outfile} PROPERTIES SKIP_AUTOMOC TRUE)  # dont run automoc on this file
1181
1182      MACRO_ADD_FILE_DEPENDENCIES(${abs_infile} ${outfile})
1183   ENDMACRO (QT4_GENERATE_MOC)
1184
1185
1186   # QT4_WRAP_CPP(outfiles inputfile ... )
1187
1188   MACRO (QT4_WRAP_CPP outfiles )
1189     # get include dirs
1190     # QT4_GET_MOC_INC_DIRS(moc_includes) # Not needed
1191     # QT4_GET_MOC_DEFINES(moc_defines)   # Now supplied via ${MOC_DEFINES}
1192     QT4_EXTRACT_OPTIONS(moc_files moc_options ${ARGN})
1193
1194     FOREACH (it ${moc_files})
1195       GET_FILENAME_COMPONENT(it ${it} ABSOLUTE)
1196       GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)
1197
1198       SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/moc_${outfile}.cxx)
1199       ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1200         COMMAND ${QT_MOC_EXECUTABLE}
1201         ARGS ${moc_includes} ${MOC_DEFINES} ${moc_options} -o ${outfile} ${it}
1202         DEPENDS ${it})
1203       SET(${outfiles} ${${outfiles}} ${outfile})
1204     ENDFOREACH(it)
1205
1206   ENDMACRO (QT4_WRAP_CPP)
1207
1208
1209   # QT4_WRAP_UI(outfiles inputfile ... )
1210
1211   MACRO (QT4_WRAP_UI outfiles )
1212     QT4_EXTRACT_OPTIONS(ui_files ui_options ${ARGN})
1213
1214     FOREACH (it ${ui_files})
1215       GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)
1216       GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
1217       SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.h)
1218       ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1219         COMMAND ${QT_UIC_EXECUTABLE}
1220         ARGS ${ui_options} -o ${outfile} ${infile}
1221         MAIN_DEPENDENCY ${infile})
1222       SET(${outfiles} ${${outfiles}} ${outfile})
1223     ENDFOREACH (it)
1224
1225   ENDMACRO (QT4_WRAP_UI)
1226
1227
1228   # QT4_ADD_RESOURCES(outfiles inputfile ... )
1229
1230   MACRO (QT4_ADD_RESOURCES outfiles )
1231     QT4_EXTRACT_OPTIONS(rcc_files rcc_options ${ARGN})
1232
1233     FOREACH (it ${rcc_files})
1234       GET_FILENAME_COMPONENT(outfilename ${it} NAME_WE)
1235       GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
1236       GET_FILENAME_COMPONENT(rc_path ${infile} PATH)
1237       SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cxx)
1238       #  parse file for dependencies
1239       #  all files are absolute paths or relative to the location of the qrc file
1240       FILE(READ "${infile}" _RC_FILE_CONTENTS)
1241       STRING(REGEX MATCHALL "<file[^<]+" _RC_FILES "${_RC_FILE_CONTENTS}")
1242       SET(_RC_DEPENDS)
1243       FOREACH(_RC_FILE ${_RC_FILES})
1244         STRING(REGEX REPLACE "^<file[^>]*>" "" _RC_FILE "${_RC_FILE}")
1245         STRING(REGEX MATCH "^/|([A-Za-z]:/)" _ABS_PATH_INDICATOR "${_RC_FILE}")
1246         IF(NOT _ABS_PATH_INDICATOR)
1247           SET(_RC_FILE "${rc_path}/${_RC_FILE}")
1248         ENDIF(NOT _ABS_PATH_INDICATOR)
1249         SET(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")
1250       ENDFOREACH(_RC_FILE)
1251       ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1252         COMMAND ${QT_RCC_EXECUTABLE}
1253         ARGS ${rcc_options} -name ${outfilename} -o ${outfile} ${infile}
1254         MAIN_DEPENDENCY ${infile}
1255         DEPENDS ${_RC_DEPENDS})
1256       SET(${outfiles} ${${outfiles}} ${outfile})
1257     ENDFOREACH (it)
1258
1259   ENDMACRO (QT4_ADD_RESOURCES)
1260
1261   MACRO(QT4_ADD_DBUS_INTERFACE _sources _interface _basename)
1262     GET_FILENAME_COMPONENT(_infile ${_interface} ABSOLUTE)
1263     SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
1264     SET(_impl   ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
1265     SET(_moc    ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
1266
1267     GET_SOURCE_FILE_PROPERTY(_nonamespace ${_interface} NO_NAMESPACE)
1268     IF ( _nonamespace )
1269         SET(_params -N -m)
1270     ELSE ( _nonamespace )
1271         SET(_params -m)
1272     ENDIF ( _nonamespace )
1273
1274     GET_SOURCE_FILE_PROPERTY(_include ${_interface} INCLUDE)
1275     IF ( _include )
1276         SET(_params ${_params} -i ${_include})
1277     ENDIF ( _include )
1278
1279     ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1280         COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} ${_params} -p ${_basename} ${_infile}
1281         DEPENDS ${_infile})
1282
1283     SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
1284
1285     QT4_GENERATE_MOC(${_header} ${_moc})
1286
1287     SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
1288     MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
1289
1290   ENDMACRO(QT4_ADD_DBUS_INTERFACE)
1291
1292
1293   MACRO(QT4_ADD_DBUS_INTERFACES _sources)
1294      FOREACH (_current_FILE ${ARGN})
1295         GET_FILENAME_COMPONENT(_infile ${_current_FILE} ABSOLUTE)
1296         # get the part before the ".xml" suffix
1297         STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2" _basename ${_current_FILE})
1298         STRING(TOLOWER ${_basename} _basename)
1299         QT4_ADD_DBUS_INTERFACE(${_sources} ${_infile} ${_basename}interface)
1300      ENDFOREACH (_current_FILE)
1301   ENDMACRO(QT4_ADD_DBUS_INTERFACES)
1302
1303
1304   MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName OPTIONS -some -options )
1305     QT4_EXTRACT_OPTIONS(_customName _qt4_dbus_options ${ARGN})
1306
1307     GET_FILENAME_COMPONENT(_in_file ${_header} ABSOLUTE)
1308     GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE)
1309
1310     IF (_customName)
1311       SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})
1312     ELSE (_customName)
1313       SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml)
1314     ENDIF (_customName)
1315
1316     ADD_CUSTOM_COMMAND(OUTPUT ${_target}
1317         COMMAND ${QT_DBUSCPP2XML_EXECUTABLE} ${_qt4_dbus_options} ${_in_file} > ${_target}
1318         DEPENDS ${_in_file}
1319     )
1320   ENDMACRO(QT4_GENERATE_DBUS_INTERFACE)
1321
1322
1323   MACRO(QT4_ADD_DBUS_ADAPTOR _sources _xml_file _include _parentClass) # _optionalBasename _optionalClassName)
1324     GET_FILENAME_COMPONENT(_infile ${_xml_file} ABSOLUTE)
1325
1326     SET(_optionalBasename "${ARGV4}")
1327     IF (_optionalBasename)
1328        SET(_basename ${_optionalBasename} )
1329     ELSE (_optionalBasename)
1330        STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _basename ${_infile})
1331        STRING(TOLOWER ${_basename} _basename)
1332     ENDIF (_optionalBasename)
1333
1334     SET(_optionalClassName "${ARGV5}")
1335     SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
1336     SET(_impl   ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
1337     SET(_moc    ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
1338
1339     IF(_optionalClassName)
1340        ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1341           COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -c ${_optionalClassName} -i ${_include} -l ${_parentClass} ${_infile}
1342           DEPENDS ${_infile}
1343         )
1344     ELSE(_optionalClassName)
1345        ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1346           COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -i ${_include} -l ${_parentClass} ${_infile}
1347           DEPENDS ${_infile}
1348         )
1349     ENDIF(_optionalClassName)
1350
1351     QT4_GENERATE_MOC(${_header} ${_moc})
1352     SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
1353     MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
1354
1355     SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
1356   ENDMACRO(QT4_ADD_DBUS_ADAPTOR)
1357
1358    MACRO(QT4_AUTOMOC)
1359       # QT4_GET_MOC_INC_DIRS(_moc_INCS)
1360       QT4_GET_MOC_DEFINES(_moc_DEFINES)
1361
1362
1363       SET(_matching_FILES )
1364       FOREACH (_current_FILE ${ARGN})
1365
1366          GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE)
1367          # if "SKIP_AUTOMOC" is set to true, we will not handle this file here.
1368          # This is required to make uic work correctly:
1369          # we need to add generated .cpp files to the sources (to compile them),
1370          # but we cannot let automoc handle them, as the .cpp files don't exist yet when
1371          # cmake is run for the very first time on them -> however the .cpp files might
1372          # exist at a later run. at that time we need to skip them, so that we don't add two
1373          # different rules for the same moc file
1374          GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC)
1375
1376          IF ( NOT _skip AND EXISTS ${_abs_FILE} )
1377
1378             FILE(READ ${_abs_FILE} _contents)
1379
1380             GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH)
1381
1382             STRING(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}")
1383             IF(_match)
1384                FOREACH (_current_MOC_INC ${_match})
1385                   STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}")
1386
1387                   GET_filename_component(_basename ${_current_MOC} NAME_WE)
1388    #               SET(_header ${CMAKE_CURRENT_SOURCE_DIR}/${_basename}.h)
1389                   SET(_header ${_abs_PATH}/${_basename}.h)
1390                   SET(_moc    ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC})
1391                   ADD_CUSTOM_COMMAND(OUTPUT ${_moc}
1392                      COMMAND ${QT_MOC_EXECUTABLE}
1393                      ARGS ${_moc_INCS} ${_moc_DEFINES} ${_header} -o ${_moc}
1394                      DEPENDS ${_header}
1395                   )
1396
1397                   MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc})
1398                ENDFOREACH (_current_MOC_INC)
1399             ENDIF(_match)
1400          ENDIF ( NOT _skip AND EXISTS ${_abs_FILE} )
1401       ENDFOREACH (_current_FILE)
1402    ENDMACRO(QT4_AUTOMOC)
1403
1404
1405
1406   ######################################
1407   #
1408   #       decide if Qt got found
1409   #
1410   ######################################
1411
1412   # if the includes,libraries,moc,uic and rcc are found then we have it
1413   IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1414     SET( QT4_FOUND "YES" )
1415     IF( NOT Qt4_FIND_QUIETLY)
1416       MESSAGE(STATUS "Found Qt-Version ${QTVERSION} (using ${QT_QMAKE_EXECUTABLE})")
1417     ENDIF( NOT Qt4_FIND_QUIETLY)
1418   ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1419     SET( QT4_FOUND "NO")
1420     SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1421     IF( Qt4_FIND_REQUIRED)
1422       IF ( NOT QT_LIBRARY_DIR )
1423         MESSAGE(STATUS "Qt libraries NOT found!")
1424       ENDIF(NOT QT_LIBRARY_DIR )
1425       IF ( NOT QT_INCLUDE_DIR )
1426         MESSAGE(STATUS "Qt includes NOT found!")
1427       ENDIF( NOT QT_INCLUDE_DIR )
1428       IF ( NOT QT_MOC_EXECUTABLE )
1429         MESSAGE(STATUS "Qt's moc NOT found!")
1430       ENDIF( NOT QT_MOC_EXECUTABLE )
1431       IF ( NOT QT_UIC_EXECUTABLE )
1432         MESSAGE(STATUS "Qt's uic NOT found!")
1433       ENDIF( NOT QT_UIC_EXECUTABLE )
1434       IF ( NOT QT_RCC_EXECUTABLE )
1435         MESSAGE(STATUS "Qt's rcc NOT found!")
1436       ENDIF( NOT QT_RCC_EXECUTABLE )
1437       MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")
1438     ENDIF( Qt4_FIND_REQUIRED)
1439   ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND  QT_RCC_EXECUTABLE)
1440   SET(QT_FOUND ${QT4_FOUND})
1441
1442
1443   #######################################
1444   #
1445   #       Qt configuration
1446   #
1447   #######################################
1448   IF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
1449     FILE(READ ${QT_MKSPECS_DIR}/qconfig.pri _qconfig_FILE_contents)
1450     STRING(REGEX MATCH "QT_CONFIG[^\n]+" QT_QCONFIG ${_qconfig_FILE_contents})
1451     STRING(REGEX MATCH "CONFIG[^\n]+" QT_CONFIG ${_qconfig_FILE_contents})
1452     STRING(REGEX MATCH "EDITION[^\n]+" QT_EDITION ${_qconfig_FILE_contents})
1453   ENDIF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
1454   IF("${QT_EDITION}" MATCHES "DesktopLight")
1455     SET(QT_EDITION_DESKTOPLIGHT 1)
1456   ENDIF("${QT_EDITION}" MATCHES "DesktopLight")
1457
1458   ###############################################
1459   #
1460   #       configuration/system dependent settings
1461   #
1462   ###############################################
1463
1464   SET(QT_GUI_LIB_DEPENDENCIES "")
1465   SET(QT_CORE_LIB_DEPENDENCIES "")
1466
1467   # shared build needs -DQT_SHARED
1468   IF(NOT QT_CONFIG MATCHES "static")
1469     # warning currently only qconfig.pri on Windows potentially contains "static"
1470     # so QT_SHARED might not get defined properly on Mac/X11 (which seems harmless right now)
1471     # Trolltech said they'd consider exporting it for all platforms in future releases.
1472     SET(QT_DEFINITIONS ${QT_DEFINITIONS} -DQT_SHARED)
1473   ENDIF(NOT QT_CONFIG MATCHES "static")
1474
1475   # OpenSSL
1476   IF(NOT QT_QCONFIG MATCHES "openssl")
1477     SET(QT_DEFINITIONS ${QT_DEFINITIONS} -DQT_NO_OPENSSL)
1478   ENDIF(NOT QT_QCONFIG MATCHES "openssl")
1479
1480   ## system png
1481   IF(QT_QCONFIG MATCHES "system-png")
1482     FIND_LIBRARY(QT_PNG_LIBRARY NAMES png)
1483     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_PNG_LIBRARY})
1484     MARK_AS_ADVANCED(QT_PNG_LIBRARY)
1485   ENDIF(QT_QCONFIG MATCHES "system-png")
1486
1487   # for X11, get X11 library directory
1488   IF(Q_WS_X11)
1489     QT_QUERY_QMAKE(QMAKE_LIBDIR_X11 "QMAKE_LIBDIR_X11")
1490   ENDIF(Q_WS_X11)
1491
1492   ## X11 SM
1493   IF(QT_QCONFIG MATCHES "x11sm")
1494     # ask qmake where the x11 libs are
1495     FIND_LIBRARY(QT_X11_SM_LIBRARY NAMES SM PATHS ${QMAKE_LIBDIR_X11})
1496     FIND_LIBRARY(QT_X11_ICE_LIBRARY NAMES ICE PATHS ${QMAKE_LIBDIR_X11})
1497     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_X11_SM_LIBRARY} ${QT_X11_ICE_LIBRARY})
1498     MARK_AS_ADVANCED(QT_X11_SM_LIBRARY)
1499     MARK_AS_ADVANCED(QT_X11_ICE_LIBRARY)
1500   ENDIF(QT_QCONFIG MATCHES "x11sm")
1501
1502   ## Xi
1503   IF(QT_QCONFIG MATCHES "tablet")
1504     FIND_LIBRARY(QT_XI_LIBRARY NAMES Xi PATHS ${QMAKE_LIBDIR_X11})
1505     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XI_LIBRARY})
1506     MARK_AS_ADVANCED(QT_XI_LIBRARY)
1507   ENDIF(QT_QCONFIG MATCHES "tablet")
1508
1509   ## Xrender
1510   IF(QT_QCONFIG MATCHES "xrender")
1511     FIND_LIBRARY(QT_XRENDER_LIBRARY NAMES Xrender PATHS ${QMAKE_LIBDIR_X11})
1512     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XRENDER_LIBRARY})
1513     MARK_AS_ADVANCED(QT_XRENDER_LIBRARY)
1514   ENDIF(QT_QCONFIG MATCHES "xrender")
1515
1516   ## Xrandr
1517   IF(QT_QCONFIG MATCHES "xrandr")
1518     FIND_LIBRARY(QT_XRANDR_LIBRARY NAMES Xrandr PATHS ${QMAKE_LIBDIR_X11})
1519     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XRANDR_LIBRARY})
1520     MARK_AS_ADVANCED(QT_XRANDR_LIBRARY)
1521   ENDIF(QT_QCONFIG MATCHES "xrandr")
1522
1523   ## Xcursor
1524   IF(QT_QCONFIG MATCHES "xcursor")
1525     FIND_LIBRARY(QT_XCURSOR_LIBRARY NAMES Xcursor PATHS ${QMAKE_LIBDIR_X11})
1526     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XCURSOR_LIBRARY})
1527     MARK_AS_ADVANCED(QT_XCURSOR_LIBRARY)
1528   ENDIF(QT_QCONFIG MATCHES "xcursor")
1529
1530   ## Xinerama
1531   IF(QT_QCONFIG MATCHES "xinerama")
1532     FIND_LIBRARY(QT_XINERAMA_LIBRARY NAMES Xinerama PATHS ${QMAKE_LIBDIR_X11})
1533     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XINERAMA_LIBRARY})
1534     MARK_AS_ADVANCED(QT_XINERAMA_LIBRARY)
1535   ENDIF(QT_QCONFIG MATCHES "xinerama")
1536
1537   ## Xfixes
1538   IF(QT_QCONFIG MATCHES "xfixes")
1539     FIND_LIBRARY(QT_XFIXES_LIBRARY NAMES Xfixes PATHS ${QMAKE_LIBDIR_X11})
1540     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XFIXES_LIBRARY})
1541     MARK_AS_ADVANCED(QT_XFIXES_LIBRARY)
1542   ENDIF(QT_QCONFIG MATCHES "xfixes")
1543
1544   ## system-freetype
1545   IF(QT_QCONFIG MATCHES "system-freetype")
1546     FIND_LIBRARY(QT_FREETYPE_LIBRARY NAMES freetype)
1547     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_FREETYPE_LIBRARY})
1548     MARK_AS_ADVANCED(QT_FREETYPE_LIBRARY)
1549   ENDIF(QT_QCONFIG MATCHES "system-freetype")
1550
1551   ## fontconfig
1552   IF(QT_QCONFIG MATCHES "fontconfig")
1553     FIND_LIBRARY(QT_FONTCONFIG_LIBRARY NAMES fontconfig)
1554     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_FONTCONFIG_LIBRARY})
1555     MARK_AS_ADVANCED(QT_FONTCONFIG_LIBRARY)
1556   ENDIF(QT_QCONFIG MATCHES "fontconfig")
1557
1558   ## system-zlib
1559   IF(QT_QCONFIG MATCHES "system-zlib")
1560     FIND_LIBRARY(QT_ZLIB_LIBRARY NAMES z)
1561     SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QT_ZLIB_LIBRARY})
1562     MARK_AS_ADVANCED(QT_ZLIB_LIBRARY)
1563   ENDIF(QT_QCONFIG MATCHES "system-zlib")
1564
1565   ## glib
1566   IF(QT_QCONFIG MATCHES "glib")
1567     # Qt less than Qt 4.2.0 doesn't use glib
1568     # Qt 4.2.0 uses glib-2.0 (wish we could ask Qt that it uses 2.0)
1569     FIND_LIBRARY(QT_GLIB_LIBRARY NAMES glib-2.0)
1570     FIND_LIBRARY(QT_GTHREAD_LIBRARY NAMES gthread-2.0)
1571     IF(QT_GTHREAD_LIBRARY AND QT_GLIB_LIBRARY)  #TEMP: need more robust find of glib2
1572       SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES}
1573         ${QT_GTHREAD_LIBRARY} ${QT_GLIB_LIBRARY})
1574     ENDIF(QT_GTHREAD_LIBRARY AND QT_GLIB_LIBRARY)
1575     MARK_AS_ADVANCED(QT_GLIB_LIBRARY)
1576     MARK_AS_ADVANCED(QT_GTHREAD_LIBRARY)
1577   ENDIF(QT_QCONFIG MATCHES "glib")
1578
1579   ## clock-monotonic, just see if we need to link with rt
1580   IF(QT_QCONFIG MATCHES "clock-monotonic")
1581     SET(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
1582     SET(CMAKE_REQUIRED_LIBRARIES rt)
1583     CHECK_SYMBOL_EXISTS(_POSIX_TIMERS "unistd.h;time.h" QT_POSIX_TIMERS)
1584     SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
1585     IF(QT_POSIX_TIMERS)
1586       FIND_LIBRARY(QT_RT_LIBRARY NAMES rt)
1587       SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QT_RT_LIBRARY})
1588       MARK_AS_ADVANCED(QT_RT_LIBRARY)
1589     ENDIF(QT_POSIX_TIMERS)
1590   ENDIF(QT_QCONFIG MATCHES "clock-monotonic")
1591
1592   IF(Q_WS_X11)
1593     # X11 libraries Qt absolutely depends on
1594     QT_QUERY_QMAKE(QT_LIBS_X11 "QMAKE_LIBS_X11")
1595     SEPARATE_ARGUMENTS(QT_LIBS_X11)
1596     FOREACH(QT_X11_LIB ${QT_LIBS_X11})
1597       STRING(REGEX REPLACE "-l" "" QT_X11_LIB "${QT_X11_LIB}")
1598       SET(QT_TMP_STR "QT_X11_${QT_X11_LIB}_LIBRARY")
1599       FIND_LIBRARY(${QT_TMP_STR} NAMES "${QT_X11_LIB}" PATHS ${QMAKE_LIBDIR_X11})
1600       SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${${QT_TMP_STR}})
1601       MARK_AS_ADVANCED(${QT_TMP_STR})
1602     ENDFOREACH(QT_X11_LIB)
1603
1604     QT_QUERY_QMAKE(QT_LIBS_THREAD "QMAKE_LIBS_THREAD")
1605     SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QT_LIBS_THREAD})
1606
1607     QT_QUERY_QMAKE(QMAKE_LIBS_DYNLOAD "QMAKE_LIBS_DYNLOAD")
1608     SET (QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QMAKE_LIBS_DYNLOAD})
1609
1610   ENDIF(Q_WS_X11)
1611
1612   IF(Q_WS_WIN)
1613     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} imm32 winmm)
1614     SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ws2_32)
1615   ENDIF(Q_WS_WIN)
1616
1617   IF(Q_WS_MAC)
1618     SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} "-framework Carbon" "-framework QuickTime")
1619     SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} "-framework ApplicationServices")
1620   ENDIF(Q_WS_MAC)
1621
1622   #######################################
1623   #
1624   #       compatibility settings
1625   #
1626   #######################################
1627   # Backwards compatibility for CMake1.4 and 1.2
1628   SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
1629   SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
1630
1631   SET( QT_QT_LIBRARY "")
1632
1633 ELSE(QT4_QMAKE_FOUND)
1634
1635    SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1636    IF(Qt4_FIND_REQUIRED)
1637       IF(QT4_INSTALLED_VERSION_TOO_OLD)
1638          MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1639       ELSE(QT4_INSTALLED_VERSION_TOO_OLD)
1640          MESSAGE( FATAL_ERROR "Qt qmake not found!")
1641       ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)
1642    ELSE(Qt4_FIND_REQUIRED)
1643       IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1644          MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1645       ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1646    ENDIF(Qt4_FIND_REQUIRED)
1647
1648 ENDIF (QT4_QMAKE_FOUND)
1649 ENDIF (QT4_QMAKE_FOUND)
1650