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.
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})
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.
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:
48 # QT_USE_QTASSISTANTCLIENT
51 # QT_USE_QTXMLPATTERNS
53 # QT_USE_QTSCRIPTTOOLS
54 # QT_USE_QTDECLARATIVE
56 # QT_USE_IMPORTED_TARGETS
57 # If this variable is set to TRUE, FindQt4.cmake will create imported
58 # library targets for the various Qt libraries and set the
59 # library variables like QT_QTCORE_LIBRARY to point at these imported
60 # targets instead of the library file on disk. This provides much better
61 # handling of the release and debug versions of the Qt libraries and is
62 # also always backwards compatible, except for the case that dependencies
63 # of libraries are exported, these will then also list the names of the
64 # imported targets as dependency and not the file location on disk. This
65 # is much more flexible, but requires that FindQt4.cmake is executed before
66 # such an exported dependency file is processed.
68 # There are also some files that need processing by some Qt tools such as moc
69 # and uic. Listed below are macros that may be used to process those files.
71 # macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
72 # create moc code from a list of files containing Qt class with
73 # the Q_OBJECT declaration. Per-direcotry preprocessor definitions
74 # are also added. Options may be given to moc, such as those found
75 # when executing "moc -help".
77 # macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
78 # create code from a list of Qt designer ui files.
79 # Options may be given to uic, such as those found
80 # when executing "uic -help"
82 # macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
83 # create code from a list of Qt resource files.
84 # Options may be given to rcc, such as those found
85 # when executing "rcc -help"
87 # macro QT4_GENERATE_MOC(inputfile outputfile )
88 # creates a rule to run moc on infile and create outfile.
89 # Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
90 # because you need a custom filename for the moc file or something similar.
92 # macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... )
93 # This macro is still experimental.
94 # It can be used to have moc automatically handled.
95 # So if you have the files foo.h and foo.cpp, and in foo.h a
96 # a class uses the Q_OBJECT macro, moc has to run on it. If you don't
97 # want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
99 # in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
100 # scan all listed files at cmake-time for such included moc files and if it finds
101 # them cause a rule to be generated to run moc at build time on the
102 # accompanying header file foo.h.
103 # If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.
105 # macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
106 # create a the interface header and implementation files with the
107 # given basename from the given interface xml file and add it to
108 # the list of sources.
109 # To disable generating a namespace header, set the source file property
110 # NO_NAMESPACE to TRUE on the interface file.
111 # To include a header in the interface header, set the source file property
112 # INCLUDE to the name of the header.
113 # To specify a class name to use, set the source file property CLASSNAME
114 # to the name of the class.
116 # macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
117 # create the interface header and implementation files
118 # for all listed interface xml files
119 # the name will be automatically determined from the name of the xml file
120 # To disable generating namespace headers, set the source file property
121 # NO_NAMESPACE to TRUE for these inputfiles.
122 # To include a header in the interface header, set the source file property
123 # INCLUDE to the name of the header.
124 # To specify a class name to use, set the source file property CLASSNAME
125 # to the name of the class.
127 # macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])
128 # create a dbus adaptor (header and implementation file) from the xml file
129 # describing the interface, and add it to the list of sources. The adaptor
130 # forwards the calls to a parent class, defined in parentheader and named
131 # parentclassname. The name of the generated files will be
132 # <basename>adaptor.{cpp,h} where basename defaults to the basename of the xml file.
133 # If <classname> is provided, then it will be used as the classname of the
136 # macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
137 # generate the xml interface file from the given header.
138 # If the optional argument interfacename is omitted, the name of the
139 # interface file is constructed from the basename of the header with
140 # the suffix .xml appended.
141 # Options may be given to qdbuscpp2xml, such as those found when executing "qdbuscpp2xml --help"
143 # macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ...
144 # ts_files ... OPTIONS ...)
146 # in: directories sources ts_files
147 # options: flags to pass to lupdate, such as -extensions to specify
148 # extensions for a directory scan.
149 # generates commands to create .ts (vie lupdate) and .qm
150 # (via lrelease) - files from directories and/or sources. The ts files are
151 # created and/or updated in the source tree (unless given with full paths).
152 # The qm files are generated in the build tree.
153 # Updating the translations can be done by adding the qm_files
154 # to the source list of your library/executable, so they are
155 # always updated, or by adding a custom target to control when
156 # they get updated/generated.
158 # macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
161 # generates commands to create .qm from .ts - files. The generated
162 # filenames can be found in qm_files. The ts_files
163 # must exists and are not updated in any way.
166 # Below is a detailed list of variables that FindQt4.cmake sets.
167 # QT_FOUND If false, don't try to use Qt.
168 # QT4_FOUND If false, don't try to use Qt 4.
170 # QT_VERSION_MAJOR The major version of Qt found.
171 # QT_VERSION_MINOR The minor version of Qt found.
172 # QT_VERSION_PATCH The patch version of Qt found.
174 # QT_EDITION Set to the edition of Qt (i.e. DesktopLight)
175 # QT_EDITION_DESKTOPLIGHT True if QT_EDITION == DesktopLight
176 # QT_QTCORE_FOUND True if QtCore was found.
177 # QT_QTGUI_FOUND True if QtGui was found.
178 # QT_QT3SUPPORT_FOUND True if Qt3Support was found.
179 # QT_QTASSISTANT_FOUND True if QtAssistant was found.
180 # QT_QTASSISTANTCLIENT_FOUND True if QtAssistantClient was found.
181 # QT_QAXCONTAINER_FOUND True if QAxContainer was found (Windows only).
182 # QT_QAXSERVER_FOUND True if QAxServer was found (Windows only).
183 # QT_QTDBUS_FOUND True if QtDBus was found.
184 # QT_QTDESIGNER_FOUND True if QtDesigner was found.
185 # QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.
186 # QT_QTHELP_FOUND True if QtHelp was found.
187 # QT_QTMOTIF_FOUND True if QtMotif was found.
188 # QT_QTMULTIMEDIA_FOUND True if QtMultimedia was found (since Qt 4.6.0).
189 # QT_QTNETWORK_FOUND True if QtNetwork was found.
190 # QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found.
191 # QT_QTOPENGL_FOUND True if QtOpenGL was found.
192 # QT_QTSQL_FOUND True if QtSql was found.
193 # QT_QTSVG_FOUND True if QtSvg was found.
194 # QT_QTSCRIPT_FOUND True if QtScript was found.
195 # QT_QTSCRIPTTOOLS_FOUND True if QtScriptTools was found.
196 # QT_QTTEST_FOUND True if QtTest was found.
197 # QT_QTUITOOLS_FOUND True if QtUiTools was found.
198 # QT_QTWEBKIT_FOUND True if QtWebKit was found.
199 # QT_QTXML_FOUND True if QtXml was found.
200 # QT_QTXMLPATTERNS_FOUND True if QtXmlPatterns was found.
201 # QT_PHONON_FOUND True if phonon was found.
202 # QT_QTDECLARATIVE_FOUND True if QtDeclarative was found.
204 # QT_MAC_USE_COCOA For Mac OS X, its whether Cocoa or Carbon is used.
205 # In general, this should not be used, but its useful
206 # when having platform specific code.
208 # QT_DEFINITIONS Definitions to use when compiling code that uses Qt.
209 # You do not need to use this if you include QT_USE_FILE.
210 # The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
211 # to fit your current build type. Those are not contained
214 # QT_INCLUDES List of paths to all include directories of
215 # Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
216 # always in this variable even if NOTFOUND,
217 # all other INCLUDE_DIRS are
218 # only added if they are found.
219 # You do not need to use this if you include QT_USE_FILE.
222 # Include directories for the Qt modules are listed here.
223 # You do not need to use these variables if you include QT_USE_FILE.
225 # QT_INCLUDE_DIR Path to "include" of Qt4
226 # QT_QT_INCLUDE_DIR Path to "include/Qt"
227 # QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support"
228 # QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant"
229 # QT_QTASSISTANTCLIENT_INCLUDE_DIR Path to "include/QtAssistant"
230 # QT_QAXCONTAINER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
231 # QT_QAXSERVER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
232 # QT_QTCORE_INCLUDE_DIR Path to "include/QtCore"
233 # QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus"
234 # QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner"
235 # QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner"
236 # QT_QTGUI_INCLUDE_DIR Path to "include/QtGui"
237 # QT_QTHELP_INCLUDE_DIR Path to "include/QtHelp"
238 # QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif"
239 # QT_QTMULTIMEDIA_INCLUDE_DIR Path to "include/QtMultimedia"
240 # QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork"
241 # QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin"
242 # QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL"
243 # QT_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript"
244 # QT_QTSQL_INCLUDE_DIR Path to "include/QtSql"
245 # QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg"
246 # QT_QTTEST_INCLUDE_DIR Path to "include/QtTest"
247 # QT_QTWEBKIT_INCLUDE_DIR Path to "include/QtWebKit"
248 # QT_QTXML_INCLUDE_DIR Path to "include/QtXml"
249 # QT_QTXMLPATTERNS_INCLUDE_DIR Path to "include/QtXmlPatterns"
250 # QT_PHONON_INCLUDE_DIR Path to "include/phonon"
251 # QT_QTSCRIPTTOOLS_INCLUDE_DIR Path to "include/QtScriptTools"
252 # QT_QTDECLARATIVE_INCLUDE_DIR Path to "include/QtDeclarative"
254 # QT_BINARY_DIR Path to "bin" of Qt4
255 # QT_LIBRARY_DIR Path to "lib" of Qt4
256 # QT_PLUGINS_DIR Path to "plugins" for Qt4
257 # QT_TRANSLATIONS_DIR Path to "translations" of Qt4
258 # QT_DOC_DIR Path to "doc" of Qt4
259 # QT_MKSPECS_DIR Path to "mkspecs" of Qt4
262 # For every library of Qt, a QT_QTFOO_LIBRARY variable is defined, with the full path to the library.
264 # So there are the following variables:
265 # The Qt3Support library: QT_QT3SUPPORT_LIBRARY
267 # The QtAssistant library: QT_QTASSISTANT_LIBRARY
269 # The QtAssistantClient library: QT_QTASSISTANTCLIENT_LIBRARY
271 # The QAxServer library: QT_QAXSERVER_LIBRARY
273 # The QAxContainer library: QT_QAXCONTAINER_LIBRARY
275 # The QtCore library: QT_QTCORE_LIBRARY
277 # The QtDBus library: QT_QTDBUS_LIBRARY
279 # The QtDesigner library: QT_QTDESIGNER_LIBRARY
281 # The QtDesignerComponents library: QT_QTDESIGNERCOMPONENTS_LIBRARY
283 # The QtGui library: QT_QTGUI_LIBRARY
285 # The QtHelp library: QT_QTHELP_LIBRARY
287 # The QtMotif library: QT_QTMOTIF_LIBRARY
289 # The QtMultimedia library: QT_QTMULTIMEDIA_LIBRARY
291 # The QtNetwork library: QT_QTNETWORK_LIBRARY
293 # The QtNsPLugin library: QT_QTNSPLUGIN_LIBRARY
295 # The QtOpenGL library: QT_QTOPENGL_LIBRARY
297 # The QtScript library: QT_QTSCRIPT_LIBRARY
299 # The QtScriptTools library: QT_QTSCRIPTTOOLS_LIBRARY
301 # The QtSql library: QT_QTSQL_LIBRARY
303 # The QtSvg library: QT_QTSVG_LIBRARY
305 # The QtTest library: QT_QTTEST_LIBRARY
307 # The QtUiTools library: QT_QTUITOOLS_LIBRARY
309 # The QtWebKit library: QT_QTWEBKIT_LIBRARY
311 # The QtXml library: QT_QTXML_LIBRARY
313 # The QtXmlPatterns library: QT_QTXMLPATTERNS_LIBRARY
315 # The qtmain library for Windows QT_QTMAIN_LIBRARY
317 # The Phonon library: QT_PHONON_LIBRARY
319 # The QtDeclarative library: QT_QTDECLARATIVE_LIBRARY
321 # also defined, but NOT for general use are
322 # QT_MOC_EXECUTABLE Where to find the moc tool.
323 # QT_UIC_EXECUTABLE Where to find the uic tool.
324 # QT_UIC3_EXECUTABLE Where to find the uic3 tool.
325 # QT_RCC_EXECUTABLE Where to find the rcc tool
326 # QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool.
327 # QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool.
328 # QT_LUPDATE_EXECUTABLE Where to find the lupdate tool.
329 # QT_LRELEASE_EXECUTABLE Where to find the lrelease tool.
330 # QT_LCONVERT_EXECUTABLE Where to find the lconvert tool.
331 # QT_QCOLLECTIONGENERATOR_EXECUTABLE Where to find the qcollectiongenerator tool.
332 # QT_DESIGNER_EXECUTABLE Where to find the Qt designer tool.
333 # QT_LINGUIST_EXECUTABLE Where to find the Qt linguist tool.
336 # These are around for backwards compatibility
338 # QT_WRAP_CPP Set true if QT_MOC_EXECUTABLE is found
339 # QT_WRAP_UI Set true if QT_UIC_EXECUTABLE is found
341 # These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)
342 # QT_MT_REQUIRED Qt4 is now always multithreaded
344 # These variables are set to "" Because Qt structure changed
345 # (They make no sense in Qt4)
346 # QT_QT_LIBRARY Qt-Library is now split
348 # Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
349 # See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
351 # Use FIND_PACKAGE( Qt4 COMPONENTS ... ) to enable modules
352 IF( Qt4_FIND_COMPONENTS )
353 FOREACH( component ${Qt4_FIND_COMPONENTS} )
354 STRING( TOUPPER ${component} _COMPONENT )
355 SET( QT_USE_${_COMPONENT} 1 )
356 ENDFOREACH( component )
358 # To make sure we don't use QtCore or QtGui when not in COMPONENTS
359 IF(NOT QT_USE_QTCORE)
360 SET( QT_DONT_USE_QTCORE 1 )
361 ENDIF(NOT QT_USE_QTCORE)
364 SET( QT_DONT_USE_QTGUI 1 )
365 ENDIF(NOT QT_USE_QTGUI)
367 ENDIF( Qt4_FIND_COMPONENTS )
369 # If Qt3 has already been found, fail.
371 IF(Qt4_FIND_REQUIRED)
372 MESSAGE( FATAL_ERROR "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
373 ELSE(Qt4_FIND_REQUIRED)
374 IF(NOT Qt4_FIND_QUIETLY)
375 MESSAGE( STATUS "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
376 ENDIF(NOT Qt4_FIND_QUIETLY)
378 ENDIF(Qt4_FIND_REQUIRED)
382 IF (QT4_QMAKE_FOUND AND Qt4::QtCore)
383 # Check already done in this cmake run, nothing more to do
385 ENDIF (QT4_QMAKE_FOUND AND Qt4::QtCore)
387 # check that QT_NO_DEBUG is defined for release configurations
388 MACRO(QT_CHECK_FLAG_EXISTS FLAG VAR DOC)
389 IF(NOT ${VAR} MATCHES "${FLAG}")
390 SET(${VAR} "${${VAR}} ${FLAG}"
391 CACHE STRING "Flags used by the compiler during ${DOC} builds." FORCE)
392 ENDIF(NOT ${VAR} MATCHES "${FLAG}")
393 ENDMACRO(QT_CHECK_FLAG_EXISTS FLAG VAR)
395 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO "Release with Debug Info")
396 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELEASE "release")
397 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL "release minsize")
399 INCLUDE(MacroPushRequiredVars)
400 INCLUDE(CheckSymbolExists)
401 INCLUDE(MacroAddFileDependencies)
403 SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
405 SET( QT_DEFINITIONS "")
407 SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)
409 # macro for asking qmake to process pro files
410 MACRO(QT_QUERY_QMAKE outvar invar)
411 IF(QT_QMAKE_EXECUTABLE)
412 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro
413 "message(CMAKE_MESSAGE<$$${invar}>)")
415 # Invoke qmake with the tmp.pro program to get the desired
416 # information. Use the same variable for both stdout and stderr
417 # to make sure we get the output on all platforms.
418 EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}
420 ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake
421 OUTPUT_VARIABLE _qmake_query_output
422 RESULT_VARIABLE _qmake_result
423 ERROR_VARIABLE _qmake_query_output )
426 "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake")
429 MESSAGE(WARNING " querying qmake for ${invar}. qmake reported:\n${_qmake_query_output}")
431 STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}")
434 ENDIF(QT_QMAKE_EXECUTABLE)
435 ENDMACRO(QT_QUERY_QMAKE)
437 GET_FILENAME_COMPONENT(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME)
439 # Debian uses qmake-qt4
440 # macports' Qt uses qmake-mac
441 FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 qmake-mac PATHS
442 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
443 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
444 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]/bin"
446 DOC "The qmake executable for the Qt installation to use"
449 IF (QT_QMAKE_EXECUTABLE)
451 IF(QT_QMAKE_EXECUTABLE_LAST)
452 STRING(COMPARE NOTEQUAL "${QT_QMAKE_EXECUTABLE_LAST}" "${QT_QMAKE_EXECUTABLE}" QT_QMAKE_CHANGED)
453 ENDIF(QT_QMAKE_EXECUTABLE_LAST)
455 SET(QT_QMAKE_EXECUTABLE_LAST "${QT_QMAKE_EXECUTABLE}" CACHE INTERNAL "" FORCE)
457 SET(QT4_QMAKE_FOUND FALSE)
459 EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
461 # check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
462 IF("${QTVERSION}" MATCHES "Unknown")
463 SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
464 FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS
465 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
466 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
468 DOC "The qmake executable for the Qt installation to use"
470 IF(QT_QMAKE_EXECUTABLE)
471 EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
472 ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
473 ENDIF(QT_QMAKE_EXECUTABLE)
474 ENDIF("${QTVERSION}" MATCHES "Unknown")
476 # check that we found the Qt4 qmake, Qt3 qmake output won't match here
477 STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")
480 # we need at least version 4.0.0
481 IF (NOT QT_MIN_VERSION)
482 SET(QT_MIN_VERSION "4.0.0")
483 ENDIF (NOT QT_MIN_VERSION)
485 #now parse the parts of the user given version string into variables
486 STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}")
487 IF (NOT req_qt_major_vers)
488 MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"")
489 ENDIF (NOT req_qt_major_vers)
491 # now parse the parts of the user given version string into variables
492 STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}")
493 STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}")
494 STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}")
496 # Suppport finding at least a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 )
497 # This implementation is a hack to avoid duplicating code and make sure we stay
498 # source-compatible with CMake 2.6.x
499 IF( Qt4_FIND_VERSION )
500 SET( QT_MIN_VERSION ${Qt4_FIND_VERSION} )
501 SET( req_qt_major_vers ${Qt4_FIND_VERSION_MAJOR} )
502 SET( req_qt_minor_vers ${Qt4_FIND_VERSION_MINOR} )
503 SET( req_qt_patch_vers ${Qt4_FIND_VERSION_PATCH} )
504 ENDIF( Qt4_FIND_VERSION )
506 IF (NOT req_qt_major_vers EQUAL 4)
507 MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")
508 ENDIF (NOT req_qt_major_vers EQUAL 4)
510 # and now the version string given by qmake
511 STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" QT_VERSION_MAJOR "${QTVERSION}")
512 STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" QT_VERSION_MINOR "${QTVERSION}")
513 STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" QT_VERSION_PATCH "${QTVERSION}")
515 # compute an overall version number which can be compared at once
516 MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")
517 MATH(EXPR found_vers "${QT_VERSION_MAJOR}*10000 + ${QT_VERSION_MINOR}*100 + ${QT_VERSION_PATCH}")
519 # Support finding *exactly* a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 EXACT )
520 IF( Qt4_FIND_VERSION_EXACT )
521 IF(found_vers EQUAL req_vers)
522 SET( QT4_QMAKE_FOUND TRUE )
523 ELSE(found_vers EQUAL req_vers)
524 SET( QT4_QMAKE_FOUND FALSE )
525 IF (found_vers LESS req_vers)
526 SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
527 ELSE (found_vers LESS req_vers)
528 SET(QT4_INSTALLED_VERSION_TOO_NEW TRUE)
529 ENDIF (found_vers LESS req_vers)
530 ENDIF(found_vers EQUAL req_vers)
531 ELSE( Qt4_FIND_VERSION_EXACT )
532 IF (found_vers LESS req_vers)
533 SET(QT4_QMAKE_FOUND FALSE)
534 SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
535 ELSE (found_vers LESS req_vers)
536 SET(QT4_QMAKE_FOUND TRUE)
537 ENDIF (found_vers LESS req_vers)
538 ENDIF( Qt4_FIND_VERSION_EXACT )
539 ENDIF (qt_version_tmp)
541 ENDIF (QT_QMAKE_EXECUTABLE)
547 get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )
548 get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )
551 # ask qmake for the library dir
553 IF (NOT QT_LIBRARY_DIR OR QT_QMAKE_CHANGED)
554 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
555 ARGS "-query QT_INSTALL_LIBS"
556 OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP )
557 # make sure we have / and not \ as qmake gives on windows
558 FILE(TO_CMAKE_PATH "${QT_LIBRARY_DIR_TMP}" QT_LIBRARY_DIR_TMP)
559 IF(EXISTS "${QT_LIBRARY_DIR_TMP}")
560 SET(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir" FORCE)
561 ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}")
562 MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT_LIBRARY_DIR_TMP}")
563 MESSAGE("Warning: ${QT_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.")
564 ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}")
565 ENDIF(NOT QT_LIBRARY_DIR OR QT_QMAKE_CHANGED)
568 IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
569 SET(QT_USE_FRAMEWORKS ON
570 CACHE BOOL "Set to ON if Qt build uses frameworks." FORCE)
571 ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
572 SET(QT_USE_FRAMEWORKS OFF
573 CACHE BOOL "Set to ON if Qt build uses frameworks." FORCE)
574 ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
576 MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)
579 # ask qmake for the binary dir
580 IF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR OR QT_QMAKE_CHANGED)
581 EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
582 ARGS "-query QT_INSTALL_BINS"
583 OUTPUT_VARIABLE qt_bins )
584 # make sure we have / and not \ as qmake gives on windows
585 FILE(TO_CMAKE_PATH "${qt_bins}" qt_bins)
586 SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "" FORCE)
587 ENDIF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR OR QT_QMAKE_CHANGED)
589 # ask qmake for the include dir
590 IF (QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR OR QT_QMAKE_CHANGED)
591 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
592 ARGS "-query QT_INSTALL_HEADERS"
593 OUTPUT_VARIABLE qt_headers )
594 # make sure we have / and not \ as qmake gives on windows
595 FILE(TO_CMAKE_PATH "${qt_headers}" qt_headers)
596 SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "" FORCE)
597 ENDIF (QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR OR QT_QMAKE_CHANGED)
600 # ask qmake for the documentation directory
601 IF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR OR QT_QMAKE_CHANGED)
602 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
603 ARGS "-query QT_INSTALL_DOCS"
604 OUTPUT_VARIABLE qt_doc_dir )
605 # make sure we have / and not \ as qmake gives on windows
606 FILE(TO_CMAKE_PATH "${qt_doc_dir}" qt_doc_dir)
607 SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs" FORCE)
608 ENDIF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR OR QT_QMAKE_CHANGED)
610 # ask qmake for the mkspecs directory
611 IF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR OR QT_QMAKE_CHANGED)
612 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
613 ARGS "-query QMAKE_MKSPECS"
614 OUTPUT_VARIABLE qt_mkspecs_dirs )
615 # do not replace : on windows as it might be a drive letter
616 # and windows should already use ; as a separator
618 STRING(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}")
620 SET(QT_MKSPECS_DIR NOTFOUND)
621 FIND_PATH(QT_MKSPECS_DIR qconfig.pri PATHS ${qt_mkspecs_dirs}
622 DOC "The location of the Qt mkspecs containing qconfig.pri"
624 ENDIF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR OR QT_QMAKE_CHANGED)
626 # ask qmake for the plugins directory
627 IF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR OR QT_QMAKE_CHANGED)
628 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
629 ARGS "-query QT_INSTALL_PLUGINS"
630 OUTPUT_VARIABLE qt_plugins_dir )
631 # make sure we have / and not \ as qmake gives on windows
632 FILE(TO_CMAKE_PATH "${qt_plugins_dir}" qt_plugins_dir)
633 SET(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins" FORCE)
634 ENDIF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR OR QT_QMAKE_CHANGED)
636 # ask qmake for the translations directory
637 IF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR OR QT_QMAKE_CHANGED)
638 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
639 ARGS "-query QT_INSTALL_TRANSLATIONS"
640 OUTPUT_VARIABLE qt_translations_dir )
641 # make sure we have / and not \ as qmake gives on windows
642 FILE(TO_CMAKE_PATH "${qt_translations_dir}" qt_translations_dir)
643 SET(QT_TRANSLATIONS_DIR ${qt_translations_dir} CACHE PATH "The location of the Qt translations" FORCE)
644 ENDIF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR OR QT_QMAKE_CHANGED)
646 # Make variables changeble to the advanced user
647 MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_DOC_DIR QT_MKSPECS_DIR
648 QT_PLUGINS_DIR QT_TRANSLATIONS_DIR)
651 #############################################
653 # Find out what window system we're using
655 #############################################
656 # Save required includes and required_flags variables
657 MACRO_PUSH_REQUIRED_VARS()
658 # Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES
659 SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_HEADERS_DIR}")
660 # On Mac OS X when Qt has framework support, also add the framework path
661 IF( QT_USE_FRAMEWORKS )
662 SET(CMAKE_REQUIRED_FLAGS "-F${QT_LIBRARY_DIR} ")
663 ENDIF( QT_USE_FRAMEWORKS )
664 # Check for Window system symbols (note: only one should end up being set)
665 CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)
666 CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)
667 CHECK_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)
668 CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)
671 UNSET(QT_MAC_USE_COCOA CACHE)
672 ENDIF(QT_QMAKE_CHANGED)
673 CHECK_SYMBOL_EXISTS(QT_MAC_USE_COCOA "QtCore/qconfig.h" QT_MAC_USE_COCOA)
676 IF (QT_QTCOPY_REQUIRED)
677 CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)
678 IF (NOT QT_IS_QTCOPY)
679 MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found")
680 ENDIF (NOT QT_IS_QTCOPY)
681 ENDIF (QT_QTCOPY_REQUIRED)
683 # Restore CMAKE_REQUIRED_INCLUDES+CMAKE_REQUIRED_FLAGS variables
684 MACRO_POP_REQUIRED_VARS()
686 #############################################
690 ########################################
692 # Setting the INCLUDE-Variables
694 ########################################
696 SET(QT_MODULES QtCore QtGui Qt3Support QtSvg QtScript QtTest QtUiTools
697 QtHelp QtWebKit QtXmlPatterns QtNetwork QtMultimedia
698 QtNsPlugin QtOpenGL QtSql QtXml QtDesigner QtDBus QtScriptTools
702 SET(QT_MODULES ${QT_MODULES} QtMotif)
706 FOREACH(QT_MODULE ${QT_MODULES})
707 STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
708 SET(QT_${_upper_qt_module}_INCLUDE_DIR NOTFOUND)
709 SET(QT_${_upper_qt_module}_LIBRARY_RELEASE NOTFOUND)
710 SET(QT_${_upper_qt_module}_LIBRARY_DEBUG NOTFOUND)
711 ENDFOREACH(QT_MODULE)
712 SET(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR NOTFOUND)
713 SET(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NOTFOUND)
714 SET(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NOTFOUND)
715 SET(QT_QTASSISTANTCLIENT_INCLUDE_DIR NOTFOUND)
716 SET(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NOTFOUND)
717 SET(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG NOTFOUND)
718 SET(QT_QTASSISTANT_INCLUDE_DIR NOTFOUND)
719 SET(QT_QTASSISTANT_LIBRARY_RELEASE NOTFOUND)
720 SET(QT_QTASSISTANT_LIBRARY_DEBUG NOTFOUND)
721 SET(QT_QTCLUCENE_LIBRARY_RELEASE NOTFOUND)
722 SET(QT_QTCLUCENE_LIBRARY_DEBUG NOTFOUND)
723 SET(QT_QAXCONTAINER_INCLUDE_DIR NOTFOUND)
724 SET(QT_QAXCONTAINER_LIBRARY_RELEASE NOTFOUND)
725 SET(QT_QAXCONTAINER_LIBRARY_DEBUG NOTFOUND)
726 SET(QT_QAXSERVER_INCLUDE_DIR NOTFOUND)
727 SET(QT_QAXSERVER_LIBRARY_RELEASE NOTFOUND)
728 SET(QT_QAXSERVER_LIBRARY_DEBUG NOTFOUND)
730 SET(QT_QTMAIN_LIBRARY_DEBUG NOTFOUND)
731 SET(QT_QTMAIN_LIBRARY_RELEASE NOTFOUND)
733 SET(QT_PHONON_INCLUDE_DIR NOTFOUND)
734 ENDIF(QT_QMAKE_CHANGED)
736 FOREACH(QT_MODULE ${QT_MODULES})
737 STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
738 FIND_PATH(QT_${_upper_qt_module}_INCLUDE_DIR ${QT_MODULE}
740 ${QT_HEADERS_DIR}/${QT_MODULE}
741 ${QT_LIBRARY_DIR}/${QT_MODULE}.framework/Headers
744 ENDFOREACH(QT_MODULE)
747 SET(QT_MODULES ${QT_MODULES} QAxContainer QAxServer)
748 # Set QT_AXCONTAINER_INCLUDE_DIR and QT_AXSERVER_INCLUDE_DIR
749 FIND_PATH(QT_QAXCONTAINER_INCLUDE_DIR ActiveQt
751 ${QT_HEADERS_DIR}/ActiveQt
754 FIND_PATH(QT_QAXSERVER_INCLUDE_DIR ActiveQt
756 ${QT_HEADERS_DIR}/ActiveQt
761 # Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR
762 FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents
764 ${QT_HEADERS_DIR}/QtDesigner
765 ${QT_LIBRARY_DIR}/QtDesigner.framework/Headers
769 # Set QT_QTASSISTANT_INCLUDE_DIR
770 FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant
772 ${QT_HEADERS_DIR}/QtAssistant
773 ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
777 # Set QT_QTASSISTANTCLIENT_INCLUDE_DIR
778 FIND_PATH(QT_QTASSISTANTCLIENT_INCLUDE_DIR QAssistantClient
780 ${QT_HEADERS_DIR}/QtAssistant
781 ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
785 # Set QT_QT_INCLUDE_DIR
786 FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h
789 ${QT_LIBRARY_DIR}/QtCore.framework/Headers
793 # Set QT_PHONON_INCLUDE_DIR
794 # Qt >= 4.5.3 (or kde-qt-4.5.2 which has the fix too) : Phonon/ClassName is inside include/phonon
795 # With previous versions of Qt, this could not work; upgrade Qt or use a standalone phonon
796 FIND_PATH(QT_PHONON_INCLUDE_DIR Phonon
798 ${QT_HEADERS_DIR}/phonon
801 SET(QT_MODULES ${QT_MODULES} phonon)
803 # Set QT_INCLUDE_DIR by removine "/QtCore" in the string ${QT_QTCORE_INCLUDE_DIR}
804 IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
805 IF (QT_USE_FRAMEWORKS)
806 SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR})
807 ELSE (QT_USE_FRAMEWORKS)
808 STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT_QTCORE_INCLUDE_DIR})
809 SET( QT_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "")
810 ENDIF (QT_USE_FRAMEWORKS)
811 ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
813 IF( NOT QT_INCLUDE_DIR)
814 IF(Qt4_FIND_REQUIRED)
815 MESSAGE( FATAL_ERROR "Could NOT find QtCore header")
816 ENDIF(Qt4_FIND_REQUIRED)
817 ENDIF( NOT QT_INCLUDE_DIR)
819 # Make variables changeble to the advanced user
820 MARK_AS_ADVANCED( QT_INCLUDE_DIR QT_QT_INCLUDE_DIR)
823 SET( QT_INCLUDES ${QT_QT_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ${QT_INCLUDE_DIR} )
826 #######################################
830 #######################################
831 IF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
832 FILE(READ ${QT_MKSPECS_DIR}/qconfig.pri _qconfig_FILE_contents)
833 STRING(REGEX MATCH "QT_CONFIG[^\n]+" QT_QCONFIG "${_qconfig_FILE_contents}")
834 STRING(REGEX MATCH "CONFIG[^\n]+" QT_CONFIG "${_qconfig_FILE_contents}")
835 STRING(REGEX MATCH "EDITION[^\n]+" QT_EDITION "${_qconfig_FILE_contents}")
836 STRING(REGEX MATCH "QT_LIBINFIX[^\n]+" _qconfig_qt_libinfix "${_qconfig_FILE_contents}")
837 STRING(REGEX REPLACE "QT_LIBINFIX *= *([^\n]*)" "\\1" QT_LIBINFIX "${_qconfig_qt_libinfix}")
838 ENDIF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
839 IF("${QT_EDITION}" MATCHES "DesktopLight")
840 SET(QT_EDITION_DESKTOPLIGHT 1)
841 ENDIF("${QT_EDITION}" MATCHES "DesktopLight")
843 ########################################
845 # Setting the LIBRARY-Variables
847 ########################################
850 FOREACH(QT_MODULE ${QT_MODULES})
851 STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
852 FIND_LIBRARY(QT_${_upper_qt_module}_LIBRARY_RELEASE
853 NAMES ${QT_MODULE}${QT_LIBINFIX} ${QT_MODULE}${QT_LIBINFIX}4
854 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH
856 FIND_LIBRARY(QT_${_upper_qt_module}_LIBRARY_DEBUG
857 NAMES ${QT_MODULE}${QT_LIBINFIX}_debug ${QT_MODULE}${QT_LIBINFIX}d ${QT_MODULE}${QT_LIBINFIX}d4
858 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH
860 ENDFOREACH(QT_MODULE)
862 # QtUiTools not with other frameworks with binary installation (in /usr/lib)
863 IF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE)
864 FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
865 ENDIF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE)
867 IF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
869 # try dropping a hint if trying to use Visual Studio with Qt built by mingw
870 IF(QT_LIBRARY_DIR AND MSVC)
871 IF(EXISTS ${QT_LIBRARY_DIR}/libqtmain.a)
872 MESSAGE( FATAL_ERROR "It appears you're trying to use Visual Studio with Qt built by mingw")
873 ENDIF(EXISTS ${QT_LIBRARY_DIR}/libqtmain.a)
874 ENDIF(QT_LIBRARY_DIR AND MSVC)
876 IF(Qt4_FIND_REQUIRED)
877 MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
878 ENDIF(Qt4_FIND_REQUIRED)
879 ENDIF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
881 # Set QT_QTDESIGNERCOMPONENTS_LIBRARY
882 FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents${QT_LIBINFIX} QtDesignerComponents${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
883 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)
885 # Set QT_QTMAIN_LIBRARY
887 FIND_LIBRARY(QT_QTMAIN_LIBRARY_RELEASE NAMES qtmain${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR}
889 FIND_LIBRARY(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmain${QT_LIBINFIX}d PATHS ${QT_LIBRARY_DIR}
893 # Set QT_QTASSISTANTCLIENT_LIBRARY
894 FIND_LIBRARY(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
895 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)
897 # Set QT_QTASSISTANT_LIBRARY
898 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)
899 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)
901 # Set QT_QTHELP_LIBRARY
902 FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} QtCLucene${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
903 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)
904 # QtCLucene not with other frameworks with binary installation (in /usr/lib)
905 IF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE)
906 FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
907 ENDIF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE)
909 ############################################
911 # Check the existence of the libraries.
913 ############################################
915 # On OSX when Qt is found as framework, never use the imported targets for now, since
916 # in this case the handling of the framework directory currently does not work correctly.
917 IF(QT_USE_FRAMEWORKS)
918 SET(QT_USE_IMPORTED_TARGETS FALSE)
919 ENDIF(QT_USE_FRAMEWORKS)
922 MACRO (_QT4_ADJUST_LIB_VARS _camelCaseBasename)
924 STRING(TOUPPER "${_camelCaseBasename}" basename)
926 # The name of the imported targets, i.e. the prefix "Qt4::" must not change,
927 # since it is stored in EXPORT-files as name of a required library. If the name would change
928 # here, this would lead to the imported Qt4-library targets not being resolved by cmake anymore.
929 IF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
931 IF(NOT TARGET Qt4::${_camelCaseBasename})
932 ADD_LIBRARY(Qt4::${_camelCaseBasename} UNKNOWN IMPORTED )
934 IF (QT_${basename}_LIBRARY_RELEASE)
935 SET_PROPERTY(TARGET Qt4::${_camelCaseBasename} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
936 SET_PROPERTY(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_RELEASE "${QT_${basename}_LIBRARY_RELEASE}" )
937 ENDIF (QT_${basename}_LIBRARY_RELEASE)
939 IF (QT_${basename}_LIBRARY_DEBUG)
940 SET_PROPERTY(TARGET Qt4::${_camelCaseBasename} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
941 SET_PROPERTY(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_DEBUG "${QT_${basename}_LIBRARY_DEBUG}" )
942 ENDIF (QT_${basename}_LIBRARY_DEBUG)
943 ENDIF(NOT TARGET Qt4::${_camelCaseBasename})
945 # If QT_USE_IMPORTED_TARGETS is enabled, the QT_QTFOO_LIBRARY variables are set to point at these
946 # imported targets. This works better in general, and is also in almost all cases fully
947 # backward compatible. The only issue is when a project A which had this enabled then exports its
948 # libraries via export or EXPORT_LIBRARY_DEPENDENCIES(). In this case the libraries from project
949 # A will depend on the imported Qt targets, and the names of these imported targets will be stored
950 # in the dependency files on disk. This means when a project B then uses project A, these imported
951 # targets must be created again, otherwise e.g. "Qt4__QtCore" will be interpreted as name of a
952 # library file on disk, and not as a target, and linking will fail:
953 IF(QT_USE_IMPORTED_TARGETS)
954 SET(QT_${basename}_LIBRARY Qt4::${_camelCaseBasename} )
955 SET(QT_${basename}_LIBRARIES Qt4::${_camelCaseBasename} )
956 ELSE(QT_USE_IMPORTED_TARGETS)
958 # if the release- as well as the debug-version of the library have been found:
959 IF (QT_${basename}_LIBRARY_DEBUG AND QT_${basename}_LIBRARY_RELEASE)
960 # if the generator supports configuration types then set
961 # optimized and debug libraries, or if the CMAKE_BUILD_TYPE has a value
962 IF (CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
963 SET(QT_${basename}_LIBRARY optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})
964 ELSE(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
965 # if there are no configuration types and CMAKE_BUILD_TYPE has no value
966 # then just use the release libraries
967 SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE} )
968 ENDIF(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
969 SET(QT_${basename}_LIBRARIES optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})
970 ENDIF (QT_${basename}_LIBRARY_DEBUG AND QT_${basename}_LIBRARY_RELEASE)
972 # if only the release version was found, set the debug variable also to the release version
973 IF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)
974 SET(QT_${basename}_LIBRARY_DEBUG ${QT_${basename}_LIBRARY_RELEASE})
975 SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE})
976 SET(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_RELEASE})
977 ENDIF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)
979 # if only the debug version was found, set the release variable also to the debug version
980 IF (QT_${basename}_LIBRARY_DEBUG AND NOT QT_${basename}_LIBRARY_RELEASE)
981 SET(QT_${basename}_LIBRARY_RELEASE ${QT_${basename}_LIBRARY_DEBUG})
982 SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_DEBUG})
983 SET(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_DEBUG})
984 ENDIF (QT_${basename}_LIBRARY_DEBUG AND NOT QT_${basename}_LIBRARY_RELEASE)
986 # put the value in the cache:
987 SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY} CACHE STRING "The Qt ${basename} library" FORCE)
989 ENDIF(QT_USE_IMPORTED_TARGETS)
991 # message(STATUS "QT_${basename}_LIBRARY: ${QT_${basename}_LIBRARY}")
993 SET(QT_${basename}_FOUND 1)
995 ENDIF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
997 IF (QT_${basename}_INCLUDE_DIR)
998 #add the include directory to QT_INCLUDES
999 SET(QT_INCLUDES "${QT_${basename}_INCLUDE_DIR}" ${QT_INCLUDES})
1000 ENDIF (QT_${basename}_INCLUDE_DIR)
1002 # Make variables changeble to the advanced user
1003 MARK_AS_ADVANCED(QT_${basename}_LIBRARY QT_${basename}_LIBRARY_RELEASE QT_${basename}_LIBRARY_DEBUG QT_${basename}_INCLUDE_DIR)
1004 ENDMACRO (_QT4_ADJUST_LIB_VARS)
1007 # Set QT_xyz_LIBRARY variable and add
1008 # library include path to QT_INCLUDES
1009 _QT4_ADJUST_LIB_VARS(QtCore)
1010 _QT4_ADJUST_LIB_VARS(QtGui)
1011 _QT4_ADJUST_LIB_VARS(Qt3Support)
1012 _QT4_ADJUST_LIB_VARS(QtAssistant)
1013 _QT4_ADJUST_LIB_VARS(QtAssistantClient)
1014 _QT4_ADJUST_LIB_VARS(QtCLucene)
1015 _QT4_ADJUST_LIB_VARS(QtDBus)
1016 _QT4_ADJUST_LIB_VARS(QtDeclarative)
1017 _QT4_ADJUST_LIB_VARS(QtDesigner)
1018 _QT4_ADJUST_LIB_VARS(QtDesignerComponents)
1019 _QT4_ADJUST_LIB_VARS(QtHelp)
1020 _QT4_ADJUST_LIB_VARS(QtMultimedia)
1021 _QT4_ADJUST_LIB_VARS(QtNetwork)
1022 _QT4_ADJUST_LIB_VARS(QtNsPlugin)
1023 _QT4_ADJUST_LIB_VARS(QtOpenGL)
1024 _QT4_ADJUST_LIB_VARS(QtScript)
1025 _QT4_ADJUST_LIB_VARS(QtScriptTools)
1026 _QT4_ADJUST_LIB_VARS(QtSql)
1027 _QT4_ADJUST_LIB_VARS(QtSvg)
1028 _QT4_ADJUST_LIB_VARS(QtTest)
1029 _QT4_ADJUST_LIB_VARS(QtUiTools)
1030 _QT4_ADJUST_LIB_VARS(QtWebKit)
1031 _QT4_ADJUST_LIB_VARS(QtXml)
1032 _QT4_ADJUST_LIB_VARS(QtXmlPatterns)
1033 _QT4_ADJUST_LIB_VARS(phonon)
1035 # platform dependent libraries
1037 _QT4_ADJUST_LIB_VARS(QtMotif)
1040 _QT4_ADJUST_LIB_VARS(qtmain)
1041 _QT4_ADJUST_LIB_VARS(QAxServer)
1042 _QT4_ADJUST_LIB_VARS(QAxContainer)
1045 # If Qt is installed as a framework, we need to add QT_QTCORE_LIBRARY here (which
1046 # is the framework directory in that case), since this will make the cmake include_directories()
1047 # command recognize that we need the framework flag with the respective directory (-F)
1048 IF(QT_USE_FRAMEWORKS)
1049 SET(QT_INCLUDES ${QT_INCLUDES} ${QT_QTCORE_LIBRARY} )
1050 SET(QT_INCLUDE_DIR ${QT_INCLUDE_DIR} ${QT_QTCORE_LIBRARY} )
1051 ENDIF(QT_USE_FRAMEWORKS)
1055 #######################################
1057 # Check the executables of Qt
1060 #######################################
1063 IF(QT_QMAKE_CHANGED)
1064 SET(QT_UIC_EXECUTABLE NOTFOUND)
1065 SET(QT_MOC_EXECUTABLE NOTFOUND)
1066 SET(QT_UIC3_EXECUTABLE NOTFOUND)
1067 SET(QT_RCC_EXECUTABLE NOTFOUND)
1068 SET(QT_DBUSCPP2XML_EXECUTABLE NOTFOUND)
1069 SET(QT_DBUSXML2CPP_EXECUTABLE NOTFOUND)
1070 SET(QT_LUPDATE_EXECUTABLE NOTFOUND)
1071 SET(QT_LRELEASE_EXECUTABLE NOTFOUND)
1072 SET(QT_LCONVERT_EXECUTABLE NOTFOUND)
1073 SET(QT_QCOLLECTIONGENERATOR_EXECUTABLE NOTFOUND)
1074 SET(QT_DESIGNER_EXECUTABLE NOTFOUND)
1075 SET(QT_LINGUIST_EXECUTABLE NOTFOUND)
1076 ENDIF(QT_QMAKE_CHANGED)
1078 FIND_PROGRAM(QT_MOC_EXECUTABLE
1080 PATHS ${QT_BINARY_DIR}
1084 FIND_PROGRAM(QT_UIC_EXECUTABLE
1086 PATHS ${QT_BINARY_DIR}
1090 FIND_PROGRAM(QT_UIC3_EXECUTABLE
1092 PATHS ${QT_BINARY_DIR}
1096 FIND_PROGRAM(QT_RCC_EXECUTABLE
1098 PATHS ${QT_BINARY_DIR}
1102 FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE
1104 PATHS ${QT_BINARY_DIR}
1108 FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE
1110 PATHS ${QT_BINARY_DIR}
1114 FIND_PROGRAM(QT_LUPDATE_EXECUTABLE
1115 NAMES lupdate-qt4 lupdate
1116 PATHS ${QT_BINARY_DIR}
1120 FIND_PROGRAM(QT_LRELEASE_EXECUTABLE
1121 NAMES lrelease-qt4 lrelease
1122 PATHS ${QT_BINARY_DIR}
1126 FIND_PROGRAM(QT_LCONVERT_EXECUTABLE
1127 NAMES lconvert-qt4 lconvert
1128 PATHS ${QT_BINARY_DIR}
1132 FIND_PROGRAM(QT_QCOLLECTIONGENERATOR_EXECUTABLE
1133 NAMES qcollectiongenerator-qt4 qcollectiongenerator
1134 PATHS ${QT_BINARY_DIR}
1138 FIND_PROGRAM(QT_DESIGNER_EXECUTABLE
1139 NAMES designer-qt4 designer
1140 PATHS ${QT_BINARY_DIR}
1144 FIND_PROGRAM(QT_LINGUIST_EXECUTABLE
1145 NAMES linguist-qt4 linguist
1146 PATHS ${QT_BINARY_DIR}
1150 IF (QT_MOC_EXECUTABLE)
1151 SET(QT_WRAP_CPP "YES")
1152 ENDIF (QT_MOC_EXECUTABLE)
1154 IF (QT_UIC_EXECUTABLE)
1155 SET(QT_WRAP_UI "YES")
1156 ENDIF (QT_UIC_EXECUTABLE)
1160 MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE
1161 QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE
1162 QT_LUPDATE_EXECUTABLE QT_LRELEASE_EXECUTABLE QT_QCOLLECTIONGENERATOR_EXECUTABLE
1163 QT_DESIGNER_EXECUTABLE QT_LINGUIST_EXECUTABLE)
1166 # get the directory of the current file, used later on in the file
1167 GET_FILENAME_COMPONENT( _qt4_current_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
1169 ######################################
1171 # Macros for building Qt files
1173 ######################################
1175 INCLUDE("${_qt4_current_dir}/Qt4Macros.cmake")
1178 ######################################
1180 # decide if Qt got found
1182 ######################################
1184 # if the includes,libraries,moc,uic and rcc are found then we have it
1185 IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1186 QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1187 SET( QT4_FOUND "YES" )
1188 IF( NOT Qt4_FIND_QUIETLY)
1189 MESSAGE(STATUS "Found Qt-Version ${QTVERSION} (using ${QT_QMAKE_EXECUTABLE})")
1190 ENDIF( NOT Qt4_FIND_QUIETLY)
1191 ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1192 QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1193 SET( QT4_FOUND "NO")
1194 SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1195 IF( Qt4_FIND_REQUIRED)
1196 IF ( NOT QT_LIBRARY_DIR )
1197 MESSAGE(STATUS "Qt libraries NOT found!")
1198 ENDIF(NOT QT_LIBRARY_DIR )
1199 IF ( NOT QT_INCLUDE_DIR )
1200 MESSAGE(STATUS "Qt includes NOT found!")
1201 ENDIF( NOT QT_INCLUDE_DIR )
1202 IF ( NOT QT_MOC_EXECUTABLE )
1203 MESSAGE(STATUS "Qt's moc NOT found!")
1204 ENDIF( NOT QT_MOC_EXECUTABLE )
1205 IF ( NOT QT_UIC_EXECUTABLE )
1206 MESSAGE(STATUS "Qt's uic NOT found!")
1207 ENDIF( NOT QT_UIC_EXECUTABLE )
1208 IF ( NOT QT_RCC_EXECUTABLE )
1209 MESSAGE(STATUS "Qt's rcc NOT found!")
1210 ENDIF( NOT QT_RCC_EXECUTABLE )
1211 MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")
1212 ENDIF( Qt4_FIND_REQUIRED)
1213 ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1214 QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1216 SET(QT_FOUND ${QT4_FOUND})
1219 ###############################################
1221 # configuration/system dependent settings
1223 ###############################################
1225 INCLUDE("${_qt4_current_dir}/Qt4ConfigDependentSettings.cmake")
1228 #######################################
1230 # compatibility settings
1232 #######################################
1233 # Backwards compatibility for CMake1.4 and 1.2
1234 SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
1235 SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
1237 SET( QT_QT_LIBRARY "")
1239 ELSE(QT4_QMAKE_FOUND)
1241 SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1243 # The code below is overly complex to make sure we do not break compatibility with CMake 2.6.x
1244 # For CMake 2.8, it should be simplified by getting rid of QT4_INSTALLED_VERSION_TOO_OLD and
1245 # QT4_INSTALLED_VERSION_TOO_NEW
1246 IF(Qt4_FIND_REQUIRED)
1247 IF(QT4_INSTALLED_VERSION_TOO_OLD)
1248 IF( Qt4_FIND_VERSION_EXACT )
1249 MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, version ${QT_MIN_VERSION} is required")
1250 ELSE( Qt4_FIND_VERSION_EXACT )
1251 MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1252 ENDIF( Qt4_FIND_VERSION_EXACT )
1253 ELSE(QT4_INSTALLED_VERSION_TOO_OLD)
1254 IF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1255 MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too new, version ${QT_MIN_VERSION} is required")
1256 ELSE( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1257 MESSAGE( FATAL_ERROR "Qt qmake not found!")
1258 ENDIF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1259 ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)
1260 ELSE(Qt4_FIND_REQUIRED)
1261 IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1262 MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1263 ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1264 ENDIF(Qt4_FIND_REQUIRED)
1266 ENDIF (QT4_QMAKE_FOUND)