#.rst: # FindQt4 # ------- # # Find Qt 4 # # This module can be used to find Qt4. The most important issue is that # the Qt4 qmake is available via the system path. This qmake is then # used to detect basically everything else. This module defines a # number of key variables and macros. The variable QT_USE_FILE is set # which is the path to a CMake file that can be included to compile Qt 4 # applications and libraries. It sets up the compilation environment # for include directories, preprocessor defines and populates a # QT_LIBRARIES variable. # # Typical usage could be something like: # # :: # # find_package(Qt4 4.4.3 REQUIRED QtCore QtGui QtXml) # include(${QT_USE_FILE}) # add_executable(myexe main.cpp) # target_link_libraries(myexe ${QT_LIBRARIES}) # # # # The minimum required version can be specified using the standard # find_package()-syntax (see example above). For compatibility with # older versions of FindQt4.cmake it is also possible to set the # variable QT_MIN_VERSION to the minimum required version of Qt4 before # the find_package(Qt4) command. If both are used, the version used in # the find_package() command overrides the one from QT_MIN_VERSION. # # When using the components argument, QT_USE_QT* variables are # automatically set for the QT_USE_FILE to pick up. If one wishes to # manually set them, the available ones to set include: # # :: # # QT_DONT_USE_QTCORE # QT_DONT_USE_QTGUI # QT_USE_QT3SUPPORT # QT_USE_QTASSISTANT # QT_USE_QAXCONTAINER # QT_USE_QAXSERVER # QT_USE_QTDESIGNER # QT_USE_QTMOTIF # QT_USE_QTMAIN # QT_USE_QTMULTIMEDIA # QT_USE_QTNETWORK # QT_USE_QTNSPLUGIN # QT_USE_QTOPENGL # QT_USE_QTSQL # QT_USE_QTXML # QT_USE_QTSVG # QT_USE_QTTEST # QT_USE_QTUITOOLS # QT_USE_QTDBUS # QT_USE_QTSCRIPT # QT_USE_QTASSISTANTCLIENT # QT_USE_QTHELP # QT_USE_QTWEBKIT # QT_USE_QTXMLPATTERNS # QT_USE_PHONON # QT_USE_QTSCRIPTTOOLS # QT_USE_QTDECLARATIVE # # # # :: # # QT_USE_IMPORTED_TARGETS # If this variable is set to TRUE, FindQt4.cmake will create imported # library targets for the various Qt libraries and set the # library variables like QT_QTCORE_LIBRARY to point at these imported # targets instead of the library file on disk. This provides much better # handling of the release and debug versions of the Qt libraries and is # also always backwards compatible, except for the case that dependencies # of libraries are exported, these will then also list the names of the # imported targets as dependency and not the file location on disk. This # is much more flexible, but requires that FindQt4.cmake is executed before # such an exported dependency file is processed. # # # # :: # # Note that if using IMPORTED targets, the qtmain.lib static library is # automatically linked on Windows. To disable that globally, set the # QT4_NO_LINK_QTMAIN variable before finding Qt4. To disable that for a # particular executable, set the QT4_NO_LINK_QTMAIN target property to # True on the executable. # # # # :: # # QT_INCLUDE_DIRS_NO_SYSTEM # If this variable is set to TRUE, the Qt include directories # in the QT_USE_FILE will NOT have the SYSTEM keyword set. # # # # There are also some files that need processing by some Qt tools such # as moc and uic. Listed below are macros that may be used to process # those files. # # :: # # macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...) # create moc code from a list of files containing Qt class with # the Q_OBJECT declaration. Per-directory preprocessor definitions # are also added. Options may be given to moc, such as those found # when executing "moc -help". # # # # :: # # macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...) # create code from a list of Qt designer ui files. # Options may be given to uic, such as those found # when executing "uic -help" # # # # :: # # macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...) # create code from a list of Qt resource files. # Options may be given to rcc, such as those found # when executing "rcc -help" # # # # :: # # macro QT4_GENERATE_MOC(inputfile outputfile ) # creates a rule to run moc on infile and create outfile. # Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g. # because you need a custom filename for the moc file or something similar. # # # # :: # # macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... ) # The qt4_automoc macro is obsolete. Use the CMAKE_AUTOMOC feature instead. # This macro is still experimental. # It can be used to have moc automatically handled. # So if you have the files foo.h and foo.cpp, and in foo.h a # a class uses the Q_OBJECT macro, moc has to run on it. If you don't # want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert # #include "foo.moc" # in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the # scan all listed files at cmake-time for such included moc files and if it finds # them cause a rule to be generated to run moc at build time on the # accompanying header file foo.h. # If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro. # # # # :: # # You should have a look on the AUTOMOC property for targets to achieve the same results. # # # # :: # # macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename) # Create the interface header and implementation files with the # given basename from the given interface xml file and add it to # the list of sources. # # # # :: # # You can pass additional parameters to the qdbusxml2cpp call by setting # properties on the input file: # # # # :: # # INCLUDE the given file will be included in the generate interface header # # # # :: # # CLASSNAME the generated class is named accordingly # # # # :: # # NO_NAMESPACE the generated class is not wrapped in a namespace # # # # :: # # macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... ) # Create the interface header and implementation files # for all listed interface xml files. # The basename will be automatically determined from the name of the xml file. # # # # :: # # The source file properties described for QT4_ADD_DBUS_INTERFACE also apply here. # # # # :: # # macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname]) # create a dbus adaptor (header and implementation file) from the xml file # describing the interface, and add it to the list of sources. The adaptor # forwards the calls to a parent class, defined in parentheader and named # parentclassname. The name of the generated files will be # adaptor.{cpp,h} where basename defaults to the basename of the xml file. # If is provided, then it will be used as the classname of the # adaptor itself. # # # # :: # # macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...) # generate the xml interface file from the given header. # If the optional argument interfacename is omitted, the name of the # interface file is constructed from the basename of the header with # the suffix .xml appended. # Options may be given to qdbuscpp2xml, such as those found when executing "qdbuscpp2xml --help" # # # # :: # # macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ... # ts_files ... OPTIONS ...) # out: qm_files # in: directories sources ts_files # options: flags to pass to lupdate, such as -extensions to specify # extensions for a directory scan. # generates commands to create .ts (vie lupdate) and .qm # (via lrelease) - files from directories and/or sources. The ts files are # created and/or updated in the source tree (unless given with full paths). # The qm files are generated in the build tree. # Updating the translations can be done by adding the qm_files # to the source list of your library/executable, so they are # always updated, or by adding a custom target to control when # they get updated/generated. # # # # :: # # macro QT4_ADD_TRANSLATION( qm_files ts_files ... ) # out: qm_files # in: ts_files # generates commands to create .qm from .ts - files. The generated # filenames can be found in qm_files. The ts_files # must exist and are not updated in any way. # # # # function QT4_USE_MODULES( target [link_type] modules...) # # :: # # This function is obsolete. Use target_link_libraries with IMPORTED targets instead. # Make use the from Qt. Using a Qt module means # to link to the library, add the relevant include directories for the module, # and add the relevant compiler defines for using the module. # Modules are roughly equivalent to components of Qt4, so usage would be # something like: # qt4_use_modules(myexe Core Gui Declarative) # to use QtCore, QtGui and QtDeclarative. The optional argument can # be specified as either LINK_PUBLIC or LINK_PRIVATE to specify the same argument # to the target_link_libraries call. # # # # # # :: # # Below is a detailed list of variables that FindQt4.cmake sets. # QT_FOUND If false, don't try to use Qt. # Qt4_FOUND If false, don't try to use Qt 4. # QT4_FOUND If false, don't try to use Qt 4. This variable is for compatibility only. # # # # :: # # QT_VERSION_MAJOR The major version of Qt found. # QT_VERSION_MINOR The minor version of Qt found. # QT_VERSION_PATCH The patch version of Qt found. # # # # :: # # QT_EDITION Set to the edition of Qt (i.e. DesktopLight) # QT_EDITION_DESKTOPLIGHT True if QT_EDITION == DesktopLight # QT_QTCORE_FOUND True if QtCore was found. # QT_QTGUI_FOUND True if QtGui was found. # QT_QT3SUPPORT_FOUND True if Qt3Support was found. # QT_QTASSISTANT_FOUND True if QtAssistant was found. # QT_QTASSISTANTCLIENT_FOUND True if QtAssistantClient was found. # QT_QAXCONTAINER_FOUND True if QAxContainer was found (Windows only). # QT_QAXSERVER_FOUND True if QAxServer was found (Windows only). # QT_QTDBUS_FOUND True if QtDBus was found. # QT_QTDESIGNER_FOUND True if QtDesigner was found. # QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found. # QT_QTHELP_FOUND True if QtHelp was found. # QT_QTMOTIF_FOUND True if QtMotif was found. # QT_QTMULTIMEDIA_FOUND True if QtMultimedia was found (since Qt 4.6.0). # QT_QTNETWORK_FOUND True if QtNetwork was found. # QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found. # QT_QTOPENGL_FOUND True if QtOpenGL was found. # QT_QTSQL_FOUND True if QtSql was found. # QT_QTSVG_FOUND True if QtSvg was found. # QT_QTSCRIPT_FOUND True if QtScript was found. # QT_QTSCRIPTTOOLS_FOUND True if QtScriptTools was found. # QT_QTTEST_FOUND True if QtTest was found. # QT_QTUITOOLS_FOUND True if QtUiTools was found. # QT_QTWEBKIT_FOUND True if QtWebKit was found. # QT_QTXML_FOUND True if QtXml was found. # QT_QTXMLPATTERNS_FOUND True if QtXmlPatterns was found. # QT_PHONON_FOUND True if phonon was found. # QT_QTDECLARATIVE_FOUND True if QtDeclarative was found. # # # # :: # # QT_MAC_USE_COCOA For Mac OS X, its whether Cocoa or Carbon is used. # In general, this should not be used, but its useful # when having platform specific code. # # # # :: # # QT_DEFINITIONS Definitions to use when compiling code that uses Qt. # You do not need to use this if you include QT_USE_FILE. # The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG # to fit your current build type. Those are not contained # in QT_DEFINITIONS. # # # # :: # # QT_INCLUDES List of paths to all include directories of # Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are # always in this variable even if NOTFOUND, # all other INCLUDE_DIRS are # only added if they are found. # You do not need to use this if you include QT_USE_FILE. # # # # # # :: # # Include directories for the Qt modules are listed here. # You do not need to use these variables if you include QT_USE_FILE. # # # # :: # # QT_INCLUDE_DIR Path to "include" of Qt4 # QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support" # QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant" # QT_QTASSISTANTCLIENT_INCLUDE_DIR Path to "include/QtAssistant" # QT_QAXCONTAINER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only) # QT_QAXSERVER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only) # QT_QTCORE_INCLUDE_DIR Path to "include/QtCore" # QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus" # QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner" # QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner" # QT_QTGUI_INCLUDE_DIR Path to "include/QtGui" # QT_QTHELP_INCLUDE_DIR Path to "include/QtHelp" # QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif" # QT_QTMULTIMEDIA_INCLUDE_DIR Path to "include/QtMultimedia" # QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork" # QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin" # QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL" # QT_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript" # QT_QTSQL_INCLUDE_DIR Path to "include/QtSql" # QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg" # QT_QTTEST_INCLUDE_DIR Path to "include/QtTest" # QT_QTWEBKIT_INCLUDE_DIR Path to "include/QtWebKit" # QT_QTXML_INCLUDE_DIR Path to "include/QtXml" # QT_QTXMLPATTERNS_INCLUDE_DIR Path to "include/QtXmlPatterns" # QT_PHONON_INCLUDE_DIR Path to "include/phonon" # QT_QTSCRIPTTOOLS_INCLUDE_DIR Path to "include/QtScriptTools" # QT_QTDECLARATIVE_INCLUDE_DIR Path to "include/QtDeclarative" # # # # :: # # QT_BINARY_DIR Path to "bin" of Qt4 # QT_LIBRARY_DIR Path to "lib" of Qt4 # QT_PLUGINS_DIR Path to "plugins" for Qt4 # QT_TRANSLATIONS_DIR Path to "translations" of Qt4 # QT_IMPORTS_DIR Path to "imports" of Qt4 # QT_DOC_DIR Path to "doc" of Qt4 # QT_MKSPECS_DIR Path to "mkspecs" of Qt4 # # # # # # The Qt toolkit may contain both debug and release libraries. In that # case, the following library variables will contain both. You do not # need to use these variables if you include QT_USE_FILE, and use # QT_LIBRARIES. # # :: # # QT_QT3SUPPORT_LIBRARY The Qt3Support library # QT_QTASSISTANT_LIBRARY The QtAssistant library # QT_QTASSISTANTCLIENT_LIBRARY The QtAssistantClient library # QT_QAXCONTAINER_LIBRARY The QAxContainer library (Windows only) # QT_QAXSERVER_LIBRARY The QAxServer library (Windows only) # QT_QTCORE_LIBRARY The QtCore library # QT_QTDBUS_LIBRARY The QtDBus library # QT_QTDESIGNER_LIBRARY The QtDesigner library # QT_QTDESIGNERCOMPONENTS_LIBRARY The QtDesignerComponents library # QT_QTGUI_LIBRARY The QtGui library # QT_QTHELP_LIBRARY The QtHelp library # QT_QTMOTIF_LIBRARY The QtMotif library # QT_QTMULTIMEDIA_LIBRARY The QtMultimedia library # QT_QTNETWORK_LIBRARY The QtNetwork library # QT_QTNSPLUGIN_LIBRARY The QtNsPLugin library # QT_QTOPENGL_LIBRARY The QtOpenGL library # QT_QTSCRIPT_LIBRARY The QtScript library # QT_QTSQL_LIBRARY The QtSql library # QT_QTSVG_LIBRARY The QtSvg library # QT_QTTEST_LIBRARY The QtTest library # QT_QTUITOOLS_LIBRARY The QtUiTools library # QT_QTWEBKIT_LIBRARY The QtWebKit library # QT_QTXML_LIBRARY The QtXml library # QT_QTXMLPATTERNS_LIBRARY The QtXmlPatterns library # QT_QTMAIN_LIBRARY The qtmain library for Windows # QT_PHONON_LIBRARY The phonon library # QT_QTSCRIPTTOOLS_LIBRARY The QtScriptTools library # # # # The QtDeclarative library: QT_QTDECLARATIVE_LIBRARY # # also defined, but NOT for general use are # # :: # # QT_MOC_EXECUTABLE Where to find the moc tool. # QT_UIC_EXECUTABLE Where to find the uic tool. # QT_UIC3_EXECUTABLE Where to find the uic3 tool. # QT_RCC_EXECUTABLE Where to find the rcc tool # QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool. # QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool. # QT_LUPDATE_EXECUTABLE Where to find the lupdate tool. # QT_LRELEASE_EXECUTABLE Where to find the lrelease tool. # QT_QCOLLECTIONGENERATOR_EXECUTABLE Where to find the qcollectiongenerator tool. # QT_DESIGNER_EXECUTABLE Where to find the Qt designer tool. # QT_LINGUIST_EXECUTABLE Where to find the Qt linguist tool. # # # # # # These are around for backwards compatibility they will be set # # :: # # QT_WRAP_CPP Set true if QT_MOC_EXECUTABLE is found # QT_WRAP_UI Set true if QT_UIC_EXECUTABLE is found # # # # These variables do _NOT_ have any effect anymore (compared to # FindQt.cmake) # # :: # # QT_MT_REQUIRED Qt4 is now always multithreaded # # # # These variables are set to "" Because Qt structure changed (They make # no sense in Qt4) # # :: # # QT_QT_LIBRARY Qt-Library is now split #============================================================================= # Copyright 2005-2009 Kitware, Inc. # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) # Use find_package( Qt4 COMPONENTS ... ) to enable modules if( Qt4_FIND_COMPONENTS ) foreach( component ${Qt4_FIND_COMPONENTS} ) string( TOUPPER ${component} _COMPONENT ) set( QT_USE_${_COMPONENT} 1 ) endforeach() # To make sure we don't use QtCore or QtGui when not in COMPONENTS if(NOT QT_USE_QTCORE) set( QT_DONT_USE_QTCORE 1 ) endif() if(NOT QT_USE_QTGUI) set( QT_DONT_USE_QTGUI 1 ) endif() endif() # If Qt3 has already been found, fail. if(QT_QT_LIBRARY) if(Qt4_FIND_REQUIRED) message( FATAL_ERROR "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.") else() if(NOT Qt4_FIND_QUIETLY) message( STATUS "Qt3 and Qt4 cannot be used together in one project. If switching to Qt4, the CMakeCache.txt needs to be cleaned.") endif() return() endif() endif() include(${CMAKE_CURRENT_LIST_DIR}/CheckCXXSymbolExists.cmake) include(${CMAKE_CURRENT_LIST_DIR}/MacroAddFileDependencies.cmake) include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) set(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake) set( QT_DEFINITIONS "") # convenience macro for dealing with debug/release library names macro (_QT4_ADJUST_LIB_VARS _camelCaseBasename) string(TOUPPER "${_camelCaseBasename}" basename) # The name of the imported targets, i.e. the prefix "Qt4::" must not change, # since it is stored in EXPORT-files as name of a required library. If the name would change # here, this would lead to the imported Qt4-library targets not being resolved by cmake anymore. if (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG) if(NOT TARGET Qt4::${_camelCaseBasename}) add_library(Qt4::${_camelCaseBasename} UNKNOWN IMPORTED ) if (QT_${basename}_LIBRARY_RELEASE) set_property(TARGET Qt4::${_camelCaseBasename} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) if(QT_USE_FRAMEWORKS) set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_RELEASE "${QT_${basename}_LIBRARY_RELEASE}/${_camelCaseBasename}" ) else() set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_RELEASE "${QT_${basename}_LIBRARY_RELEASE}" ) endif() endif () if (QT_${basename}_LIBRARY_DEBUG) set_property(TARGET Qt4::${_camelCaseBasename} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) if(QT_USE_FRAMEWORKS) set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_DEBUG "${QT_${basename}_LIBRARY_DEBUG}/${_camelCaseBasename}" ) else() set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY IMPORTED_LOCATION_DEBUG "${QT_${basename}_LIBRARY_DEBUG}" ) endif() endif () set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${QT_${basename}_INCLUDE_DIR}" ) string(REGEX REPLACE "^QT" "" _stemname ${basename}) set_property(TARGET Qt4::${_camelCaseBasename} PROPERTY INTERFACE_COMPILE_DEFINITIONS "QT_${_stemname}_LIB" ) endif() # If QT_USE_IMPORTED_TARGETS is enabled, the QT_QTFOO_LIBRARY variables are set to point at these # imported targets. This works better in general, and is also in almost all cases fully # backward compatible. The only issue is when a project A which had this enabled then exports its # libraries via export or export_library_dependencies(). In this case the libraries from project # A will depend on the imported Qt targets, and the names of these imported targets will be stored # in the dependency files on disk. This means when a project B then uses project A, these imported # targets must be created again, otherwise e.g. "Qt4__QtCore" will be interpreted as name of a # library file on disk, and not as a target, and linking will fail: if(QT_USE_IMPORTED_TARGETS) set(QT_${basename}_LIBRARY Qt4::${_camelCaseBasename} ) set(QT_${basename}_LIBRARIES Qt4::${_camelCaseBasename} ) else() # if the release- as well as the debug-version of the library have been found: if (QT_${basename}_LIBRARY_DEBUG AND QT_${basename}_LIBRARY_RELEASE) # if the generator supports configuration types then set # optimized and debug libraries, or if the CMAKE_BUILD_TYPE has a value if (CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE) set(QT_${basename}_LIBRARY optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG}) else() # if there are no configuration types and CMAKE_BUILD_TYPE has no value # then just use the release libraries set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE} ) endif() set(QT_${basename}_LIBRARIES optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG}) endif () # if only the release version was found, set the debug variable also to the release version if (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG) set(QT_${basename}_LIBRARY_DEBUG ${QT_${basename}_LIBRARY_RELEASE}) set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE}) set(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_RELEASE}) endif () # if only the debug version was found, set the release variable also to the debug version if (QT_${basename}_LIBRARY_DEBUG AND NOT QT_${basename}_LIBRARY_RELEASE) set(QT_${basename}_LIBRARY_RELEASE ${QT_${basename}_LIBRARY_DEBUG}) set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_DEBUG}) set(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_DEBUG}) endif () # put the value in the cache: set(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY} CACHE STRING "The Qt ${basename} library" FORCE) endif() set(QT_${basename}_FOUND 1) else () set(QT_${basename}_LIBRARY "" CACHE STRING "The Qt ${basename} library" FORCE) endif () if (QT_${basename}_INCLUDE_DIR) #add the include directory to QT_INCLUDES set(QT_INCLUDES "${QT_${basename}_INCLUDE_DIR}" ${QT_INCLUDES}) endif () # Make variables changeable to the advanced user mark_as_advanced(QT_${basename}_LIBRARY QT_${basename}_LIBRARY_RELEASE QT_${basename}_LIBRARY_DEBUG QT_${basename}_INCLUDE_DIR) endmacro () function(_QT4_QUERY_QMAKE VAR RESULT) execute_process(COMMAND "${QT_QMAKE_EXECUTABLE}" -query ${VAR} RESULT_VARIABLE return_code OUTPUT_VARIABLE output OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE) if(NOT return_code) file(TO_CMAKE_PATH "${output}" output) set(${RESULT} ${output} PARENT_SCOPE) endif() endfunction() function(_QT4_GET_VERSION_COMPONENTS VERSION RESULT_MAJOR RESULT_MINOR RESULT_PATCH) string(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" QT_VERSION_MAJOR "${QTVERSION}") string(REGEX REPLACE "^[0-9]+\\.([0-9]+)\\.[0-9]+.*" "\\1" QT_VERSION_MINOR "${QTVERSION}") string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" QT_VERSION_PATCH "${QTVERSION}") set(${RESULT_MAJOR} ${QT_VERSION_MAJOR} PARENT_SCOPE) set(${RESULT_MINOR} ${QT_VERSION_MINOR} PARENT_SCOPE) set(${RESULT_PATCH} ${QT_VERSION_PATCH} PARENT_SCOPE) endfunction() function(_QT4_FIND_QMAKE QMAKE_NAMES QMAKE_RESULT VERSION_RESULT) list(LENGTH QMAKE_NAMES QMAKE_NAMES_LEN) if(${QMAKE_NAMES_LEN} EQUAL 0) return() endif() list(GET QMAKE_NAMES 0 QMAKE_NAME) get_filename_component(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME) find_program(QT_QMAKE_EXECUTABLE NAMES ${QMAKE_NAME} PATHS ENV QTDIR "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]" PATH_SUFFIXES bin DOC "The qmake executable for the Qt installation to use" ) set(major 0) if (QT_QMAKE_EXECUTABLE) _qt4_query_qmake(QT_VERSION QTVERSION) _qt4_get_version_components("${QTVERSION}" major minor patch) endif() if (NOT QT_QMAKE_EXECUTABLE OR NOT "${major}" EQUAL 4) set(curr_qmake "${QT_QMAKE_EXECUTABLE}") set(curr_qt_version "${QTVERSION}") set(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE) list(REMOVE_AT QMAKE_NAMES 0) _qt4_find_qmake("${QMAKE_NAMES}" QMAKE QTVERSION) _qt4_get_version_components("${QTVERSION}" major minor patch) if (NOT ${major} EQUAL 4) # Restore possibly found qmake and it's version; these are used later # in error message if incorrect version is found set(QT_QMAKE_EXECUTABLE "${curr_qmake}" CACHE FILEPATH "" FORCE) set(QTVERSION "${curr_qt_version}") endif() endif() set(${QMAKE_RESULT} "${QT_QMAKE_EXECUTABLE}" PARENT_SCOPE) set(${VERSION_RESULT} "${QTVERSION}" PARENT_SCOPE) endfunction() set(QT4_INSTALLED_VERSION_TOO_OLD FALSE) set(_QT4_QMAKE_NAMES qmake qmake4 qmake-qt4 qmake-mac) _qt4_find_qmake("${_QT4_QMAKE_NAMES}" QT_QMAKE_EXECUTABLE QTVERSION) if (QT_QMAKE_EXECUTABLE AND QTVERSION) if (QT_QMAKE_EXECUTABLE_LAST) string(COMPARE NOTEQUAL "${QT_QMAKE_EXECUTABLE_LAST}" "${QT_QMAKE_EXECUTABLE}" QT_QMAKE_CHANGED) endif() set(QT_QMAKE_EXECUTABLE_LAST "${QT_QMAKE_EXECUTABLE}" CACHE INTERNAL "" FORCE) _qt4_get_version_components("${QTVERSION}" QT_VERSION_MAJOR QT_VERSION_MINOR QT_VERSION_PATCH) # ask qmake for the mkspecs directory # we do this first because QT_LIBINFIX might be set if (NOT QT_MKSPECS_DIR OR QT_QMAKE_CHANGED) _qt4_query_qmake(QMAKE_MKSPECS qt_mkspecs_dirs) # do not replace : on windows as it might be a drive letter # and windows should already use ; as a separator if(NOT WIN32) string(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}") endif() set(qt_cross_paths) foreach(qt_cross_path ${CMAKE_FIND_ROOT_PATH}) set(qt_cross_paths ${qt_cross_paths} "${qt_cross_path}/mkspecs") endforeach() set(QT_MKSPECS_DIR NOTFOUND) find_path(QT_MKSPECS_DIR NAMES qconfig.pri HINTS ${qt_cross_paths} ${qt_mkspecs_dirs} DOC "The location of the Qt mkspecs containing qconfig.pri" NO_CMAKE_FIND_ROOT_PATH) endif() if(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri") file(READ ${QT_MKSPECS_DIR}/qconfig.pri _qconfig_FILE_contents) string(REGEX MATCH "QT_CONFIG[^\n]+" QT_QCONFIG "${_qconfig_FILE_contents}") string(REGEX MATCH "CONFIG[^\n]+" QT_CONFIG "${_qconfig_FILE_contents}") string(REGEX MATCH "EDITION[^\n]+" QT_EDITION "${_qconfig_FILE_contents}") string(REGEX MATCH "QT_LIBINFIX[^\n]+" _qconfig_qt_libinfix "${_qconfig_FILE_contents}") string(REGEX REPLACE "QT_LIBINFIX *= *([^\n]*)" "\\1" QT_LIBINFIX "${_qconfig_qt_libinfix}") endif() if("${QT_EDITION}" MATCHES "DesktopLight") set(QT_EDITION_DESKTOPLIGHT 1) endif() # ask qmake for the library dir as a hint, then search for QtCore library and use that as a reference for finding the # others and for setting QT_LIBRARY_DIR if (NOT (QT_QTCORE_LIBRARY_RELEASE OR QT_QTCORE_LIBRARY_DEBUG) OR QT_QMAKE_CHANGED) _qt4_query_qmake(QT_INSTALL_LIBS QT_LIBRARY_DIR_TMP) set(QT_QTCORE_LIBRARY_RELEASE NOTFOUND) set(QT_QTCORE_LIBRARY_DEBUG NOTFOUND) find_library(QT_QTCORE_LIBRARY_RELEASE NAMES QtCore${QT_LIBINFIX} QtCore${QT_LIBINFIX}4 HINTS ${QT_LIBRARY_DIR_TMP} NO_DEFAULT_PATH ) find_library(QT_QTCORE_LIBRARY_DEBUG NAMES QtCore${QT_LIBINFIX}_debug QtCore${QT_LIBINFIX}d QtCore${QT_LIBINFIX}d4 HINTS ${QT_LIBRARY_DIR_TMP} NO_DEFAULT_PATH ) if(NOT QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCORE_LIBRARY_DEBUG) find_library(QT_QTCORE_LIBRARY_RELEASE NAMES QtCore${QT_LIBINFIX} QtCore${QT_LIBINFIX}4 HINTS ${QT_LIBRARY_DIR_TMP} ) find_library(QT_QTCORE_LIBRARY_DEBUG NAMES QtCore${QT_LIBINFIX}_debug QtCore${QT_LIBINFIX}d QtCore${QT_LIBINFIX}d4 HINTS ${QT_LIBRARY_DIR_TMP} ) endif() # try dropping a hint if trying to use Visual Studio with Qt built by MinGW if(NOT QT_QTCORE_LIBRARY_RELEASE AND MSVC) if(EXISTS ${QT_LIBRARY_DIR_TMP}/libqtmain.a) message( FATAL_ERROR "It appears you're trying to use Visual Studio with Qt built by MinGW. Those compilers do not produce code compatible with each other.") endif() endif() endif () # set QT_LIBRARY_DIR based on location of QtCore found. if(QT_QTCORE_LIBRARY_RELEASE) get_filename_component(QT_LIBRARY_DIR_TMP "${QT_QTCORE_LIBRARY_RELEASE}" PATH) set(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE INTERNAL "Qt library dir" FORCE) set(QT_QTCORE_FOUND 1) elseif(QT_QTCORE_LIBRARY_DEBUG) get_filename_component(QT_LIBRARY_DIR_TMP "${QT_QTCORE_LIBRARY_DEBUG}" PATH) set(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE INTERNAL "Qt library dir" FORCE) set(QT_QTCORE_FOUND 1) else() message(WARNING "${QT_QMAKE_EXECUTABLE} reported QT_INSTALL_LIBS as \"${QT_LIBRARY_DIR_TMP}\" " "but QtCore could not be found there. " "Qt is NOT installed correctly for the target build environment.") set(Qt4_FOUND FALSE) if(Qt4_FIND_REQUIRED) message( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.") else() return() endif() endif() # ask qmake for the binary dir if (NOT QT_BINARY_DIR OR QT_QMAKE_CHANGED) _qt4_query_qmake(QT_INSTALL_BINS qt_bins) set(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "" FORCE) endif () if (APPLE) set(CMAKE_FIND_FRAMEWORK_OLD ${CMAKE_FIND_FRAMEWORK}) if (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework) set(QT_USE_FRAMEWORKS ON CACHE INTERNAL "" FORCE) set(CMAKE_FIND_FRAMEWORK FIRST) else () set(QT_USE_FRAMEWORKS OFF CACHE INTERNAL "" FORCE) set(CMAKE_FIND_FRAMEWORK LAST) endif () endif () # ask qmake for the include dir if (QT_LIBRARY_DIR AND (NOT QT_QTCORE_INCLUDE_DIR OR NOT QT_HEADERS_DIR OR QT_QMAKE_CHANGED)) _qt4_query_qmake(QT_INSTALL_HEADERS qt_headers) set(QT_QTCORE_INCLUDE_DIR NOTFOUND) find_path(QT_QTCORE_INCLUDE_DIR QtCore HINTS ${qt_headers} ${QT_LIBRARY_DIR} PATH_SUFFIXES QtCore qt4/QtCore NO_DEFAULT_PATH ) if(NOT QT_QTCORE_INCLUDE_DIR) find_path(QT_QTCORE_INCLUDE_DIR QtCore HINTS ${qt_headers} ${QT_LIBRARY_DIR} PATH_SUFFIXES QtCore qt4/QtCore ) endif() # Set QT_HEADERS_DIR based on finding QtCore header if(QT_QTCORE_INCLUDE_DIR) if(QT_USE_FRAMEWORKS) set(QT_HEADERS_DIR "${qt_headers}" CACHE INTERNAL "" FORCE) else() get_filename_component(qt_headers "${QT_QTCORE_INCLUDE_DIR}/../" ABSOLUTE) set(QT_HEADERS_DIR "${qt_headers}" CACHE INTERNAL "" FORCE) endif() elseif() message("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_HEADERS as ${qt_headers}") message("Warning: But QtCore couldn't be found. Qt must NOT be installed correctly.") endif() endif() if(APPLE) set(CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_OLD}) endif() # Set QT_INCLUDE_DIR based on QT_HEADERS_DIR if(QT_HEADERS_DIR) if(QT_USE_FRAMEWORKS) # Qt/Mac frameworks has two include dirs. # One is the framework include for which CMake will add a -F flag # and the other is an include dir for non-framework Qt modules set(QT_INCLUDE_DIR ${QT_HEADERS_DIR} ${QT_QTCORE_LIBRARY_RELEASE} ) else() set(QT_INCLUDE_DIR ${QT_HEADERS_DIR}) endif() endif() # Set QT_INCLUDES set( QT_INCLUDES ${QT_MKSPECS_DIR}/default ${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR}) # ask qmake for the documentation directory if (QT_LIBRARY_DIR AND NOT QT_DOC_DIR OR QT_QMAKE_CHANGED) _qt4_query_qmake(QT_INSTALL_DOCS qt_doc_dir) set(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs" FORCE) endif () # ask qmake for the plugins directory if (QT_LIBRARY_DIR AND NOT QT_PLUGINS_DIR OR QT_QMAKE_CHANGED) _qt4_query_qmake(QT_INSTALL_PLUGINS qt_plugins_dir) set(QT_PLUGINS_DIR NOTFOUND) foreach(qt_cross_path ${CMAKE_FIND_ROOT_PATH}) set(qt_cross_paths ${qt_cross_paths} "${qt_cross_path}/plugins") endforeach() find_path(QT_PLUGINS_DIR NAMES accessible imageformats sqldrivers codecs designer HINTS ${qt_cross_paths} ${qt_plugins_dir} DOC "The location of the Qt plugins" NO_CMAKE_FIND_ROOT_PATH) endif () # ask qmake for the translations directory if (QT_LIBRARY_DIR AND NOT QT_TRANSLATIONS_DIR OR QT_QMAKE_CHANGED) _qt4_query_qmake(QT_INSTALL_TRANSLATIONS qt_translations_dir) set(QT_TRANSLATIONS_DIR ${qt_translations_dir} CACHE PATH "The location of the Qt translations" FORCE) endif () # ask qmake for the imports directory if (QT_LIBRARY_DIR AND NOT QT_IMPORTS_DIR OR QT_QMAKE_CHANGED) _qt4_query_qmake(QT_INSTALL_IMPORTS qt_imports_dir) if(qt_imports_dir) set(QT_IMPORTS_DIR NOTFOUND) foreach(qt_cross_path ${CMAKE_FIND_ROOT_PATH}) set(qt_cross_paths ${qt_cross_paths} "${qt_cross_path}/imports") endforeach() find_path(QT_IMPORTS_DIR NAMES Qt HINTS ${qt_cross_paths} ${qt_imports_dir} DOC "The location of the Qt imports" NO_CMAKE_FIND_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH) mark_as_advanced(QT_IMPORTS_DIR) endif() endif () # Make variables changeable to the advanced user mark_as_advanced( QT_LIBRARY_DIR QT_DOC_DIR QT_MKSPECS_DIR QT_PLUGINS_DIR QT_TRANSLATIONS_DIR) ############################################# # # Find out what window system we're using # ############################################# # Save required variable set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES}) set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS}) # Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES set(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_INCLUDE_DIR}") # Check for Window system symbols (note: only one should end up being set) CHECK_CXX_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11) CHECK_CXX_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN) CHECK_CXX_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS) CHECK_CXX_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC) if(Q_WS_MAC) if(QT_QMAKE_CHANGED) unset(QT_MAC_USE_COCOA CACHE) endif() CHECK_CXX_SYMBOL_EXISTS(QT_MAC_USE_COCOA "QtCore/qconfig.h" QT_MAC_USE_COCOA) endif() if (QT_QTCOPY_REQUIRED) CHECK_CXX_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY) if (NOT QT_IS_QTCOPY) message(FATAL_ERROR "qt-copy is required, but hasn't been found") endif () endif () # Restore CMAKE_REQUIRED_INCLUDES and CMAKE_REQUIRED_FLAGS variables set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE}) set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE}) # ############################################# ######################################## # # Setting the INCLUDE-Variables # ######################################## set(QT_MODULES QtGui Qt3Support QtSvg QtScript QtTest QtUiTools QtHelp QtWebKit QtXmlPatterns phonon QtNetwork QtMultimedia QtNsPlugin QtOpenGL QtSql QtXml QtDesigner QtDBus QtScriptTools QtDeclarative) if(Q_WS_X11) set(QT_MODULES ${QT_MODULES} QtMotif) endif() if(QT_QMAKE_CHANGED) foreach(QT_MODULE ${QT_MODULES}) string(TOUPPER ${QT_MODULE} _upper_qt_module) set(QT_${_upper_qt_module}_INCLUDE_DIR NOTFOUND) set(QT_${_upper_qt_module}_LIBRARY_RELEASE NOTFOUND) set(QT_${_upper_qt_module}_LIBRARY_DEBUG NOTFOUND) endforeach() set(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR NOTFOUND) set(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NOTFOUND) set(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NOTFOUND) set(QT_QTASSISTANTCLIENT_INCLUDE_DIR NOTFOUND) set(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NOTFOUND) set(QT_QTASSISTANTCLIENT_LIBRARY_DEBUG NOTFOUND) set(QT_QTASSISTANT_INCLUDE_DIR NOTFOUND) set(QT_QTASSISTANT_LIBRARY_RELEASE NOTFOUND) set(QT_QTASSISTANT_LIBRARY_DEBUG NOTFOUND) set(QT_QTCLUCENE_LIBRARY_RELEASE NOTFOUND) set(QT_QTCLUCENE_LIBRARY_DEBUG NOTFOUND) set(QT_QAXCONTAINER_INCLUDE_DIR NOTFOUND) set(QT_QAXCONTAINER_LIBRARY_RELEASE NOTFOUND) set(QT_QAXCONTAINER_LIBRARY_DEBUG NOTFOUND) set(QT_QAXSERVER_INCLUDE_DIR NOTFOUND) set(QT_QAXSERVER_LIBRARY_RELEASE NOTFOUND) set(QT_QAXSERVER_LIBRARY_DEBUG NOTFOUND) if(Q_WS_WIN) set(QT_QTMAIN_LIBRARY_DEBUG NOTFOUND) set(QT_QTMAIN_LIBRARY_RELEASE NOTFOUND) endif() endif() foreach(QT_MODULE ${QT_MODULES}) string(TOUPPER ${QT_MODULE} _upper_qt_module) find_path(QT_${_upper_qt_module}_INCLUDE_DIR ${QT_MODULE} PATHS ${QT_HEADERS_DIR}/${QT_MODULE} ${QT_LIBRARY_DIR}/${QT_MODULE}.framework/Headers NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) # phonon doesn't seem consistent, let's try phonondefs.h for some # installations if(${QT_MODULE} STREQUAL "phonon") find_path(QT_${_upper_qt_module}_INCLUDE_DIR phonondefs.h PATHS ${QT_HEADERS_DIR}/${QT_MODULE} ${QT_LIBRARY_DIR}/${QT_MODULE}.framework/Headers NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) endif() endforeach() if(Q_WS_WIN) set(QT_MODULES ${QT_MODULES} QAxContainer QAxServer) # Set QT_AXCONTAINER_INCLUDE_DIR and QT_AXSERVER_INCLUDE_DIR find_path(QT_QAXCONTAINER_INCLUDE_DIR ActiveQt PATHS ${QT_HEADERS_DIR}/ActiveQt NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_path(QT_QAXSERVER_INCLUDE_DIR ActiveQt PATHS ${QT_HEADERS_DIR}/ActiveQt NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) endif() # Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR find_path(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents PATHS ${QT_HEADERS_DIR}/QtDesigner ${QT_LIBRARY_DIR}/QtDesigner.framework/Headers NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) # Set QT_QTASSISTANT_INCLUDE_DIR find_path(QT_QTASSISTANT_INCLUDE_DIR QtAssistant PATHS ${QT_HEADERS_DIR}/QtAssistant ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) # Set QT_QTASSISTANTCLIENT_INCLUDE_DIR find_path(QT_QTASSISTANTCLIENT_INCLUDE_DIR QAssistantClient PATHS ${QT_HEADERS_DIR}/QtAssistant ${QT_LIBRARY_DIR}/QtAssistant.framework/Headers NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) ######################################## # # Setting the LIBRARY-Variables # ######################################## # find the libraries foreach(QT_MODULE ${QT_MODULES}) string(TOUPPER ${QT_MODULE} _upper_qt_module) find_library(QT_${_upper_qt_module}_LIBRARY_RELEASE NAMES ${QT_MODULE}${QT_LIBINFIX} ${QT_MODULE}${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_library(QT_${_upper_qt_module}_LIBRARY_DEBUG NAMES ${QT_MODULE}${QT_LIBINFIX}_debug ${QT_MODULE}${QT_LIBINFIX}d ${QT_MODULE}${QT_LIBINFIX}d4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) if(QT_${_upper_qt_module}_LIBRARY_RELEASE MATCHES "/${QT_MODULE}\\.framework$") if(NOT EXISTS "${QT_${_upper_qt_module}_LIBRARY_RELEASE}/${QT_MODULE}") # Release framework library file does not exist... Force to NOTFOUND: set(QT_${_upper_qt_module}_LIBRARY_RELEASE "QT_${_upper_qt_module}_LIBRARY_RELEASE-NOTFOUND" CACHE FILEPATH "Path to a library." FORCE) endif() endif() if(QT_${_upper_qt_module}_LIBRARY_DEBUG MATCHES "/${QT_MODULE}\\.framework$") if(NOT EXISTS "${QT_${_upper_qt_module}_LIBRARY_DEBUG}/${QT_MODULE}") # Debug framework library file does not exist... Force to NOTFOUND: set(QT_${_upper_qt_module}_LIBRARY_DEBUG "QT_${_upper_qt_module}_LIBRARY_DEBUG-NOTFOUND" CACHE FILEPATH "Path to a library." FORCE) endif() endif() endforeach() # QtUiTools is sometimes not in the same directory as the other found libraries # e.g. on Mac, its never a framework like the others are if(QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTUITOOLS_LIBRARY_RELEASE) find_library(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR}) endif() # Set QT_QTDESIGNERCOMPONENTS_LIBRARY find_library(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents${QT_LIBINFIX} QtDesignerComponents${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) 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 NO_CMAKE_FIND_ROOT_PATH) # Set QT_QTMAIN_LIBRARY if(Q_WS_WIN) find_library(QT_QTMAIN_LIBRARY_RELEASE NAMES qtmain${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) find_library(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmain${QT_LIBINFIX}d PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) endif() # Set QT_QTASSISTANTCLIENT_LIBRARY find_library(QT_QTASSISTANTCLIENT_LIBRARY_RELEASE NAMES QtAssistantClient${QT_LIBINFIX} QtAssistantClient${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) 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 NO_CMAKE_FIND_ROOT_PATH) # Set QT_QTASSISTANT_LIBRARY 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 NO_CMAKE_FIND_ROOT_PATH) 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 NO_CMAKE_FIND_ROOT_PATH) # Set QT_QTHELP_LIBRARY find_library(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} QtCLucene${QT_LIBINFIX}4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) 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 NO_CMAKE_FIND_ROOT_PATH) if(Q_WS_MAC AND QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCLUCENE_LIBRARY_RELEASE) find_library(QT_QTCLUCENE_LIBRARY_RELEASE NAMES QtCLucene${QT_LIBINFIX} PATHS ${QT_LIBRARY_DIR}) endif() ############################################ # # Check the existence of the libraries. # ############################################ macro(_qt4_add_target_depends_internal _QT_MODULE _PROPERTY) if (TARGET Qt4::${_QT_MODULE}) foreach(_DEPEND ${ARGN}) set(_VALID_DEPENDS) if (TARGET Qt4::Qt${_DEPEND}) list(APPEND _VALID_DEPENDS Qt4::Qt${_DEPEND}) endif() if (_VALID_DEPENDS) set_property(TARGET Qt4::${_QT_MODULE} APPEND PROPERTY ${_PROPERTY} "${_VALID_DEPENDS}" ) endif() set(_VALID_DEPENDS) endforeach() endif() endmacro() macro(_qt4_add_target_depends _QT_MODULE) get_target_property(_configs Qt4::${_QT_MODULE} IMPORTED_CONFIGURATIONS) _qt4_add_target_depends_internal(${_QT_MODULE} INTERFACE_LINK_LIBRARIES ${ARGN}) foreach(_config ${_configs}) _qt4_add_target_depends_internal(${_QT_MODULE} IMPORTED_LINK_INTERFACE_LIBRARIES_${_config} ${ARGN}) endforeach() set(_configs) endmacro() macro(_qt4_add_target_private_depends _QT_MODULE) get_target_property(_configs ${_QT_MODULE} IMPORTED_CONFIGURATIONS) foreach(_config ${_configs}) _qt4_add_target_depends_internal(${_QT_MODULE} IMPORTED_LINK_DEPENDENT_LIBRARIES_${_config} ${ARGN}) endforeach() set(_configs) endmacro() # Set QT_xyz_LIBRARY variable and add # library include path to QT_INCLUDES _QT4_ADJUST_LIB_VARS(QtCore) set_property(TARGET Qt4::QtCore APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${QT_MKSPECS_DIR}/default" ${QT_INCLUDE_DIR} ) set_property(TARGET Qt4::QtCore APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS $<$>:QT_NO_DEBUG> ) set_property(TARGET Qt4::QtCore PROPERTY INTERFACE_QT_MAJOR_VERSION 4 ) set_property(TARGET Qt4::QtCore APPEND PROPERTY COMPATIBLE_INTERFACE_STRING QT_MAJOR_VERSION ) foreach(QT_MODULE ${QT_MODULES}) _QT4_ADJUST_LIB_VARS(${QT_MODULE}) _qt4_add_target_depends(${QT_MODULE} Core) endforeach() _QT4_ADJUST_LIB_VARS(QtAssistant) _QT4_ADJUST_LIB_VARS(QtAssistantClient) _QT4_ADJUST_LIB_VARS(QtCLucene) _QT4_ADJUST_LIB_VARS(QtDesignerComponents) # platform dependent libraries if(Q_WS_WIN) _QT4_ADJUST_LIB_VARS(qtmain) _QT4_ADJUST_LIB_VARS(QAxServer) if(QT_QAXSERVER_FOUND) set_property(TARGET Qt4::QAxServer PROPERTY INTERFACE_QT4_NO_LINK_QTMAIN ON ) set_property(TARGET Qt4::QAxServer APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL QT4_NO_LINK_QTMAIN) endif() _QT4_ADJUST_LIB_VARS(QAxContainer) endif() # Only public dependencies are listed here. # Eg, QtDBus links to QtXml, but users of QtDBus do not need to # link to QtXml because QtDBus only uses it internally, not in public # headers. # Everything depends on QtCore, but that is covered above already _qt4_add_target_depends(Qt3Support Sql Gui Network) if (TARGET Qt4::Qt3Support) # An additional define is required for QT3_SUPPORT set_property(TARGET Qt4::Qt3Support APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS QT3_SUPPORT) endif() _qt4_add_target_depends(QtDeclarative Script Gui) _qt4_add_target_depends(QtDesigner Gui) _qt4_add_target_depends(QtHelp Gui) _qt4_add_target_depends(QtMultimedia Gui) _qt4_add_target_depends(QtOpenGL Gui) _qt4_add_target_depends(QtSvg Gui) _qt4_add_target_depends(QtWebKit Gui Network) _qt4_add_target_private_depends(Qt3Support Xml) if(QT_VERSION VERSION_GREATER 4.6) _qt4_add_target_private_depends(QtSvg Xml) endif() _qt4_add_target_private_depends(QtDBus Xml) _qt4_add_target_private_depends(QtUiTools Xml Gui) _qt4_add_target_private_depends(QtHelp Sql Xml Network) _qt4_add_target_private_depends(QtXmlPatterns Network) _qt4_add_target_private_depends(QtScriptTools Gui) _qt4_add_target_private_depends(QtWebKit XmlPatterns) _qt4_add_target_private_depends(QtDeclarative XmlPatterns Svg Sql Gui) _qt4_add_target_private_depends(QtMultimedia Gui) _qt4_add_target_private_depends(QtOpenGL Gui) if(QT_QAXSERVER_FOUND) _qt4_add_target_private_depends(QAxServer Gui) endif() if(QT_QAXCONTAINER_FOUND) _qt4_add_target_private_depends(QAxContainer Gui) endif() _qt4_add_target_private_depends(phonon Gui) if(QT_QTDBUS_FOUND) _qt4_add_target_private_depends(phonon DBus) endif() if (WIN32 AND NOT QT4_NO_LINK_QTMAIN) set(_isExe $,EXECUTABLE>) set(_isWin32 $>) set(_isNotExcluded $>>) set(_isPolicyNEW $) get_target_property(_configs Qt4::QtCore IMPORTED_CONFIGURATIONS) set_property(TARGET Qt4::QtCore APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$:Qt4::qtmain> ) foreach(_config ${_configs}) set_property(TARGET Qt4::QtCore APPEND PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES_${_config} $<$:Qt4::qtmain> ) endforeach() unset(_configs) unset(_isExe) unset(_isWin32) unset(_isNotExcluded) unset(_isPolicyNEW) endif() ####################################### # # Check the executables of Qt # ( moc, uic, rcc ) # ####################################### if(QT_QMAKE_CHANGED) set(QT_UIC_EXECUTABLE NOTFOUND) set(QT_MOC_EXECUTABLE NOTFOUND) set(QT_UIC3_EXECUTABLE NOTFOUND) set(QT_RCC_EXECUTABLE NOTFOUND) set(QT_DBUSCPP2XML_EXECUTABLE NOTFOUND) set(QT_DBUSXML2CPP_EXECUTABLE NOTFOUND) set(QT_LUPDATE_EXECUTABLE NOTFOUND) set(QT_LRELEASE_EXECUTABLE NOTFOUND) set(QT_QCOLLECTIONGENERATOR_EXECUTABLE NOTFOUND) set(QT_DESIGNER_EXECUTABLE NOTFOUND) set(QT_LINGUIST_EXECUTABLE NOTFOUND) endif() find_program(QT_MOC_EXECUTABLE NAMES moc-qt4 moc moc4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_UIC_EXECUTABLE NAMES uic-qt4 uic uic4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_UIC3_EXECUTABLE NAMES uic3 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_RCC_EXECUTABLE NAMES rcc PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_DBUSCPP2XML_EXECUTABLE NAMES qdbuscpp2xml PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_DBUSXML2CPP_EXECUTABLE NAMES qdbusxml2cpp PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_LUPDATE_EXECUTABLE NAMES lupdate-qt4 lupdate lupdate4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_LRELEASE_EXECUTABLE NAMES lrelease-qt4 lrelease lrelease4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_QCOLLECTIONGENERATOR_EXECUTABLE NAMES qcollectiongenerator-qt4 qcollectiongenerator PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_DESIGNER_EXECUTABLE NAMES designer-qt4 designer designer4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_program(QT_LINGUIST_EXECUTABLE NAMES linguist-qt4 linguist linguist4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) if (QT_MOC_EXECUTABLE) set(QT_WRAP_CPP "YES") endif () if (QT_UIC_EXECUTABLE) set(QT_WRAP_UI "YES") endif () mark_as_advanced( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE QT_LUPDATE_EXECUTABLE QT_LRELEASE_EXECUTABLE QT_QCOLLECTIONGENERATOR_EXECUTABLE QT_DESIGNER_EXECUTABLE QT_LINGUIST_EXECUTABLE) # get the directory of the current file, used later on in the file get_filename_component( _qt4_current_dir "${CMAKE_CURRENT_LIST_FILE}" PATH) ############################################### # # configuration/system dependent settings # ############################################### include("${_qt4_current_dir}/Qt4ConfigDependentSettings.cmake") ####################################### # # Check the plugins of Qt # ####################################### set( QT_PLUGIN_TYPES accessible bearer codecs decorations designer gfxdrivers graphicssystems iconengines imageformats inputmethods mousedrivers phonon_backend script sqldrivers ) set( QT_ACCESSIBLE_PLUGINS qtaccessiblecompatwidgets qtaccessiblewidgets ) set( QT_BEARER_PLUGINS qcorewlanbearer qgenericbearer ) set( QT_CODECS_PLUGINS qcncodecs qjpcodecs qkrcodecs qtwcodecs ) set( QT_DECORATIONS_PLUGINS qdecorationdefault qdecorationwindows ) set( QT_DESIGNER_PLUGINS arthurplugin containerextension customwidgetplugin phononwidgets qdeclarativeview qt3supportwidgets qwebview taskmenuextension worldtimeclockplugin ) set( QT_GRAPHICSDRIVERS_PLUGINS qgfxtransformed qgfxvnc qscreenvfb ) set( QT_GRAPHICSSYSTEMS_PLUGINS qglgraphicssystem qtracegraphicssystem ) set( QT_ICONENGINES_PLUGINS qsvgicon ) set( QT_IMAGEFORMATS_PLUGINS qgif qjpeg qmng qico qsvg qtiff ) set( QT_INPUTMETHODS_PLUGINS qimsw_multi ) set( QT_MOUSEDRIVERS_PLUGINS qwstslibmousehandler ) if(APPLE) set( QT_PHONON_BACKEND_PLUGINS phonon_qt7 ) elseif(WIN32) set( QT_PHONON_BACKEND_PLUGINS phonon_ds9 ) endif() set( QT_SCRIPT_PLUGINS qtscriptdbus ) set( QT_SQLDRIVERS_PLUGINS qsqldb2 qsqlibase qsqlite qsqlite2 qsqlmysql qsqloci qsqlodbc qsqlpsql qsqltds ) set( QT_PHONON_PLUGINS ${QT_PHONON_BACKEND_PLUGINS} ) set( QT_QT3SUPPORT_PLUGINS qtaccessiblecompatwidgets ) set( QT_QTCORE_PLUGINS ${QT_BEARER_PLUGINS} ${QT_CODECS_PLUGINS} ) set( QT_QTGUI_PLUGINS qtaccessiblewidgets qgif qjpeg qmng qico qtiff ${QT_DECORATIONS_PLUGINS} ${QT_GRAPHICSDRIVERS_PLUGINS} ${QT_GRAPHICSSYSTEMS_PLUGINS} ${QT_INPUTMETHODS_PLUGINS} ${QT_MOUSEDRIVERS_PLUGINS} ) set( QT_QTSCRIPT_PLUGINS ${QT_SCRIPT_PLUGINS} ) set( QT_QTSQL_PLUGINS ${QT_SQLDRIVERS_PLUGINS} ) set( QT_QTSVG_PLUGINS qsvg qsvgicon ) if(QT_QMAKE_CHANGED) foreach(QT_PLUGIN_TYPE ${QT_PLUGIN_TYPES}) string(TOUPPER ${QT_PLUGIN_TYPE} _upper_qt_plugin_type) set(QT_${_upper_qt_plugin_type}_PLUGINS_DIR ${QT_PLUGINS_DIR}/${QT_PLUGIN_TYPE}) foreach(QT_PLUGIN ${QT_${_upper_qt_plugin_type}_PLUGINS}) string(TOUPPER ${QT_PLUGIN} _upper_qt_plugin) unset(QT_${_upper_qt_plugin}_LIBRARY_RELEASE CACHE) unset(QT_${_upper_qt_plugin}_LIBRARY_DEBUG CACHE) unset(QT_${_upper_qt_plugin}_LIBRARY CACHE) unset(QT_${_upper_qt_plugin}_PLUGIN_RELEASE CACHE) unset(QT_${_upper_qt_plugin}_PLUGIN_DEBUG CACHE) unset(QT_${_upper_qt_plugin}_PLUGIN CACHE) endforeach() endforeach() endif() # find_library works better than find_file but we need to set prefixes to only match plugins foreach(QT_PLUGIN_TYPE ${QT_PLUGIN_TYPES}) string(TOUPPER ${QT_PLUGIN_TYPE} _upper_qt_plugin_type) set(QT_${_upper_qt_plugin_type}_PLUGINS_DIR ${QT_PLUGINS_DIR}/${QT_PLUGIN_TYPE}) foreach(QT_PLUGIN ${QT_${_upper_qt_plugin_type}_PLUGINS}) string(TOUPPER ${QT_PLUGIN} _upper_qt_plugin) if(QT_IS_STATIC) find_library(QT_${_upper_qt_plugin}_LIBRARY_RELEASE NAMES ${QT_PLUGIN}${QT_LIBINFIX} ${QT_PLUGIN}${QT_LIBINFIX}4 PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_library(QT_${_upper_qt_plugin}_LIBRARY_DEBUG NAMES ${QT_PLUGIN}${QT_LIBINFIX}_debug ${QT_PLUGIN}${QT_LIBINFIX}d ${QT_PLUGIN}${QT_LIBINFIX}d4 PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) _QT4_ADJUST_LIB_VARS(${QT_PLUGIN}) else() # find_library works easier/better than find_file but we need to set suffixes to only match plugins set(CMAKE_FIND_LIBRARY_SUFFIXES_DEFAULT ${CMAKE_FIND_LIBRARY_SUFFIXES}) set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_MODULE_SUFFIX} ${CMAKE_SHARED_LIBRARY_SUFFIX}) find_library(QT_${_upper_qt_plugin}_PLUGIN_RELEASE NAMES ${QT_PLUGIN}${QT_LIBINFIX} ${QT_PLUGIN}${QT_LIBINFIX}4 PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) find_library(QT_${_upper_qt_plugin}_PLUGIN_DEBUG NAMES ${QT_PLUGIN}${QT_LIBINFIX}_debug ${QT_PLUGIN}${QT_LIBINFIX}d ${QT_PLUGIN}${QT_LIBINFIX}d4 PATHS ${QT_${_upper_qt_plugin_type}_PLUGINS_DIR} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH ) mark_as_advanced(QT_${_upper_qt_plugin}_PLUGIN_RELEASE QT_${_upper_qt_plugin}_PLUGIN_DEBUG) set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_DEFAULT}) endif() endforeach() endforeach() ###################################### # # Macros for building Qt files # ###################################### include("${_qt4_current_dir}/Qt4Macros.cmake") endif() #support old QT_MIN_VERSION if set, but not if version is supplied by find_package() if(NOT Qt4_FIND_VERSION AND QT_MIN_VERSION) set(Qt4_FIND_VERSION ${QT_MIN_VERSION}) endif() if( Qt4_FIND_COMPONENTS ) # if components specified in find_package(), make sure each of those pieces were found set(_QT4_FOUND_REQUIRED_VARS QT_QMAKE_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_INCLUDE_DIR QT_LIBRARY_DIR) foreach( component ${Qt4_FIND_COMPONENTS} ) string( TOUPPER ${component} _COMPONENT ) if(${_COMPONENT} STREQUAL "QTMAIN") if(Q_WS_WIN) set(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_${_COMPONENT}_LIBRARY) endif() else() set(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_${_COMPONENT}_INCLUDE_DIR QT_${_COMPONENT}_LIBRARY) endif() endforeach() if(Qt4_FIND_COMPONENTS MATCHES QtGui) set(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_UIC_EXECUTABLE) endif() else() # if no components specified, we'll make a default set of required variables to say Qt is found set(_QT4_FOUND_REQUIRED_VARS QT_QMAKE_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_UIC_EXECUTABLE QT_INCLUDE_DIR QT_LIBRARY_DIR QT_QTCORE_LIBRARY) endif() if (NOT QT_VERSION_MAJOR EQUAL 4) set(VERSION_MSG "Found unsuitable Qt version \"${QTVERSION}\" from ${QT_QMAKE_EXECUTABLE}") set(QT4_FOUND FALSE) if(Qt4_FIND_REQUIRED) message( FATAL_ERROR "${VERSION_MSG}, this code requires Qt 4.x") else() if(NOT Qt4_FIND_QUIETLY) message( STATUS "${VERSION_MSG}") endif() endif() else() FIND_PACKAGE_HANDLE_STANDARD_ARGS(Qt4 FOUND_VAR Qt4_FOUND REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} VERSION_VAR QTVERSION ) endif() ####################################### # # compatibility settings # ####################################### # Backwards compatibility for CMake1.4 and 1.2 set (QT_MOC_EXE ${QT_MOC_EXECUTABLE} ) set (QT_UIC_EXE ${QT_UIC_EXECUTABLE} ) set( QT_QT_LIBRARY "") set(QT4_FOUND ${Qt4_FOUND}) set(QT_FOUND ${Qt4_FOUND})