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
55 # There are also some files that need processing by some Qt tools such as moc
56 # and uic. Listed below are macros that may be used to process those files.
58 # macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
59 # create moc code from a list of files containing Qt class with
60 # the Q_OBJECT declaration. Per-direcotry preprocessor definitions
61 # are also added. Options may be given to moc, such as those found
62 # when executing "moc -help".
64 # macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
65 # create code from a list of Qt designer ui files.
66 # Options may be given to uic, such as those found
67 # when executing "uic -help"
69 # macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
70 # create code from a list of Qt resource files.
71 # Options may be given to rcc, such as those found
72 # when executing "rcc -help"
74 # macro QT4_GENERATE_MOC(inputfile outputfile )
75 # creates a rule to run moc on infile and create outfile.
76 # Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
77 # because you need a custom filename for the moc file or something similar.
79 # macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... )
80 # This macro is still experimental.
81 # It can be used to have moc automatically handled.
82 # So if you have the files foo.h and foo.cpp, and in foo.h a
83 # a class uses the Q_OBJECT macro, moc has to run on it. If you don't
84 # want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
86 # in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
87 # scan all listed files at cmake-time for such included moc files and if it finds
88 # them cause a rule to be generated to run moc at build time on the
89 # accompanying header file foo.h.
90 # If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.
92 # macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
93 # create a the interface header and implementation files with the
94 # given basename from the given interface xml file and add it to
95 # the list of sources.
96 # To disable generating a namespace header, set the source file property
97 # NO_NAMESPACE to TRUE on the interface file.
98 # To include a header in the interface header, set the source file property
99 # INCLUDE to the name of the header.
100 # To specify a class name to use, set the source file property CLASSNAME
101 # to the name of the class.
103 # macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
104 # create the interface header and implementation files
105 # for all listed interface xml files
106 # the name will be automatically determined from the name of the xml file
107 # To disable generating namespace headers, set the source file property
108 # NO_NAMESPACE to TRUE for these inputfiles.
109 # To include a header in the interface header, set the source file property
110 # INCLUDE to the name of the header.
111 # To specify a class name to use, set the source file property CLASSNAME
112 # to the name of the class.
114 # macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])
115 # create a dbus adaptor (header and implementation file) from the xml file
116 # describing the interface, and add it to the list of sources. The adaptor
117 # forwards the calls to a parent class, defined in parentheader and named
118 # parentclassname. The name of the generated files will be
119 # <basename>adaptor.{cpp,h} where basename defaults to the basename of the xml file.
120 # If <classname> is provided, then it will be used as the classname of the
123 # macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
124 # generate the xml interface file from the given header.
125 # If the optional argument interfacename is omitted, the name of the
126 # interface file is constructed from the basename of the header with
127 # the suffix .xml appended.
128 # Options may be given to qdbuscpp2xml, such as those found when executing "qdbuscpp2xml --help"
130 # macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ...
131 # ts_files ... OPTIONS ...)
133 # in: directories sources ts_files
134 # options: flags to pass to lupdate, such as -extensions to specify
135 # extensions for a directory scan.
136 # generates commands to create .ts (vie lupdate) and .qm
137 # (via lrelease) - files from directories and/or sources. The ts files are
138 # created and/or updated in the source tree (unless given with full paths).
139 # The qm files are generated in the build tree.
140 # Updating the translations can be done by adding the qm_files
141 # to the source list of your library/executable, so they are
142 # always updated, or by adding a custom target to control when
143 # they get updated/generated.
145 # macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
148 # generates commands to create .qm from .ts - files. The generated
149 # filenames can be found in qm_files. The ts_files
150 # must exists and are not updated in any way.
153 # Below is a detailed list of variables that FindQt4.cmake sets.
154 # QT_FOUND If false, don't try to use Qt.
155 # QT4_FOUND If false, don't try to use Qt 4.
157 # QT_VERSION_MAJOR The major version of Qt found.
158 # QT_VERSION_MINOR The minor version of Qt found.
159 # QT_VERSION_PATCH The patch version of Qt found.
161 # QT_EDITION Set to the edition of Qt (i.e. DesktopLight)
162 # QT_EDITION_DESKTOPLIGHT True if QT_EDITION == DesktopLight
163 # QT_QTCORE_FOUND True if QtCore was found.
164 # QT_QTGUI_FOUND True if QtGui was found.
165 # QT_QT3SUPPORT_FOUND True if Qt3Support was found.
166 # QT_QTASSISTANT_FOUND True if QtAssistant was found.
167 # QT_QTASSISTANTCLIENT_FOUND True if QtAssistantClient was found.
168 # QT_QAXCONTAINER_FOUND True if QAxContainer was found (Windows only).
169 # QT_QAXSERVER_FOUND True if QAxServer was found (Windows only).
170 # QT_QTDBUS_FOUND True if QtDBus was found.
171 # QT_QTDESIGNER_FOUND True if QtDesigner was found.
172 # QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.
173 # QT_QTHELP_FOUND True if QtHelp was found.
174 # QT_QTMOTIF_FOUND True if QtMotif was found.
175 # QT_QTMULTIMEDIA_FOUND True if QtMultimedia was found (since Qt 4.6.0).
176 # QT_QTNETWORK_FOUND True if QtNetwork was found.
177 # QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found.
178 # QT_QTOPENGL_FOUND True if QtOpenGL was found.
179 # QT_QTSQL_FOUND True if QtSql was found.
180 # QT_QTSVG_FOUND True if QtSvg was found.
181 # QT_QTSCRIPT_FOUND True if QtScript was found.
182 # QT_QTSCRIPTTOOLS_FOUND True if QtScriptTools was found.
183 # QT_QTTEST_FOUND True if QtTest was found.
184 # QT_QTUITOOLS_FOUND True if QtUiTools was found.
185 # QT_QTWEBKIT_FOUND True if QtWebKit was found.
186 # QT_QTXML_FOUND True if QtXml was found.
187 # QT_QTXMLPATTERNS_FOUND True if QtXmlPatterns was found.
188 # QT_PHONON_FOUND True if phonon was found.
190 # QT_MAC_USE_COCOA For Mac OS X, its whether Cocoa or Carbon is used.
191 # In general, this should not be used, but its useful
192 # when having platform specific code.
194 # QT_DEFINITIONS Definitions to use when compiling code that uses Qt.
195 # You do not need to use this if you include QT_USE_FILE.
196 # The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
197 # to fit your current build type. Those are not contained
200 # QT_INCLUDES List of paths to all include directories of
201 # Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
202 # always in this variable even if NOTFOUND,
203 # all other INCLUDE_DIRS are
204 # only added if they are found.
205 # You do not need to use this if you include QT_USE_FILE.
208 # Include directories for the Qt modules are listed here.
209 # You do not need to use these variables if you include QT_USE_FILE.
211 # QT_INCLUDE_DIR Path to "include" of Qt4
212 # QT_QT_INCLUDE_DIR Path to "include/Qt"
213 # QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support"
214 # QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant"
215 # QT_QTASSISTANTCLIENT_INCLUDE_DIR Path to "include/QtAssistant"
216 # QT_QAXCONTAINER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
217 # QT_QAXSERVER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
218 # QT_QTCORE_INCLUDE_DIR Path to "include/QtCore"
219 # QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus"
220 # QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner"
221 # QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner"
222 # QT_QTGUI_INCLUDE_DIR Path to "include/QtGui"
223 # QT_QTHELP_INCLUDE_DIR Path to "include/QtHelp"
224 # QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif"
225 # QT_QTMULTIMEDIA_INCLUDE_DIR Path to "include/QtMultimedia"
226 # QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork"
227 # QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin"
228 # QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL"
229 # QT_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript"
230 # QT_QTSQL_INCLUDE_DIR Path to "include/QtSql"
231 # QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg"
232 # QT_QTTEST_INCLUDE_DIR Path to "include/QtTest"
233 # QT_QTWEBKIT_INCLUDE_DIR Path to "include/QtWebKit"
234 # QT_QTXML_INCLUDE_DIR Path to "include/QtXml"
235 # QT_QTXMLPATTERNS_INCLUDE_DIR Path to "include/QtXmlPatterns"
236 # QT_PHONON_INCLUDE_DIR Path to "include/phonon"
237 # QT_QTSCRIPTTOOLS_INCLUDE_DIR Path to "include/QtScriptTools"
239 # QT_BINARY_DIR Path to "bin" of Qt4
240 # QT_LIBRARY_DIR Path to "lib" of Qt4
241 # QT_PLUGINS_DIR Path to "plugins" for Qt4
242 # QT_TRANSLATIONS_DIR Path to "translations" of Qt4
243 # QT_DOC_DIR Path to "doc" of Qt4
244 # QT_MKSPECS_DIR Path to "mkspecs" of Qt4
247 # For every library of Qt, a QT_QTFOO_LIBRARY variable is defined, with the full path to the library.
249 # So there are the following variables:
250 # The Qt3Support library: QT_QT3SUPPORT_LIBRARY
252 # The QtAssistant library: QT_QTASSISTANT_LIBRARY
254 # The QtAssistantClient library: QT_QTASSISTANTCLIENT_LIBRARY
256 # The QAxServer library: QT_QAXSERVER_LIBRARY
258 # The QAxContainer library: QT_QAXCONTAINER_LIBRARY
260 # The QtCore library: QT_QTCORE_LIBRARY
262 # The QtDBus library: QT_QTDBUS_LIBRARY
264 # The QtDesigner library: QT_QTDESIGNER_LIBRARY
266 # The QtDesignerComponents library: QT_QTDESIGNERCOMPONENTS_LIBRARY
268 # The QtGui library: QT_QTGUI_LIBRARY
270 # The QtHelp library: QT_QTHELP_LIBRARY
272 # The QtMotif library: QT_QTMOTIF_LIBRARY
274 # The QtMultimedia library: QT_QTMULTIMEDIA_LIBRARY
276 # The QtNetwork library: QT_QTNETWORK_LIBRARY
278 # The QtNsPLugin library: QT_QTNSPLUGIN_LIBRARY
280 # The QtOpenGL library: QT_QTOPENGL_LIBRARY
282 # The QtScript library: QT_QTSCRIPT_LIBRARY
284 # The QtScriptTools library: QT_QTSCRIPTTOOLS_LIBRARY
286 # The QtSql library: QT_QTSQL_LIBRARY
288 # The QtSvg library: QT_QTSVG_LIBRARY
290 # The QtTest library: QT_QTTEST_LIBRARY
292 # The QtUiTools library: QT_QTUITOOLS_LIBRARY
294 # The QtWebKit library: QT_QTWEBKIT_LIBRARY
296 # The QtXml library: QT_QTXML_LIBRARY
298 # The QtXmlPatterns library: QT_QTXMLPATTERNS_LIBRARY
300 # The qtmain library for Windows QT_QTMAIN_LIBRARY
302 # The Phonon library: QT_PHONON_LIBRARY
304 # also defined, but NOT for general use are
305 # QT_MOC_EXECUTABLE Where to find the moc tool.
306 # QT_UIC_EXECUTABLE Where to find the uic tool.
307 # QT_UIC3_EXECUTABLE Where to find the uic3 tool.
308 # QT_RCC_EXECUTABLE Where to find the rcc tool
309 # QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool.
310 # QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool.
311 # QT_LUPDATE_EXECUTABLE Where to find the lupdate tool.
312 # QT_LRELEASE_EXECUTABLE Where to find the lrelease tool.
313 # QT_LCONVERT_EXECUTABLE Where to find the lconvert tool.
314 # QT_QCOLLECTIONGENERATOR_EXECUTABLE Where to find the qcollectiongenerator tool.
315 # QT_DESIGNER_EXECUTABLE Where to find the Qt designer tool.
316 # QT_LINGUIST_EXECUTABLE Where to find the Qt linguist tool.
319 # These are around for backwards compatibility
321 # QT_WRAP_CPP Set true if QT_MOC_EXECUTABLE is found
322 # QT_WRAP_UI Set true if QT_UIC_EXECUTABLE is found
324 # These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)
325 # QT_MT_REQUIRED Qt4 is now always multithreaded
327 # These variables are set to "" Because Qt structure changed
328 # (They make no sense in Qt4)
329 # QT_QT_LIBRARY Qt-Library is now split
331 # Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
332 # See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
334 # Use FIND_PACKAGE( Qt4 COMPONENTS ... ) to enable modules
335 IF( Qt4_FIND_COMPONENTS )
336 FOREACH( component ${Qt4_FIND_COMPONENTS} )
337 STRING( TOUPPER ${component} _COMPONENT )
338 SET( QT_USE_${_COMPONENT} 1 )
339 ENDFOREACH( component )
341 # To make sure we don't use QtCore or QtGui when not in COMPONENTS
342 IF(NOT QT_USE_QTCORE)
343 SET( QT_DONT_USE_QTCORE 1 )
344 ENDIF(NOT QT_USE_QTCORE)
347 SET( QT_DONT_USE_QTGUI 1 )
348 ENDIF(NOT QT_USE_QTGUI)
350 ENDIF( Qt4_FIND_COMPONENTS )
352 # If Qt3 has already been found, fail.
354 IF(Qt4_FIND_REQUIRED)
355 MESSAGE( FATAL_ERROR "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
356 ELSE(Qt4_FIND_REQUIRED)
357 IF(NOT Qt4_FIND_QUIETLY)
358 MESSAGE( STATUS "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.")
359 ENDIF(NOT Qt4_FIND_QUIETLY)
361 ENDIF(Qt4_FIND_REQUIRED)
366 # Check already done in this cmake run, nothing more to do
368 ENDIF (QT4_QMAKE_FOUND)
370 # check that QT_NO_DEBUG is defined for release configurations
371 MACRO(QT_CHECK_FLAG_EXISTS FLAG VAR DOC)
372 IF(NOT ${VAR} MATCHES "${FLAG}")
373 SET(${VAR} "${${VAR}} ${FLAG}"
374 CACHE STRING "Flags used by the compiler during ${DOC} builds." FORCE)
375 ENDIF(NOT ${VAR} MATCHES "${FLAG}")
376 ENDMACRO(QT_CHECK_FLAG_EXISTS FLAG VAR)
378 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO "Release with Debug Info")
379 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELEASE "release")
380 QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL "release minsize")
382 INCLUDE(MacroPushRequiredVars)
383 INCLUDE(CheckSymbolExists)
384 INCLUDE(MacroAddFileDependencies)
386 SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
388 SET( QT_DEFINITIONS "")
390 SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)
392 # macro for asking qmake to process pro files
393 MACRO(QT_QUERY_QMAKE outvar invar)
394 IF(QT_QMAKE_EXECUTABLE)
395 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro
396 "message(CMAKE_MESSAGE<$$${invar}>)")
398 # Invoke qmake with the tmp.pro program to get the desired
399 # information. Use the same variable for both stdout and stderr
400 # to make sure we get the output on all platforms.
401 EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}
403 ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake
404 OUTPUT_VARIABLE _qmake_query_output
405 RESULT_VARIABLE _qmake_result
406 ERROR_VARIABLE _qmake_query_output )
409 "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake")
412 MESSAGE(WARNING " querying qmake for ${invar}. qmake reported:\n${_qmake_query_output}")
414 STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}")
417 ENDIF(QT_QMAKE_EXECUTABLE)
418 ENDMACRO(QT_QUERY_QMAKE)
420 GET_FILENAME_COMPONENT(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME)
422 # Debian uses qmake-qt4
423 # macports' Qt uses qmake-mac
424 FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 qmake-mac PATHS
425 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
426 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
427 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]/bin"
431 IF (QT_QMAKE_EXECUTABLE)
433 IF(QT_QMAKE_EXECUTABLE_LAST)
434 STRING(COMPARE NOTEQUAL "${QT_QMAKE_EXECUTABLE_LAST}" "${QT_QMAKE_EXECUTABLE}" QT_QMAKE_CHANGED)
435 ENDIF(QT_QMAKE_EXECUTABLE_LAST)
437 SET(QT_QMAKE_EXECUTABLE_LAST "${QT_QMAKE_EXECUTABLE}" CACHE INTERNAL "" FORCE)
439 SET(QT4_QMAKE_FOUND FALSE)
441 EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
443 # check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
444 IF("${QTVERSION}" MATCHES "Unknown")
445 SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
446 FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS
447 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
448 "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
451 IF(QT_QMAKE_EXECUTABLE)
452 EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
453 ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
454 ENDIF(QT_QMAKE_EXECUTABLE)
455 ENDIF("${QTVERSION}" MATCHES "Unknown")
457 # check that we found the Qt4 qmake, Qt3 qmake output won't match here
458 STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")
461 # we need at least version 4.0.0
462 IF (NOT QT_MIN_VERSION)
463 SET(QT_MIN_VERSION "4.0.0")
464 ENDIF (NOT QT_MIN_VERSION)
466 #now parse the parts of the user given version string into variables
467 STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}")
468 IF (NOT req_qt_major_vers)
469 MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"")
470 ENDIF (NOT req_qt_major_vers)
472 # now parse the parts of the user given version string into variables
473 STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}")
474 STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}")
475 STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}")
477 # Suppport finding at least a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 )
478 # This implementation is a hack to avoid duplicating code and make sure we stay
479 # source-compatible with CMake 2.6.x
480 IF( Qt4_FIND_VERSION )
481 SET( QT_MIN_VERSION ${Qt4_FIND_VERSION} )
482 SET( req_qt_major_vers ${Qt4_FIND_VERSION_MAJOR} )
483 SET( req_qt_minor_vers ${Qt4_FIND_VERSION_MINOR} )
484 SET( req_qt_patch_vers ${Qt4_FIND_VERSION_PATCH} )
485 ENDIF( Qt4_FIND_VERSION )
487 IF (NOT req_qt_major_vers EQUAL 4)
488 MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")
489 ENDIF (NOT req_qt_major_vers EQUAL 4)
491 # and now the version string given by qmake
492 STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" QT_VERSION_MAJOR "${QTVERSION}")
493 STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" QT_VERSION_MINOR "${QTVERSION}")
494 STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" QT_VERSION_PATCH "${QTVERSION}")
496 # compute an overall version number which can be compared at once
497 MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")
498 MATH(EXPR found_vers "${QT_VERSION_MAJOR}*10000 + ${QT_VERSION_MINOR}*100 + ${QT_VERSION_PATCH}")
500 # Support finding *exactly* a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 EXACT )
501 IF( Qt4_FIND_VERSION_EXACT )
502 IF(found_vers EQUAL req_vers)
503 SET( QT4_QMAKE_FOUND TRUE )
504 ELSE(found_vers EQUAL req_vers)
505 SET( QT4_QMAKE_FOUND FALSE )
506 IF (found_vers LESS req_vers)
507 SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
508 ELSE (found_vers LESS req_vers)
509 SET(QT4_INSTALLED_VERSION_TOO_NEW TRUE)
510 ENDIF (found_vers LESS req_vers)
511 ENDIF(found_vers EQUAL req_vers)
512 ELSE( Qt4_FIND_VERSION_EXACT )
513 IF (found_vers LESS req_vers)
514 SET(QT4_QMAKE_FOUND FALSE)
515 SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
516 ELSE (found_vers LESS req_vers)
517 SET(QT4_QMAKE_FOUND TRUE)
518 ENDIF (found_vers LESS req_vers)
519 ENDIF( Qt4_FIND_VERSION_EXACT )
520 ENDIF (qt_version_tmp)
522 ENDIF (QT_QMAKE_EXECUTABLE)
528 get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )
529 get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )
532 # ask qmake for the library dir
534 IF (NOT QT_LIBRARY_DIR OR QT_QMAKE_CHANGED)
535 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
536 ARGS "-query QT_INSTALL_LIBS"
537 OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP )
538 # make sure we have / and not \ as qmake gives on windows
539 FILE(TO_CMAKE_PATH "${QT_LIBRARY_DIR_TMP}" QT_LIBRARY_DIR_TMP)
540 IF(EXISTS "${QT_LIBRARY_DIR_TMP}")
541 SET(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir" FORCE)
542 ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}")
543 MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT_LIBRARY_DIR_TMP}")
544 MESSAGE("Warning: ${QT_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.")
545 ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}")
546 ENDIF(NOT QT_LIBRARY_DIR OR QT_QMAKE_CHANGED)
549 IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
550 SET(QT_USE_FRAMEWORKS ON
551 CACHE BOOL "Set to ON if Qt build uses frameworks." FORCE)
552 ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
553 SET(QT_USE_FRAMEWORKS OFF
554 CACHE BOOL "Set to ON if Qt build uses frameworks." FORCE)
555 ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
557 MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)
560 # ask qmake for the binary dir
561 IF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR OR QT_QMAKE_CHANGED)
562 EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
563 ARGS "-query QT_INSTALL_BINS"
564 OUTPUT_VARIABLE qt_bins )
565 # make sure we have / and not \ as qmake gives on windows
566 FILE(TO_CMAKE_PATH "${qt_bins}" qt_bins)
567 SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "" FORCE)
568 ENDIF (QT_LIBRARY_DIR AND NOT QT_BINARY_DIR OR QT_QMAKE_CHANGED)
570 # ask qmake for the include dir
571 IF (QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR OR QT_QMAKE_CHANGED)
572 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
573 ARGS "-query QT_INSTALL_HEADERS"
574 OUTPUT_VARIABLE qt_headers )
575 # make sure we have / and not \ as qmake gives on windows
576 FILE(TO_CMAKE_PATH "${qt_headers}" qt_headers)
577 SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "" FORCE)
578 ENDIF (QT_LIBRARY_DIR AND NOT QT_HEADERS_DIR OR QT_QMAKE_CHANGED)
581 # ask qmake for the documentation directory
582 IF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR OR QT_QMAKE_CHANGED)
583 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
584 ARGS "-query QT_INSTALL_DOCS"
585 OUTPUT_VARIABLE qt_doc_dir )
586 # make sure we have / and not \ as qmake gives on windows
587 FILE(TO_CMAKE_PATH "${qt_doc_dir}" qt_doc_dir)
588 SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs" FORCE)
589 ENDIF (QT_LIBRARY_DIR AND NOT QT_DOC_DIR OR QT_QMAKE_CHANGED)
591 # ask qmake for the mkspecs directory
592 IF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR OR QT_QMAKE_CHANGED)
593 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
594 ARGS "-query QMAKE_MKSPECS"
595 OUTPUT_VARIABLE qt_mkspecs_dirs )
596 # do not replace : on windows as it might be a drive letter
597 # and windows should already use ; as a separator
599 STRING(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}")
601 SET(QT_MKSPECS_DIR NOTFOUND)
602 FIND_PATH(QT_MKSPECS_DIR qconfig.pri PATHS ${qt_mkspecs_dirs}
603 DOC "The location of the Qt mkspecs containing qconfig.pri"
605 ENDIF (QT_LIBRARY_DIR AND NOT QT_MKSPECS_DIR OR QT_QMAKE_CHANGED)
607 # ask qmake for the plugins directory
608 IF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR OR QT_QMAKE_CHANGED)
609 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
610 ARGS "-query QT_INSTALL_PLUGINS"
611 OUTPUT_VARIABLE qt_plugins_dir )
612 # make sure we have / and not \ as qmake gives on windows
613 FILE(TO_CMAKE_PATH "${qt_plugins_dir}" qt_plugins_dir)
614 SET(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins" FORCE)
615 ENDIF (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR OR QT_QMAKE_CHANGED)
617 # ask qmake for the translations directory
618 IF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR OR QT_QMAKE_CHANGED)
619 EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
620 ARGS "-query QT_INSTALL_TRANSLATIONS"
621 OUTPUT_VARIABLE qt_translations_dir )
622 # make sure we have / and not \ as qmake gives on windows
623 FILE(TO_CMAKE_PATH "${qt_translations_dir}" qt_translations_dir)
624 SET(QT_TRANSLATIONS_DIR ${qt_translations_dir} CACHE PATH "The location of the Qt translations" FORCE)
625 ENDIF (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR OR QT_QMAKE_CHANGED)
627 # Make variables changeble to the advanced user
628 MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_DOC_DIR QT_MKSPECS_DIR
629 QT_PLUGINS_DIR QT_TRANSLATIONS_DIR)
632 #############################################
634 # Find out what window system we're using
636 #############################################
637 # Save required includes and required_flags variables
638 MACRO_PUSH_REQUIRED_VARS()
639 # Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES
640 SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_HEADERS_DIR}")
641 # On Mac OS X when Qt has framework support, also add the framework path
642 IF( QT_USE_FRAMEWORKS )
643 SET(CMAKE_REQUIRED_FLAGS "-F${QT_LIBRARY_DIR} ")
644 ENDIF( QT_USE_FRAMEWORKS )
645 # Check for Window system symbols (note: only one should end up being set)
646 CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)
647 CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)
648 CHECK_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)
649 CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)
652 SET(QT_MAC_USE_COCOA "" CACHE BOOL "Use Cocoa on Mac" FORCE)
653 ENDIF(QT_QMAKE_CHANGED)
654 CHECK_SYMBOL_EXISTS(QT_MAC_USE_COCOA "QtCore/qconfig.h" QT_MAC_USE_COCOA)
657 IF (QT_QTCOPY_REQUIRED)
658 CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)
659 IF (NOT QT_IS_QTCOPY)
660 MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found")
661 ENDIF (NOT QT_IS_QTCOPY)
662 ENDIF (QT_QTCOPY_REQUIRED)
664 # Restore CMAKE_REQUIRED_INCLUDES+CMAKE_REQUIRED_FLAGS variables
665 MACRO_POP_REQUIRED_VARS()
667 #############################################
671 ########################################
673 # Setting the INCLUDE-Variables
675 ########################################
677 SET(QT_MODULES QtCore QtGui Qt3Support QtSvg QtScript QtTest QtUiTools
678 QtHelp QtWebKit QtXmlPatterns QtNetwork QtMultimedia
679 QtNsPlugin QtOpenGL QtSql QtXml QtDesigner QtDBus QtScriptTools)
682 SET(QT_MODULES ${QT_MODULES} QtMotif)
686 FOREACH(QT_MODULE ${QT_MODULES})
687 STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
688 SET(QT_${_upper_qt_module}_INCLUDE_DIR NOTFOUND)
689 SET(QT_${_upper_qt_module}_LIBRARY_RELEASE NOTFOUND)
690 SET(QT_${_upper_qt_module}_LIBRARY_DEBUG NOTFOUND)
691 ENDFOREACH(QT_MODULE)
692 SET(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR NOTFOUND)
693 SET(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NOTFOUND)
694 SET(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NOTFOUND)
695 SET(QT_QTASSISTANTCLIENT_INCLUDE_DIR NOTFOUND)
696 SET(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NOTFOUND)
697 SET(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG NOTFOUND)
698 SET(QT_QTASSISTANT_INCLUDE_DIR NOTFOUND)
699 SET(QT_QTASSISTANT_LIBRARY_RELEASE NOTFOUND)
700 SET(QT_QTASSISTANT_LIBRARY_DEBUG NOTFOUND)
701 SET(QT_QTCLUCENE_LIBRARY_RELEASE NOTFOUND)
702 SET(QT_QTCLUCENE_LIBRARY_DEBUG NOTFOUND)
703 SET(QT_QAXCONTAINER_INCLUDE_DIR NOTFOUND)
704 SET(QT_QAXCONTAINER_LIBRARY_RELEASE NOTFOUND)
705 SET(QT_QAXCONTAINER_LIBRARY_DEBUG NOTFOUND)
706 SET(QT_QAXSERVER_INCLUDE_DIR NOTFOUND)
707 SET(QT_QAXSERVER_LIBRARY_RELEASE NOTFOUND)
708 SET(QT_QAXSERVER_LIBRARY_DEBUG NOTFOUND)
710 SET(QT_QTMAIN_LIBRARY_DEBUG NOTFOUND)
711 SET(QT_QTMAIN_LIBRARY_RELEASE NOTFOUND)
713 SET(QT_PHONON_INCLUDE_DIR NOTFOUND)
714 ENDIF(QT_QMAKE_CHANGED)
716 FOREACH(QT_MODULE ${QT_MODULES})
717 STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
718 FIND_PATH(QT_${_upper_qt_module}_INCLUDE_DIR ${QT_MODULE}
720 ${QT_HEADERS_DIR}/${QT_MODULE}
721 ${QT_LIBRARY_DIR}/${QT_MODULE}.framework/Headers
724 ENDFOREACH(QT_MODULE)
727 SET(QT_MODULES ${QT_MODULES} QAxContainer QAxServer)
728 # Set QT_AXCONTAINER_INCLUDE_DIR and QT_AXSERVER_INCLUDE_DIR
729 FIND_PATH(QT_QAXCONTAINER_INCLUDE_DIR ActiveQt
731 ${QT_HEADERS_DIR}/ActiveQt
734 FIND_PATH(QT_QAXSERVER_INCLUDE_DIR ActiveQt
736 ${QT_HEADERS_DIR}/ActiveQt
741 # Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR
742 FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents
744 ${QT_HEADERS_DIR}/QtDesigner
745 ${QT_LIBRARY_DIR}/QtDesigner.framework/Headers
749 # Set QT_QTASSISTANT_INCLUDE_DIR
750 FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant
752 ${QT_HEADERS_DIR}/QtAssistant
753 ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
757 # Set QT_QTASSISTANTCLIENT_INCLUDE_DIR
758 FIND_PATH(QT_QTASSISTANTCLIENT_INCLUDE_DIR QAssistantClient
760 ${QT_HEADERS_DIR}/QtAssistant
761 ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
765 # Set QT_QT_INCLUDE_DIR
766 FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h
769 ${QT_LIBRARY_DIR}/QtCore.framework/Headers
773 # Set QT_PHONON_INCLUDE_DIR
774 # Qt >= 4.5.3 (or kde-qt-4.5.2 which has the fix too) : Phonon/ClassName is inside include/phonon
775 # With previous versions of Qt, this could not work; upgrade Qt or use a standalone phonon
776 FIND_PATH(QT_PHONON_INCLUDE_DIR Phonon
778 ${QT_HEADERS_DIR}/phonon
781 SET(QT_MODULES ${QT_MODULES} phonon)
783 # Set QT_INCLUDE_DIR by removine "/QtCore" in the string ${QT_QTCORE_INCLUDE_DIR}
784 IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
785 IF (QT_USE_FRAMEWORKS)
786 SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR})
787 ELSE (QT_USE_FRAMEWORKS)
788 STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT_QTCORE_INCLUDE_DIR})
789 SET( QT_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "")
790 ENDIF (QT_USE_FRAMEWORKS)
791 ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
793 IF( NOT QT_INCLUDE_DIR)
794 IF(Qt4_FIND_REQUIRED)
795 MESSAGE( FATAL_ERROR "Could NOT find QtCore header")
796 ENDIF(Qt4_FIND_REQUIRED)
797 ENDIF( NOT QT_INCLUDE_DIR)
799 # Make variables changeble to the advanced user
800 MARK_AS_ADVANCED( QT_INCLUDE_DIR QT_QT_INCLUDE_DIR)
803 SET( QT_INCLUDES ${QT_QT_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ${QT_INCLUDE_DIR} )
806 #######################################
810 #######################################
811 IF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
812 FILE(READ ${QT_MKSPECS_DIR}/qconfig.pri _qconfig_FILE_contents)
813 STRING(REGEX MATCH "QT_CONFIG[^\n]+" QT_QCONFIG "${_qconfig_FILE_contents}")
814 STRING(REGEX MATCH "CONFIG[^\n]+" QT_CONFIG "${_qconfig_FILE_contents}")
815 STRING(REGEX MATCH "EDITION[^\n]+" QT_EDITION "${_qconfig_FILE_contents}")
816 STRING(REGEX MATCH "QT_LIBINFIX[^\n]+" _qconfig_qt_libinfix "${_qconfig_FILE_contents}")
817 STRING(REGEX REPLACE "QT_LIBINFIX *= *([^\n]*)" "\\1" QT_LIBINFIX "${_qconfig_qt_libinfix}")
818 ENDIF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
819 IF("${QT_EDITION}" MATCHES "DesktopLight")
820 SET(QT_EDITION_DESKTOPLIGHT 1)
821 ENDIF("${QT_EDITION}" MATCHES "DesktopLight")
823 ########################################
825 # Setting the LIBRARY-Variables
827 ########################################
830 FOREACH(QT_MODULE ${QT_MODULES})
831 STRING(TOUPPER ${QT_MODULE} _upper_qt_module)
832 FIND_LIBRARY(QT_${_upper_qt_module}_LIBRARY_RELEASE
833 NAMES ${QT_MODULE}${QT_LIBINFIX} ${QT_MODULE}${QT_LIBINFIX}4
834 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH
836 FIND_LIBRARY(QT_${_upper_qt_module}_LIBRARY_DEBUG
837 NAMES ${QT_MODULE}${QT_LIBINFIX}_debug ${QT_MODULE}${QT_LIBINFIX}d ${QT_MODULE}${QT_LIBINFIX}d4
838 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH
840 ENDFOREACH(QT_MODULE)
842 # QtUiTools not with other frameworks with binary installation (in /usr/lib)
843 IF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE)
844 FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
845 ENDIF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE)
847 IF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
849 # try dropping a hint if trying to use Visual Studio with Qt built by mingw
850 IF(QT_LIBRARY_DIR AND MSVC)
851 IF(EXISTS ${QT_LIBRARY_DIR}/libqtmain.a)
852 MESSAGE( FATAL_ERROR "It appears you're trying to use Visual Studio with Qt built by mingw")
853 ENDIF(EXISTS ${QT_LIBRARY_DIR}/libqtmain.a)
854 ENDIF(QT_LIBRARY_DIR AND MSVC)
856 IF(Qt4_FIND_REQUIRED)
857 MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
858 ENDIF(Qt4_FIND_REQUIRED)
859 ENDIF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
861 # Set QT_QTDESIGNERCOMPONENTS_LIBRARY
862 FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents${QT_LIBINFIX} QtDesignerComponents${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
863 FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NAMES QtDesignerComponents${QT_LIBINFIX}_debug QtDesignerComponents${QT_LIBINFIX}d QtDesignerComponents${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
865 # Set QT_QTMAIN_LIBRARY
867 FIND_LIBRARY(QT_QTMAIN_LIBRARY_RELEASE NAMES qtmain${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR}
869 FIND_LIBRARY(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmain${QT_LIBINFIX}d PATHS ${QT_LIBRARY_DIR}
873 # Set QT_QTASSISTANTCLIENT_LIBRARY
874 FIND_LIBRARY(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
875 FIND_LIBRARY(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG NAMES QtAssistantClient${QT_LIBINFIX}_debug QtAssistantClient${QT_LIBINFIX}d QtAssistantClient${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
877 # Set QT_QTASSISTANT_LIBRARY
878 FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 QtAssistant${QT_LIBINFIX} QtAssistant${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
879 FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_DEBUG NAMES QtAssistantClient${QT_LIBINFIX}_debug QtAssistantClient${QT_LIBINFIX}d QtAssistantClient${QT_LIBINFIX}d4 QtAssistant${QT_LIBINFIX}_debug QtAssistant${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
881 # Set QT_QTHELP_LIBRARY
882 FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} QtCLucene${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
883 FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_DEBUG NAMES QtCLucene${QT_LIBINFIX}_debug QtCLucene${QT_LIBINFIX}d QtCLucene${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
884 # QtCLucene not with other frameworks with binary installation (in /usr/lib)
885 IF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE)
886 FIND_LIBRARY(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR})
887 ENDIF(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE)
889 ############################################
891 # Check the existence of the libraries.
893 ############################################
895 MACRO (_QT4_ADJUST_LIB_VARS basename)
896 # message(STATUS "Adjusting ${basename}, release: -${QT_${basename}_LIBRARY_RELEASE}- debug: -${QT_${basename}_LIBRARY_DEBUG}-")
897 IF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
898 ADD_LIBRARY(Qt4__${basename} SHARED IMPORTED )
901 SET(_QT4_LIBRARY_PROPERTY_NAME IMPLIB)
903 SET(_QT4_LIBRARY_PROPERTY_NAME LOCATION)
907 IF (QT_${basename}_LIBRARY_RELEASE)
908 SET_PROPERTY(TARGET Qt4__${basename} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
909 SET_PROPERTY(TARGET Qt4__${basename} PROPERTY IMPORTED_${_QT4_LIBRARY_PROPERTY_NAME}_RELEASE "${QT_${basename}_LIBRARY_RELEASE}" )
910 # message(STATUS "Setting IMPORTED_LOCATION_RELEASE to -${QT_${basename}_LIBRARY_RELEASE}-")
911 ENDIF (QT_${basename}_LIBRARY_RELEASE)
913 IF (QT_${basename}_LIBRARY_DEBUG)
914 SET_PROPERTY(TARGET Qt4__${basename} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
915 SET_PROPERTY(TARGET Qt4__${basename} PROPERTY IMPORTED_${_QT4_LIBRARY_PROPERTY_NAME}_DEBUG "${QT_${basename}_LIBRARY_DEBUG}" )
917 # message(STATUS "Setting IMPORTED_LOCATION_DEBUG to -${QT_${basename}_LIBRARY_DEBUG}-")
919 SET_PROPERTY(TARGET Qt4__${basename} PROPERTY MAP_IMPORTED_CONFIG_PROFILE DEBUG)
920 SET_PROPERTY(TARGET Qt4__${basename} PROPERTY MAP_IMPORTED_CONFIG_DEBUGFULL DEBUG)
921 ENDIF (QT_${basename}_LIBRARY_DEBUG)
923 SET(QT_${basename}_LIBRARY Qt4__${basename} )
924 SET(QT_${basename}_LIBRARIES Qt4__${basename} )
926 IF (QT_${basename}_LIBRARY)
927 SET(QT_${basename}_FOUND 1)
928 ENDIF (QT_${basename}_LIBRARY)
930 ENDIF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
932 IF (QT_${basename}_INCLUDE_DIR)
933 #add the include directory to QT_INCLUDES
934 SET(QT_INCLUDES "${QT_${basename}_INCLUDE_DIR}" ${QT_INCLUDES})
935 ENDIF (QT_${basename}_INCLUDE_DIR)
937 # Make variables changeble to the advanced user
938 MARK_AS_ADVANCED(QT_${basename}_LIBRARY QT_${basename}_LIBRARY_RELEASE QT_${basename}_LIBRARY_DEBUG QT_${basename}_INCLUDE_DIR)
939 ENDMACRO (_QT4_ADJUST_LIB_VARS)
942 # Set QT_xyz_LIBRARY variable and add
943 # library include path to QT_INCLUDES
944 _QT4_ADJUST_LIB_VARS(QTCORE)
945 _QT4_ADJUST_LIB_VARS(QTGUI)
946 _QT4_ADJUST_LIB_VARS(QT3SUPPORT)
947 _QT4_ADJUST_LIB_VARS(QTASSISTANT)
948 _QT4_ADJUST_LIB_VARS(QTASSISTANTCLIENT)
949 _QT4_ADJUST_LIB_VARS(QTCLUCENE)
950 _QT4_ADJUST_LIB_VARS(QTDBUS)
951 _QT4_ADJUST_LIB_VARS(QTDESIGNER)
952 _QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS)
953 _QT4_ADJUST_LIB_VARS(QTHELP)
954 _QT4_ADJUST_LIB_VARS(QTMULTIMEDIA)
955 _QT4_ADJUST_LIB_VARS(QTNETWORK)
956 _QT4_ADJUST_LIB_VARS(QTNSPLUGIN)
957 _QT4_ADJUST_LIB_VARS(QTOPENGL)
958 _QT4_ADJUST_LIB_VARS(QTSCRIPT)
959 _QT4_ADJUST_LIB_VARS(QTSCRIPTTOOLS)
960 _QT4_ADJUST_LIB_VARS(QTSQL)
961 _QT4_ADJUST_LIB_VARS(QTSVG)
962 _QT4_ADJUST_LIB_VARS(QTTEST)
963 _QT4_ADJUST_LIB_VARS(QTUITOOLS)
964 _QT4_ADJUST_LIB_VARS(QTWEBKIT)
965 _QT4_ADJUST_LIB_VARS(QTXML)
966 _QT4_ADJUST_LIB_VARS(QTXMLPATTERNS)
967 _QT4_ADJUST_LIB_VARS(PHONON)
969 # platform dependent libraries
971 _QT4_ADJUST_LIB_VARS(QTMOTIF)
974 _QT4_ADJUST_LIB_VARS(QTMAIN)
975 _QT4_ADJUST_LIB_VARS(QAXSERVER)
976 _QT4_ADJUST_LIB_VARS(QAXCONTAINER)
979 # If Qt is installed as a framework, we need to add QT_QTCORE_LIBRARY here (which
980 # is the framework directory in that case), since this will make the cmake include_directories()
981 # command recognize that we need the framework flag with the respective directory (-F)
982 IF(QT_USE_FRAMEWORKS)
983 SET(QT_INCLUDES ${QT_INCLUDES} ${QT_QTCORE_LIBRARY} )
984 SET(QT_INCLUDE_DIR ${QT_INCLUDE_DIR} ${QT_QTCORE_LIBRARY} )
985 ENDIF(QT_USE_FRAMEWORKS)
989 #######################################
991 # Check the executables of Qt
994 #######################################
998 SET(QT_UIC_EXECUTABLE NOTFOUND)
999 SET(QT_MOC_EXECUTABLE NOTFOUND)
1000 SET(QT_UIC3_EXECUTABLE NOTFOUND)
1001 SET(QT_RCC_EXECUTABLE NOTFOUND)
1002 SET(QT_DBUSCPP2XML_EXECUTABLE NOTFOUND)
1003 SET(QT_DBUSXML2CPP_EXECUTABLE NOTFOUND)
1004 SET(QT_LUPDATE_EXECUTABLE NOTFOUND)
1005 SET(QT_LRELEASE_EXECUTABLE NOTFOUND)
1006 SET(QT_QCOLLECTIONGENERATOR_EXECUTABLE NOTFOUND)
1007 SET(QT_DESIGNER_EXECUTABLE NOTFOUND)
1008 SET(QT_LINGUIST_EXECUTABLE NOTFOUND)
1009 ENDIF(QT_QMAKE_CHANGED)
1011 FIND_PROGRAM(QT_MOC_EXECUTABLE
1013 PATHS ${QT_BINARY_DIR}
1017 FIND_PROGRAM(QT_UIC_EXECUTABLE
1019 PATHS ${QT_BINARY_DIR}
1023 FIND_PROGRAM(QT_UIC3_EXECUTABLE
1025 PATHS ${QT_BINARY_DIR}
1029 FIND_PROGRAM(QT_RCC_EXECUTABLE
1031 PATHS ${QT_BINARY_DIR}
1035 FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE
1037 PATHS ${QT_BINARY_DIR}
1041 FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE
1043 PATHS ${QT_BINARY_DIR}
1047 FIND_PROGRAM(QT_LUPDATE_EXECUTABLE
1048 NAMES lupdate-qt4 lupdate
1049 PATHS ${QT_BINARY_DIR}
1053 FIND_PROGRAM(QT_LRELEASE_EXECUTABLE
1054 NAMES lrelease-qt4 lrelease
1055 PATHS ${QT_BINARY_DIR}
1059 FIND_PROGRAM(QT_LCONVERT_EXECUTABLE
1060 NAMES lconvert-qt4 lconvert
1061 PATHS ${QT_BINARY_DIR}
1065 FIND_PROGRAM(QT_QCOLLECTIONGENERATOR_EXECUTABLE
1066 NAMES qcollectiongenerator-qt4 qcollectiongenerator
1067 PATHS ${QT_BINARY_DIR}
1071 FIND_PROGRAM(QT_DESIGNER_EXECUTABLE
1072 NAMES designer-qt4 designer
1073 PATHS ${QT_BINARY_DIR}
1077 FIND_PROGRAM(QT_LINGUIST_EXECUTABLE
1078 NAMES linguist-qt4 linguist
1079 PATHS ${QT_BINARY_DIR}
1083 IF (QT_MOC_EXECUTABLE)
1084 SET(QT_WRAP_CPP "YES")
1085 ENDIF (QT_MOC_EXECUTABLE)
1087 IF (QT_UIC_EXECUTABLE)
1088 SET(QT_WRAP_UI "YES")
1089 ENDIF (QT_UIC_EXECUTABLE)
1093 MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE
1094 QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE
1095 QT_LUPDATE_EXECUTABLE QT_LRELEASE_EXECUTABLE QT_QCOLLECTIONGENERATOR_EXECUTABLE
1096 QT_DESIGNER_EXECUTABLE QT_LINGUIST_EXECUTABLE)
1099 # get the directory of the current file, used later on in the file
1100 GET_FILENAME_COMPONENT( _qt4_current_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
1102 ######################################
1104 # Macros for building Qt files
1106 ######################################
1108 INCLUDE("${_qt4_current_dir}/Qt4Macros.cmake")
1111 ######################################
1113 # decide if Qt got found
1115 ######################################
1117 # if the includes,libraries,moc,uic and rcc are found then we have it
1118 IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1119 QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1120 SET( QT4_FOUND "YES" )
1121 IF( NOT Qt4_FIND_QUIETLY)
1122 MESSAGE(STATUS "Found Qt-Version ${QTVERSION} (using ${QT_QMAKE_EXECUTABLE})")
1123 ENDIF( NOT Qt4_FIND_QUIETLY)
1124 ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1125 QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1126 SET( QT4_FOUND "NO")
1127 SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1128 IF( Qt4_FIND_REQUIRED)
1129 IF ( NOT QT_LIBRARY_DIR )
1130 MESSAGE(STATUS "Qt libraries NOT found!")
1131 ENDIF(NOT QT_LIBRARY_DIR )
1132 IF ( NOT QT_INCLUDE_DIR )
1133 MESSAGE(STATUS "Qt includes NOT found!")
1134 ENDIF( NOT QT_INCLUDE_DIR )
1135 IF ( NOT QT_MOC_EXECUTABLE )
1136 MESSAGE(STATUS "Qt's moc NOT found!")
1137 ENDIF( NOT QT_MOC_EXECUTABLE )
1138 IF ( NOT QT_UIC_EXECUTABLE )
1139 MESSAGE(STATUS "Qt's uic NOT found!")
1140 ENDIF( NOT QT_UIC_EXECUTABLE )
1141 IF ( NOT QT_RCC_EXECUTABLE )
1142 MESSAGE(STATUS "Qt's rcc NOT found!")
1143 ENDIF( NOT QT_RCC_EXECUTABLE )
1144 MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")
1145 ENDIF( Qt4_FIND_REQUIRED)
1146 ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
1147 QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
1149 SET(QT_FOUND ${QT4_FOUND})
1152 ###############################################
1154 # configuration/system dependent settings
1156 ###############################################
1158 INCLUDE("${_qt4_current_dir}/Qt4ConfigDependentSettings.cmake")
1161 #######################################
1163 # compatibility settings
1165 #######################################
1166 # Backwards compatibility for CMake1.4 and 1.2
1167 SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
1168 SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
1170 SET( QT_QT_LIBRARY "")
1172 ELSE(QT4_QMAKE_FOUND)
1174 SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1176 # The code below is overly complex to make sure we do not break compatibility with CMake 2.6.x
1177 # For CMake 2.8, it should be simplified by getting rid of QT4_INSTALLED_VERSION_TOO_OLD and
1178 # QT4_INSTALLED_VERSION_TOO_NEW
1179 IF(Qt4_FIND_REQUIRED)
1180 IF(QT4_INSTALLED_VERSION_TOO_OLD)
1181 IF( Qt4_FIND_VERSION_EXACT )
1182 MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, version ${QT_MIN_VERSION} is required")
1183 ELSE( Qt4_FIND_VERSION_EXACT )
1184 MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1185 ENDIF( Qt4_FIND_VERSION_EXACT )
1186 ELSE(QT4_INSTALLED_VERSION_TOO_OLD)
1187 IF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1188 MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too new, version ${QT_MIN_VERSION} is required")
1189 ELSE( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1190 MESSAGE( FATAL_ERROR "Qt qmake not found!")
1191 ENDIF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
1192 ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)
1193 ELSE(Qt4_FIND_REQUIRED)
1194 IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1195 MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1196 ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1197 ENDIF(Qt4_FIND_REQUIRED)
1199 ENDIF (QT4_QMAKE_FOUND)