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. First is
6
# QT_USE_FILE which is the path to a CMake file that can be included to compile
7
# Qt 4 applications and libraries. By default, the QtCore and QtGui
8
# libraries are loaded. This behavior can be changed by setting one or more
9
# of the following variables to true:
28
# All the libraries required are stored in a variable called QT_LIBRARIES.
29
# Add this variable to your TARGET_LINK_LIBRARIES.
31
# macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
32
# create moc code from a list of files containing Qt class with
33
# the Q_OBJECT declaration. Options may be given to moc, such as those found
34
# when executing "moc -help"
36
# macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
37
# create code from a list of Qt designer ui files.
38
# Options may be given to uic, such as those found
39
# when executing "uic -help"
41
# macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
42
# create code from a list of Qt resource files.
43
# Options may be given to rcc, such as those found
44
# when executing "rcc -help"
46
# macro QT4_AUTOMOC(inputfile ... )
47
# macro QT4_GENERATE_MOC(inputfile outputfile )
49
# macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
50
# create a the interface header and implementation files with the
51
# given basename from the given interface xml file and add it to
52
# the list of sources.
53
# To disable generating a namespace header, set the source file property
54
# NO_NAMESPACE to TRUE on the interface file.
56
# macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
57
# create the interface header and implementation files
58
# for all listed interface xml files
59
# the name will be automatically determined from the name of the xml file
60
# To disable generating namespace headers, set the source file property
61
# NO_NAMESPACE to TRUE for these inputfiles.
63
# macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])
64
# create a dbus adaptor (header and implementation file) from the xml file
65
# describing the interface, and add it to the list of sources. The adaptor
66
# forwards the calls to a parent class, defined in parentheader and named
67
# parentclassname. The name of the generated files will be
68
# <basename>adaptor.{cpp,h} where basename defaults to the basename of the xml file.
69
# If <classname> is provided, then it will be used as the classname of the
72
# macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
73
# generate the xml interface file from the given header.
74
# If the optional argument interfacename is omitted, the name of the
75
# interface file is constructed from the basename of the header with
76
# the suffix .xml appended.
77
# Options may be given to uic, such as those found when executing "qdbuscpp2xml --help"
79
# QT_FOUND If false, don't try to use Qt.
80
# QT4_FOUND If false, don't try to use Qt 4.
82
# QT4_QTCORE_FOUND True if QtCore was found.
83
# QT4_QTGUI_FOUND True if QtGui was found.
84
# QT4_QT3SUPPORT_FOUND True if Qt3Support was found.
85
# QT4_QTASSISTANT_FOUND True if QtAssistant was found.
86
# QT4_QTDBUS_FOUND True if QtDBus was found.
87
# QT4_QTDESIGNER_FOUND True if QtDesigner was found.
88
# QT4_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.
89
# QT4_QTMOTIF_FOUND True if QtMotif was found.
90
# QT4_QTNETWORK_FOUND True if QtNetwork was found.
91
# QT4_QTNSPLUGIN_FOUND True if QtNsPlugin was found.
92
# QT4_QTOPENGL_FOUND True if QtOpenGL was found.
93
# QT4_QTSQL_FOUND True if QtSql was found.
94
# QT4_QTXML_FOUND True if QtXml was found.
95
# QT4_QTSVG_FOUND True if QtSvg was found.
96
# QT4_QTSCRIPT_FOUND True if QtScript was found.
97
# QT4_QTTEST_FOUND True if QtTest was found.
98
# QT4_QTUITOOLS_FOUND True if QtUiTools was found.
100
# QT4_DEFINITIONS Definitions to use when compiling code that uses Qt.
102
# QT4_INCLUDES List of paths to all include directories of
103
# Qt4 QT4_INCLUDE_DIR and QT4_QTCORE_INCLUDE_DIR are
104
# always in this variable even if NOTFOUND,
105
# all other INCLUDE_DIRS are
106
# only added if they are found.
108
# QT4_INCLUDE_DIR Path to "include" of Qt4
109
# QT4_QT4_INCLUDE_DIR Path to "include/Qt"
110
# QT4_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support"
111
# QT4_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant"
112
# QT4_QTCORE_INCLUDE_DIR Path to "include/QtCore"
113
# QT4_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner"
114
# QT4_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner"
115
# QT4_QTDBUS_INCLUDE_DIR Path to "include/QtDBus"
116
# QT4_QTGUI_INCLUDE_DIR Path to "include/QtGui"
117
# QT4_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif"
118
# QT4_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork"
119
# QT4_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin"
120
# QT4_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL"
121
# QT4_QTSQL_INCLUDE_DIR Path to "include/QtSql"
122
# QT4_QTXML_INCLUDE_DIR Path to "include/QtXml"
123
# QT4_QTSVG_INCLUDE_DIR Path to "include/QtSvg"
124
# QT4_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript"
125
# QT4_QTTEST_INCLUDE_DIR Path to "include/QtTest"
127
# QT4_LIBRARY_DIR Path to "lib" of Qt4
129
# QT4_PLUGINS_DIR Path to "plugins" for Qt4
131
# For every library of Qt, a QT4_QTFOO_LIBRARY variable is defined, with the full path to the library.
133
# So there are the following variables:
134
# The Qt3Support library: QT4_QT3SUPPORT_LIBRARY
136
# The QtAssistant library: QT4_QTASSISTANT_LIBRARY
138
# The QtCore library: QT4_QTCORE_LIBRARY
140
# The QtDBus library: QT4_QTDBUS_LIBRARY
142
# The QtDesigner library: QT4_QTDESIGNER_LIBRARY
144
# The QtDesignerComponents library: QT4_QTDESIGNERCOMPONENTS_LIBRARY
146
# The QtGui library: QT4_QTGUI_LIBRARY
148
# The QtMotif library: QT4_QTMOTIF_LIBRARY
150
# The QtNetwork library: QT4_QTNETWORK_LIBRARY
152
# The QtNsPLugin library: QT4_QTNSPLUGIN_LIBRARY
154
# The QtOpenGL library: QT4_QTOPENGL_LIBRARY
156
# The QtSql library: QT4_QTSQL_LIBRARY
158
# The QtXml library: QT4_QTXML_LIBRARY
160
# The QtSvg library: QT4_QTSVG_LIBRARY
162
# The QtScript library: QT4_QTSCRIPT_LIBRARY
164
# The QtTest library: QT4_QTTEST_LIBRARY
166
# The qtmain library for Windows QT4_QTMAIN_LIBRARY
168
# The QtUiTools library: QT4_QTUITOOLS_LIBRARY
170
# also defined, but NOT for general use are
171
# QT4_MOC_EXECUTABLE Where to find the moc tool.
172
# QT4_UIC_EXECUTABLE Where to find the uic tool.
173
# QT_UIC3_EXECUTABLE Where to find the uic3 tool.
174
# QT_RCC_EXECUTABLE Where to find the rcc tool
175
# QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool.
176
# QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool.
178
# QT_DOC_DIR Path to "doc" of Qt4
179
# QT_MKSPECS_DIR Path to "mkspecs" of Qt4
182
# These are around for backwards compatibility
184
# QT_WRAP_CPP Set true if QT4_MOC_EXECUTABLE is found
185
# QT_WRAP_UI Set true if QT4_UIC_EXECUTABLE is found
187
# These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)
188
# QT_MT_REQUIRED Qt4 is now always multithreaded
190
# These variables are set to "" Because Qt structure changed
191
# (They make no sense in Qt4)
192
# QT4_QT_LIBRARY Qt-Library is now split
194
# Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
195
# See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
198
# Check already done in this cmake run, nothing more to do
200
else (QT4_QMAKE_FOUND)
202
# check that QT_NO_DEBUG is defined for release configurations
203
MACRO(QT_CHECK_FLAG_EXISTS FLAG VAR DOC)
204
IF(NOT ${VAR} MATCHES "${FLAG}")
205
SET(${VAR} "${${VAR}} ${FLAG}"
206
CACHE STRING "Flags used by the compiler during ${DOC} builds." FORCE)
207
ENDIF(NOT ${VAR} MATCHES "${FLAG}")
208
ENDMACRO(QT_CHECK_FLAG_EXISTS FLAG VAR)
209
QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO "Release with Debug Info")
210
QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_RELEASE "release")
211
QT_CHECK_FLAG_EXISTS(-DQT_NO_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL "release minsize")
213
INCLUDE(CheckSymbolExists)
214
INCLUDE(MacroAddFileDependencies)
215
INCLUDE(MacroPushRequiredVars)
217
SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
219
SET( QT4_DEFINITIONS "")
222
SET(QT4_DEFINITIONS -DQT_DLL)
225
SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)
227
# macro for asking qmake to process pro files
228
MACRO(QT_QUERY_QMAKE outvar invar)
229
FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro
230
"message(CMAKE_MESSAGE<$$${invar}>)")
232
# Invoke qmake with the tmp.pro program to get the desired
233
# information. Use the same variable for both stdout and stderr
234
# to make sure we get the output on all platforms.
235
EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}
237
${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake
238
OUTPUT_VARIABLE _qmake_query_output
239
RESULT_VARIABLE _qmake_result
240
ERROR_VARIABLE _qmake_query_output )
243
"${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake")
246
MESSAGE(WARNING " querying qmake for ${invar}. qmake reported:\n${_qmake_query_output}")
248
STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}")
251
ENDMACRO(QT_QUERY_QMAKE)
253
GET_FILENAME_COMPONENT(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME)
255
FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 PATHS
256
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
257
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
258
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]/bin"
262
IF (QT_QMAKE_EXECUTABLE)
264
SET(QT4_QMAKE_FOUND FALSE)
266
EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
268
# check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
269
IF("${QTVERSION}" MATCHES "Unknown")
270
SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
271
FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS
272
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
273
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
276
IF(QT_QMAKE_EXECUTABLE)
277
EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
278
ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
279
ENDIF(QT_QMAKE_EXECUTABLE)
280
ENDIF("${QTVERSION}" MATCHES "Unknown")
282
# check that we found the Qt4 qmake, Qt3 qmake output won't match here
283
STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")
286
# we need at least version 4.0.0
287
IF (NOT QT4_MIN_VERSION)
288
SET(QT4_MIN_VERSION "4.0.0")
289
ENDIF (NOT QT4_MIN_VERSION)
291
#now parse the parts of the user given version string into variables
292
STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT4_MIN_VERSION}")
293
IF (NOT req_qt_major_vers)
294
MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT4_MIN_VERSION}\", expected e.g. \"4.0.1\"")
295
ENDIF (NOT req_qt_major_vers)
297
# now parse the parts of the user given version string into variables
298
STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT4_MIN_VERSION}")
299
STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT4_MIN_VERSION}")
300
STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT4_MIN_VERSION}")
302
IF (NOT req_qt_major_vers EQUAL 4)
303
MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT4_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")
304
ENDIF (NOT req_qt_major_vers EQUAL 4)
306
# and now the version string given by qmake
307
STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" found_qt_major_vers "${QTVERSION}")
308
STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" found_qt_minor_vers "${QTVERSION}")
309
STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" found_qt_patch_vers "${QTVERSION}")
311
# compute an overall version number which can be compared at once
312
MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")
313
MATH(EXPR found_vers "${found_qt_major_vers}*10000 + ${found_qt_minor_vers}*100 + ${found_qt_patch_vers}")
315
IF (found_vers LESS req_vers)
316
SET(QT4_QMAKE_FOUND FALSE)
317
SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
318
ELSE (found_vers LESS req_vers)
319
SET(QT4_QMAKE_FOUND TRUE)
320
ENDIF (found_vers LESS req_vers)
321
ENDIF (qt_version_tmp)
323
ENDIF (QT_QMAKE_EXECUTABLE)
329
get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )
330
get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )
333
# ask qmake for the library dir
334
# Set QT4_LIBRARY_DIR
335
IF (NOT QT4_LIBRARY_DIR)
336
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
337
ARGS "-query QT_INSTALL_LIBS"
338
OUTPUT_VARIABLE QT4_LIBRARY_DIR_TMP )
339
IF(EXISTS "${QT4_LIBRARY_DIR_TMP}")
340
SET(QT4_LIBRARY_DIR ${QT4_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir")
341
ELSE(EXISTS "${QT4_LIBRARY_DIR_TMP}")
342
MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT4_LIBRARY_DIR_TMP}")
343
MESSAGE("Warning: ${QT4_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.")
344
ENDIF(EXISTS "${QT4_LIBRARY_DIR_TMP}")
345
ENDIF(NOT QT4_LIBRARY_DIR)
348
IF (EXISTS ${QT4_LIBRARY_DIR}/QtCore.framework)
349
SET(QT_USE_FRAMEWORKS ON
350
CACHE BOOL "Set to ON if Qt build uses frameworks.")
351
ELSE (EXISTS ${QT4_LIBRARY_DIR}/QtCore.framework)
352
SET(QT_USE_FRAMEWORKS OFF
353
CACHE BOOL "Set to ON if Qt build uses frameworks.")
354
ENDIF (EXISTS ${QT4_LIBRARY_DIR}/QtCore.framework)
356
MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)
359
# ask qmake for the binary dir
360
IF (NOT QT_BINARY_DIR)
361
EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
362
ARGS "-query QT_INSTALL_BINS"
363
OUTPUT_VARIABLE qt_bins )
364
SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "")
365
ENDIF (NOT QT_BINARY_DIR)
367
# ask qmake for the include dir
368
IF (NOT QT_HEADERS_DIR)
369
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
370
ARGS "-query QT_INSTALL_HEADERS"
371
OUTPUT_VARIABLE qt_headers )
372
SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "")
373
ENDIF(NOT QT_HEADERS_DIR)
376
# ask qmake for the documentation directory
378
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
379
ARGS "-query QT_INSTALL_DOCS"
380
OUTPUT_VARIABLE qt_doc_dir )
381
SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs")
382
ENDIF (NOT QT_DOC_DIR)
384
# ask qmake for the mkspecs directory
385
IF (NOT QT_MKSPECS_DIR)
386
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
387
ARGS "-query QMAKE_MKSPECS"
388
OUTPUT_VARIABLE qt_mkspecs_dirs )
389
STRING(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}")
390
FIND_PATH(QT_MKSPECS_DIR qconfig.pri PATHS ${qt_mkspecs_dirs}
391
DOC "The location of the Qt mkspecs containing qconfig.pri"
393
ENDIF (NOT QT_MKSPECS_DIR)
395
# ask qmake for the plugins directory
396
IF (NOT QT4_PLUGINS_DIR)
397
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
398
ARGS "-query QT_INSTALL_PLUGINS"
399
OUTPUT_VARIABLE qt_plugins_dir )
400
SET(QT4_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins")
401
ENDIF (NOT QT4_PLUGINS_DIR)
402
########################################
404
# Setting the INCLUDE-Variables
406
########################################
408
FIND_PATH(QT4_QTCORE_INCLUDE_DIR QtGlobal
409
${QT_HEADERS_DIR}/QtCore
410
${QT4_LIBRARY_DIR}/QtCore.framework/Headers
414
# Set QT4_INCLUDE_DIR by removine "/QtCore" in the string ${QT4_QTCORE_INCLUDE_DIR}
415
IF( QT4_QTCORE_INCLUDE_DIR AND NOT QT4_INCLUDE_DIR)
416
IF (QT_USE_FRAMEWORKS)
417
SET(QT4_INCLUDE_DIR ${QT_HEADERS_DIR})
418
ELSE (QT_USE_FRAMEWORKS)
419
STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT4_QTCORE_INCLUDE_DIR})
420
SET( QT4_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "")
421
ENDIF (QT_USE_FRAMEWORKS)
422
ENDIF( QT4_QTCORE_INCLUDE_DIR AND NOT QT4_INCLUDE_DIR)
424
IF( NOT QT4_INCLUDE_DIR)
425
IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
426
MESSAGE( FATAL_ERROR "Could NOT find QtGlobal header")
427
ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
428
ENDIF( NOT QT4_INCLUDE_DIR)
430
#############################################
432
# Find out what window system we're using
434
#############################################
435
# Save required includes and required_flags variables
436
macro_push_required_vars()
437
# Add QT4_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES
438
SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT4_INCLUDE_DIR}")
439
# On Mac OS X when Qt has framework support, also add the framework path
440
IF( QT_USE_FRAMEWORKS )
441
SET(CMAKE_REQUIRED_FLAGS "-F${QT4_LIBRARY_DIR} ")
442
ENDIF( QT_USE_FRAMEWORKS )
443
# Check for Window system symbols (note: only one should end up being set)
444
CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)
445
CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)
446
CHECK_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)
447
CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)
449
IF (QT4_QTCOPY_REQUIRED)
450
CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)
451
IF (NOT QT_IS_QTCOPY)
452
MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found")
453
ENDIF (NOT QT_IS_QTCOPY)
454
ENDIF (QT4_QTCOPY_REQUIRED)
456
# Restore CMAKE_REQUIRED_INCLUDES+CMAKE_REQUIRED_FLAGS variables
457
macro_pop_required_vars()
459
#############################################
461
IF (QT_USE_FRAMEWORKS)
462
SET(QT4_DEFINITIONS ${QT4_DEFINITIONS} -F${QT4_LIBRARY_DIR} -L${QT4_LIBRARY_DIR} )
463
ENDIF (QT_USE_FRAMEWORKS)
465
# Set QT4_QT3SUPPORT_INCLUDE_DIR
466
FIND_PATH(QT4_QT3SUPPORT_INCLUDE_DIR Qt3Support
468
${QT4_INCLUDE_DIR}/Qt3Support
469
${QT4_LIBRARY_DIR}/Qt3Support.framework/Headers
473
# Set QT4_QT4_INCLUDE_DIR
474
FIND_PATH(QT4_QT4_INCLUDE_DIR qglobal.h
476
${QT4_INCLUDE_DIR}/Qt
477
${QT4_LIBRARY_DIR}/QtCore.framework/Headers
481
# Set QT4_QTGUI_INCLUDE_DIR
482
FIND_PATH(QT4_QTGUI_INCLUDE_DIR QtGui
484
${QT4_INCLUDE_DIR}/QtGui
485
${QT4_LIBRARY_DIR}/QtGui.framework/Headers
489
# Set QT4_QTSVG_INCLUDE_DIR
490
FIND_PATH(QT4_QTSVG_INCLUDE_DIR QtSvg
492
${QT4_INCLUDE_DIR}/QtSvg
493
${QT4_LIBRARY_DIR}/QtSvg.framework/Headers
497
# Set QT4_QTSCRIPT_INCLUDE_DIR
498
FIND_PATH(QT4_QTSCRIPT_INCLUDE_DIR QtScript
500
${QT4_INCLUDE_DIR}/QtScript
501
${QT4_LIBRARY_DIR}/QtScript.framework/Headers
505
# Set QT4_QTTEST_INCLUDE_DIR
506
FIND_PATH(QT4_QTTEST_INCLUDE_DIR QtTest
508
${QT4_INCLUDE_DIR}/QtTest
509
${QT4_LIBRARY_DIR}/QtTest.framework/Headers
513
# Set QT4_QTUITOOLS_INCLUDE_DIR
514
FIND_PATH(QT4_QTUITOOLS_INCLUDE_DIR QtUiTools
516
${QT4_INCLUDE_DIR}/QtUiTools
517
${QT4_LIBRARY_DIR}/QtUiTools.framework/Headers
523
# Set QT4_QTMOTIF_INCLUDE_DIR
525
FIND_PATH(QT4_QTMOTIF_INCLUDE_DIR QtMotif PATHS ${QT4_INCLUDE_DIR}/QtMotif NO_DEFAULT_PATH )
528
# Set QT4_QTNETWORK_INCLUDE_DIR
529
FIND_PATH(QT4_QTNETWORK_INCLUDE_DIR QtNetwork
531
${QT4_INCLUDE_DIR}/QtNetwork
532
${QT4_LIBRARY_DIR}/QtNetwork.framework/Headers
536
# Set QT4_QTNSPLUGIN_INCLUDE_DIR
537
FIND_PATH(QT4_QTNSPLUGIN_INCLUDE_DIR QtNsPlugin
539
${QT4_INCLUDE_DIR}/QtNsPlugin
540
${QT4_LIBRARY_DIR}/QtNsPlugin.framework/Headers
544
# Set QT4_QTOPENGL_INCLUDE_DIR
545
FIND_PATH(QT4_QTOPENGL_INCLUDE_DIR QtOpenGL
547
${QT4_INCLUDE_DIR}/QtOpenGL
548
${QT4_LIBRARY_DIR}/QtOpenGL.framework/Headers
552
# Set QT4_QTSQL_INCLUDE_DIR
553
FIND_PATH(QT4_QTSQL_INCLUDE_DIR QtSql
555
${QT4_INCLUDE_DIR}/QtSql
556
${QT4_LIBRARY_DIR}/QtSql.framework/Headers
560
# Set QT4_QTXML_INCLUDE_DIR
561
FIND_PATH(QT4_QTXML_INCLUDE_DIR QtXml
563
${QT4_INCLUDE_DIR}/QtXml
564
${QT4_LIBRARY_DIR}/QtXml.framework/Headers
568
# Set QT4_QTASSISTANT_INCLUDE_DIR
569
FIND_PATH(QT4_QTASSISTANT_INCLUDE_DIR QtAssistant
571
${QT4_INCLUDE_DIR}/QtAssistant
572
${QT_HEADERS_DIR}/QtAssistant
573
${QT4_LIBRARY_DIR}/QtAssistant.framework/Headers
577
# Set QT4_QTDESIGNER_INCLUDE_DIR
578
FIND_PATH(QT4_QTDESIGNER_INCLUDE_DIR QDesignerComponents
580
${QT4_INCLUDE_DIR}/QtDesigner
581
${QT_HEADERS_DIR}/QtDesigner
582
${QT4_LIBRARY_DIR}/QtDesigner.framework/Headers
586
# Set QT4_QTDESIGNERCOMPONENTS_INCLUDE_DIR
587
FIND_PATH(QT4_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents
589
${QT4_INCLUDE_DIR}/QtDesigner
590
${QT_HEADERS_DIR}/QtDesigner
595
# Set QT4_QTDBUS_INCLUDE_DIR
596
FIND_PATH(QT4_QTDBUS_INCLUDE_DIR QtDBus
598
${QT4_INCLUDE_DIR}/QtDBus
599
${QT_HEADERS_DIR}/QtDBus
603
# Make variables changeble to the advanced user
604
MARK_AS_ADVANCED( QT4_LIBRARY_DIR QT4_INCLUDE_DIR QT4_QT4_INCLUDE_DIR QT_DOC_DIR QT_MKSPECS_DIR QT4_PLUGINS_DIR)
607
SET( QT4_INCLUDES ${QT4_QT4_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ${QT4_INCLUDE_DIR})
610
########################################
612
# Setting the LIBRARY-Variables
614
########################################
616
IF (QT_USE_FRAMEWORKS)
617
# If FIND_LIBRARY found libraries in Apple frameworks, we would NOT have
618
# to jump through these hoops.
619
IF(EXISTS ${QT4_LIBRARY_DIR}/QtCore.framework)
620
SET(QT4_QTCORE_FOUND TRUE)
621
SET(QT4_QTCORE_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtCore" CACHE STRING "The QtCore library.")
622
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtCore.framework)
623
SET(QT4_QTCORE_FOUND FALSE)
624
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtCore.framework)
626
IF(EXISTS ${QT4_LIBRARY_DIR}/QtGui.framework)
627
SET(QT4_QTGUI_FOUND TRUE)
628
SET(QT4_QTGUI_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtGui" CACHE STRING "The QtGui library.")
629
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtGui.framework)
630
SET(QT4_QTGUI_FOUND FALSE)
631
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtGui.framework)
633
IF(EXISTS ${QT4_LIBRARY_DIR}/Qt3Support.framework)
634
SET(QT4_QT3SUPPORT_FOUND TRUE)
635
SET(QT4_QT3SUPPORT_LIBRARY "-F${QT4_LIBRARY_DIR} -framework Qt3Support" CACHE STRING "The Qt3Support library.")
636
ELSE(EXISTS ${QT4_LIBRARY_DIR}/Qt3Support.framework)
637
SET(QT4_QT3SUPPORT_FOUND FALSE)
638
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/Qt3Support.framework)
640
IF(EXISTS ${QT4_LIBRARY_DIR}/QtNetwork.framework)
641
SET(QT4_QTNETWORK_FOUND TRUE)
642
SET(QT4_QTNETWORK_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtNetwork" CACHE STRING "The QtNetwork library.")
643
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtNetwork.framework)
644
SET(QT4_QTNETWORK_FOUND FALSE)
645
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtNetwork.framework)
647
IF(EXISTS ${QT4_LIBRARY_DIR}/QtOpenGL.framework)
648
SET(QT4_QTOPENGL_FOUND TRUE)
649
SET(QT4_QTOPENGL_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtOpenGL" CACHE STRING "The QtOpenGL library.")
650
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtOpenGL.framework)
651
SET(QT4_QTOPENGL_FOUND FALSE)
652
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtOpenGL.framework)
654
IF(EXISTS ${QT4_LIBRARY_DIR}/QtSql.framework)
655
SET(QT4_QTSQL_FOUND TRUE)
656
SET(QT4_QTSQL_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtSql" CACHE STRING "The QtSql library.")
657
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtSql.framework)
658
SET(QT4_QTSQL_FOUND FALSE)
659
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtSql.framework)
661
IF(EXISTS ${QT4_LIBRARY_DIR}/QtXml.framework)
662
SET(QT4_QTXML_FOUND TRUE)
663
SET(QT4_QTXML_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtXml" CACHE STRING "The QtXml library.")
664
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtXml.framework)
665
SET(QT4_QTXML_FOUND FALSE)
666
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtXml.framework)
668
IF(EXISTS ${QT4_LIBRARY_DIR}/QtSvg.framework)
669
SET(QT4_QTSVG_FOUND TRUE)
670
SET(QT4_QTSVG_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtSvg" CACHE STRING "The QtSvg library.")
671
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtSvg.framework)
672
SET(QT4_QTSVG_FOUND FALSE)
673
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtSvg.framework)
675
IF(EXISTS ${QT4_LIBRARY_DIR}/QtDBus.framework)
676
SET(QT4_QTDBUS_FOUND TRUE)
677
SET(QT4_QTDBUS_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtDBus" CACHE STRING "The QtDBus library.")
678
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtDBus.framework)
679
SET(QT4_QTDBUS_FOUND FALSE)
680
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtDBus.framework)
682
IF(EXISTS ${QT4_LIBRARY_DIR}/QtTest.framework)
683
SET(QT4_QTTEST_FOUND TRUE)
684
SET(QT4_QTTEST_LIBRARY "-F${QT4_LIBRARY_DIR} -framework QtTest" CACHE STRING "The QtTest library.")
685
ELSE(EXISTS ${QT4_LIBRARY_DIR}/QtTest.framework)
686
SET(QT4_QTTEST_FOUND FALSE)
687
ENDIF(EXISTS ${QT4_LIBRARY_DIR}/QtTest.framework)
689
# WTF? why don't we have frameworks? :P
690
# Set QT4_QTUITOOLS_LIBRARY
691
FIND_LIBRARY(QT4_QTUITOOLS_LIBRARY NAMES QtUiTools QtUiTools4 PATHS ${QT4_LIBRARY_DIR} )
692
# Set QT4_QTSCRIPT_LIBRARY
693
FIND_LIBRARY(QT4_QTSCRIPT_LIBRARY NAMES QtScript QtScript4 PATHS ${QT4_LIBRARY_DIR} )
695
ELSE (QT_USE_FRAMEWORKS)
697
# Set QT4_QTCORE_LIBRARY by searching for a lib with "QtCore." as part of the filename
698
FIND_LIBRARY(QT4_QTCORE_LIBRARY NAMES QtCore QtCore4 QtCored4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH )
700
# Set QT4_QT3SUPPORT_LIBRARY
701
FIND_LIBRARY(QT4_QT3SUPPORT_LIBRARY NAMES Qt3Support Qt3Support4 Qt3Supportd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
703
# Set QT4_QTGUI_LIBRARY
704
FIND_LIBRARY(QT4_QTGUI_LIBRARY NAMES QtGui QtGui4 QtGuid4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
706
# Set QT4_QTMOTIF_LIBRARY
708
FIND_LIBRARY(QT4_QTMOTIF_LIBRARY NAMES QtMotif PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
711
# Set QT4_QTNETWORK_LIBRARY
712
FIND_LIBRARY(QT4_QTNETWORK_LIBRARY NAMES QtNetwork QtNetwork4 QtNetworkd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
714
# Set QT4_QTNSPLUGIN_LIBRARY
715
FIND_LIBRARY(QT4_QTNSPLUGIN_LIBRARY NAMES QtNsPlugin PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
717
# Set QT4_QTOPENGL_LIBRARY
718
FIND_LIBRARY(QT4_QTOPENGL_LIBRARY NAMES QtOpenGL QtOpenGL4 QtOpenGLd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
720
# Set QT4_QTSQL_LIBRARY
721
FIND_LIBRARY(QT4_QTSQL_LIBRARY NAMES QtSql QtSql4 QtSqld4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
723
# Set QT4_QTXML_LIBRARY
724
FIND_LIBRARY(QT4_QTXML_LIBRARY NAMES QtXml QtXml4 QtXmld4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
726
# Set QT4_QTSVG_LIBRARY
727
FIND_LIBRARY(QT4_QTSVG_LIBRARY NAMES QtSvg QtSvg4 QtSvgd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
729
# Set QT4_QTSCRIPT_LIBRARY
730
FIND_LIBRARY(QT4_QTSCRIPT_LIBRARY NAMES QtScript QtScript4 QtScriptd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
732
# Set QT4_QTUITOOLS_LIBRARY
733
FIND_LIBRARY(QT4_QTUITOOLS_LIBRARY NAMES QtUiTools QtUiTools4 QtUiToolsd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
735
# Set QT4_QTTEST_LIBRARY
736
FIND_LIBRARY(QT4_QTTEST_LIBRARY NAMES QtTest QtTest4 QtTestd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
738
FIND_LIBRARY(QT4_QTDBUS_LIBRARY NAMES QtDBus QtDBus4 QtDBusd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
741
FIND_LIBRARY(QT4_QTCORE_LIBRARY_RELEASE NAMES QtCore4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
742
FIND_LIBRARY(QT4_QTCORE_LIBRARY_DEBUG NAMES QtCored4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
743
FIND_LIBRARY(QT4_QT3SUPPORT_LIBRARY_RELEASE NAMES Qt3Support4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
744
FIND_LIBRARY(QT4_QT3SUPPORT_LIBRARY_DEBUG NAMES Qt3Supportd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
745
FIND_LIBRARY(QT4_QTGUI_LIBRARY_RELEASE NAMES QtGui4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
746
FIND_LIBRARY(QT4_QTGUI_LIBRARY_DEBUG NAMES QtGuid4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
747
FIND_LIBRARY(QT4_QTNETWORK_LIBRARY_RELEASE NAMES QtNetwork4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
748
FIND_LIBRARY(QT4_QTNETWORK_LIBRARY_DEBUG NAMES QtNetworkd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
749
FIND_LIBRARY(QT4_QTOPENGL_LIBRARY_RELEASE NAMES QtOpenGL4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
750
FIND_LIBRARY(QT4_QTOPENGL_LIBRARY_DEBUG NAMES QtOpenGLd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
751
FIND_LIBRARY(QT4_QTSQL_LIBRARY_RELEASE NAMES QtSql4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
752
FIND_LIBRARY(QT4_QTSQL_LIBRARY_DEBUG NAMES QtSqld4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
753
FIND_LIBRARY(QT4_QTXML_LIBRARY_RELEASE NAMES QtXml4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
754
FIND_LIBRARY(QT4_QTXML_LIBRARY_DEBUG NAMES QtXmld4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
755
FIND_LIBRARY(QT4_QTSVG_LIBRARY_RELEASE NAMES QtSvg4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
756
FIND_LIBRARY(QT4_QTSVG_LIBRARY_DEBUG NAMES QtSvgd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
757
FIND_LIBRARY(QT4_QTSCRIPT_LIBRARY_RELEASE NAMES QtScript4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
758
FIND_LIBRARY(QT4_QTSCRIPT_LIBRARY_DEBUG NAMES QtScriptd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
759
FIND_LIBRARY(QT4_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools QtUiTools4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
760
FIND_LIBRARY(QT4_QTUITOOLS_LIBRARY_DEBUG NAMES QtUiToolsd QtUiToolsd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
761
FIND_LIBRARY(QT4_QTTEST_LIBRARY_RELEASE NAMES QtTest4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
762
FIND_LIBRARY(QT4_QTTEST_LIBRARY_DEBUG NAMES QtTestd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
763
FIND_LIBRARY(QT4_QTDBUS_LIBRARY_RELEASE NAMES QtDBus4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
764
FIND_LIBRARY(QT4_QTDBUS_LIBRARY_DEBUG NAMES QtDBusd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
765
FIND_LIBRARY(QT4_QTASSISTANT_LIBRARY_RELEASE NAMES QtAssistantClient4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
766
FIND_LIBRARY(QT4_QTASSISTANT_LIBRARY_DEBUG NAMES QtAssistantClientd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
767
FIND_LIBRARY(QT4_QTDESIGNER_LIBRARY_RELEASE NAMES QtDesigner4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
768
FIND_LIBRARY(QT4_QTDESIGNER_LIBRARY_DEBUG NAMES QtDesignerd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
769
FIND_LIBRARY(QT4_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
770
FIND_LIBRARY(QT4_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NAMES QtDesignerComponentsd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
771
FIND_LIBRARY(QT4_QTMAIN_LIBRARY_RELEASE NAMES qtmain PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
772
FIND_LIBRARY(QT4_QTMAIN_LIBRARY_DEBUG NAMES qtmaind PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
774
ENDIF (QT_USE_FRAMEWORKS)
776
IF( NOT QT4_QTCORE_LIBRARY )
777
IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
778
MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
779
ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
780
ENDIF( NOT QT4_QTCORE_LIBRARY )
782
# Set QT4_QTASSISTANT_LIBRARY
783
FIND_LIBRARY(QT4_QTASSISTANT_LIBRARY NAMES QtAssistantClient QtAssistantClient4 QtAssistant QtAssistant4 QtAssistantd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
785
# Set QT4_QTDESIGNER_LIBRARY
786
FIND_LIBRARY(QT4_QTDESIGNER_LIBRARY NAMES QtDesigner QtDesigner4 QtDesignerd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
788
# Set QT4_QTDESIGNERCOMPONENTS_LIBRARY
789
FIND_LIBRARY(QT4_QTDESIGNERCOMPONENTS_LIBRARY NAMES QtDesignerComponents QtDesignerComponents4 QtDesignerComponentsd4 PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
791
# Set QT4_QTMAIN_LIBRARY
793
FIND_LIBRARY(QT4_QTMAIN_LIBRARY NAMES qtmain qtmaind PATHS ${QT4_LIBRARY_DIR} NO_DEFAULT_PATH)
796
############################################
798
# Check the existence of the libraries.
800
############################################
802
MACRO (_QT4_ADJUST_LIB_VARS basename)
803
IF (QT4_${basename}_LIBRARY OR QT4_${basename}_LIBRARY_DEBUG)
807
IF (QT4_${basename}_LIBRARY_RELEASE AND QT4_${basename}_LIBRARY_DEBUG)
808
SET(QT4_${basename}_LIBRARY optimized ${QT4_${basename}_LIBRARY_RELEASE} debug ${QT4_${basename}_LIBRARY_DEBUG})
809
ENDIF (QT4_${basename}_LIBRARY_RELEASE AND QT4_${basename}_LIBRARY_DEBUG)
811
# Only debug was found
812
IF (NOT QT4_${basename}_LIBRARY_RELEASE AND QT4_${basename}_LIBRARY_DEBUG)
813
SET(QT4_${basename}_LIBRARY ${QT4_${basename}_LIBRARY_DEBUG})
814
ENDIF (NOT QT4_${basename}_LIBRARY_RELEASE AND QT4_${basename}_LIBRARY_DEBUG)
816
# Only release was found
817
IF (QT4_${basename}_LIBRARY_RELEASE AND NOT QT4_${basename}_LIBRARY_DEBUG)
818
SET(QT4_${basename}_LIBRARY ${QT4_${basename}_LIBRARY_RELEASE})
819
ENDIF (QT4_${basename}_LIBRARY_RELEASE AND NOT QT4_${basename}_LIBRARY_DEBUG)
821
# Hmm, is this used anywhere ? Yes, in UseQt4.cmake. We are currently incompatible :-(
822
SET(QT4_${basename}_LIBRARIES optimized ${QT4_${basename}_LIBRARY} debug ${QT4_${basename}_LIBRARY_DEBUG})
826
SET(QT4_${basename}_LIBRARY ${QT4_${basename}_LIBRARY} CACHE FILEPATH "The Qt4 ${basename} library")
828
IF (QT4_${basename}_LIBRARY)
829
SET(QT4_${basename}_FOUND 1)
830
ENDIF (QT4_${basename}_LIBRARY)
832
ENDIF (QT4_${basename}_LIBRARY OR QT4_${basename}_LIBRARY_DEBUG)
834
IF (QT4_${basename}_INCLUDE_DIR)
835
#add the include directory to QT4_INCLUDES
836
SET(QT4_INCLUDES "${QT4_${basename}_INCLUDE_DIR}" ${QT4_INCLUDES})
837
ENDIF (QT4_${basename}_INCLUDE_DIR)
839
# Make variables changeble to the advanced user
840
MARK_AS_ADVANCED(QT4_${basename}_LIBRARY QT4_${basename}_INCLUDE_DIR)
841
ENDMACRO (_QT4_ADJUST_LIB_VARS)
844
# Set QT_xyz_LIBRARY variable and add
845
# library include path to QT4_INCLUDES
846
_QT4_ADJUST_LIB_VARS(QTCORE)
847
_QT4_ADJUST_LIB_VARS(QTGUI)
848
_QT4_ADJUST_LIB_VARS(QT3SUPPORT)
849
_QT4_ADJUST_LIB_VARS(QTASSISTANT)
850
_QT4_ADJUST_LIB_VARS(QTDESIGNER)
851
_QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS)
852
_QT4_ADJUST_LIB_VARS(QTNETWORK)
853
_QT4_ADJUST_LIB_VARS(QTNSPLUGIN)
854
_QT4_ADJUST_LIB_VARS(QTOPENGL)
855
_QT4_ADJUST_LIB_VARS(QTSQL)
856
_QT4_ADJUST_LIB_VARS(QTXML)
857
_QT4_ADJUST_LIB_VARS(QTSVG)
858
_QT4_ADJUST_LIB_VARS(QTSCRIPT)
859
_QT4_ADJUST_LIB_VARS(QTUITOOLS)
860
_QT4_ADJUST_LIB_VARS(QTTEST)
861
_QT4_ADJUST_LIB_VARS(QTDBUS)
863
# platform dependent libraries
865
_QT4_ADJUST_LIB_VARS(QTMOTIF)
868
_QT4_ADJUST_LIB_VARS(QTMAIN)
872
#######################################
874
# Check the executables of Qt
877
#######################################
880
# find moc and uic using qmake
881
QT_QUERY_QMAKE(QT4_MOC_EXECUTABLE_INTERNAL "QMAKE_MOC")
882
QT_QUERY_QMAKE(QT4_UIC_EXECUTABLE_INTERNAL "QMAKE_UIC")
885
"${QT4_MOC_EXECUTABLE_INTERNAL}" QT4_MOC_EXECUTABLE_INTERNAL)
887
"${QT4_UIC_EXECUTABLE_INTERNAL}" QT4_UIC_EXECUTABLE_INTERNAL)
889
SET(QT4_MOC_EXECUTABLE
890
${QT4_MOC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The moc executable")
891
SET(QT4_UIC_EXECUTABLE
892
${QT4_UIC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The uic executable")
894
FIND_PROGRAM(QT_UIC3_EXECUTABLE
896
PATHS ${QT_BINARY_DIR}
900
FIND_PROGRAM(QT_RCC_EXECUTABLE
902
PATHS ${QT_BINARY_DIR}
906
FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE
908
PATHS ${QT_BINARY_DIR}
912
FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE
914
PATHS ${QT_BINARY_DIR}
918
IF (QT4_MOC_EXECUTABLE)
919
SET(QT_WRAP_CPP "YES")
920
ENDIF (QT4_MOC_EXECUTABLE)
922
IF (QT4_UIC_EXECUTABLE)
923
SET(QT_WRAP_UI "YES")
924
ENDIF (QT4_UIC_EXECUTABLE)
928
MARK_AS_ADVANCED( QT4_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT4_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE)
930
######################################
932
# Macros for building Qt files
934
######################################
935
MACRO (QT4_EXTRACT_OPTIONS _qt4_files _qt4_options)
938
SET(_QT4_DOING_OPTIONS FALSE)
939
FOREACH(_currentArg ${ARGN})
940
IF ("${_currentArg}" STREQUAL "OPTIONS")
941
SET(_QT4_DOING_OPTIONS TRUE)
942
ELSE ("${_currentArg}" STREQUAL "OPTIONS")
943
IF(_QT4_DOING_OPTIONS)
944
LIST(APPEND ${_qt4_options} "${_currentArg}")
945
ELSE(_QT4_DOING_OPTIONS)
946
LIST(APPEND ${_qt4_files} "${_currentArg}")
947
ENDIF(_QT4_DOING_OPTIONS)
948
ENDIF ("${_currentArg}" STREQUAL "OPTIONS")
949
ENDFOREACH(_currentArg)
950
ENDMACRO (QT4_EXTRACT_OPTIONS)
952
MACRO (QT4_GET_MOC_INC_DIRS _moc_INC_DIRS)
953
SET(${_moc_INC_DIRS})
954
GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)
956
FOREACH(_current ${_inc_DIRS})
957
SET(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-I" ${_current})
958
ENDFOREACH(_current ${_inc_DIRS})
960
ENDMACRO(QT4_GET_MOC_INC_DIRS)
963
MACRO (QT4_GENERATE_MOC infile outfile )
965
QT4_GET_MOC_INC_DIRS(moc_includes)
967
GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE)
970
SET (_moc_parameter_file ${outfile}_parameters)
971
SET (_moc_param "${moc_includes} \n-o${outfile} \n${abs_infile}")
972
STRING(REGEX REPLACE ";-I;" "\\n-I" _moc_param "${_moc_param}")
973
FILE (WRITE ${_moc_parameter_file} "${_moc_param}")
974
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
975
COMMAND ${QT4_MOC_EXECUTABLE}
976
ARGS @"${_moc_parameter_file}"
977
DEPENDS ${abs_infile})
979
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
980
COMMAND ${QT4_MOC_EXECUTABLE}
981
ARGS ${moc_includes} -o ${outfile} ${abs_infile}
982
DEPENDS ${abs_infile})
985
SET_SOURCE_FILES_PROPERTIES(${outfile} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file
987
MACRO_ADD_FILE_DEPENDENCIES(${abs_infile} ${outfile})
988
ENDMACRO (QT4_GENERATE_MOC)
991
# QT4_WRAP_CPP(outfiles inputfile ... )
992
# TODO perhaps add support for -D, -U and other minor options
994
MACRO (QT4_WRAP_CPP outfiles )
996
QT4_GET_MOC_INC_DIRS(moc_includes)
997
QT4_EXTRACT_OPTIONS(moc_files moc_options ${ARGN})
999
FOREACH (it ${moc_files})
1000
GET_FILENAME_COMPONENT(it ${it} ABSOLUTE)
1001
GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)
1003
SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/moc_${outfile}.cxx)
1004
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1005
COMMAND ${QT4_MOC_EXECUTABLE}
1006
ARGS ${moc_includes} ${moc_options} -o ${outfile} ${it}
1008
SET(${outfiles} ${${outfiles}} ${outfile})
1011
ENDMACRO (QT4_WRAP_CPP)
1014
# QT4_WRAP_UI(outfiles inputfile ... )
1016
MACRO (QT4_WRAP_UI outfiles )
1017
QT4_EXTRACT_OPTIONS(ui_files ui_options ${ARGN})
1019
FOREACH (it ${ui_files})
1020
GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)
1021
GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
1022
SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.h)
1023
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1024
COMMAND ${QT4_UIC_EXECUTABLE}
1025
ARGS ${ui_options} -o ${outfile} ${infile}
1026
MAIN_DEPENDENCY ${infile})
1027
SET(${outfiles} ${${outfiles}} ${outfile})
1030
ENDMACRO (QT4_WRAP_UI)
1033
# QT4_ADD_RESOURCES(outfiles inputfile ... )
1034
# TODO perhaps consider adding support for compression and root options to rcc
1036
MACRO (QT4_ADD_RESOURCES outfiles )
1037
QT4_EXTRACT_OPTIONS(rcc_files rcc_options ${ARGN})
1039
FOREACH (it ${rcc_files})
1040
GET_FILENAME_COMPONENT(outfilename ${it} NAME_WE)
1041
GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
1042
GET_FILENAME_COMPONENT(rc_path ${infile} PATH)
1043
SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cxx)
1044
# parse file for dependencies
1045
# all files are absolute paths or relative to the location of the qrc file
1046
FILE(READ "${infile}" _RC_FILE_CONTENTS)
1047
STRING(REGEX MATCHALL "<file[^<]+" _RC_FILES "${_RC_FILE_CONTENTS}")
1049
FOREACH(_RC_FILE ${_RC_FILES})
1050
STRING(REGEX REPLACE "^<file[^>]*>" "" _RC_FILE "${_RC_FILE}")
1051
STRING(REGEX MATCH "^/|([A-Za-z]:/)" _ABS_PATH_INDICATOR "${_RC_FILE}")
1052
IF(NOT _ABS_PATH_INDICATOR)
1053
SET(_RC_FILE "${rc_path}/${_RC_FILE}")
1054
ENDIF(NOT _ABS_PATH_INDICATOR)
1055
SET(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")
1056
ENDFOREACH(_RC_FILE)
1057
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
1058
COMMAND ${QT_RCC_EXECUTABLE}
1059
ARGS ${rcc_options} -name ${outfilename} -o ${outfile} ${infile}
1060
MAIN_DEPENDENCY ${infile}
1061
DEPENDS ${_RC_DEPENDS})
1062
SET(${outfiles} ${${outfiles}} ${outfile})
1065
ENDMACRO (QT4_ADD_RESOURCES)
1067
MACRO(QT4_ADD_DBUS_INTERFACE _sources _interface _basename)
1068
GET_FILENAME_COMPONENT(_infile ${_interface} ABSOLUTE)
1069
SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
1070
SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
1071
SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
1073
GET_SOURCE_FILE_PROPERTY(_nonamespace ${_interface} NO_NAMESPACE)
1076
ELSE ( _nonamespace )
1078
ENDIF ( _nonamespace )
1080
GET_SOURCE_FILE_PROPERTY(_include ${_interface} INCLUDE)
1082
SET(_params ${_params} -i ${_include})
1085
ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1086
COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} ${_params} -p ${_basename} ${_infile}
1089
SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
1091
QT4_GENERATE_MOC(${_header} ${_moc})
1093
SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
1094
MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
1096
ENDMACRO(QT4_ADD_DBUS_INTERFACE)
1099
MACRO(QT4_ADD_DBUS_INTERFACES _sources)
1100
FOREACH (_current_FILE ${ARGN})
1101
GET_FILENAME_COMPONENT(_infile ${_current_FILE} ABSOLUTE)
1102
# get the part before the ".xml" suffix
1103
STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2" _basename ${_current_FILE})
1104
STRING(TOLOWER ${_basename} _basename)
1105
QT4_ADD_DBUS_INTERFACE(${_sources} ${_infile} ${_basename}interface)
1106
ENDFOREACH (_current_FILE)
1107
ENDMACRO(QT4_ADD_DBUS_INTERFACES)
1110
MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName OPTIONS -some -options )
1111
QT4_EXTRACT_OPTIONS(_customName _qt4_dbus_options ${ARGN})
1113
GET_FILENAME_COMPONENT(_in_file ${_header} ABSOLUTE)
1114
GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE)
1117
SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})
1119
SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml)
1122
ADD_CUSTOM_COMMAND(OUTPUT ${_target}
1123
COMMAND ${QT_DBUSCPP2XML_EXECUTABLE} ${_qt4_dbus_options} ${_in_file} > ${_target}
1126
ENDMACRO(QT4_GENERATE_DBUS_INTERFACE)
1129
MACRO(QT4_ADD_DBUS_ADAPTOR _sources _xml_file _include _parentClass) # _optionalBasename _optionalClassName)
1130
GET_FILENAME_COMPONENT(_infile ${_xml_file} ABSOLUTE)
1132
SET(_optionalBasename "${ARGV4}")
1133
IF (_optionalBasename)
1134
SET(_basename ${_optionalBasename} )
1135
ELSE (_optionalBasename)
1136
STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _basename ${_infile})
1137
STRING(TOLOWER ${_basename} _basename)
1138
ENDIF (_optionalBasename)
1140
SET(_optionalClassName "${ARGV5}")
1141
SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
1142
SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
1143
SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
1145
IF(_optionalClassName)
1146
ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1147
COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -c ${_optionalClassName} -i ${_include} -l ${_parentClass} ${_infile}
1150
ELSE(_optionalClassName)
1151
ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1152
COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -i ${_include} -l ${_parentClass} ${_infile}
1155
ENDIF(_optionalClassName)
1157
QT4_GENERATE_MOC(${_header} ${_moc})
1158
SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
1159
MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
1161
SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
1162
ENDMACRO(QT4_ADD_DBUS_ADAPTOR)
1165
QT4_GET_MOC_INC_DIRS(_moc_INCS)
1167
SET(_matching_FILES )
1168
FOREACH (_current_FILE ${ARGN})
1170
GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE)
1171
# if "SKIP_AUTOMOC" is set to true, we will not handle this file here.
1172
# here. this is required to make bouic work correctly:
1173
# we need to add generated .cpp files to the sources (to compile them),
1174
# but we cannot let automoc handle them, as the .cpp files don't exist yet when
1175
# cmake is run for the very first time on them -> however the .cpp files might
1176
# exist at a later run. at that time we need to skip them, so that we don't add two
1177
# different rules for the same moc file
1178
GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC)
1180
IF ( NOT _skip AND EXISTS ${_abs_FILE} )
1182
FILE(READ ${_abs_FILE} _contents)
1184
GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH)
1186
STRING(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}")
1188
FOREACH (_current_MOC_INC ${_match})
1189
STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}")
1191
GET_filename_component(_basename ${_current_MOC} NAME_WE)
1192
# SET(_header ${CMAKE_CURRENT_SOURCE_DIR}/${_basename}.h)
1193
IF (EXISTS ${_abs_PATH}/${_basename}.h)
1194
SET(_header ${_abs_PATH}/${_basename}.h)
1195
ELSE (EXISTS ${_abs_PATH}/${_basename}.h)
1196
SET(_header ${_abs_FILE})
1197
ENDIF (EXISTS ${_abs_PATH}/${_basename}.h)
1198
SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC})
1199
ADD_CUSTOM_COMMAND(OUTPUT ${_moc}
1200
COMMAND ${QT4_MOC_EXECUTABLE}
1201
ARGS ${_moc_INCS} ${_header} -o ${_moc}
1205
MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc})
1206
ENDFOREACH (_current_MOC_INC)
1208
ENDIF ( NOT _skip AND EXISTS ${_abs_FILE} )
1209
ENDFOREACH (_current_FILE)
1210
ENDMACRO(QT4_AUTOMOC)
1214
######################################
1216
# decide if Qt got found
1218
######################################
1220
# if the includes,libraries,moc,uic and rcc are found then we have it
1221
IF( QT4_LIBRARY_DIR AND QT4_INCLUDE_DIR AND QT4_MOC_EXECUTABLE AND QT4_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1222
SET( QT4_FOUND "YES" )
1223
IF( NOT Qt4_FIND_QUIETLY)
1224
MESSAGE(STATUS "Found Qt-Version ${QTVERSION} (using ${QT_QMAKE_EXECUTABLE})")
1225
ENDIF( NOT Qt4_FIND_QUIETLY)
1226
ELSE( QT4_LIBRARY_DIR AND QT4_INCLUDE_DIR AND QT4_MOC_EXECUTABLE AND QT4_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1227
SET( QT4_FOUND "NO")
1228
SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1229
IF( Qt4_FIND_REQUIRED)
1230
IF ( NOT QT4_LIBRARY_DIR )
1231
MESSAGE(STATUS "Qt libraries NOT found!")
1232
ENDIF(NOT QT4_LIBRARY_DIR )
1233
IF ( NOT QT4_INCLUDE_DIR )
1234
MESSAGE(STATUS "Qt includes NOT found!")
1235
ENDIF( NOT QT4_INCLUDE_DIR )
1236
IF ( NOT QT4_MOC_EXECUTABLE )
1237
MESSAGE(STATUS "Qt's moc NOT found!")
1238
ENDIF( NOT QT4_MOC_EXECUTABLE )
1239
IF ( NOT QT4_UIC_EXECUTABLE )
1240
MESSAGE(STATUS "Qt's uic NOT found!")
1241
ENDIF( NOT QT4_UIC_EXECUTABLE )
1242
IF ( NOT QT_RCC_EXECUTABLE )
1243
MESSAGE(STATUS "Qt's rcc NOT found!")
1244
ENDIF( NOT QT_RCC_EXECUTABLE )
1245
MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")
1246
ENDIF( Qt4_FIND_REQUIRED)
1247
ENDIF( QT4_LIBRARY_DIR AND QT4_INCLUDE_DIR AND QT4_MOC_EXECUTABLE AND QT4_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1248
SET(QT_FOUND ${QT4_FOUND})
1251
#######################################
1253
# System dependent settings
1255
#######################################
1256
# for unix add X11 stuff
1258
# on OS X X11 may not be required
1260
FIND_PACKAGE(X11 REQUIRED)
1262
FIND_PACKAGE(Threads)
1263
SET(QT4_QTCORE_LIBRARY ${QT4_QTCORE_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
1267
#######################################
1269
# compatibility settings
1271
#######################################
1272
# Backwards compatibility for CMake1.4 and 1.2
1273
SET (QT_MOC_EXE ${QT4_MOC_EXECUTABLE} )
1274
SET (QT_UIC_EXE ${QT4_UIC_EXECUTABLE} )
1276
SET( QT4_QT_LIBRARY "")
1278
ELSE(QT4_QMAKE_FOUND)
1280
SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1281
IF(Qt4_FIND_REQUIRED)
1282
IF(QT4_INSTALLED_VERSION_TOO_OLD)
1283
MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT4_MIN_VERSION} is required")
1284
ELSE(QT4_INSTALLED_VERSION_TOO_OLD)
1285
MESSAGE( FATAL_ERROR "Qt qmake not found!")
1286
ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)
1287
ELSE(Qt4_FIND_REQUIRED)
1288
IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1289
MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT4_MIN_VERSION} is required")
1290
ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1291
ENDIF(Qt4_FIND_REQUIRED)
1293
ENDIF (QT4_QMAKE_FOUND)
1294
ENDIF (QT4_QMAKE_FOUND)
added
removed
tests/poppler/cmake/modules/FindQt4.cmake
