~ubuntu-branches/ubuntu/wily/qimageblitz/wily : revision 3

1

# - Find QT 4

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:

10

# QT_DONT_USE_QTCORE

11

# QT_DONT_USE_QTGUI

12

# QT_USE_QT3SUPPORT

13

# QT_USE_QTASSISTANT

14

# QT_USE_QTDESIGNER

15

# QT_USE_QTMOTIF

16

# QT_USE_QTMAIN

17

# QT_USE_QTNETWORK

18

# QT_USE_QTNSPLUGIN

19

# QT_USE_QTOPENGL

20

# QT_USE_QTSQL

21

# QT_USE_QTXML

22

# QT_USE_QTSVG

23

# QT_USE_QTTEST

24

# QT_USE_QTUITOOLS

25

# QT_USE_QTDBUS

26

# QT_USE_QTSCRIPT

27

#

28

# All the libraries required are stored in a variable called QT_LIBRARIES.

29

# Add this variable to your TARGET_LINK_LIBRARIES.

30

#

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 )

36

#

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

40

# the list of sources.

41

# To disable generating a namespace header, set the source file property

42

# NO_NAMESPACE to TRUE on the interface file.

43

#

44

# macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )

45

# create the interface header and implementation files

46

# for all listed interface xml files

47

# the name will be automatically determined from the name of the xml file

48

# To disable generating namespace headers, set the source file property

49

# NO_NAMESPACE to TRUE for these inputfiles.

50

#

51

# macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])

52

# create a dbus adaptor (header and implementation file) from the xml file

53

# describing the interface, and add it to the list of sources. The adaptor

54

# forwards the calls to a parent class, defined in parentheader and named

55

# parentclassname. The name of the generated files will be

56

# <basename>adaptor.{cpp,h} where basename defaults to the basename of the xml file.

57

# If <classname> is provided, then it will be used as the classname of the

58

# adaptor itself.

59

#

60

# macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] )

61

# generate the xml interface file from the given header.

62

# If the optional argument interfacename is omitted, the name of the

63

# interface file is constructed from the basename of the header with

64

# the suffix .xml appended.

65

#

66

# QT_FOUND If false, don't try to use Qt.

67

# QT4_FOUND If false, don't try to use Qt 4.

68

#

69

# QT_QTCORE_FOUND True if QtCore was found.

70

# QT_QTGUI_FOUND True if QtGui was found.

71

# QT_QT3SUPPORT_FOUND True if Qt3Support was found.

72

# QT_QTASSISTANT_FOUND True if QtAssistant was found.

73

# QT_QTDBUS_FOUND True if QtDBus was found.

74

# QT_QTDESIGNER_FOUND True if QtDesigner was found.

75

# QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.

76

# QT_QTMOTIF_FOUND True if QtMotif was found.

77

# QT_QTNETWORK_FOUND True if QtNetwork was found.

78

# QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found.

79

# QT_QTOPENGL_FOUND True if QtOpenGL was found.

80

# QT_QTSQL_FOUND True if QtSql was found.

81

# QT_QTXML_FOUND True if QtXml was found.

82

# QT_QTSVG_FOUND True if QtSvg was found.

83

# QT_QTSCRIPT_FOUND True if QtScript was found.

84

# QT_QTTEST_FOUND True if QtTest was found.

85

# QT_QTUITOOLS_FOUND True if QtUiTools was found.

86

#

87

# QT_DEFINITIONS Definitions to use when compiling code that uses Qt.

88

#

89

# QT_INCLUDES List of paths to all include directories of

90

# Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are

91

# always in this variable even if NOTFOUND,

92

# all other INCLUDE_DIRS are

93

# only added if they are found.

94

#

95

# QT_INCLUDE_DIR Path to "include" of Qt4

96

# QT_QT_INCLUDE_DIR Path to "include/Qt"

97

# QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support"

98

# QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant"

99

# QT_QTCORE_INCLUDE_DIR Path to "include/QtCore"

100

# QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner"

101

# QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner"

102

# QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus"

103

# QT_QTGUI_INCLUDE_DIR Path to "include/QtGui"

104

# QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif"

105

# QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork"

106

# QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin"

107

# QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL"

108

# QT_QTSQL_INCLUDE_DIR Path to "include/QtSql"

109

# QT_QTXML_INCLUDE_DIR Path to "include/QtXml"

110

# QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg"

111

# QT_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript"

112

# QT_QTTEST_INCLUDE_DIR Path to "include/QtTest"

113

#

114

# QT_LIBRARY_DIR Path to "lib" of Qt4

115

#

116

# QT_PLUGINS_DIR Path to "plugins" for Qt4

117

#

118

# For every library of Qt, a QT_QTFOO_LIBRARY variable is defined, with the full path to the library.

119

#

120

# So there are the following variables:

121

# The Qt3Support library: QT_QT3SUPPORT_LIBRARY

122

#

123

# The QtAssistant library: QT_QTASSISTANT_LIBRARY

124

#

125

# The QtCore library: QT_QTCORE_LIBRARY

126

#

127

# The QtDBus library: QT_QTDBUS_LIBRARY

128

#

129

# The QtDesigner library: QT_QTDESIGNER_LIBRARY

130

#

131

# The QtDesignerComponents library: QT_QTDESIGNERCOMPONENTS_LIBRARY

132

#

133

# The QtGui library: QT_QTGUI_LIBRARY

134

#

135

# The QtMotif library: QT_QTMOTIF_LIBRARY

136

#

137

# The QtNetwork library: QT_QTNETWORK_LIBRARY

138

#

139

# The QtNsPLugin library: QT_QTNSPLUGIN_LIBRARY

140

#

141

# The QtOpenGL library: QT_QTOPENGL_LIBRARY

142

#

143

# The QtSql library: QT_QTSQL_LIBRARY

144

#

145

# The QtXml library: QT_QTXML_LIBRARY

146

#

147

# The QtSvg library: QT_QTSVG_LIBRARY

148

#

149

# The QtScript library: QT_QTSCRIPT_LIBRARY

150

#

151

# The QtTest library: QT_QTTEST_LIBRARY

152

#

153

# The qtmain library for Windows QT_QTMAIN_LIBRARY

154

#

155

# The QtUiTools library: QT_QTUITOOLS_LIBRARY

156

#

157

# also defined, but NOT for general use are

158

# QT_MOC_EXECUTABLE Where to find the moc tool.

159

# QT_UIC_EXECUTABLE Where to find the uic tool.

160

# QT_UIC3_EXECUTABLE Where to find the uic3 tool.

161

# QT_RCC_EXECUTABLE Where to find the rcc tool

162

# QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool.

163

# QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool.

164

#

165

# QT_DOC_DIR Path to "doc" of Qt4

166

# QT_MKSPECS_DIR Path to "mkspecs" of Qt4

167

#

168

#

169

# These are around for backwards compatibility

170

# they will be set

171

# QT_WRAP_CPP Set true if QT_MOC_EXECUTABLE is found

172

# QT_WRAP_UI Set true if QT_UIC_EXECUTABLE is found

173

#

174

# These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)

175

# QT_MT_REQUIRED Qt4 is now always multithreaded

176

#

177

# These variables are set to "" Because Qt structure changed

178

# (They make no sense in Qt4)

179

# QT_QT_LIBRARY Qt-Library is now split

180

181

182

# See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.

183

184

if (QT4_QMAKE_FOUND)

185

# Check already done in this cmake run, nothing more to do

186

187

else (QT4_QMAKE_FOUND)

188

189

INCLUDE(CheckSymbolExists)

190

INCLUDE(MacroAddFileDependencies)

191

INCLUDE(MacroPushRequiredVars)

192

193

SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)

194

195

SET( QT_DEFINITIONS "")

196

197

IF (WIN32)

198

SET(QT_DEFINITIONS -DQT_DLL)

199

ENDIF(WIN32)

200

201

SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)

202

203

# macro for asking qmake to process pro files

204

MACRO(QT_QUERY_QMAKE outvar invar)

205

FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro

206

"message(CMAKE_MESSAGE<$$${invar}>)")

207

208

# Invoke qmake with the tmp.pro program to get the desired

209

# information. Use the same variable for both stdout and stderr

210

# to make sure we get the output on all platforms.

211

EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}

212

WORKING_DIRECTORY

213

${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake

214

OUTPUT_VARIABLE _qmake_query_output

215

RESULT_VARIABLE _qmake_result

216

ERROR_VARIABLE _qmake_query_output )

217

218

FILE(REMOVE_RECURSE

219

"${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake")

220

221

IF(_qmake_result)

222

MESSAGE(WARNING " querying qmake for ${invar}. qmake reported:\n${_qmake_query_output}")

223

ELSE(_qmake_result)

224

STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}")

225

ENDIF(_qmake_result)

226

227

ENDMACRO(QT_QUERY_QMAKE)

228

229

# check for qmake

230

FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 PATHS

231

"[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"

232

"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"

233

$ENV{QTDIR}/bin

234

)

235

236

IF (QT_QMAKE_EXECUTABLE)

237

238

SET(QT4_QMAKE_FOUND FALSE)

239

240

EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)

241

242

# check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path

243

IF("${QTVERSION}" MATCHES "Unknown")

244

SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)

245

FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS

246

"[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"

247

"[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin"

248

$ENV{QTDIR}/bin

249

)

250

IF(QT_QMAKE_EXECUTABLE)

251

EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}

252

ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)

253

ENDIF(QT_QMAKE_EXECUTABLE)

254

ENDIF("${QTVERSION}" MATCHES "Unknown")

255

256

# check that we found the Qt4 qmake, Qt3 qmake output won't match here

257

STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")

258

IF (qt_version_tmp)

259

260

# we need at least version 4.0.0

261

IF (NOT QT_MIN_VERSION)

262

SET(QT_MIN_VERSION "4.0.0")

263

ENDIF (NOT QT_MIN_VERSION)

264

265

#now parse the parts of the user given version string into variables

266

STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}")

267

IF (NOT req_qt_major_vers)

268

MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"")

269

ENDIF (NOT req_qt_major_vers)

270

271

# now parse the parts of the user given version string into variables

272

STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}")

273

STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}")

274

STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}")

275

276

IF (NOT req_qt_major_vers EQUAL 4)

277

MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")

278

ENDIF (NOT req_qt_major_vers EQUAL 4)

279

280

# and now the version string given by qmake

281

STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" found_qt_major_vers "${QTVERSION}")

282

STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" found_qt_minor_vers "${QTVERSION}")

283

STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" found_qt_patch_vers "${QTVERSION}")

284

285

# compute an overall version number which can be compared at once

286

MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")

287

MATH(EXPR found_vers "${found_qt_major_vers}*10000 + ${found_qt_minor_vers}*100 + ${found_qt_patch_vers}")

288

289

IF (found_vers LESS req_vers)

290

SET(QT4_QMAKE_FOUND FALSE)

291

SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)

292

ELSE (found_vers LESS req_vers)

293

SET(QT4_QMAKE_FOUND TRUE)

294

ENDIF (found_vers LESS req_vers)

295

ENDIF (qt_version_tmp)

296

297

ENDIF (QT_QMAKE_EXECUTABLE)

298

299

IF (QT4_QMAKE_FOUND)

300

301

if (WIN32)

302

# get qt install dir

303

get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )

304

get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )

305

endif (WIN32)

306

307

# ask qmake for the library dir

308

# Set QT_LIBRARY_DIR

309

IF (NOT QT_LIBRARY_DIR)

310

EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

311

ARGS "-query QT_INSTALL_LIBS"

312

OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP )

313

IF(EXISTS "${QT_LIBRARY_DIR_TMP}")

314

SET(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir")

315

ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}")

316

MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT_LIBRARY_DIR_TMP}")

317

MESSAGE("Warning: ${QT_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.")

318

ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}")

319

ENDIF(NOT QT_LIBRARY_DIR)

320

321

IF (APPLE)

322

IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)

323

SET(QT_USE_FRAMEWORKS ON

324

CACHE BOOL "Set to ON if Qt build uses frameworks.")

325

ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)

326

SET(QT_USE_FRAMEWORKS OFF

327

CACHE BOOL "Set to ON if Qt build uses frameworks.")

328

ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)

329

330

MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)

331

ENDIF (APPLE)

332

333

# ask qmake for the binary dir

334

IF (NOT QT_BINARY_DIR)

335

EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}

336

ARGS "-query QT_INSTALL_BINS"

337

OUTPUT_VARIABLE qt_bins )

338

SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "")

339

ENDIF (NOT QT_BINARY_DIR)

340

341

# ask qmake for the include dir

342

IF (NOT QT_HEADERS_DIR)

343

EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

344

ARGS "-query QT_INSTALL_HEADERS"

345

OUTPUT_VARIABLE qt_headers )

346

SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "")

347

ENDIF(NOT QT_HEADERS_DIR)

348

349

350

# ask qmake for the documentation directory

351

IF (NOT QT_DOC_DIR)

352

EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

353

ARGS "-query QT_INSTALL_DOCS"

354

OUTPUT_VARIABLE qt_doc_dir )

355

SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs")

356

ENDIF (NOT QT_DOC_DIR)

357

358

# ask qmake for the mkspecs directory

359

IF (NOT QT_MKSPECS_DIR)

360

EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

361

ARGS "-query QMAKE_MKSPECS"

362

OUTPUT_VARIABLE qt_mkspecs_dir )

363

SET(QT_MKSPECS_DIR ${qt_mkspecs_dir} CACHE PATH "The location of the Qt mkspecs")

364

ENDIF (NOT QT_MKSPECS_DIR)

365

366

# ask qmake for the plugins directory

367

IF (NOT QT_PLUGINS_DIR)

368

EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

369

ARGS "-query QT_INSTALL_PLUGINS"

370

OUTPUT_VARIABLE qt_plugins_dir )

371

SET(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins")

372

ENDIF (NOT QT_PLUGINS_DIR)

373

########################################

374

#

375

# Setting the INCLUDE-Variables

376

#

377

########################################

378

379

FIND_PATH(QT_QTCORE_INCLUDE_DIR QtGlobal

380

${QT_HEADERS_DIR}/QtCore

381

${QT_LIBRARY_DIR}/QtCore.framework/Headers

382

NO_DEFAULT_PATH

383

)

384

385

# Set QT_INCLUDE_DIR by removine "/QtCore" in the string ${QT_QTCORE_INCLUDE_DIR}

386

IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)

387

IF (QT_USE_FRAMEWORKS)

388

SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR})

389

ELSE (QT_USE_FRAMEWORKS)

390

STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT_QTCORE_INCLUDE_DIR})

391

SET( QT_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "")

392

ENDIF (QT_USE_FRAMEWORKS)

393

ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)

394

395

IF( NOT QT_INCLUDE_DIR)

396

IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

397

MESSAGE( FATAL_ERROR "Could NOT find QtGlobal header")

398

ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

399

ENDIF( NOT QT_INCLUDE_DIR)

400

401

#############################################

402

#

403

# Find out what window system we're using

404

#

405

#############################################

406

# Save required includes and required_flags variables

407

macro_push_required_vars()

408

# Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES

409

SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_INCLUDE_DIR}")

410

# On Mac OS X when Qt has framework support, also add the framework path

411

IF( QT_USE_FRAMEWORKS )

412

SET(CMAKE_REQUIRED_FLAGS "-F${QT_LIBRARY_DIR} ")

413

ENDIF( QT_USE_FRAMEWORKS )

414

# Check for Window system symbols (note: only one should end up being set)

415

CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11)

416

CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN)

417

CHECK_SYMBOL_EXISTS(Q_WS_QWS "QtCore/qglobal.h" Q_WS_QWS)

418

CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC)

419

420

IF (QT_QTCOPY_REQUIRED)

421

CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY)

422

IF (NOT QT_IS_QTCOPY)

423

MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found")

424

ENDIF (NOT QT_IS_QTCOPY)

425

ENDIF (QT_QTCOPY_REQUIRED)

426

427

# Restore CMAKE_REQUIRED_INCLUDES+CMAKE_REQUIRED_FLAGS variables

428

macro_pop_required_vars()

429

#

430

#############################################

431

432

IF (QT_USE_FRAMEWORKS)

433

SET(QT_DEFINITIONS ${QT_DEFINITIONS} -F${QT_LIBRARY_DIR} -L${QT_LIBRARY_DIR} )

434

ENDIF (QT_USE_FRAMEWORKS)

435

436

# Set QT_QT3SUPPORT_INCLUDE_DIR

437

FIND_PATH(QT_QT3SUPPORT_INCLUDE_DIR Qt3Support

438

PATHS

439

${QT_INCLUDE_DIR}/Qt3Support

440

${QT_LIBRARY_DIR}/Qt3Support.framework/Headers

441

NO_DEFAULT_PATH

442

)

443

444

# Set QT_QT_INCLUDE_DIR

445

FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h

446

PATHS

447

${QT_INCLUDE_DIR}/Qt

448

${QT_LIBRARY_DIR}/QtCore.framework/Headers

449

NO_DEFAULT_PATH

450

)

451

452

# Set QT_QTGUI_INCLUDE_DIR

453

FIND_PATH(QT_QTGUI_INCLUDE_DIR QtGui

454

PATHS

455

${QT_INCLUDE_DIR}/QtGui

456

${QT_LIBRARY_DIR}/QtGui.framework/Headers

457

NO_DEFAULT_PATH

458

)

459

460

# Set QT_QTSVG_INCLUDE_DIR

461

FIND_PATH(QT_QTSVG_INCLUDE_DIR QtSvg

462

PATHS

463

${QT_INCLUDE_DIR}/QtSvg

464

${QT_LIBRARY_DIR}/QtSvg.framework/Headers

465

NO_DEFAULT_PATH

466

)

467

468

# Set QT_QTSCRIPT_INCLUDE_DIR

469

FIND_PATH(QT_QTSCRIPT_INCLUDE_DIR QtScript

470

PATHS

471

${QT_INCLUDE_DIR}/QtScript

472

${QT_LIBRARY_DIR}/QtScript.framework/Headers

473

NO_DEFAULT_PATH

474

)

475

476

# Set QT_QTTEST_INCLUDE_DIR

477

FIND_PATH(QT_QTTEST_INCLUDE_DIR QtTest

478

PATHS

479

${QT_INCLUDE_DIR}/QtTest

480

${QT_LIBRARY_DIR}/QtTest.framework/Headers

481

NO_DEFAULT_PATH

482

)

483

484

# Set QT_QTUITOOLS_INCLUDE_DIR

485

FIND_PATH(QT_QTUITOOLS_INCLUDE_DIR QtUiTools

486

PATHS

487

${QT_INCLUDE_DIR}/QtUiTools

488

${QT_LIBRARY_DIR}/QtUiTools.framework/Headers

489

NO_DEFAULT_PATH

490

)

491

492

493

494

# Set QT_QTMOTIF_INCLUDE_DIR

495

IF(Q_WS_X11)

496

FIND_PATH(QT_QTMOTIF_INCLUDE_DIR QtMotif PATHS ${QT_INCLUDE_DIR}/QtMotif NO_DEFAULT_PATH )

497

ENDIF(Q_WS_X11)

498

499

# Set QT_QTNETWORK_INCLUDE_DIR

500

FIND_PATH(QT_QTNETWORK_INCLUDE_DIR QtNetwork

501

PATHS

502

${QT_INCLUDE_DIR}/QtNetwork

503

${QT_LIBRARY_DIR}/QtNetwork.framework/Headers

504

NO_DEFAULT_PATH

505

)

506

507

# Set QT_QTNSPLUGIN_INCLUDE_DIR

508

FIND_PATH(QT_QTNSPLUGIN_INCLUDE_DIR QtNsPlugin

509

PATHS

510

${QT_INCLUDE_DIR}/QtNsPlugin

511

${QT_LIBRARY_DIR}/QtNsPlugin.framework/Headers

512

NO_DEFAULT_PATH

513

)

514

515

# Set QT_QTOPENGL_INCLUDE_DIR

516

FIND_PATH(QT_QTOPENGL_INCLUDE_DIR QtOpenGL

517

PATHS

518

${QT_INCLUDE_DIR}/QtOpenGL

519

${QT_LIBRARY_DIR}/QtOpenGL.framework/Headers

520

NO_DEFAULT_PATH

521

)

522

523

# Set QT_QTSQL_INCLUDE_DIR

524

FIND_PATH(QT_QTSQL_INCLUDE_DIR QtSql

525

PATHS

526

${QT_INCLUDE_DIR}/QtSql

527

${QT_LIBRARY_DIR}/QtSql.framework/Headers

528

NO_DEFAULT_PATH

529

)

530

531

# Set QT_QTXML_INCLUDE_DIR

532

FIND_PATH(QT_QTXML_INCLUDE_DIR QtXml

533

PATHS

534

${QT_INCLUDE_DIR}/QtXml

535

${QT_LIBRARY_DIR}/QtXml.framework/Headers

536

NO_DEFAULT_PATH

537

)

538

539

# Set QT_QTASSISTANT_INCLUDE_DIR

540

FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant

541

PATHS

542

${QT_INCLUDE_DIR}/QtAssistant

543

${QT_HEADERS_DIR}/QtAssistant

544

NO_DEFAULT_PATH

545

)

546

547

# Set QT_QTDESIGNER_INCLUDE_DIR

548

FIND_PATH(QT_QTDESIGNER_INCLUDE_DIR QDesignerComponents

549

PATHS

550

${QT_INCLUDE_DIR}/QtDesigner

551

${QT_HEADERS_DIR}/QtDesigner

552

NO_DEFAULT_PATH

553

)

554

555

# Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR

556

FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents

557

PATHS

558

${QT_INCLUDE_DIR}/QtDesigner

559

${QT_HEADERS_DIR}/QtDesigner

560

NO_DEFAULT_PATH

561

)

562

563

564

# Set QT_QTDBUS_INCLUDE_DIR

565

FIND_PATH(QT_QTDBUS_INCLUDE_DIR QtDBus

566

PATHS

567

${QT_INCLUDE_DIR}/QtDBus

568

${QT_HEADERS_DIR}/QtDBus

569

NO_DEFAULT_PATH

570

)

571

572

# Make variables changeble to the advanced user

573

MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_INCLUDE_DIR QT_QT_INCLUDE_DIR QT_DOC_DIR QT_MKSPECS_DIR QT_PLUGINS_DIR)

574

575

# Set QT_INCLUDES

576

SET( QT_INCLUDES ${QT_INCLUDE_DIR} ${QT_QT_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default )

577

578

579

########################################

580

#

581

# Setting the LIBRARY-Variables

582

#

583

########################################

584

585

IF (QT_USE_FRAMEWORKS)

586

# If FIND_LIBRARY found libraries in Apple frameworks, we would NOT have

587

# to jump through these hoops.

588

IF(EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)

589

SET(QT_QTCORE_FOUND TRUE)

590

SET(QT_QTCORE_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtCore" CACHE STRING "The QtCore library.")

591

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)

592

SET(QT_QTCORE_FOUND FALSE)

593

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)

594

595

IF(EXISTS ${QT_LIBRARY_DIR}/QtGui.framework)

596

SET(QT_QTGUI_FOUND TRUE)

597

SET(QT_QTGUI_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtGui" CACHE STRING "The QtGui library.")

598

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtGui.framework)

599

SET(QT_QTGUI_FOUND FALSE)

600

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtGui.framework)

601

602

IF(EXISTS ${QT_LIBRARY_DIR}/Qt3Support.framework)

603

SET(QT_QT3SUPPORT_FOUND TRUE)

604

SET(QT_QT3SUPPORT_LIBRARY "-F${QT_LIBRARY_DIR} -framework Qt3Support" CACHE STRING "The Qt3Support library.")

605

ELSE(EXISTS ${QT_LIBRARY_DIR}/Qt3Support.framework)

606

SET(QT_QT3SUPPORT_FOUND FALSE)

607

ENDIF(EXISTS ${QT_LIBRARY_DIR}/Qt3Support.framework)

608

609

IF(EXISTS ${QT_LIBRARY_DIR}/QtNetwork.framework)

610

SET(QT_QTNETWORK_FOUND TRUE)

611

SET(QT_QTNETWORK_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtNetwork" CACHE STRING "The QtNetwork library.")

612

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtNetwork.framework)

613

SET(QT_QTNETWORK_FOUND FALSE)

614

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtNetwork.framework)

615

616

IF(EXISTS ${QT_LIBRARY_DIR}/QtOpenGL.framework)

617

SET(QT_QTOPENGL_FOUND TRUE)

618

SET(QT_QTOPENGL_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtOpenGL" CACHE STRING "The QtOpenGL library.")

619

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtOpenGL.framework)

620

SET(QT_QTOPENGL_FOUND FALSE)

621

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtOpenGL.framework)

622

623

IF(EXISTS ${QT_LIBRARY_DIR}/QtSql.framework)

624

SET(QT_QTSQL_FOUND TRUE)

625

SET(QT_QTSQL_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtSql" CACHE STRING "The QtSql library.")

626

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtSql.framework)

627

SET(QT_QTSQL_FOUND FALSE)

628

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtSql.framework)

629

630

IF(EXISTS ${QT_LIBRARY_DIR}/QtXml.framework)

631

SET(QT_QTXML_FOUND TRUE)

632

SET(QT_QTXML_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtXml" CACHE STRING "The QtXml library.")

633

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtXml.framework)

634

SET(QT_QTXML_FOUND FALSE)

635

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtXml.framework)

636

637

IF(EXISTS ${QT_LIBRARY_DIR}/QtSvg.framework)

638

SET(QT_QTSVG_FOUND TRUE)

639

SET(QT_QTSVG_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtSvg" CACHE STRING "The QtSvg library.")

640

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtSvg.framework)

641

SET(QT_QTSVG_FOUND FALSE)

642

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtSvg.framework)

643

644

IF(EXISTS ${QT_LIBRARY_DIR}/QtDBus.framework)

645

SET(QT_QTDBUS_FOUND TRUE)

646

SET(QT_QTDBUS_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtDBus" CACHE STRING "The QtDBus library.")

647

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtDBus.framework)

648

SET(QT_QTDBUS_FOUND FALSE)

649

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtDBus.framework)

650

651

IF(EXISTS ${QT_LIBRARY_DIR}/QtTest.framework)

652

SET(QT_QTTEST_FOUND TRUE)

653

SET(QT_QTTEST_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtTest" CACHE STRING "The QtTest library.")

654

ELSE(EXISTS ${QT_LIBRARY_DIR}/QtTest.framework)

655

SET(QT_QTTEST_FOUND FALSE)

656

ENDIF(EXISTS ${QT_LIBRARY_DIR}/QtTest.framework)

657

658

# WTF? why don't we have frameworks? :P

659

# Set QT_QTUITOOLS_LIBRARY

660

FIND_LIBRARY(QT_QTUITOOLS_LIBRARY NAMES QtUiTools QtUiTools4 PATHS ${QT_LIBRARY_DIR} )

661

# Set QT_QTSCRIPT_LIBRARY

662

FIND_LIBRARY(QT_QTSCRIPT_LIBRARY NAMES QtScript QtScript4 PATHS ${QT_LIBRARY_DIR} )

663

664

ELSE (QT_USE_FRAMEWORKS)

665

666

# Set QT_QTCORE_LIBRARY by searching for a lib with "QtCore." as part of the filename

667

FIND_LIBRARY(QT_QTCORE_LIBRARY NAMES QtCore QtCore4 QtCored4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH )

668

669

# Set QT_QT3SUPPORT_LIBRARY

670

FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY NAMES Qt3Support Qt3Support4 Qt3Supportd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

671

672

# Set QT_QTGUI_LIBRARY

673

FIND_LIBRARY(QT_QTGUI_LIBRARY NAMES QtGui QtGui4 QtGuid4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

674

675

# Set QT_QTMOTIF_LIBRARY

676

IF(Q_WS_X11)

677

FIND_LIBRARY(QT_QTMOTIF_LIBRARY NAMES QtMotif PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

678

ENDIF(Q_WS_X11)

679

680

# Set QT_QTNETWORK_LIBRARY

681

FIND_LIBRARY(QT_QTNETWORK_LIBRARY NAMES QtNetwork QtNetwork4 QtNetworkd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

682

683

# Set QT_QTNSPLUGIN_LIBRARY

684

FIND_LIBRARY(QT_QTNSPLUGIN_LIBRARY NAMES QtNsPlugin PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

685

686

# Set QT_QTOPENGL_LIBRARY

687

FIND_LIBRARY(QT_QTOPENGL_LIBRARY NAMES QtOpenGL QtOpenGL4 QtOpenGLd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

688

689

# Set QT_QTSQL_LIBRARY

690

FIND_LIBRARY(QT_QTSQL_LIBRARY NAMES QtSql QtSql4 QtSqld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

691

692

# Set QT_QTXML_LIBRARY

693

FIND_LIBRARY(QT_QTXML_LIBRARY NAMES QtXml QtXml4 QtXmld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

694

695

# Set QT_QTSVG_LIBRARY

696

FIND_LIBRARY(QT_QTSVG_LIBRARY NAMES QtSvg QtSvg4 QtSvgd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

697

698

# Set QT_QTSCRIPT_LIBRARY

699

FIND_LIBRARY(QT_QTSCRIPT_LIBRARY NAMES QtScript QtScript4 QtScriptd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

700

701

# Set QT_QTUITOOLS_LIBRARY

702

FIND_LIBRARY(QT_QTUITOOLS_LIBRARY NAMES QtUiTools QtUiTools4 QtUiToolsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

703

704

# Set QT_QTTEST_LIBRARY

705

FIND_LIBRARY(QT_QTTEST_LIBRARY NAMES QtTest QtTest4 QtTestd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

706

707

FIND_LIBRARY(QT_QTDBUS_LIBRARY NAMES QtDBus QtDBus4 QtDBusd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

708

709

IF(MSVC)

710

FIND_LIBRARY(QT_QTCORE_LIBRARY_RELEASE NAMES QtCore4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

711

FIND_LIBRARY(QT_QTCORE_LIBRARY_DEBUG NAMES QtCored4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

712

FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY_RELEASE NAMES Qt3Support4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

713

FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY_DEBUG NAMES Qt3Supportd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

714

FIND_LIBRARY(QT_QTGUI_LIBRARY_RELEASE NAMES QtGui4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

715

FIND_LIBRARY(QT_QTGUI_LIBRARY_DEBUG NAMES QtGuid4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

716

FIND_LIBRARY(QT_QTNETWORK_LIBRARY_RELEASE NAMES QtNetwork4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

717

FIND_LIBRARY(QT_QTNETWORK_LIBRARY_DEBUG NAMES QtNetworkd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

718

FIND_LIBRARY(QT_QTOPENGL_LIBRARY_RELEASE NAMES QtOpenGL4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

719

FIND_LIBRARY(QT_QTOPENGL_LIBRARY_DEBUG NAMES QtOpenGLd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

720

FIND_LIBRARY(QT_QTSQL_LIBRARY_RELEASE NAMES QtSql4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

721

FIND_LIBRARY(QT_QTSQL_LIBRARY_DEBUG NAMES QtSqld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

722

FIND_LIBRARY(QT_QTXML_LIBRARY_RELEASE NAMES QtXml4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

723

FIND_LIBRARY(QT_QTXML_LIBRARY_DEBUG NAMES QtXmld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

724

FIND_LIBRARY(QT_QTSVG_LIBRARY_RELEASE NAMES QtSvg4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

725

FIND_LIBRARY(QT_QTSVG_LIBRARY_DEBUG NAMES QtSvgd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

726

FIND_LIBRARY(QT_QTSCRIPT_LIBRARY_RELEASE NAMES QtScript4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

727

FIND_LIBRARY(QT_QTSCRIPT_LIBRARY_DEBUG NAMES QtScriptd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

728

FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_RELEASE NAMES QtUiTools QtUiTools4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

729

FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_DEBUG NAMES QtUiToolsd QtUiToolsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

730

FIND_LIBRARY(QT_QTTEST_LIBRARY_RELEASE NAMES QtTest4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

731

FIND_LIBRARY(QT_QTTEST_LIBRARY_DEBUG NAMES QtTestd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

732

FIND_LIBRARY(QT_QTDBUS_LIBRARY_RELEASE NAMES QtDBus4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

733

FIND_LIBRARY(QT_QTDBUS_LIBRARY_DEBUG NAMES QtDBusd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

734

FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_RELEASE NAMES QtAssistantClient4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

735

FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_DEBUG NAMES QtAssistantClientd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

736

FIND_LIBRARY(QT_QTDESIGNER_LIBRARY_RELEASE NAMES QtDesigner4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

737

FIND_LIBRARY(QT_QTDESIGNER_LIBRARY_DEBUG NAMES QtDesignerd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

738

FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_RELEASE NAMES QtDesignerComponents4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

739

FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY_DEBUG NAMES QtDesignerComponentsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

740

FIND_LIBRARY(QT_QTMAIN_LIBRARY_RELEASE NAMES qtmain PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

741

FIND_LIBRARY(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmaind PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

742

ENDIF(MSVC)

743

ENDIF (QT_USE_FRAMEWORKS)

744

745

IF( NOT QT_QTCORE_LIBRARY )

746

IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

747

MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check CMakeFiles/CMakeError.log for more details.")

748

ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

749

ENDIF( NOT QT_QTCORE_LIBRARY )

750

751

# Set QT_QTASSISTANT_LIBRARY

752

FIND_LIBRARY(QT_QTASSISTANT_LIBRARY NAMES QtAssistantClient QtAssistantClient4 QtAssistant QtAssistant4 QtAssistantd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

753

754

# Set QT_QTDESIGNER_LIBRARY

755

FIND_LIBRARY(QT_QTDESIGNER_LIBRARY NAMES QtDesigner QtDesigner4 QtDesignerd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

756

757

# Set QT_QTDESIGNERCOMPONENTS_LIBRARY

758

FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY NAMES QtDesignerComponents QtDesignerComponents4 QtDesignerComponentsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

759

760

# Set QT_QTMAIN_LIBRARY

761

IF(WIN32)

762

FIND_LIBRARY(QT_QTMAIN_LIBRARY NAMES qtmain qtmaind PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH)

763

ENDIF(WIN32)

764

765

############################################

766

#

767

# Check the existence of the libraries.

768

#

769

############################################

770

771

MACRO (_QT4_ADJUST_LIB_VARS basename)

772

IF (QT_${basename}_LIBRARY OR QT_${basename}_LIBRARY_DEBUG)

773

774

IF(MSVC)

775

# Both set

776

IF (QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)

777

SET(QT_${basename}_LIBRARY optimized ${QT_${basename}_LIBRARY_RELEASE} debug ${QT_${basename}_LIBRARY_DEBUG})

778

ENDIF (QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)

779

780

# Only debug was found

781

IF (NOT QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)

782

SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_DEBUG})

783

ENDIF (NOT QT_${basename}_LIBRARY_RELEASE AND QT_${basename}_LIBRARY_DEBUG)

784

785

# Only release was found

786

IF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)

787

SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_RELEASE})

788

ENDIF (QT_${basename}_LIBRARY_RELEASE AND NOT QT_${basename}_LIBRARY_DEBUG)

789

790

# Hmm, is this used anywhere ? Yes, in UseQt4.cmake. We are currently incompatible :-(

791

SET(QT_${basename}_LIBRARIES optimized ${QT_${basename}_LIBRARY} debug ${QT_${basename}_LIBRARY_DEBUG})

792

793

ENDIF(MSVC)

794

795

SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY} CACHE FILEPATH "The Qt ${basename} library")

796

797

IF (QT_${basename}_LIBRARY)

798

SET(QT_${basename}_FOUND 1)

799

ENDIF (QT_${basename}_LIBRARY)

800

801

ENDIF (QT_${basename}_LIBRARY OR QT_${basename}_LIBRARY_DEBUG)

802

803

IF (QT_${basename}_INCLUDE_DIR)

804

#add the include directory to QT_INCLUDES

805

SET(QT_INCLUDES ${QT_INCLUDES} "${QT_${basename}_INCLUDE_DIR}")

806

ENDIF (QT_${basename}_INCLUDE_DIR)

807

808

# Make variables changeble to the advanced user

809

MARK_AS_ADVANCED(QT_${basename}_LIBRARY QT_${basename}_INCLUDE_DIR)

810

ENDMACRO (_QT4_ADJUST_LIB_VARS)

811

812

813

# Set QT_xyz_LIBRARY variable and add

814

# library include path to QT_INCLUDES

815

_QT4_ADJUST_LIB_VARS(QTCORE)

816

_QT4_ADJUST_LIB_VARS(QTGUI)

817

_QT4_ADJUST_LIB_VARS(QT3SUPPORT)

818

_QT4_ADJUST_LIB_VARS(QTASSISTANT)

819

_QT4_ADJUST_LIB_VARS(QTDESIGNER)

820

_QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS)

821

_QT4_ADJUST_LIB_VARS(QTNETWORK)

822

_QT4_ADJUST_LIB_VARS(QTNSPLUGIN)

823

_QT4_ADJUST_LIB_VARS(QTOPENGL)

824

_QT4_ADJUST_LIB_VARS(QTSQL)

825

_QT4_ADJUST_LIB_VARS(QTXML)

826

_QT4_ADJUST_LIB_VARS(QTSVG)

827

_QT4_ADJUST_LIB_VARS(QTSCRIPT)

828

_QT4_ADJUST_LIB_VARS(QTUITOOLS)

829

_QT4_ADJUST_LIB_VARS(QTTEST)

830

_QT4_ADJUST_LIB_VARS(QTDBUS)

831

832

833

# platform dependent libraries

834

IF(Q_WS_X11)

835

_QT4_ADJUST_LIB_VARS(QTMOTIF)

836

ENDIF(Q_WS_X11)

837

IF(WIN32)

838

_QT4_ADJUST_LIB_VARS(QTMAIN)

839

ENDIF(WIN32)

840

841

842

#######################################

843

#

844

# Check the executables of Qt

845

# ( moc, uic, rcc )

846

#

847

#######################################

848

849

850

# find moc and uic using qmake

851

QT_QUERY_QMAKE(QT_MOC_EXECUTABLE_INTERNAL "QMAKE_MOC")

852

QT_QUERY_QMAKE(QT_UIC_EXECUTABLE_INTERNAL "QMAKE_UIC")

853

854

FILE(TO_CMAKE_PATH

855

"${QT_MOC_EXECUTABLE_INTERNAL}" QT_MOC_EXECUTABLE_INTERNAL)

856

FILE(TO_CMAKE_PATH

857

"${QT_UIC_EXECUTABLE_INTERNAL}" QT_UIC_EXECUTABLE_INTERNAL)

858

859

SET(QT_MOC_EXECUTABLE

860

${QT_MOC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The moc executable")

861

SET(QT_UIC_EXECUTABLE

862

${QT_UIC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The uic executable")

863

864

FIND_PROGRAM(QT_UIC3_EXECUTABLE

865

NAMES uic3

866

PATHS ${QT_BINARY_DIR}

867

NO_DEFAULT_PATH

868

)

869

870

FIND_PROGRAM(QT_RCC_EXECUTABLE

871

NAMES rcc

872

PATHS ${QT_BINARY_DIR}

873

NO_DEFAULT_PATH

874

)

875

876

FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE

877

NAMES qdbuscpp2xml

878

PATHS ${QT_BINARY_DIR}

879

NO_DEFAULT_PATH

880

)

881

882

FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE

883

NAMES qdbusxml2cpp

884

PATHS ${QT_BINARY_DIR}

885

NO_DEFAULT_PATH

886

)

887

888

IF (QT_MOC_EXECUTABLE)

889

SET(QT_WRAP_CPP "YES")

890

ENDIF (QT_MOC_EXECUTABLE)

891

892

IF (QT_UIC_EXECUTABLE)

893

SET(QT_WRAP_UI "YES")

894

ENDIF (QT_UIC_EXECUTABLE)

895

896

897

898

MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE)

899

900

######################################

901

#

902

# Macros for building Qt files

903

#

904

######################################

905

906

MACRO (QT4_GET_MOC_INC_DIRS _moc_INC_DIRS)

907

SET(${_moc_INC_DIRS})

908

GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)

909

910

FOREACH(_current ${_inc_DIRS})

911

SET(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-I" ${_current})

912

ENDFOREACH(_current ${_inc_DIRS})

913

ENDMACRO(QT4_GET_MOC_INC_DIRS)

914

915

916

MACRO (QT4_GENERATE_MOC infile outfile )

917

# get include dirs

918

QT4_GET_MOC_INC_DIRS(moc_includes)

919

920

GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE)

921

922

IF (MSVC_IDE)

923

SET (_moc_parameter_file ${outfile}_parameters)

924

SET (_moc_param "${moc_includes} \n-o${outfile} \n${abs_infile}")

925

STRING(REGEX REPLACE ";-I;" "\\n-I" _moc_param "${_moc_param}")

926

FILE (WRITE ${_moc_parameter_file} "${_moc_param}")

927

ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

928

COMMAND ${QT_MOC_EXECUTABLE}

929

ARGS @"${_moc_parameter_file}"

930

DEPENDS ${abs_infile})

931

ELSE (MSVC_IDE)

932

ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

933

COMMAND ${QT_MOC_EXECUTABLE}

934

ARGS ${moc_includes} -o ${outfile} ${abs_infile}

935

DEPENDS ${abs_infile})

936

ENDIF (MSVC_IDE)

937

938

SET_SOURCE_FILES_PROPERTIES(${outfile} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file

939

940

MACRO_ADD_FILE_DEPENDENCIES(${abs_infile} ${outfile})

941

ENDMACRO (QT4_GENERATE_MOC)

942

943

944

# QT4_WRAP_CPP(outfiles inputfile ... )

945

# TODO perhaps add support for -D, -U and other minor options

946

947

MACRO (QT4_WRAP_CPP outfiles )

948

# get include dirs

949

QT4_GET_MOC_INC_DIRS(moc_includes)

950

951

FOREACH (it ${ARGN})

952

GET_FILENAME_COMPONENT(it ${it} ABSOLUTE)

953

GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)

954

955

SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/moc_${outfile}.cxx)

956

ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

957

COMMAND ${QT_MOC_EXECUTABLE}

958

ARGS ${moc_includes} -o ${outfile} ${it}

959

DEPENDS ${it})

960

SET(${outfiles} ${${outfiles}} ${outfile})

961

ENDFOREACH(it)

962

963

ENDMACRO (QT4_WRAP_CPP)

964

965

966

# QT4_WRAP_UI(outfiles inputfile ... )

967

968

MACRO (QT4_WRAP_UI outfiles )

969

970

FOREACH (it ${ARGN})

971

GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)

972

GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)

973

SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.h)

974

ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

975

COMMAND ${QT_UIC_EXECUTABLE}

976

ARGS -o ${outfile} ${infile}

977

MAIN_DEPENDENCY ${infile})

978

SET(${outfiles} ${${outfiles}} ${outfile})

979

ENDFOREACH (it)

980

981

ENDMACRO (QT4_WRAP_UI)

982

983

984

# QT4_ADD_RESOURCES(outfiles inputfile ... )

985

# TODO perhaps consider adding support for compression and root options to rcc

986

987

MACRO (QT4_ADD_RESOURCES outfiles )

988

989

FOREACH (it ${ARGN})

990

GET_FILENAME_COMPONENT(outfilename ${it} NAME_WE)

991

GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)

992

GET_FILENAME_COMPONENT(rc_path ${infile} PATH)

993

SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cxx)

994

# parse file for dependencies

995

# all files are absolute paths or relative to the location of the qrc file

996

FILE(READ "${infile}" _RC_FILE_CONTENTS)

997

STRING(REGEX MATCHALL "<file[^<]+" _RC_FILES "${_RC_FILE_CONTENTS}")

998

SET(_RC_DEPENDS)

999

FOREACH(_RC_FILE ${_RC_FILES})

1000

STRING(REGEX REPLACE "^<file[^>]*>" "" _RC_FILE "${_RC_FILE}")

1001

STRING(REGEX MATCH "^/|([A-Za-z]:/)" _ABS_PATH_INDICATOR "${_RC_FILE}")

1002

IF(NOT _ABS_PATH_INDICATOR)

1003

SET(_RC_FILE "${rc_path}/${_RC_FILE}")

1004

ENDIF(NOT _ABS_PATH_INDICATOR)

1005

SET(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")

1006

ENDFOREACH(_RC_FILE)

1007

ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

1008

COMMAND ${QT_RCC_EXECUTABLE}

1009

ARGS -name ${outfilename} -o ${outfile} ${infile}

1010

MAIN_DEPENDENCY ${infile}

1011

DEPENDS ${_RC_DEPENDS})

1012

SET(${outfiles} ${${outfiles}} ${outfile})

1013

ENDFOREACH (it)

1014

1015

ENDMACRO (QT4_ADD_RESOURCES)

1016

1017

MACRO(QT4_ADD_DBUS_INTERFACE _sources _interface _basename)

1018

GET_FILENAME_COMPONENT(_infile ${_interface} ABSOLUTE)

1019

SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)

1020

SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)

1021

SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)

1022

1023

GET_SOURCE_FILE_PROPERTY(_nonamespace ${_interface} NO_NAMESPACE)

1024

IF ( _nonamespace )

1025

SET(_params -N -m)

1026

ELSE ( _nonamespace )

1027

SET(_params -m)

1028

ENDIF ( _nonamespace )

1029

1030

GET_SOURCE_FILE_PROPERTY(_include ${_interface} INCLUDE)

1031

IF ( _include )

1032

SET(_params ${_params} -i ${_include})

1033

ENDIF ( _include )

1034

1035

ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}

1036

COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} ${_params} -p ${_basename} ${_infile}

1037

DEPENDS ${_infile})

1038

1039

SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)

1040

1041

QT4_GENERATE_MOC(${_header} ${_moc})

1042

1043

SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})

1044

MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})

1045

1046

ENDMACRO(QT4_ADD_DBUS_INTERFACE)

1047

1048

MACRO(QT4_ADD_DBUS_INTERFACES _sources)

1049

FOREACH (_current_FILE ${ARGN})

1050

GET_FILENAME_COMPONENT(_infile ${_current_FILE} ABSOLUTE)

1051

# get the part before the ".xml" suffix

1052

STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2" _basename ${_current_FILE})

1053

STRING(TOLOWER ${_basename} _basename)

1054

QT4_ADD_DBUS_INTERFACE(${_sources} ${_infile} ${_basename}interface)

1055

ENDFOREACH (_current_FILE)

1056

ENDMACRO(QT4_ADD_DBUS_INTERFACES)

1057

1058

MACRO(QT4_ADD_DBUS_INTERFACE_NO_NAMESPACE _sources _interface _basename)

1059

MESSAGE(SEND_ERROR "QT4_ADD_DBUS_INTERFACE_NO_NAMESPACE() is deprecated. Use the following instead:

1060

SET_SOURCE_FILES_PROPERTIES(<interface> PROPERTIES NO_NAMESPACE TRUE)

1061

QT4_ADD_DBUS_INTERFACE(<srcList> <interface> <basename>)\n")

1062

ENDMACRO(QT4_ADD_DBUS_INTERFACE_NO_NAMESPACE)

1063

1064

MACRO(QT4_ADD_DBUS_INTERFACES_NO_NAMESPACE _sources)

1065

MESSAGE(SEND_ERROR "QT4_ADD_DBUS_INTERFACES_NO_NAMESPACE() is deprecated. Use the following instead:

1066

SET_SOURCE_FILES_PROPERTIES(<files> PROPERTIES NO_NAMESPACE TRUE)

1067

QT4_ADD_DBUS_INTERFACES(<srcList> <files>)\n")

1068

ENDMACRO(QT4_ADD_DBUS_INTERFACES_NO_NAMESPACE)

1069

1070

MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName )

1071

SET(_customName "${ARGV1}")

1072

GET_FILENAME_COMPONENT(_in_file ${_header} ABSOLUTE)

1073

GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE)

1074

1075

IF (_customName)

1076

SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})

1077

ELSE (_customName)

1078

SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml)

1079

ENDIF (_customName)

1080

1081

ADD_CUSTOM_COMMAND(OUTPUT ${_target}

1082

COMMAND ${QT_DBUSCPP2XML_EXECUTABLE} ${_in_file} > ${_target}

1083

DEPENDS ${_in_file}

1084

)

1085

ENDMACRO(QT4_GENERATE_DBUS_INTERFACE)

1086

1087

1088

MACRO(QT4_ADD_DBUS_ADAPTOR _sources _xml_file _include _parentClass) # _optionalBasename _optionalClassName)

1089

GET_FILENAME_COMPONENT(_infile ${_xml_file} ABSOLUTE)

1090

1091

SET(_optionalBasename "${ARGV4}")

1092

IF (_optionalBasename)

1093

SET(_basename ${_optionalBasename} )

1094

ELSE (_optionalBasename)

1095

STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _basename ${_infile})

1096

STRING(TOLOWER ${_basename} _basename)

1097

ENDIF (_optionalBasename)

1098

1099

SET(_optionalClassName "${ARGV5}")

1100

SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)

1101

SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)

1102

SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)

1103

1104

IF(_optionalClassName)

1105

ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}

1106

COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -c ${_optionalClassName} -i ${_include} -l ${_parentClass} ${_infile}

1107

DEPENDS ${_infile}

1108

)

1109

ELSE(_optionalClassName)

1110

ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}

1111

COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -i ${_include} -l ${_parentClass} ${_infile}

1112

DEPENDS ${_infile}

1113

)

1114

ENDIF(_optionalClassName)

1115

1116

QT4_GENERATE_MOC(${_header} ${_moc})

1117

SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)

1118

MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})

1119

1120

SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})

1121

ENDMACRO(QT4_ADD_DBUS_ADAPTOR)

1122

1123

MACRO(QT4_AUTOMOC)

1124

QT4_GET_MOC_INC_DIRS(_moc_INCS)

1125

1126

SET(_matching_FILES )

1127

FOREACH (_current_FILE ${ARGN})

1128

1129

GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE)

1130

# if "SKIP_AUTOMOC" is set to true, we will not handle this file here.

1131

# here. this is required to make bouic work correctly:

1132

# we need to add generated .cpp files to the sources (to compile them),

1133

# but we cannot let automoc handle them, as the .cpp files don't exist yet when

1134

# cmake is run for the very first time on them -> however the .cpp files might

1135

# exist at a later run. at that time we need to skip them, so that we don't add two

1136

# different rules for the same moc file

1137

GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC)

1138

1139

IF ( NOT _skip AND EXISTS ${_abs_FILE} )

1140

1141

FILE(READ ${_abs_FILE} _contents)

1142

1143

GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH)

1144

1145

STRING(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}")

1146

IF(_match)

1147

FOREACH (_current_MOC_INC ${_match})

1148

STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}")

1149

1150

GET_filename_component(_basename ${_current_MOC} NAME_WE)

1151

# SET(_header ${CMAKE_CURRENT_SOURCE_DIR}/${_basename}.h)

1152

SET(_header ${_abs_PATH}/${_basename}.h)

1153

SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC})

1154

ADD_CUSTOM_COMMAND(OUTPUT ${_moc}

1155

COMMAND ${QT_MOC_EXECUTABLE}

1156

ARGS ${_moc_INCS} ${_header} -o ${_moc}

1157

DEPENDS ${_header}

1158

)

1159

1160

MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc})

1161

ENDFOREACH (_current_MOC_INC)

1162

ENDIF(_match)

1163

ENDIF ( NOT _skip AND EXISTS ${_abs_FILE} )

1164

ENDFOREACH (_current_FILE)

1165

ENDMACRO(QT4_AUTOMOC)

1166

1167

1168

1169

######################################

1170

#

1171

# decide if Qt got found

1172

#

1173

######################################

1174

1175

# if the includes,libraries,moc,uic and rcc are found then we have it

1176

IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)

1177

SET( QT4_FOUND "YES" )

1178

IF( NOT Qt4_FIND_QUIETLY)

1179

IF (WIN32)

1180

MESSAGE(STATUS "Found Qt-Version ${QTVERSION} with qmake at ${QT_QMAKE_EXECUTABLE}")

1181

ELSE (WIN32)

1182

MESSAGE(STATUS "Found Qt-Version ${QTVERSION}")

1183

ENDIF (WIN32)

1184

ENDIF( NOT Qt4_FIND_QUIETLY)

1185

ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)

1186

SET( QT4_FOUND "NO")

1187

SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)

1188

IF( Qt4_FIND_REQUIRED)

1189

IF ( NOT QT_LIBRARY_DIR )

1190

MESSAGE(STATUS "Qt libraries NOT found!")

1191

ENDIF(NOT QT_LIBRARY_DIR )

1192

IF ( NOT QT_INCLUDE_DIR )

1193

MESSAGE(STATUS "Qt includes NOT found!")

1194

ENDIF( NOT QT_INCLUDE_DIR )

1195

IF ( NOT QT_MOC_EXECUTABLE )

1196

MESSAGE(STATUS "Qt's moc NOT found!")

1197

ENDIF( NOT QT_MOC_EXECUTABLE )

1198

IF ( NOT QT_UIC_EXECUTABLE )

1199

MESSAGE(STATUS "Qt's uic NOT found!")

1200

ENDIF( NOT QT_UIC_EXECUTABLE )

1201

IF ( NOT QT_RCC_EXECUTABLE )

1202

MESSAGE(STATUS "Qt's rcc NOT found!")

1203

ENDIF( NOT QT_RCC_EXECUTABLE )

1204

MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")

1205

ENDIF( Qt4_FIND_REQUIRED)

1206

ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE)

1207

SET(QT_FOUND ${QT4_FOUND})

1208

1209

1210

#######################################

1211

#

1212

# System dependent settings

1213

#

1214

#######################################

1215

# for unix add X11 stuff

1216

IF(UNIX)

1217

# on OS X X11 may not be required

1218

IF (Q_WS_X11)

1219

FIND_PACKAGE(X11 REQUIRED)

1220

ENDIF (Q_WS_X11)

1221

FIND_PACKAGE(Threads)

1222

SET(QT_QTCORE_LIBRARY ${QT_QTCORE_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})

1223

ENDIF(UNIX)

1224

1225

1226

#######################################

1227

#

1228

# compatibility settings

1229

#

1230

#######################################

1231

# Backwards compatibility for CMake1.4 and 1.2

1232

SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )

1233

SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )

1234

1235

SET( QT_QT_LIBRARY "")

1236

1237

ELSE(QT4_QMAKE_FOUND)

1238

1239

SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)

1240

IF(Qt4_FIND_REQUIRED)

1241

IF(QT4_INSTALLED_VERSION_TOO_OLD)

1242

MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")

1243

ELSE(QT4_INSTALLED_VERSION_TOO_OLD)

1244

MESSAGE( FATAL_ERROR "Qt qmake not found!")

1245

ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)

1246

ELSE(Qt4_FIND_REQUIRED)

1247

IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)

1248

MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")

1249

ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)

1250

ENDIF(Qt4_FIND_REQUIRED)

1251

1252

ENDIF (QT4_QMAKE_FOUND)

1253

ENDIF (QT4_QMAKE_FOUND)

1254