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 ... )
32
# macro QT4_WRAP_UI(outfiles inputfile ... )
33
# macro QT4_ADD_RESOURCES(outfiles inputfile ... )
34
# macro QT4_AUTOMOC(inputfile ... )
35
# macro QT4_GENERATE_MOC(inputfile outputfile )
37
# macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
38
# create a the interface header and implementation files with the
39
# given basename from the given interface xml file and add it to
42
# macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
43
# create the interface header and implementation files
44
# for all listed interface xml files
45
# the name will be automatically determined from the name of the xml file
47
# macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] )
48
# create a dbus adaptor (header and implementation file) from the xml file
49
# describing the interface, and add it to the list of sources. The adaptor
50
# forwards the calls to a parent class, defined in parentheader and named
51
# parentclassname. The name of the generated files will be
52
# <basename>adaptor.{cpp,h} where basename is the basename of the xml file.
54
# macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] )
55
# generate the xml interface file from the given header.
56
# If the optional argument interfacename is omitted, the name of the
57
# interface file is constructed from the basename of the header with
58
# the suffix .xml appended.
60
# QT_FOUND If false, don't try to use Qt.
61
# QT4_FOUND If false, don't try to use Qt 4.
63
# QT_EDITION Set to the edition of Qt (i.e. DesktopLight)
64
# QT_EDITION_DESKTOPLIGHT True if QT_EDITION == DesktopLight
65
# QT_QTCORE_FOUND True if QtCore was found.
66
# QT_QTGUI_FOUND True if QtGui was found.
67
# QT_QT3SUPPORT_FOUND True if Qt3Support was found.
68
# QT_QTASSISTANT_FOUND True if QtAssistant was found.
69
# QT_QTDBUS_FOUND True if QtDBus was found.
70
# QT_QTDESIGNER_FOUND True if QtDesigner was found.
71
# QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.
72
# QT_QTMOTIF_FOUND True if QtMotif was found.
73
# QT_QTNETWORK_FOUND True if QtNetwork was found.
74
# QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found.
75
# QT_QTOPENGL_FOUND True if QtOpenGL was found.
76
# QT_QTSQL_FOUND True if QtSql was found.
77
# QT_QTXML_FOUND True if QtXml was found.
78
# QT_QTSVG_FOUND True if QtSvg was found.
79
# QT_QTSCRIPT_FOUND True if QtScript was found.
80
# QT_QTTEST_FOUND True if QtTest was found.
81
# QT_QTUITOOLS_FOUND True if QtUiTools was found.
83
# QT_DEFINITIONS Definitions to use when compiling code that uses Qt.
85
# QT_INCLUDES List of paths to all include directories of
86
# Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
87
# always in this variable even if NOTFOUND,
88
# all other INCLUDE_DIRS are
89
# only added if they are found.
91
# QT_INCLUDE_DIR Path to "include" of Qt4
92
# QT_QT_INCLUDE_DIR Path to "include/Qt"
93
# QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support"
94
# QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant"
95
# QT_QTCORE_INCLUDE_DIR Path to "include/QtCore"
96
# QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner"
97
# QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner"
98
# QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus"
99
# QT_QTGUI_INCLUDE_DIR Path to "include/QtGui"
100
# QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif"
101
# QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork"
102
# QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin"
103
# QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL"
104
# QT_QTSQL_INCLUDE_DIR Path to "include/QtSql"
105
# QT_QTXML_INCLUDE_DIR Path to "include/QtXml"
106
# QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg"
107
# QT_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript"
108
# QT_QTTEST_INCLUDE_DIR Path to "include/QtTest"
110
# QT_LIBRARY_DIR Path to "lib" of Qt4
112
# QT_PLUGINS_DIR Path to "plugins" for Qt4
114
# For every library of Qt there are three variables:
115
# QT_QTFOO_LIBRARY_RELEASE, which contains the full path to the release version
116
# QT_QTFOO_LIBRARY_DEBUG, which contains the full path to the debug version
117
# QT_QTFOO_LIBRARY, the full path to the release version if available, otherwise to the debug version
119
# So there are the following variables:
120
# The Qt3Support library: QT_QT3SUPPORT_LIBRARY
121
# QT_QT3SUPPORT_LIBRARY_RELEASE
122
# QT_QT3SUPPORT_DEBUG
124
# The QtAssistant library: QT_QTASSISTANT_LIBRARY
125
# QT_QTASSISTANT_LIBRARY_RELEASE
126
# QT_QTASSISTANT_LIBRARY_DEBUG
128
# The QtCore library: QT_QTCORE_LIBRARY
129
# QT_QTCORE_LIBRARY_RELEASE
130
# QT_QTCORE_LIBRARY_DEBUG
132
# The QtDBus library: QT_QTDBUS_LIBRARY
133
# QT_QTDBUS_LIBRARY_RELEASE
134
# QT_QTDBUS_LIBRARY_DEBUG
136
# The QtDesigner library: QT_QTDESIGNER_LIBRARY
137
# QT_QTDESIGNER_LIBRARY_RELEASE
138
# QT_QTDESIGNER_LIBRARY_DEBUG
140
# The QtDesignerComponents library: QT_QTDESIGNERCOMPONENTS_LIBRARY
141
# QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE
142
# QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG
144
# The QtGui library: QT_QTGUI_LIBRARY
145
# QT_QTGUI_LIBRARY_RELEASE
146
# QT_QTGUI_LIBRARY_DEBUG
148
# The QtMotif library: QT_QTMOTIF_LIBRARY
149
# QT_QTMOTIF_LIBRARY_RELEASE
150
# QT_QTMOTIF_LIBRARY_DEBUG
152
# The QtNetwork library: QT_QTNETWORK_LIBRARY
153
# QT_QTNETWORK_LIBRARY_RELEASE
154
# QT_QTNETWORK_LIBRARY_DEBUG
156
# The QtNsPLugin library: QT_QTNSPLUGIN_LIBRARY
157
# QT_QTNSPLUGIN_LIBRARY_RELEASE
158
# QT_QTNSPLUGIN_LIBRARY_DEBUG
160
# The QtOpenGL library: QT_QTOPENGL_LIBRARY
161
# QT_QTOPENGL_LIBRARY_RELEASE
162
# QT_QTOPENGL_LIBRARY_DEBUG
164
# The QtSql library: QT_QTSQL_LIBRARY
165
# QT_QTSQL_LIBRARY_RELEASE
166
# QT_QTSQL_LIBRARY_DEBUG
168
# The QtXml library: QT_QTXML_LIBRARY
169
# QT_QTXML_LIBRARY_RELEASE
170
# QT_QTXML_LIBRARY_DEBUG
172
# The QtSvg library: QT_QTSVG_LIBRARY
173
# QT_QTSVG_LIBRARY_RELEASE
174
# QT_QTSVG_LIBRARY_DEBUG
176
# The QtScript library: QT_QTSCRIPT_LIBRARY
177
# QT_QTSCRIPT_LIBRARY_RELEASE
178
# QT_QTSCRIPT_LIBRARY_DEBUG
180
# The QtTest library: QT_QTTEST_LIBRARY
181
# QT_QTTEST_LIBRARY_RELEASE
182
# QT_QTTEST_LIBRARY_DEBUG
184
# The qtmain library for Windows QT_QTMAIN_LIBRARY
185
# QT_QTMAIN_LIBRARY_RELEASE
186
# QT_QTMAIN_LIBRARY_DEBUG
188
# The QtUiTools library: QT_QTUITOOLS_LIBRARY
189
# QT_QTUITOOLS_LIBRARY_RELEASE
190
# QT_QTUITOOLS_LIBRARY_DEBUG
192
# also defined, but NOT for general use are
193
# QT_MOC_EXECUTABLE Where to find the moc tool.
194
# QT_UIC_EXECUTABLE Where to find the uic tool.
195
# QT_UIC3_EXECUTABLE Where to find the uic3 tool.
196
# QT_RCC_EXECUTABLE Where to find the rcc tool
197
# QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool.
198
# QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool.
200
# QT_DOC_DIR Path to "doc" of Qt4
201
# QT_MKSPECS_DIR Path to "mkspecs" of Qt4
204
# These are around for backwards compatibility
206
# QT_WRAP_CPP Set true if QT_MOC_EXECUTABLE is found
207
# QT_WRAP_UI Set true if QT_UIC_EXECUTABLE is found
209
# These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)
210
# QT_MT_REQUIRED Qt4 is now always multithreaded
212
# These variables are set to "" Because Qt structure changed
213
# (They make no sense in Qt4)
214
# QT_QT_LIBRARY Qt-Library is now split
216
INCLUDE(CheckSymbolExists)
217
INCLUDE(MacroAddFileDependencies)
219
SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
221
SET( QT_DEFINITIONS "")
223
SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)
225
# macro for asking qmake to process pro files
226
MACRO(QT_QUERY_QMAKE outvar invar)
227
FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro
228
"message(CMAKE_MESSAGE<$$${invar}>)")
230
# Invoke qmake with the tmp.pro program to get the desired
231
# information. Use the same variable for both stdout and stderr
232
# to make sure we get the output on all platforms.
233
EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}
235
${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake
236
OUTPUT_VARIABLE _qmake_query_output
237
RESULT_VARIABLE _qmake_result
238
ERROR_VARIABLE _qmake_query_output )
241
"${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake")
244
MESSAGE(WARNING " querying qmake for ${invar}. qmake reported:\n${_qmake_query_output}")
246
STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}")
249
ENDMACRO(QT_QUERY_QMAKE)
250
GET_FILENAME_COMPONENT(qt_install_version "[HKEY_CURRENT_USER\\Software\\trolltech\\Versions;DefaultQtVersion]" NAME)
252
FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 PATHS
253
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
254
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
255
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\${qt_install_version};InstallDir]/bin"
259
IF (QT_QMAKE_EXECUTABLE)
261
SET(QT4_QMAKE_FOUND FALSE)
263
EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
264
# check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
265
IF("${QTVERSION}" MATCHES "Unknown")
266
SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
267
FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS
268
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
269
"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"
272
IF(QT_QMAKE_EXECUTABLE)
273
EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
274
ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)
275
ENDIF(QT_QMAKE_EXECUTABLE)
276
ENDIF("${QTVERSION}" MATCHES "Unknown")
278
# check that we found the Qt4 qmake, Qt3 qmake output won't match here
279
STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")
282
# we need at least version 4.0.0
283
IF (NOT QT_MIN_VERSION)
284
SET(QT_MIN_VERSION "4.0.0")
285
ENDIF (NOT QT_MIN_VERSION)
287
#now parse the parts of the user given version string into variables
288
STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}")
289
IF (NOT req_qt_major_vers)
290
MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"")
291
ENDIF (NOT req_qt_major_vers)
293
# now parse the parts of the user given version string into variables
294
STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}")
295
STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}")
296
STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}")
298
IF (NOT req_qt_major_vers EQUAL 4)
299
MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")
300
ENDIF (NOT req_qt_major_vers EQUAL 4)
302
# and now the version string given by qmake
303
STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" found_qt_major_vers "${QTVERSION}")
304
STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" found_qt_minor_vers "${QTVERSION}")
305
STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" found_qt_patch_vers "${QTVERSION}")
307
# compute an overall version number which can be compared at once
308
MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")
309
MATH(EXPR found_vers "${found_qt_major_vers}*10000 + ${found_qt_minor_vers}*100 + ${found_qt_patch_vers}")
311
IF (found_vers LESS req_vers)
312
SET(QT4_QMAKE_FOUND FALSE)
313
SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
314
ELSE (found_vers LESS req_vers)
315
SET(QT4_QMAKE_FOUND TRUE)
316
ENDIF (found_vers LESS req_vers)
317
ENDIF (qt_version_tmp)
319
ENDIF (QT_QMAKE_EXECUTABLE)
323
# ask qmake for the library dir
325
IF (NOT QT_LIBRARY_DIR)
326
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
327
ARGS "-query QT_INSTALL_LIBS"
328
OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP )
329
IF(EXISTS "${QT_LIBRARY_DIR_TMP}")
330
SET(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir")
331
ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}")
332
MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT_LIBRARY_DIR_TMP}")
333
MESSAGE("Warning: ${QT_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.")
334
ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}")
335
ENDIF(NOT QT_LIBRARY_DIR)
338
IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
339
SET(QT_USE_FRAMEWORKS ON
340
CACHE BOOL "Set to ON if Qt build uses frameworks.")
341
ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
342
SET(QT_USE_FRAMEWORKS OFF
343
CACHE BOOL "Set to ON if Qt build uses frameworks.")
344
ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
346
MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)
349
# ask qmake for the binary dir
350
IF (NOT QT_BINARY_DIR)
351
EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}
352
ARGS "-query QT_INSTALL_BINS"
353
OUTPUT_VARIABLE qt_bins )
354
SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "")
355
ENDIF (NOT QT_BINARY_DIR)
357
# ask qmake for the include dir
358
IF (NOT QT_HEADERS_DIR)
359
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
360
ARGS "-query QT_INSTALL_HEADERS"
361
OUTPUT_VARIABLE qt_headers )
362
SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "")
363
ENDIF(NOT QT_HEADERS_DIR)
366
# ask qmake for the documentation directory
368
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
369
ARGS "-query QT_INSTALL_DOCS"
370
OUTPUT_VARIABLE qt_doc_dir )
371
SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs")
372
ENDIF (NOT QT_DOC_DIR)
374
# ask qmake for the mkspecs directory
375
IF (NOT QT_MKSPECS_DIR)
376
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
377
ARGS "-query QMAKE_MKSPECS"
378
OUTPUT_VARIABLE qt_mkspecs_dirs )
379
STRING(REPLACE ":" ";" qt_mkspecs_dirs "${qt_mkspecs_dirs}")
380
FIND_PATH(QT_MKSPECS_DIR qconfig.pri PATHS ${qt_mkspecs_dirs}
381
DOC "The location of the Qt mkspecs containing qconfig.pri"
383
ENDIF (NOT QT_MKSPECS_DIR)
385
# ask qmake for the plugins directory
386
IF (NOT QT_PLUGINS_DIR)
387
EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}
388
ARGS "-query QT_INSTALL_PLUGINS"
389
OUTPUT_VARIABLE qt_plugins_dir )
390
SET(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins")
391
ENDIF (NOT QT_PLUGINS_DIR)
392
########################################
394
# Setting the INCLUDE-Variables
396
########################################
398
FIND_PATH(QT_QTCORE_INCLUDE_DIR QtGlobal
399
${QT_HEADERS_DIR}/QtCore
400
${QT_LIBRARY_DIR}/QtCore.framework/Headers
404
# Set QT_INCLUDE_DIR by removine "/QtCore" in the string ${QT_QTCORE_INCLUDE_DIR}
405
IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
406
IF (QT_USE_FRAMEWORKS)
407
SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR})
408
ELSE (QT_USE_FRAMEWORKS)
409
STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT_QTCORE_INCLUDE_DIR})
410
SET( QT_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "")
411
ENDIF (QT_USE_FRAMEWORKS)
412
ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)
414
IF( NOT QT_INCLUDE_DIR)
415
IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
416
MESSAGE( FATAL_ERROR "Could NOT find QtGlobal header")
417
ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
418
ENDIF( NOT QT_INCLUDE_DIR)
420
#############################################
422
# Find out what window system we're using
424
#############################################
425
# Save required variable
426
SET(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES})
427
SET(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
428
# Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES
429
SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_INCLUDE_DIR}")
430
# On Mac OS X when Qt has framework support, also add the framework path
431
IF( QT_USE_FRAMEWORKS )
432
SET(CMAKE_REQUIRED_FLAGS "-F${QT_LIBRARY_DIR} ")
433
ENDIF( QT_USE_FRAMEWORKS )
434
# Check for Window system symbols (note: only one should end up being set)
435
CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)
436
CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)
437
CHECK_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)
438
CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)
440
IF (QT_QTCOPY_REQUIRED)
441
CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)
442
IF (NOT QT_IS_QTCOPY)
443
MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found")
444
ENDIF (NOT QT_IS_QTCOPY)
445
ENDIF (QT_QTCOPY_REQUIRED)
447
# Restore CMAKE_REQUIRED_INCLUDES and CMAKE_REQUIRED_FLAGS variables
448
SET(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
449
SET(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE})
451
#############################################
453
IF (QT_USE_FRAMEWORKS)
454
SET(QT_DEFINITIONS ${QT_DEFINITIONS} -F${QT_LIBRARY_DIR} -L${QT_LIBRARY_DIR} )
455
ENDIF (QT_USE_FRAMEWORKS)
457
# Set QT_QT3SUPPORT_INCLUDE_DIR
458
FIND_PATH(QT_QT3SUPPORT_INCLUDE_DIR Qt3Support
460
${QT_INCLUDE_DIR}/Qt3Support
461
${QT_LIBRARY_DIR}/Qt3Support.framework/Headers
465
# Set QT_QT_INCLUDE_DIR
466
FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h
469
${QT_LIBRARY_DIR}/QtCore.framework/Headers
473
# Set QT_QTGUI_INCLUDE_DIR
474
FIND_PATH(QT_QTGUI_INCLUDE_DIR QtGui
476
${QT_INCLUDE_DIR}/QtGui
477
${QT_LIBRARY_DIR}/QtGui.framework/Headers
481
# Set QT_QTSVG_INCLUDE_DIR
482
FIND_PATH(QT_QTSVG_INCLUDE_DIR QtSvg
484
${QT_INCLUDE_DIR}/QtSvg
485
${QT_LIBRARY_DIR}/QtSvg.framework/Headers
489
# Set QT_QTSCRIPT_INCLUDE_DIR
490
FIND_PATH(QT_QTSCRIPT_INCLUDE_DIR QtScript
492
${QT_INCLUDE_DIR}/QtScript
493
${QT_LIBRARY_DIR}/QtScript.framework/Headers
497
# Set QT_QTTEST_INCLUDE_DIR
498
FIND_PATH(QT_QTTEST_INCLUDE_DIR QtTest
500
${QT_INCLUDE_DIR}/QtTest
501
${QT_LIBRARY_DIR}/QtTest.framework/Headers
505
# Set QT_QTUITOOLS_INCLUDE_DIR
506
FIND_PATH(QT_QTUITOOLS_INCLUDE_DIR QtUiTools
508
${QT_INCLUDE_DIR}/QtUiTools
509
${QT_LIBRARY_DIR}/QtUiTools.framework/Headers
515
# Set QT_QTMOTIF_INCLUDE_DIR
517
FIND_PATH(QT_QTMOTIF_INCLUDE_DIR QtMotif PATHS ${QT_INCLUDE_DIR}/QtMotif NO_DEFAULT_PATH )
520
# Set QT_QTNETWORK_INCLUDE_DIR
521
FIND_PATH(QT_QTNETWORK_INCLUDE_DIR QtNetwork
523
${QT_INCLUDE_DIR}/QtNetwork
524
${QT_LIBRARY_DIR}/QtNetwork.framework/Headers
528
# Set QT_QTNSPLUGIN_INCLUDE_DIR
529
FIND_PATH(QT_QTNSPLUGIN_INCLUDE_DIR QtNsPlugin
531
${QT_INCLUDE_DIR}/QtNsPlugin
532
${QT_LIBRARY_DIR}/QtNsPlugin.framework/Headers
536
# Set QT_QTOPENGL_INCLUDE_DIR
537
FIND_PATH(QT_QTOPENGL_INCLUDE_DIR QtOpenGL
539
${QT_INCLUDE_DIR}/QtOpenGL
540
${QT_LIBRARY_DIR}/QtOpenGL.framework/Headers
544
# Set QT_QTSQL_INCLUDE_DIR
545
FIND_PATH(QT_QTSQL_INCLUDE_DIR QtSql
547
${QT_INCLUDE_DIR}/QtSql
548
${QT_LIBRARY_DIR}/QtSql.framework/Headers
552
# Set QT_QTXML_INCLUDE_DIR
553
FIND_PATH(QT_QTXML_INCLUDE_DIR QtXml
555
${QT_INCLUDE_DIR}/QtXml
556
${QT_LIBRARY_DIR}/QtXml.framework/Headers
560
# Set QT_QTASSISTANT_INCLUDE_DIR
561
FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant
563
${QT_INCLUDE_DIR}/QtAssistant
564
${QT_HEADERS_DIR}/QtAssistant
565
${QT_LIBRARY_DIR}/QtAssistant.framework/Headers
569
# Set QT_QTDESIGNER_INCLUDE_DIR
570
FIND_PATH(QT_QTDESIGNER_INCLUDE_DIR QDesignerComponents
572
${QT_INCLUDE_DIR}/QtDesigner
573
${QT_HEADERS_DIR}/QtDesigner
574
${QT_LIBRARY_DIR}/QtDesigner.framework/Headers
578
# Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR
579
FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents
581
${QT_INCLUDE_DIR}/QtDesigner
582
${QT_HEADERS_DIR}/QtDesigner
587
# Set QT_QTDBUS_INCLUDE_DIR
588
FIND_PATH(QT_QTDBUS_INCLUDE_DIR QtDBus
590
${QT_INCLUDE_DIR}/QtDBus
591
${QT_HEADERS_DIR}/QtDBus
595
# Make variables changeble to the advanced user
596
MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_INCLUDE_DIR QT_QT_INCLUDE_DIR QT_DOC_DIR QT_MKSPECS_DIR QT_PLUGINS_DIR)
599
SET( QT_INCLUDES ${QT_INCLUDE_DIR} ${QT_QT_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default )
601
# Set QT_QTCORE_LIBRARY by searching for a lib with "QtCore." as part of the filename
602
FIND_LIBRARY(QT_QTCORE_LIBRARY_RELEASE NAMES QtCore QtCore4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH )
603
FIND_LIBRARY(QT_QTCORE_LIBRARY_DEBUG NAMES QtCore_debug QtCored QtCored4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
605
# Set QT_QT3SUPPORT_LIBRARY
606
FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY_RELEASE NAMES Qt3Support Qt3Support4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
607
FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY_DEBUG NAMES Qt3Support_debug Qt3Supportd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
609
# Set QT_QTGUI_LIBRARY
610
FIND_LIBRARY(QT_QTGUI_LIBRARY_RELEASE NAMES QtGui QtGui4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
611
FIND_LIBRARY(QT_QTGUI_LIBRARY_DEBUG NAMES QtGui_debug QtGuid4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
613
# Set QT_QTMOTIF_LIBRARY
615
FIND_LIBRARY(QT_QTMOTIF_LIBRARY_RELEASE NAMES QtMotif PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
616
FIND_LIBRARY(QT_QTMOTIF_LIBRARY_DEBUG NAMES QtMotif_debug PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
619
# Set QT_QTNETWORK_LIBRARY
620
FIND_LIBRARY(QT_QTNETWORK_LIBRARY_RELEASE NAMES QtNetwork QtNetwork4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
621
FIND_LIBRARY(QT_QTNETWORK_LIBRARY_DEBUG NAMES QtNetwork_debug QtNetworkd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
623
# Set QT_QTNSPLUGIN_LIBRARY
624
FIND_LIBRARY(QT_QTNSPLUGIN_LIBRARY_RELEASE NAMES QtNsPlugin PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
625
FIND_LIBRARY(QT_QTNSPLUGIN_LIBRARY_DEBUG NAMES QtNsPlugin_debug PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
627
# Set QT_QTOPENGL_LIBRARY
628
FIND_LIBRARY(QT_QTOPENGL_LIBRARY_RELEASE NAMES QtOpenGL QtOpenGL4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
629
FIND_LIBRARY(QT_QTOPENGL_LIBRARY_DEBUG NAMES QtOpenGL_debug QtOpenGLd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
631
# Set QT_QTSQL_LIBRARY
632
FIND_LIBRARY(QT_QTSQL_LIBRARY_RELEASE NAMES QtSql QtSql4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
633
FIND_LIBRARY(QT_QTSQL_LIBRARY_DEBUG NAMES QtSql_debug QtSqld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
635
# Set QT_QTXML_LIBRARY
636
FIND_LIBRARY(QT_QTXML_LIBRARY_RELEASE NAMES QtXml QtXml4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
637
FIND_LIBRARY(QT_QTXML_LIBRARY_DEBUG NAMES QtXml_debug QtXmld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
639
# Set QT_QTSVG_LIBRARY
640
FIND_LIBRARY(QT_QTSVG_LIBRARY_RELEASE NAMES QtSvg QtSvg4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
641
FIND_LIBRARY(QT_QTSVG_LIBRARY_DEBUG NAMES QtSvg_debug QtSvgd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
643
# Set QT_QTUITOOLS_LIBRARY
644
FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools QtUiTools4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
645
FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_DEBUG NAMES QtUiTools_debug QtUiToolsd QtUiToolsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
647
# Set QT_QTTEST_LIBRARY
648
FIND_LIBRARY(QT_QTTEST_LIBRARY_RELEASE NAMES QtTest QtTest4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
649
FIND_LIBRARY(QT_QTTEST_LIBRARY_DEBUG NAMES QtTest_debug QtTest_debug4 QtTestd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
651
# Set QT_QTDBUS_LIBRARY
652
# This was introduced with Qt 4.2, where also the naming scheme for debug libs was changed
653
# So does any of the debug lib names listed here actually exist ?
654
FIND_LIBRARY(QT_QTDBUS_LIBRARY_RELEASE NAMES QtDBus QtDBus4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
655
FIND_LIBRARY(QT_QTDBUS_LIBRARY_DEBUG NAMES QtDBus_debug QtDBus_debug4 QtDBusd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
657
# Set QT_QTSCRIPT_LIBRARY
658
FIND_LIBRARY(QT_QTSCRIPT_LIBRARY_RELEASE NAMES QtScript QtScript4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
659
FIND_LIBRARY(QT_QTSCRIPT_LIBRARY_DEBUG NAMES QtScript_debug QtScriptd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
661
IF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
662
IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
663
MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
664
ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)
665
ENDIF( NOT QT_QTCORE_LIBRARY_DEBUG AND NOT QT_QTCORE_LIBRARY_RELEASE )
667
# Set QT_QTASSISTANT_LIBRARY
668
FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_RELEASE NAMES QtAssistantClient QtAssistantClient4 QtAssistant QtAssistant4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
669
FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_DEBUG NAMES QtAssistantClientd QtAssistantClientd4 QtAssistantClient_debug QtAssistant_debug QtAssistantd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
671
# Set QT_QTDESIGNER_LIBRARY
672
FIND_LIBRARY(QT_QTDESIGNER_LIBRARY_RELEASE NAMES QtDesigner QtDesigner4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
673
FIND_LIBRARY(QT_QTDESIGNER_LIBRARY_DEBUG NAMES QtDesigner_debug QtDesignerd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
675
# Set QT_QTDESIGNERCOMPONENTS_LIBRARY
676
FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents QtDesignerComponents4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
677
FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NAMES QtDesigner_debug QtDesignerd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)
679
# Set QT_QTMAIN_LIBRARY
681
FIND_LIBRARY(QT_QTMAIN_LIBRARY_RELEASE NAMES qtmain PATHS ${QT_LIBRARY_DIR}
683
FIND_LIBRARY(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmaind PATHS ${QT_LIBRARY_DIR}
687
############################################
689
# Check the existence of the libraries.
691
############################################
693
MACRO (_QT4_ADJUST_LIB_VARS basename)
694
IF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
696
# if only the release version was found, set the debug variable also to the release version
697
IF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)
698
SET(QT_${basename}_LIBRARY_DEBUG ${QT_${basename}_LIBRARY_RELEASE})
699
SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE})
700
SET(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_RELEASE})
701
ENDIF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)
703
# if only the debug version was found, set the release variable also to the debug version
704
IF (QT_${basename}_LIBRARY_DEBUG AND NOT QT_${basename}_LIBRARY_RELEASE)
705
SET(QT_${basename}_LIBRARY_RELEASE ${QT_${basename}_LIBRARY_DEBUG})
706
SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_DEBUG})
707
SET(QT_${basename}_LIBRARIES ${QT_${basename}_LIBRARY_DEBUG})
708
ENDIF (QT_${basename}_LIBRARY_DEBUG AND NOT QT_${basename}_LIBRARY_RELEASE)
710
IF (QT_${basename}_LIBRARY_DEBUG AND QT_${basename}_LIBRARY_RELEASE)
711
# if the generator supports configuration types then set
712
# optimized and debug libraries, or if the CMAKE_BUILD_TYPE has a value
713
IF (CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
714
SET(QT_${basename}_LIBRARY optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})
715
ELSE(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
716
# if there are no configuration types and CMAKE_BUILD_TYPE has no value
717
# then just use the release libraries
718
SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE} )
719
ENDIF(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
720
SET(QT_${basename}_LIBRARIES optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})
721
ENDIF (QT_${basename}_LIBRARY_DEBUG AND QT_${basename}_LIBRARY_RELEASE)
723
SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY} CACHE FILEPATH "The Qt ${basename} library")
725
IF (QT_${basename}_LIBRARY)
726
SET(QT_${basename}_FOUND 1)
727
ENDIF (QT_${basename}_LIBRARY)
729
ENDIF (QT_${basename}_LIBRARY_RELEASE OR QT_${basename}_LIBRARY_DEBUG)
731
IF (QT_${basename}_INCLUDE_DIR)
732
#add the include directory to QT_INCLUDES
733
SET(QT_INCLUDES ${QT_INCLUDES} "${QT_${basename}_INCLUDE_DIR}")
734
ENDIF (QT_${basename}_INCLUDE_DIR)
736
# Make variables changeble to the advanced user
737
MARK_AS_ADVANCED(QT_${basename}_LIBRARY QT_${basename}_LIBRARY_RELEASE QT_${basename}_LIBRARY_DEBUG QT_${basename}_INCLUDE_DIR)
738
ENDMACRO (_QT4_ADJUST_LIB_VARS)
741
# Set QT_xyz_LIBRARY variable and add
742
# library include path to QT_INCLUDES
743
_QT4_ADJUST_LIB_VARS(QTCORE)
744
_QT4_ADJUST_LIB_VARS(QTGUI)
745
_QT4_ADJUST_LIB_VARS(QT3SUPPORT)
746
_QT4_ADJUST_LIB_VARS(QTASSISTANT)
747
_QT4_ADJUST_LIB_VARS(QTDESIGNER)
748
_QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS)
749
_QT4_ADJUST_LIB_VARS(QTNETWORK)
750
_QT4_ADJUST_LIB_VARS(QTNSPLUGIN)
751
_QT4_ADJUST_LIB_VARS(QTOPENGL)
752
_QT4_ADJUST_LIB_VARS(QTSQL)
753
_QT4_ADJUST_LIB_VARS(QTXML)
754
_QT4_ADJUST_LIB_VARS(QTSVG)
755
_QT4_ADJUST_LIB_VARS(QTSCRIPT)
756
_QT4_ADJUST_LIB_VARS(QTUITOOLS)
757
_QT4_ADJUST_LIB_VARS(QTTEST)
758
_QT4_ADJUST_LIB_VARS(QTDBUS)
760
# platform dependent libraries
762
_QT4_ADJUST_LIB_VARS(QTMOTIF)
765
_QT4_ADJUST_LIB_VARS(QTMAIN)
769
#######################################
771
# Check the executables of Qt
774
#######################################
777
# find moc and uic using qmake
778
QT_QUERY_QMAKE(QT_MOC_EXECUTABLE_INTERNAL "QMAKE_MOC")
779
QT_QUERY_QMAKE(QT_UIC_EXECUTABLE_INTERNAL "QMAKE_UIC")
782
"${QT_MOC_EXECUTABLE_INTERNAL}" QT_MOC_EXECUTABLE_INTERNAL)
784
"${QT_UIC_EXECUTABLE_INTERNAL}" QT_UIC_EXECUTABLE_INTERNAL)
786
SET(QT_MOC_EXECUTABLE
787
${QT_MOC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The moc executable")
788
SET(QT_UIC_EXECUTABLE
789
${QT_UIC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The uic executable")
791
FIND_PROGRAM(QT_UIC3_EXECUTABLE
793
PATHS ${QT_BINARY_DIR}
797
FIND_PROGRAM(QT_RCC_EXECUTABLE
799
PATHS ${QT_BINARY_DIR}
803
FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE
805
PATHS ${QT_BINARY_DIR}
809
FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE
811
PATHS ${QT_BINARY_DIR}
815
IF (QT_MOC_EXECUTABLE)
816
SET(QT_WRAP_CPP "YES")
817
ENDIF (QT_MOC_EXECUTABLE)
819
IF (QT_UIC_EXECUTABLE)
820
SET(QT_WRAP_UI "YES")
821
ENDIF (QT_UIC_EXECUTABLE)
825
MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE)
827
######################################
829
# Macros for building Qt files
831
######################################
833
MACRO (QT4_GET_MOC_INC_DIRS _moc_INC_DIRS)
834
SET(${_moc_INC_DIRS})
835
GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)
837
FOREACH(_current ${_inc_DIRS})
838
SET(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-I" ${_current})
839
ENDFOREACH(_current ${_inc_DIRS})
840
ENDMACRO(QT4_GET_MOC_INC_DIRS)
843
MACRO (QT4_GENERATE_MOC infile outfile )
845
QT4_GET_MOC_INC_DIRS(moc_includes)
847
GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE)
849
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
850
COMMAND ${QT_MOC_EXECUTABLE}
851
ARGS ${moc_includes} -o ${outfile} ${abs_infile}
852
DEPENDS ${abs_infile})
854
SET_SOURCE_FILES_PROPERTIES(${outfile} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file
856
MACRO_ADD_FILE_DEPENDENCIES(${abs_infile} ${outfile})
857
ENDMACRO (QT4_GENERATE_MOC)
860
# QT4_WRAP_CPP(outfiles inputfile ... )
861
# TODO perhaps add support for -D, -U and other minor options
863
MACRO (QT4_WRAP_CPP outfiles )
865
QT4_GET_MOC_INC_DIRS(moc_includes)
868
GET_FILENAME_COMPONENT(it ${it} ABSOLUTE)
869
GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)
871
SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/moc_${outfile}.cxx)
872
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
873
COMMAND ${QT_MOC_EXECUTABLE}
874
ARGS ${moc_includes} -o ${outfile} ${it}
876
SET(${outfiles} ${${outfiles}} ${outfile})
879
ENDMACRO (QT4_WRAP_CPP)
882
# QT4_WRAP_UI(outfiles inputfile ... )
884
MACRO (QT4_WRAP_UI outfiles )
887
GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)
888
GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
889
SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.h)
890
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
891
COMMAND ${QT_UIC_EXECUTABLE}
892
ARGS -o ${outfile} ${infile}
893
MAIN_DEPENDENCY ${infile})
894
SET(${outfiles} ${${outfiles}} ${outfile})
897
ENDMACRO (QT4_WRAP_UI)
900
# QT4_ADD_RESOURCES(outfiles inputfile ... )
901
# TODO perhaps consider adding support for compression and root options to rcc
903
MACRO (QT4_ADD_RESOURCES outfiles )
906
GET_FILENAME_COMPONENT(outfilename ${it} NAME_WE)
907
GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
908
GET_FILENAME_COMPONENT(rc_path ${infile} PATH)
909
SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cxx)
910
# parse file for dependencies
911
# all files are absolute paths or relative to the location of the qrc file
912
FILE(READ "${infile}" _RC_FILE_CONTENTS)
913
STRING(REGEX MATCHALL "<file[^<]+" _RC_FILES "${_RC_FILE_CONTENTS}")
915
FOREACH(_RC_FILE ${_RC_FILES})
916
STRING(REGEX REPLACE "^<file[^>]*>" "" _RC_FILE "${_RC_FILE}")
917
STRING(REGEX MATCH "^/|([A-Za-z]:/)" _ABS_PATH_INDICATOR "${_RC_FILE}")
918
IF(NOT _ABS_PATH_INDICATOR)
919
SET(_RC_FILE "${rc_path}/${_RC_FILE}")
920
ENDIF(NOT _ABS_PATH_INDICATOR)
921
SET(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")
923
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
924
COMMAND ${QT_RCC_EXECUTABLE}
925
ARGS -name ${outfilename} -o ${outfile} ${infile}
926
MAIN_DEPENDENCY ${infile}
927
DEPENDS ${_RC_DEPENDS})
928
SET(${outfiles} ${${outfiles}} ${outfile})
931
ENDMACRO (QT4_ADD_RESOURCES)
933
MACRO(QT4_ADD_DBUS_INTERFACE _sources _interface _basename)
934
GET_FILENAME_COMPONENT(_infile ${_interface} ABSOLUTE)
935
SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
936
SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
937
SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
939
ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
940
COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -p ${_basename} ${_infile}
943
SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
945
QT4_GENERATE_MOC(${_header} ${_moc})
947
SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
948
MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
950
ENDMACRO(QT4_ADD_DBUS_INTERFACE)
953
MACRO(QT4_ADD_DBUS_INTERFACES _sources)
954
FOREACH (_current_FILE ${ARGN})
955
GET_FILENAME_COMPONENT(_infile ${_current_FILE} ABSOLUTE)
957
# get the part before the ".xml" suffix
958
STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2" _basename ${_current_FILE})
959
STRING(TOLOWER ${_basename} _basename)
961
QT4_ADD_DBUS_INTERFACE(${_sources} ${_infile} ${_basename}interface)
962
ENDFOREACH (_current_FILE)
963
ENDMACRO(QT4_ADD_DBUS_INTERFACES)
966
MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName )
967
SET(_customName "${ARGV1}")
968
GET_FILENAME_COMPONENT(_in_file ${_header} ABSOLUTE)
969
GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE)
972
SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})
974
SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml)
977
ADD_CUSTOM_COMMAND(OUTPUT ${_target}
978
COMMAND ${QT_DBUSCPP2XML_EXECUTABLE} ${_in_file} > ${_target}
981
ENDMACRO(QT4_GENERATE_DBUS_INTERFACE)
984
MACRO(QT4_ADD_DBUS_ADAPTOR _sources _xml_file _include _parentClass) # _optionalBasename )
985
GET_FILENAME_COMPONENT(_infile ${_xml_file} ABSOLUTE)
987
SET(_optionalBasename "${ARGV4}")
988
IF (_optionalBasename)
989
SET(_basename ${_optionalBasename} )
990
ELSE (_optionalBasename)
991
STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _basename ${_infile})
992
STRING(TOLOWER ${_basename} _basename)
993
ENDIF (_optionalBasename)
995
SET(_optionalClassName "${ARGV5}")
996
SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
997
SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
998
SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
1000
IF(_optionalClassName)
1001
ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1002
COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -c ${_optionalClassName} -i ${_include} -l ${_parentClass} ${_infile}
1005
ELSE(_optionalClassName)
1006
ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
1007
COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -i ${_include} -l ${_parentClass} ${_infile}
1010
ENDIF(_optionalClassName)
1012
QT4_GENERATE_MOC(${_header} ${_moc})
1013
SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
1014
MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
1016
SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
1017
ENDMACRO(QT4_ADD_DBUS_ADAPTOR)
1020
QT4_GET_MOC_INC_DIRS(_moc_INCS)
1022
SET(_matching_FILES )
1023
FOREACH (_current_FILE ${ARGN})
1025
GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE)
1026
# if "SKIP_AUTOMOC" is set to true, we will not handle this file here.
1027
# here. this is required to make bouic work correctly:
1028
# we need to add generated .cpp files to the sources (to compile them),
1029
# but we cannot let automoc handle them, as the .cpp files don't exist yet when
1030
# cmake is run for the very first time on them -> however the .cpp files might
1031
# exist at a later run. at that time we need to skip them, so that we don't add two
1032
# different rules for the same moc file
1033
GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC)
1035
IF ( NOT _skip AND EXISTS ${_abs_FILE} )
1037
FILE(READ ${_abs_FILE} _contents)
1039
GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH)
1041
STRING(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}")
1043
FOREACH (_current_MOC_INC ${_match})
1044
STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}")
1046
GET_filename_component(_basename ${_current_MOC} NAME_WE)
1047
# SET(_header ${CMAKE_CURRENT_SOURCE_DIR}/${_basename}.h)
1048
SET(_header ${_abs_PATH}/${_basename}.h)
1049
SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC})
1050
ADD_CUSTOM_COMMAND(OUTPUT ${_moc}
1051
COMMAND ${QT_MOC_EXECUTABLE}
1052
ARGS ${_moc_INCS} ${_header} -o ${_moc}
1056
MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc})
1057
ENDFOREACH (_current_MOC_INC)
1059
ENDIF ( NOT _skip AND EXISTS ${_abs_FILE} )
1060
ENDFOREACH (_current_FILE)
1061
ENDMACRO(QT4_AUTOMOC)
1065
######################################
1067
# decide if Qt got found
1069
######################################
1071
# if the includes,libraries,moc,uic and rcc are found then we have it
1072
IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1073
SET( QT4_FOUND "YES" )
1074
IF( NOT Qt4_FIND_QUIETLY)
1075
MESSAGE(STATUS "Found Qt-Version ${QTVERSION}")
1076
ENDIF( NOT Qt4_FIND_QUIETLY)
1077
ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1078
SET( QT4_FOUND "NO")
1079
SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1080
IF( Qt4_FIND_REQUIRED)
1081
MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")
1082
ENDIF( Qt4_FIND_REQUIRED)
1083
ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)
1084
SET(QT_FOUND ${QT4_FOUND})
1087
#######################################
1091
#######################################
1092
IF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
1093
FILE(READ ${QT_MKSPECS_DIR}/qconfig.pri _qconfig_FILE_contents)
1094
STRING(REGEX MATCH "QT_CONFIG[^\n]+" QT_QCONFIG ${_qconfig_FILE_contents})
1095
STRING(REGEX MATCH "CONFIG[^\n]+" QT_CONFIG ${_qconfig_FILE_contents})
1096
STRING(REGEX MATCH "EDITION[^\n]+" QT_EDITION ${_qconfig_FILE_contents})
1097
ENDIF(EXISTS "${QT_MKSPECS_DIR}/qconfig.pri")
1098
IF("${QT_EDITION}" MATCHES "DesktopLight")
1099
SET(QT_EDITION_DESKTOPLIGHT 1)
1100
ENDIF("${QT_EDITION}" MATCHES "DesktopLight")
1103
###############################################
1105
# configuration/system dependent settings
1107
###############################################
1109
SET(QT_GUI_LIB_DEPENDENCIES "")
1110
SET(QT_CORE_LIB_DEPENDENCIES "")
1112
# shared build needs -DQT_SHARED
1113
IF(NOT QT_CONFIG MATCHES "static")
1114
# warning currently only qconfig.pri on Windows potentially contains "static"
1115
# so QT_SHARED might not get defined properly on Mac/X11 (which seems harmless right now)
1116
# Trolltech said they'd consider exporting it for all platforms in future releases.
1117
SET(QT_DEFINITIONS ${QT_DEFINITIONS} -DQT_SHARED)
1118
ENDIF(NOT QT_CONFIG MATCHES "static")
1121
IF(QT_QCONFIG MATCHES "system-png")
1122
FIND_LIBRARY(QT_PNG_LIBRARY NAMES png)
1123
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_PNG_LIBRARY})
1124
MARK_AS_ADVANCED(QT_PNG_LIBRARY)
1125
ENDIF(QT_QCONFIG MATCHES "system-png")
1127
# for X11, get X11 library directory
1129
QT_QUERY_QMAKE(QMAKE_LIBDIR_X11 "QMAKE_LIBDIR_X11")
1133
IF(QT_QCONFIG MATCHES "x11sm")
1134
# ask qmake where the x11 libs are
1135
FIND_LIBRARY(QT_X11_SM_LIBRARY NAMES SM PATHS ${QMAKE_LIBDIR_X11})
1136
FIND_LIBRARY(QT_X11_ICE_LIBRARY NAMES ICE PATHS ${QMAKE_LIBDIR_X11})
1137
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_X11_SM_LIBRARY} ${QT_X11_ICE_LIBRARY})
1138
MARK_AS_ADVANCED(QT_X11_SM_LIBRARY)
1139
MARK_AS_ADVANCED(QT_X11_ICE_LIBRARY)
1140
ENDIF(QT_QCONFIG MATCHES "x11sm")
1143
IF(QT_QCONFIG MATCHES "tablet")
1144
FIND_LIBRARY(QT_XI_LIBRARY NAMES Xi PATHS ${QMAKE_LIBDIR_X11})
1145
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XI_LIBRARY})
1146
MARK_AS_ADVANCED(QT_XI_LIBRARY)
1147
ENDIF(QT_QCONFIG MATCHES "tablet")
1150
IF(QT_QCONFIG MATCHES "xrender")
1151
FIND_LIBRARY(QT_XRENDER_LIBRARY NAMES Xrender PATHS ${QMAKE_LIBDIR_X11})
1152
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XRENDER_LIBRARY})
1153
MARK_AS_ADVANCED(QT_XRENDER_LIBRARY)
1154
ENDIF(QT_QCONFIG MATCHES "xrender")
1157
IF(QT_QCONFIG MATCHES "xrandr")
1158
FIND_LIBRARY(QT_XRANDR_LIBRARY NAMES Xrandr PATHS ${QMAKE_LIBDIR_X11})
1159
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XRANDR_LIBRARY})
1160
MARK_AS_ADVANCED(QT_XRANDR_LIBRARY)
1161
ENDIF(QT_QCONFIG MATCHES "xrandr")
1164
IF(QT_QCONFIG MATCHES "xcursor")
1165
FIND_LIBRARY(QT_XCURSOR_LIBRARY NAMES Xcursor PATHS ${QMAKE_LIBDIR_X11})
1166
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XCURSOR_LIBRARY})
1167
MARK_AS_ADVANCED(QT_XCURSOR_LIBRARY)
1168
ENDIF(QT_QCONFIG MATCHES "xcursor")
1171
IF(QT_QCONFIG MATCHES "xinerama")
1172
FIND_LIBRARY(QT_XINERAMA_LIBRARY NAMES Xinerama PATHS ${QMAKE_LIBDIR_X11})
1173
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XINERAMA_LIBRARY})
1174
MARK_AS_ADVANCED(QT_XINERAMA_LIBRARY)
1175
ENDIF(QT_QCONFIG MATCHES "xinerama")
1178
IF(QT_QCONFIG MATCHES "xfixes")
1179
FIND_LIBRARY(QT_XFIXES_LIBRARY NAMES Xfixes PATHS ${QMAKE_LIBDIR_X11})
1180
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_XFIXES_LIBRARY})
1181
MARK_AS_ADVANCED(QT_XFIXES_LIBRARY)
1182
ENDIF(QT_QCONFIG MATCHES "xfixes")
1185
IF(QT_QCONFIG MATCHES "system-freetype")
1186
FIND_LIBRARY(QT_FREETYPE_LIBRARY NAMES freetype)
1187
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_FREETYPE_LIBRARY})
1188
MARK_AS_ADVANCED(QT_FREETYPE_LIBRARY)
1189
ENDIF(QT_QCONFIG MATCHES "system-freetype")
1192
IF(QT_QCONFIG MATCHES "fontconfig")
1193
FIND_LIBRARY(QT_FONTCONFIG_LIBRARY NAMES fontconfig)
1194
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${QT_FONTCONFIG_LIBRARY})
1195
MARK_AS_ADVANCED(QT_FONTCONFIG_LIBRARY)
1196
ENDIF(QT_QCONFIG MATCHES "fontconfig")
1199
IF(QT_QCONFIG MATCHES "system-zlib")
1200
FIND_LIBRARY(QT_ZLIB_LIBRARY NAMES z)
1201
SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QT_ZLIB_LIBRARY})
1202
MARK_AS_ADVANCED(QT_ZLIB_LIBRARY)
1203
ENDIF(QT_QCONFIG MATCHES "system-zlib")
1206
IF(QT_QCONFIG MATCHES "glib")
1207
# Qt less than Qt 4.2.0 doesn't use glib
1208
# Qt 4.2.0 uses glib-2.0 (wish we could ask Qt that it uses 2.0)
1209
FIND_LIBRARY(QT_GLIB_LIBRARY NAMES glib-2.0)
1210
FIND_LIBRARY(QT_GTHREAD_LIBRARY NAMES gthread-2.0)
1211
SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES}
1212
${QT_GTHREAD_LIBRARY} ${QT_GLIB_LIBRARY})
1213
MARK_AS_ADVANCED(QT_GLIB_LIBRARY)
1214
MARK_AS_ADVANCED(QT_GTHREAD_LIBRARY)
1215
ENDIF(QT_QCONFIG MATCHES "glib")
1217
## clock-monotonic, just see if we need to link with rt
1218
IF(QT_QCONFIG MATCHES "clock-monotonic")
1219
SET(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
1220
SET(CMAKE_REQUIRED_LIBRARIES rt)
1221
CHECK_SYMBOL_EXISTS(_POSIX_TIMERS "unistd.h;time.h" QT_POSIX_TIMERS)
1222
SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
1224
FIND_LIBRARY(QT_RT_LIBRARY NAMES rt)
1225
SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QT_RT_LIBRARY})
1226
MARK_AS_ADVANCED(QT_RT_LIBRARY)
1227
ENDIF(QT_POSIX_TIMERS)
1228
ENDIF(QT_QCONFIG MATCHES "clock-monotonic")
1231
# X11 libraries Qt absolutely depends on
1232
QT_QUERY_QMAKE(QT_LIBS_X11 "QMAKE_LIBS_X11")
1233
SEPARATE_ARGUMENTS(QT_LIBS_X11)
1234
FOREACH(QT_X11_LIB ${QT_LIBS_X11})
1235
STRING(REGEX REPLACE "-l" "" QT_X11_LIB "${QT_X11_LIB}")
1236
SET(QT_TMP_STR "QT_X11_${QT_X11_LIB}_LIBRARY")
1237
FIND_LIBRARY(${QT_TMP_STR} NAMES "${QT_X11_LIB}" PATHS ${QMAKE_LIBDIR_X11})
1238
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} ${${QT_TMP_STR}})
1239
MARK_AS_ADVANCED(${QT_TMP_STR})
1240
ENDFOREACH(QT_X11_LIB)
1242
QT_QUERY_QMAKE(QT_LIBS_THREAD "QMAKE_LIBS_THREAD")
1243
SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QT_LIBS_THREAD})
1245
QT_QUERY_QMAKE(QMAKE_LIBS_DYNLOAD "QMAKE_LIBS_DYNLOAD")
1246
SET (QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} ${QMAKE_LIBS_DYNLOAD})
1251
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} Imm32 Winmm)
1252
SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} Ws2_32)
1256
SET(QT_GUI_LIB_DEPENDENCIES ${QT_GUI_LIB_DEPENDENCIES} "-framework Carbon" "-framework QuickTime")
1257
SET(QT_CORE_LIB_DEPENDENCIES ${QT_CORE_LIB_DEPENDENCIES} "-framework ApplicationServices")
1260
#######################################
1262
# compatibility settings
1264
#######################################
1265
# Backwards compatibility for CMake1.4 and 1.2
1266
SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
1267
SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
1269
SET( QT_QT_LIBRARY "")
1271
ELSE(QT4_QMAKE_FOUND)
1273
SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
1274
IF(Qt4_FIND_REQUIRED)
1275
IF(QT4_INSTALLED_VERSION_TOO_OLD)
1276
MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1277
ELSE(QT4_INSTALLED_VERSION_TOO_OLD)
1278
MESSAGE( FATAL_ERROR "Qt qmake not found!")
1279
ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)
1280
ELSE(Qt4_FIND_REQUIRED)
1281
IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1282
MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
1283
ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
1284
ENDIF(Qt4_FIND_REQUIRED)
1286
ENDIF (QT4_QMAKE_FOUND)
added
removed
cmake/FindQt4.cmake
