~ubuntu-branches/ubuntu/karmic/qimageblitz/karmic : revision 4

1

--- a/cmake/modules/FindQt4.cmake

2

+++ /dev/null

3

@@ -1,1254 +0,0 @@

4

-# - Find QT 4

5

-# This module can be used to find Qt4.

6

-# The most important issue is that the Qt4 qmake is available via the system path.

7

-# This qmake is then used to detect basically everything else.

8

-# This module defines a number of key variables and macros. First is

9

-# QT_USE_FILE which is the path to a CMake file that can be included to compile

10

-# Qt 4 applications and libraries. By default, the QtCore and QtGui

11

-# libraries are loaded. This behavior can be changed by setting one or more

12

-# of the following variables to true:

13

-# QT_DONT_USE_QTCORE

14

-# QT_DONT_USE_QTGUI

15

-# QT_USE_QT3SUPPORT

16

-# QT_USE_QTASSISTANT

17

-# QT_USE_QTDESIGNER

18

-# QT_USE_QTMOTIF

19

-# QT_USE_QTMAIN

20

-# QT_USE_QTNETWORK

21

-# QT_USE_QTNSPLUGIN

22

-# QT_USE_QTOPENGL

23

-# QT_USE_QTSQL

24

-# QT_USE_QTXML

25

-# QT_USE_QTSVG

26

-# QT_USE_QTTEST

27

-# QT_USE_QTUITOOLS

28

-# QT_USE_QTDBUS

29

-# QT_USE_QTSCRIPT

30

-#

31

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

32

-# Add this variable to your TARGET_LINK_LIBRARIES.

33

-#

34

-# macro QT4_WRAP_CPP(outfiles inputfile ... )

35

-# macro QT4_WRAP_UI(outfiles inputfile ... )

36

-# macro QT4_ADD_RESOURCES(outfiles inputfile ... )

37

-# macro QT4_AUTOMOC(inputfile ... )

38

-# macro QT4_GENERATE_MOC(inputfile outputfile )

39

-#

40

-# macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)

41

-# create a the interface header and implementation files with the

42

-# given basename from the given interface xml file and add it to

43

-# the list of sources.

44

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

45

-# NO_NAMESPACE to TRUE on the interface file.

46

-#

47

-# macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )

48

-# create the interface header and implementation files

49

-# for all listed interface xml files

50

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

51

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

52

-# NO_NAMESPACE to TRUE for these inputfiles.

53

-#

54

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

55

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

56

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

57

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

58

-# parentclassname. The name of the generated files will be

59

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

60

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

61

-# adaptor itself.

62

-#

63

-# macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] )

64

-# generate the xml interface file from the given header.

65

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

66

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

67

-# the suffix .xml appended.

68

-#

69

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

70

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

71

-#

72

-# QT_QTCORE_FOUND True if QtCore was found.

73

-# QT_QTGUI_FOUND True if QtGui was found.

74

-# QT_QT3SUPPORT_FOUND True if Qt3Support was found.

75

-# QT_QTASSISTANT_FOUND True if QtAssistant was found.

76

-# QT_QTDBUS_FOUND True if QtDBus was found.

77

-# QT_QTDESIGNER_FOUND True if QtDesigner was found.

78

-# QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found.

79

-# QT_QTMOTIF_FOUND True if QtMotif was found.

80

-# QT_QTNETWORK_FOUND True if QtNetwork was found.

81

-# QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found.

82

-# QT_QTOPENGL_FOUND True if QtOpenGL was found.

83

-# QT_QTSQL_FOUND True if QtSql was found.

84

-# QT_QTXML_FOUND True if QtXml was found.

85

-# QT_QTSVG_FOUND True if QtSvg was found.

86

-# QT_QTSCRIPT_FOUND True if QtScript was found.

87

-# QT_QTTEST_FOUND True if QtTest was found.

88

-# QT_QTUITOOLS_FOUND True if QtUiTools was found.

89

-#

90

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

91

-#

92

-# QT_INCLUDES List of paths to all include directories of

93

-# Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are

94

-# always in this variable even if NOTFOUND,

95

-# all other INCLUDE_DIRS are

96

-# only added if they are found.

97

-#

98

-# QT_INCLUDE_DIR Path to "include" of Qt4

99

-# QT_QT_INCLUDE_DIR Path to "include/Qt"

100

-# QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support"

101

-# QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant"

102

-# QT_QTCORE_INCLUDE_DIR Path to "include/QtCore"

103

-# QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner"

104

-# QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner"

105

-# QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus"

106

-# QT_QTGUI_INCLUDE_DIR Path to "include/QtGui"

107

-# QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif"

108

-# QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork"

109

-# QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin"

110

-# QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL"

111

-# QT_QTSQL_INCLUDE_DIR Path to "include/QtSql"

112

-# QT_QTXML_INCLUDE_DIR Path to "include/QtXml"

113

-# QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg"

114

-# QT_QTSCRIPT_INCLUDE_DIR Path to "include/QtScript"

115

-# QT_QTTEST_INCLUDE_DIR Path to "include/QtTest"

116

-#

117

-# QT_LIBRARY_DIR Path to "lib" of Qt4

118

-#

119

-# QT_PLUGINS_DIR Path to "plugins" for Qt4

120

-#

121

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

122

-#

123

-# So there are the following variables:

124

-# The Qt3Support library: QT_QT3SUPPORT_LIBRARY

125

-#

126

-# The QtAssistant library: QT_QTASSISTANT_LIBRARY

127

-#

128

-# The QtCore library: QT_QTCORE_LIBRARY

129

-#

130

-# The QtDBus library: QT_QTDBUS_LIBRARY

131

-#

132

-# The QtDesigner library: QT_QTDESIGNER_LIBRARY

133

-#

134

-# The QtDesignerComponents library: QT_QTDESIGNERCOMPONENTS_LIBRARY

135

-#

136

-# The QtGui library: QT_QTGUI_LIBRARY

137

-#

138

-# The QtMotif library: QT_QTMOTIF_LIBRARY

139

-#

140

-# The QtNetwork library: QT_QTNETWORK_LIBRARY

141

-#

142

-# The QtNsPLugin library: QT_QTNSPLUGIN_LIBRARY

143

-#

144

-# The QtOpenGL library: QT_QTOPENGL_LIBRARY

145

-#

146

-# The QtSql library: QT_QTSQL_LIBRARY

147

-#

148

-# The QtXml library: QT_QTXML_LIBRARY

149

-#

150

-# The QtSvg library: QT_QTSVG_LIBRARY

151

-#

152

-# The QtScript library: QT_QTSCRIPT_LIBRARY

153

-#

154

-# The QtTest library: QT_QTTEST_LIBRARY

155

-#

156

-# The qtmain library for Windows QT_QTMAIN_LIBRARY

157

-#

158

-# The QtUiTools library: QT_QTUITOOLS_LIBRARY

159

-#

160

-# also defined, but NOT for general use are

161

-# QT_MOC_EXECUTABLE Where to find the moc tool.

162

-# QT_UIC_EXECUTABLE Where to find the uic tool.

163

-# QT_UIC3_EXECUTABLE Where to find the uic3 tool.

164

-# QT_RCC_EXECUTABLE Where to find the rcc tool

165

-# QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool.

166

-# QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool.

167

-#

168

-# QT_DOC_DIR Path to "doc" of Qt4

169

-# QT_MKSPECS_DIR Path to "mkspecs" of Qt4

170

-#

171

-#

172

-# These are around for backwards compatibility

173

-# they will be set

174

-# QT_WRAP_CPP Set true if QT_MOC_EXECUTABLE is found

175

-# QT_WRAP_UI Set true if QT_UIC_EXECUTABLE is found

176

-#

177

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

178

-# QT_MT_REQUIRED Qt4 is now always multithreaded

179

-#

180

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

181

-# (They make no sense in Qt4)

182

-# QT_QT_LIBRARY Qt-Library is now split

183

-

184

185

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

186

-

187

-if (QT4_QMAKE_FOUND)

188

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

189

-

190

-else (QT4_QMAKE_FOUND)

191

-

192

-INCLUDE(CheckSymbolExists)

193

-INCLUDE(MacroAddFileDependencies)

194

-INCLUDE(MacroPushRequiredVars)

195

-

196

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

197

-

198

-SET( QT_DEFINITIONS "")

199

-

200

-IF (WIN32)

201

- SET(QT_DEFINITIONS -DQT_DLL)

202

-ENDIF(WIN32)

203

-

204

-SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE)

205

-

206

-# macro for asking qmake to process pro files

207

-MACRO(QT_QUERY_QMAKE outvar invar)

208

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

209

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

210

-

211

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

212

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

213

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

214

- EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE}

215

- WORKING_DIRECTORY

216

- ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake

217

- OUTPUT_VARIABLE _qmake_query_output

218

- RESULT_VARIABLE _qmake_result

219

- ERROR_VARIABLE _qmake_query_output )

220

-

221

- FILE(REMOVE_RECURSE

222

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

223

-

224

- IF(_qmake_result)

225

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

226

- ELSE(_qmake_result)

227

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

228

- ENDIF(_qmake_result)

229

-

230

-ENDMACRO(QT_QUERY_QMAKE)

231

-

232

-# check for qmake

233

-FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 PATHS

234

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

235

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

236

- $ENV{QTDIR}/bin

237

-)

238

-

239

-IF (QT_QMAKE_EXECUTABLE)

240

-

241

- SET(QT4_QMAKE_FOUND FALSE)

242

-

243

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

244

-

245

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

246

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

247

- SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)

248

- FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS

249

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

250

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

251

- $ENV{QTDIR}/bin

252

- )

253

- IF(QT_QMAKE_EXECUTABLE)

254

- EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}

255

- ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION)

256

- ENDIF(QT_QMAKE_EXECUTABLE)

257

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

258

-

259

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

260

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

261

- IF (qt_version_tmp)

262

-

263

- # we need at least version 4.0.0

264

- IF (NOT QT_MIN_VERSION)

265

- SET(QT_MIN_VERSION "4.0.0")

266

- ENDIF (NOT QT_MIN_VERSION)

267

-

268

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

269

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

270

- IF (NOT req_qt_major_vers)

271

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

272

- ENDIF (NOT req_qt_major_vers)

273

-

274

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

275

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

276

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

277

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

278

-

279

- IF (NOT req_qt_major_vers EQUAL 4)

280

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

281

- ENDIF (NOT req_qt_major_vers EQUAL 4)

282

-

283

- # and now the version string given by qmake

284

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

285

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

286

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

287

-

288

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

289

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

290

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

291

-

292

- IF (found_vers LESS req_vers)

293

- SET(QT4_QMAKE_FOUND FALSE)

294

- SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)

295

- ELSE (found_vers LESS req_vers)

296

- SET(QT4_QMAKE_FOUND TRUE)

297

- ENDIF (found_vers LESS req_vers)

298

- ENDIF (qt_version_tmp)

299

-

300

-ENDIF (QT_QMAKE_EXECUTABLE)

301

-

302

-IF (QT4_QMAKE_FOUND)

303

-

304

- if (WIN32)

305

- # get qt install dir

306

- get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )

307

- get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )

308

- endif (WIN32)

309

-

310

- # ask qmake for the library dir

311

- # Set QT_LIBRARY_DIR

312

- IF (NOT QT_LIBRARY_DIR)

313

- EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

314

- ARGS "-query QT_INSTALL_LIBS"

315

- OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP )

316

- IF(EXISTS "${QT_LIBRARY_DIR_TMP}")

317

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

318

- ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}")

319

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

320

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

321

- ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}")

322

- ENDIF(NOT QT_LIBRARY_DIR)

323

-

324

- IF (APPLE)

325

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

326

- SET(QT_USE_FRAMEWORKS ON

327

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

328

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

329

- SET(QT_USE_FRAMEWORKS OFF

330

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

331

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

332

-

333

- MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)

334

- ENDIF (APPLE)

335

-

336

- # ask qmake for the binary dir

337

- IF (NOT QT_BINARY_DIR)

338

- EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE}

339

- ARGS "-query QT_INSTALL_BINS"

340

- OUTPUT_VARIABLE qt_bins )

341

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

342

- ENDIF (NOT QT_BINARY_DIR)

343

-

344

- # ask qmake for the include dir

345

- IF (NOT QT_HEADERS_DIR)

346

- EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

347

- ARGS "-query QT_INSTALL_HEADERS"

348

- OUTPUT_VARIABLE qt_headers )

349

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

350

- ENDIF(NOT QT_HEADERS_DIR)

351

-

352

-

353

- # ask qmake for the documentation directory

354

- IF (NOT QT_DOC_DIR)

355

- EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

356

- ARGS "-query QT_INSTALL_DOCS"

357

- OUTPUT_VARIABLE qt_doc_dir )

358

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

359

- ENDIF (NOT QT_DOC_DIR)

360

-

361

- # ask qmake for the mkspecs directory

362

- IF (NOT QT_MKSPECS_DIR)

363

- EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

364

- ARGS "-query QMAKE_MKSPECS"

365

- OUTPUT_VARIABLE qt_mkspecs_dir )

366

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

367

- ENDIF (NOT QT_MKSPECS_DIR)

368

-

369

- # ask qmake for the plugins directory

370

- IF (NOT QT_PLUGINS_DIR)

371

- EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE}

372

- ARGS "-query QT_INSTALL_PLUGINS"

373

- OUTPUT_VARIABLE qt_plugins_dir )

374

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

375

- ENDIF (NOT QT_PLUGINS_DIR)

376

- ########################################

377

- #

378

- # Setting the INCLUDE-Variables

379

- #

380

- ########################################

381

-

382

- FIND_PATH(QT_QTCORE_INCLUDE_DIR QtGlobal

383

- ${QT_HEADERS_DIR}/QtCore

384

- ${QT_LIBRARY_DIR}/QtCore.framework/Headers

385

- NO_DEFAULT_PATH

386

- )

387

-

388

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

389

- IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)

390

- IF (QT_USE_FRAMEWORKS)

391

- SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR})

392

- ELSE (QT_USE_FRAMEWORKS)

393

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

394

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

395

- ENDIF (QT_USE_FRAMEWORKS)

396

- ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR)

397

-

398

- IF( NOT QT_INCLUDE_DIR)

399

- IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

400

- MESSAGE( FATAL_ERROR "Could NOT find QtGlobal header")

401

- ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

402

- ENDIF( NOT QT_INCLUDE_DIR)

403

-

404

- #############################################

405

- #

406

- # Find out what window system we're using

407

- #

408

- #############################################

409

- # Save required includes and required_flags variables

410

- macro_push_required_vars()

411

- # Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES

412

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

413

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

414

- IF( QT_USE_FRAMEWORKS )

415

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

416

- ENDIF( QT_USE_FRAMEWORKS )

417

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

418

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

419

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

420

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

421

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

422

-

423

- IF (QT_QTCOPY_REQUIRED)

424

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

425

- IF (NOT QT_IS_QTCOPY)

426

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

427

- ENDIF (NOT QT_IS_QTCOPY)

428

- ENDIF (QT_QTCOPY_REQUIRED)

429

-

430

- # Restore CMAKE_REQUIRED_INCLUDES+CMAKE_REQUIRED_FLAGS variables

431

- macro_pop_required_vars()

432

- #

433

- #############################################

434

-

435

- IF (QT_USE_FRAMEWORKS)

436

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

437

- ENDIF (QT_USE_FRAMEWORKS)

438

-

439

- # Set QT_QT3SUPPORT_INCLUDE_DIR

440

- FIND_PATH(QT_QT3SUPPORT_INCLUDE_DIR Qt3Support

441

- PATHS

442

- ${QT_INCLUDE_DIR}/Qt3Support

443

- ${QT_LIBRARY_DIR}/Qt3Support.framework/Headers

444

- NO_DEFAULT_PATH

445

- )

446

-

447

- # Set QT_QT_INCLUDE_DIR

448

- FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h

449

- PATHS

450

- ${QT_INCLUDE_DIR}/Qt

451

- ${QT_LIBRARY_DIR}/QtCore.framework/Headers

452

- NO_DEFAULT_PATH

453

- )

454

-

455

- # Set QT_QTGUI_INCLUDE_DIR

456

- FIND_PATH(QT_QTGUI_INCLUDE_DIR QtGui

457

- PATHS

458

- ${QT_INCLUDE_DIR}/QtGui

459

- ${QT_LIBRARY_DIR}/QtGui.framework/Headers

460

- NO_DEFAULT_PATH

461

- )

462

-

463

- # Set QT_QTSVG_INCLUDE_DIR

464

- FIND_PATH(QT_QTSVG_INCLUDE_DIR QtSvg

465

- PATHS

466

- ${QT_INCLUDE_DIR}/QtSvg

467

- ${QT_LIBRARY_DIR}/QtSvg.framework/Headers

468

- NO_DEFAULT_PATH

469

- )

470

-

471

- # Set QT_QTSCRIPT_INCLUDE_DIR

472

- FIND_PATH(QT_QTSCRIPT_INCLUDE_DIR QtScript

473

- PATHS

474

- ${QT_INCLUDE_DIR}/QtScript

475

- ${QT_LIBRARY_DIR}/QtScript.framework/Headers

476

- NO_DEFAULT_PATH

477

- )

478

-

479

- # Set QT_QTTEST_INCLUDE_DIR

480

- FIND_PATH(QT_QTTEST_INCLUDE_DIR QtTest

481

- PATHS

482

- ${QT_INCLUDE_DIR}/QtTest

483

- ${QT_LIBRARY_DIR}/QtTest.framework/Headers

484

- NO_DEFAULT_PATH

485

- )

486

-

487

- # Set QT_QTUITOOLS_INCLUDE_DIR

488

- FIND_PATH(QT_QTUITOOLS_INCLUDE_DIR QtUiTools

489

- PATHS

490

- ${QT_INCLUDE_DIR}/QtUiTools

491

- ${QT_LIBRARY_DIR}/QtUiTools.framework/Headers

492

- NO_DEFAULT_PATH

493

- )

494

-

495

-

496

-

497

- # Set QT_QTMOTIF_INCLUDE_DIR

498

- IF(Q_WS_X11)

499

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

500

- ENDIF(Q_WS_X11)

501

-

502

- # Set QT_QTNETWORK_INCLUDE_DIR

503

- FIND_PATH(QT_QTNETWORK_INCLUDE_DIR QtNetwork

504

- PATHS

505

- ${QT_INCLUDE_DIR}/QtNetwork

506

- ${QT_LIBRARY_DIR}/QtNetwork.framework/Headers

507

- NO_DEFAULT_PATH

508

- )

509

-

510

- # Set QT_QTNSPLUGIN_INCLUDE_DIR

511

- FIND_PATH(QT_QTNSPLUGIN_INCLUDE_DIR QtNsPlugin

512

- PATHS

513

- ${QT_INCLUDE_DIR}/QtNsPlugin

514

- ${QT_LIBRARY_DIR}/QtNsPlugin.framework/Headers

515

- NO_DEFAULT_PATH

516

- )

517

-

518

- # Set QT_QTOPENGL_INCLUDE_DIR

519

- FIND_PATH(QT_QTOPENGL_INCLUDE_DIR QtOpenGL

520

- PATHS

521

- ${QT_INCLUDE_DIR}/QtOpenGL

522

- ${QT_LIBRARY_DIR}/QtOpenGL.framework/Headers

523

- NO_DEFAULT_PATH

524

- )

525

-

526

- # Set QT_QTSQL_INCLUDE_DIR

527

- FIND_PATH(QT_QTSQL_INCLUDE_DIR QtSql

528

- PATHS

529

- ${QT_INCLUDE_DIR}/QtSql

530

- ${QT_LIBRARY_DIR}/QtSql.framework/Headers

531

- NO_DEFAULT_PATH

532

- )

533

-

534

- # Set QT_QTXML_INCLUDE_DIR

535

- FIND_PATH(QT_QTXML_INCLUDE_DIR QtXml

536

- PATHS

537

- ${QT_INCLUDE_DIR}/QtXml

538

- ${QT_LIBRARY_DIR}/QtXml.framework/Headers

539

- NO_DEFAULT_PATH

540

- )

541

-

542

- # Set QT_QTASSISTANT_INCLUDE_DIR

543

- FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant

544

- PATHS

545

- ${QT_INCLUDE_DIR}/QtAssistant

546

- ${QT_HEADERS_DIR}/QtAssistant

547

- NO_DEFAULT_PATH

548

- )

549

-

550

- # Set QT_QTDESIGNER_INCLUDE_DIR

551

- FIND_PATH(QT_QTDESIGNER_INCLUDE_DIR QDesignerComponents

552

- PATHS

553

- ${QT_INCLUDE_DIR}/QtDesigner

554

- ${QT_HEADERS_DIR}/QtDesigner

555

- NO_DEFAULT_PATH

556

- )

557

-

558

- # Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR

559

- FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents

560

- PATHS

561

- ${QT_INCLUDE_DIR}/QtDesigner

562

- ${QT_HEADERS_DIR}/QtDesigner

563

- NO_DEFAULT_PATH

564

- )

565

-

566

-

567

- # Set QT_QTDBUS_INCLUDE_DIR

568

- FIND_PATH(QT_QTDBUS_INCLUDE_DIR QtDBus

569

- PATHS

570

- ${QT_INCLUDE_DIR}/QtDBus

571

- ${QT_HEADERS_DIR}/QtDBus

572

- NO_DEFAULT_PATH

573

- )

574

-

575

- # Make variables changeble to the advanced user

576

- MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_INCLUDE_DIR QT_QT_INCLUDE_DIR QT_DOC_DIR QT_MKSPECS_DIR QT_PLUGINS_DIR)

577

-

578

- # Set QT_INCLUDES

579

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

580

-

581

-

582

- ########################################

583

- #

584

- # Setting the LIBRARY-Variables

585

- #

586

- ########################################

587

-

588

- IF (QT_USE_FRAMEWORKS)

589

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

590

- # to jump through these hoops.

591

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

592

- SET(QT_QTCORE_FOUND TRUE)

593

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

594

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

595

- SET(QT_QTCORE_FOUND FALSE)

596

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

597

-

598

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

599

- SET(QT_QTGUI_FOUND TRUE)

600

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

601

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

602

- SET(QT_QTGUI_FOUND FALSE)

603

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

604

-

605

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

606

- SET(QT_QT3SUPPORT_FOUND TRUE)

607

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

608

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

609

- SET(QT_QT3SUPPORT_FOUND FALSE)

610

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

611

-

612

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

613

- SET(QT_QTNETWORK_FOUND TRUE)

614

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

615

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

616

- SET(QT_QTNETWORK_FOUND FALSE)

617

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

618

-

619

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

620

- SET(QT_QTOPENGL_FOUND TRUE)

621

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

622

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

623

- SET(QT_QTOPENGL_FOUND FALSE)

624

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

625

-

626

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

627

- SET(QT_QTSQL_FOUND TRUE)

628

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

629

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

630

- SET(QT_QTSQL_FOUND FALSE)

631

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

632

-

633

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

634

- SET(QT_QTXML_FOUND TRUE)

635

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

636

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

637

- SET(QT_QTXML_FOUND FALSE)

638

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

639

-

640

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

641

- SET(QT_QTSVG_FOUND TRUE)

642

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

643

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

644

- SET(QT_QTSVG_FOUND FALSE)

645

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

646

-

647

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

648

- SET(QT_QTDBUS_FOUND TRUE)

649

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

650

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

651

- SET(QT_QTDBUS_FOUND FALSE)

652

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

653

-

654

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

655

- SET(QT_QTTEST_FOUND TRUE)

656

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

657

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

658

- SET(QT_QTTEST_FOUND FALSE)

659

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

660

-

661

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

662

- # Set QT_QTUITOOLS_LIBRARY

663

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

664

- # Set QT_QTSCRIPT_LIBRARY

665

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

666

-

667

- ELSE (QT_USE_FRAMEWORKS)

668

-

669

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

670

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

671

-

672

- # Set QT_QT3SUPPORT_LIBRARY

673

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

674

-

675

- # Set QT_QTGUI_LIBRARY

676

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

677

-

678

- # Set QT_QTMOTIF_LIBRARY

679

- IF(Q_WS_X11)

680

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

681

- ENDIF(Q_WS_X11)

682

-

683

- # Set QT_QTNETWORK_LIBRARY

684

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

685

-

686

- # Set QT_QTNSPLUGIN_LIBRARY

687

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

688

-

689

- # Set QT_QTOPENGL_LIBRARY

690

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

691

-

692

- # Set QT_QTSQL_LIBRARY

693

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

694

-

695

- # Set QT_QTXML_LIBRARY

696

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

697

-

698

- # Set QT_QTSVG_LIBRARY

699

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

700

-

701

- # Set QT_QTSCRIPT_LIBRARY

702

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

703

-

704

- # Set QT_QTUITOOLS_LIBRARY

705

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

706

-

707

- # Set QT_QTTEST_LIBRARY

708

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

709

-

710

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

711

-

712

- IF(MSVC)

713

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

714

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

715

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

716

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

717

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

718

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

719

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

720

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

721

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

722

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

723

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

724

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

725

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

726

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

727

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

728

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

729

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

730

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

731

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

732

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

733

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

734

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

735

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

736

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

737

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

738

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

739

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

740

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

741

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

742

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

743

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

744

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

745

- ENDIF(MSVC)

746

- ENDIF (QT_USE_FRAMEWORKS)

747

-

748

- IF( NOT QT_QTCORE_LIBRARY )

749

- IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

750

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

751

- ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED)

752

- ENDIF( NOT QT_QTCORE_LIBRARY )

753

-

754

- # Set QT_QTASSISTANT_LIBRARY

755

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

756

-

757

- # Set QT_QTDESIGNER_LIBRARY

758

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

759

-

760

- # Set QT_QTDESIGNERCOMPONENTS_LIBRARY

761

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

762

-

763

- # Set QT_QTMAIN_LIBRARY

764

- IF(WIN32)

765

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

766

- ENDIF(WIN32)

767

-

768

- ############################################

769

- #

770

- # Check the existence of the libraries.

771

- #

772

- ############################################

773

-

774

- MACRO (_QT4_ADJUST_LIB_VARS basename)

775

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

776

-

777

- IF(MSVC)

778

- # Both set

779

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

780

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

781

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

782

-

783

- # Only debug was found

784

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

785

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

786

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

787

-

788

- # Only release was found

789

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

790

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

791

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

792

-

793

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

794

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

795

-

796

- ENDIF(MSVC)

797

-

798

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

799

-

800

- IF (QT_${basename}_LIBRARY)

801

- SET(QT_${basename}_FOUND 1)

802

- ENDIF (QT_${basename}_LIBRARY)

803

-

804

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

805

-

806

- IF (QT_${basename}_INCLUDE_DIR)

807

- #add the include directory to QT_INCLUDES

808

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

809

- ENDIF (QT_${basename}_INCLUDE_DIR)

810

-

811

- # Make variables changeble to the advanced user

812

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

813

- ENDMACRO (_QT4_ADJUST_LIB_VARS)

814

-

815

-

816

- # Set QT_xyz_LIBRARY variable and add

817

- # library include path to QT_INCLUDES

818

- _QT4_ADJUST_LIB_VARS(QTCORE)

819

- _QT4_ADJUST_LIB_VARS(QTGUI)

820

- _QT4_ADJUST_LIB_VARS(QT3SUPPORT)

821

- _QT4_ADJUST_LIB_VARS(QTASSISTANT)

822

- _QT4_ADJUST_LIB_VARS(QTDESIGNER)

823

- _QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS)

824

- _QT4_ADJUST_LIB_VARS(QTNETWORK)

825

- _QT4_ADJUST_LIB_VARS(QTNSPLUGIN)

826

- _QT4_ADJUST_LIB_VARS(QTOPENGL)

827

- _QT4_ADJUST_LIB_VARS(QTSQL)

828

- _QT4_ADJUST_LIB_VARS(QTXML)

829

- _QT4_ADJUST_LIB_VARS(QTSVG)

830

- _QT4_ADJUST_LIB_VARS(QTSCRIPT)

831

- _QT4_ADJUST_LIB_VARS(QTUITOOLS)

832

- _QT4_ADJUST_LIB_VARS(QTTEST)

833

- _QT4_ADJUST_LIB_VARS(QTDBUS)

834

-

835

-

836

- # platform dependent libraries

837

- IF(Q_WS_X11)

838

- _QT4_ADJUST_LIB_VARS(QTMOTIF)

839

- ENDIF(Q_WS_X11)

840

- IF(WIN32)

841

- _QT4_ADJUST_LIB_VARS(QTMAIN)

842

- ENDIF(WIN32)

843

-

844

-

845

- #######################################

846

- #

847

- # Check the executables of Qt

848

- # ( moc, uic, rcc )

849

- #

850

- #######################################

851

-

852

-

853

- # find moc and uic using qmake

854

- QT_QUERY_QMAKE(QT_MOC_EXECUTABLE_INTERNAL "QMAKE_MOC")

855

- QT_QUERY_QMAKE(QT_UIC_EXECUTABLE_INTERNAL "QMAKE_UIC")

856

-

857

- FILE(TO_CMAKE_PATH

858

- "${QT_MOC_EXECUTABLE_INTERNAL}" QT_MOC_EXECUTABLE_INTERNAL)

859

- FILE(TO_CMAKE_PATH

860

- "${QT_UIC_EXECUTABLE_INTERNAL}" QT_UIC_EXECUTABLE_INTERNAL)

861

-

862

- SET(QT_MOC_EXECUTABLE

863

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

864

- SET(QT_UIC_EXECUTABLE

865

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

866

-

867

- FIND_PROGRAM(QT_UIC3_EXECUTABLE

868

- NAMES uic3

869

- PATHS ${QT_BINARY_DIR}

870

- NO_DEFAULT_PATH

871

- )

872

-

873

- FIND_PROGRAM(QT_RCC_EXECUTABLE

874

- NAMES rcc

875

- PATHS ${QT_BINARY_DIR}

876

- NO_DEFAULT_PATH

877

- )

878

-

879

- FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE

880

- NAMES qdbuscpp2xml

881

- PATHS ${QT_BINARY_DIR}

882

- NO_DEFAULT_PATH

883

- )

884

-

885

- FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE

886

- NAMES qdbusxml2cpp

887

- PATHS ${QT_BINARY_DIR}

888

- NO_DEFAULT_PATH

889

- )

890

-

891

- IF (QT_MOC_EXECUTABLE)

892

- SET(QT_WRAP_CPP "YES")

893

- ENDIF (QT_MOC_EXECUTABLE)

894

-

895

- IF (QT_UIC_EXECUTABLE)

896

- SET(QT_WRAP_UI "YES")

897

- ENDIF (QT_UIC_EXECUTABLE)

898

-

899

-

900

-

901

- MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE)

902

-

903

- ######################################

904

- #

905

- # Macros for building Qt files

906

- #

907

- ######################################

908

-

909

- MACRO (QT4_GET_MOC_INC_DIRS _moc_INC_DIRS)

910

- SET(${_moc_INC_DIRS})

911

- GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)

912

-

913

- FOREACH(_current ${_inc_DIRS})

914

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

915

- ENDFOREACH(_current ${_inc_DIRS})

916

- ENDMACRO(QT4_GET_MOC_INC_DIRS)

917

-

918

-

919

- MACRO (QT4_GENERATE_MOC infile outfile )

920

- # get include dirs

921

- QT4_GET_MOC_INC_DIRS(moc_includes)

922

-

923

- GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE)

924

-

925

- IF (MSVC_IDE)

926

- SET (_moc_parameter_file ${outfile}_parameters)

927

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

928

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

929

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

930

- ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

931

- COMMAND ${QT_MOC_EXECUTABLE}

932

- ARGS @"${_moc_parameter_file}"

933

- DEPENDS ${abs_infile})

934

- ELSE (MSVC_IDE)

935

- ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

936

- COMMAND ${QT_MOC_EXECUTABLE}

937

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

938

- DEPENDS ${abs_infile})

939

- ENDIF (MSVC_IDE)

940

-

941

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

942

-

943

- MACRO_ADD_FILE_DEPENDENCIES(${abs_infile} ${outfile})

944

- ENDMACRO (QT4_GENERATE_MOC)

945

-

946

-

947

- # QT4_WRAP_CPP(outfiles inputfile ... )

948

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

949

-

950

- MACRO (QT4_WRAP_CPP outfiles )

951

- # get include dirs

952

- QT4_GET_MOC_INC_DIRS(moc_includes)

953

-

954

- FOREACH (it ${ARGN})

955

- GET_FILENAME_COMPONENT(it ${it} ABSOLUTE)

956

- GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)

957

-

958

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

959

- ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

960

- COMMAND ${QT_MOC_EXECUTABLE}

961

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

962

- DEPENDS ${it})

963

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

964

- ENDFOREACH(it)

965

-

966

- ENDMACRO (QT4_WRAP_CPP)

967

-

968

-

969

- # QT4_WRAP_UI(outfiles inputfile ... )

970

-

971

- MACRO (QT4_WRAP_UI outfiles )

972

-

973

- FOREACH (it ${ARGN})

974

- GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)

975

- GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)

976

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

977

- ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

978

- COMMAND ${QT_UIC_EXECUTABLE}

979

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

980

- MAIN_DEPENDENCY ${infile})

981

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

982

- ENDFOREACH (it)

983

-

984

- ENDMACRO (QT4_WRAP_UI)

985

-

986

-

987

- # QT4_ADD_RESOURCES(outfiles inputfile ... )

988

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

989

-

990

- MACRO (QT4_ADD_RESOURCES outfiles )

991

-

992

- FOREACH (it ${ARGN})

993

- GET_FILENAME_COMPONENT(outfilename ${it} NAME_WE)

994

- GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)

995

- GET_FILENAME_COMPONENT(rc_path ${infile} PATH)

996

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

997

- # parse file for dependencies

998

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

999

- FILE(READ "${infile}" _RC_FILE_CONTENTS)

1000

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

1001

- SET(_RC_DEPENDS)

1002

- FOREACH(_RC_FILE ${_RC_FILES})

1003

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

1004

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

1005

- IF(NOT _ABS_PATH_INDICATOR)

1006

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

1007

- ENDIF(NOT _ABS_PATH_INDICATOR)

1008

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

1009

- ENDFOREACH(_RC_FILE)

1010

- ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

1011

- COMMAND ${QT_RCC_EXECUTABLE}

1012

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

1013

- MAIN_DEPENDENCY ${infile}

1014

- DEPENDS ${_RC_DEPENDS})

1015

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

1016

- ENDFOREACH (it)

1017

-

1018

- ENDMACRO (QT4_ADD_RESOURCES)

1019

-

1020

- MACRO(QT4_ADD_DBUS_INTERFACE _sources _interface _basename)

1021

- GET_FILENAME_COMPONENT(_infile ${_interface} ABSOLUTE)

1022

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

1023

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

1024

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

1025

-

1026

- GET_SOURCE_FILE_PROPERTY(_nonamespace ${_interface} NO_NAMESPACE)

1027

- IF ( _nonamespace )

1028

- SET(_params -N -m)

1029

- ELSE ( _nonamespace )

1030

- SET(_params -m)

1031

- ENDIF ( _nonamespace )

1032

-

1033

- GET_SOURCE_FILE_PROPERTY(_include ${_interface} INCLUDE)

1034

- IF ( _include )

1035

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

1036

- ENDIF ( _include )

1037

-

1038

- ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}

1039

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

1040

- DEPENDS ${_infile})

1041

-

1042

- SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)

1043

-

1044

- QT4_GENERATE_MOC(${_header} ${_moc})

1045

-

1046

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

1047

- MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})

1048

-

1049

- ENDMACRO(QT4_ADD_DBUS_INTERFACE)

1050

-

1051

- MACRO(QT4_ADD_DBUS_INTERFACES _sources)

1052

- FOREACH (_current_FILE ${ARGN})

1053

- GET_FILENAME_COMPONENT(_infile ${_current_FILE} ABSOLUTE)

1054

- # get the part before the ".xml" suffix

1055

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

1056

- STRING(TOLOWER ${_basename} _basename)

1057

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

1058

- ENDFOREACH (_current_FILE)

1059

- ENDMACRO(QT4_ADD_DBUS_INTERFACES)

1060

-

1061

- MACRO(QT4_ADD_DBUS_INTERFACE_NO_NAMESPACE _sources _interface _basename)

1062

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

1063

-SET_SOURCE_FILES_PROPERTIES(<interface> PROPERTIES NO_NAMESPACE TRUE)

1064

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

1065

- ENDMACRO(QT4_ADD_DBUS_INTERFACE_NO_NAMESPACE)

1066

-

1067

- MACRO(QT4_ADD_DBUS_INTERFACES_NO_NAMESPACE _sources)

1068

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

1069

-SET_SOURCE_FILES_PROPERTIES(<files> PROPERTIES NO_NAMESPACE TRUE)

1070

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

1071

- ENDMACRO(QT4_ADD_DBUS_INTERFACES_NO_NAMESPACE)

1072

-

1073

- MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName )

1074

- SET(_customName "${ARGV1}")

1075

- GET_FILENAME_COMPONENT(_in_file ${_header} ABSOLUTE)

1076

- GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE)

1077

-

1078

- IF (_customName)

1079

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

1080

- ELSE (_customName)

1081

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

1082

- ENDIF (_customName)

1083

-

1084

- ADD_CUSTOM_COMMAND(OUTPUT ${_target}

1085

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

1086

- DEPENDS ${_in_file}

1087

- )

1088

- ENDMACRO(QT4_GENERATE_DBUS_INTERFACE)

1089

-

1090

-

1091

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

1092

- GET_FILENAME_COMPONENT(_infile ${_xml_file} ABSOLUTE)

1093

-

1094

- SET(_optionalBasename "${ARGV4}")

1095

- IF (_optionalBasename)

1096

- SET(_basename ${_optionalBasename} )

1097

- ELSE (_optionalBasename)

1098

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

1099

- STRING(TOLOWER ${_basename} _basename)

1100

- ENDIF (_optionalBasename)

1101

-

1102

- SET(_optionalClassName "${ARGV5}")

1103

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

1104

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

1105

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

1106

-

1107

- IF(_optionalClassName)

1108

- ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}

1109

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

1110

- DEPENDS ${_infile}

1111

- )

1112

- ELSE(_optionalClassName)

1113

- ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}

1114

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

1115

- DEPENDS ${_infile}

1116

- )

1117

- ENDIF(_optionalClassName)

1118

-

1119

- QT4_GENERATE_MOC(${_header} ${_moc})

1120

- SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)

1121

- MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})

1122

-

1123

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

1124

- ENDMACRO(QT4_ADD_DBUS_ADAPTOR)

1125

-

1126

- MACRO(QT4_AUTOMOC)

1127

- QT4_GET_MOC_INC_DIRS(_moc_INCS)

1128

-

1129

- SET(_matching_FILES )

1130

- FOREACH (_current_FILE ${ARGN})

1131

-

1132

- GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE)

1133

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

1134

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

1135

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

1136

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

1137

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

1138

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

1139

- # different rules for the same moc file

1140

- GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC)

1141

-

1142

- IF ( NOT _skip AND EXISTS ${_abs_FILE} )

1143

-

1144

- FILE(READ ${_abs_FILE} _contents)

1145

-

1146

- GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH)

1147

-

1148

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

1149

- IF(_match)

1150

- FOREACH (_current_MOC_INC ${_match})

1151

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

1152

-

1153

- GET_filename_component(_basename ${_current_MOC} NAME_WE)

1154

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

1155

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

1156

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

1157

- ADD_CUSTOM_COMMAND(OUTPUT ${_moc}

1158

- COMMAND ${QT_MOC_EXECUTABLE}

1159

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

1160

- DEPENDS ${_header}

1161

- )

1162

-

1163

- MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc})

1164

- ENDFOREACH (_current_MOC_INC)

1165

- ENDIF(_match)

1166

- ENDIF ( NOT _skip AND EXISTS ${_abs_FILE} )

1167

- ENDFOREACH (_current_FILE)

1168

- ENDMACRO(QT4_AUTOMOC)

1169

-

1170

-

1171

-

1172

- ######################################

1173

- #

1174

- # decide if Qt got found

1175

- #

1176

- ######################################

1177

-

1178

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

1179

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

1180

- SET( QT4_FOUND "YES" )

1181

- IF( NOT Qt4_FIND_QUIETLY)

1182

- IF (WIN32)

1183

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

1184

- ELSE (WIN32)

1185

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

1186

- ENDIF (WIN32)

1187

- ENDIF( NOT Qt4_FIND_QUIETLY)

1188

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

1189

- SET( QT4_FOUND "NO")

1190

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

1191

- IF( Qt4_FIND_REQUIRED)

1192

- IF ( NOT QT_LIBRARY_DIR )

1193

- MESSAGE(STATUS "Qt libraries NOT found!")

1194

- ENDIF(NOT QT_LIBRARY_DIR )

1195

- IF ( NOT QT_INCLUDE_DIR )

1196

- MESSAGE(STATUS "Qt includes NOT found!")

1197

- ENDIF( NOT QT_INCLUDE_DIR )

1198

- IF ( NOT QT_MOC_EXECUTABLE )

1199

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

1200

- ENDIF( NOT QT_MOC_EXECUTABLE )

1201

- IF ( NOT QT_UIC_EXECUTABLE )

1202

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

1203

- ENDIF( NOT QT_UIC_EXECUTABLE )

1204

- IF ( NOT QT_RCC_EXECUTABLE )

1205

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

1206

- ENDIF( NOT QT_RCC_EXECUTABLE )

1207

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

1208

- ENDIF( Qt4_FIND_REQUIRED)

1209

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

1210

- SET(QT_FOUND ${QT4_FOUND})

1211

-

1212

-

1213

- #######################################

1214

- #

1215

- # System dependent settings

1216

- #

1217

- #######################################

1218

- # for unix add X11 stuff

1219

- IF(UNIX)

1220

- # on OS X X11 may not be required

1221

- IF (Q_WS_X11)

1222

- FIND_PACKAGE(X11 REQUIRED)

1223

- ENDIF (Q_WS_X11)

1224

- FIND_PACKAGE(Threads)

1225

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

1226

- ENDIF(UNIX)

1227

-

1228

-

1229

- #######################################

1230

- #

1231

- # compatibility settings

1232

- #

1233

- #######################################

1234

- # Backwards compatibility for CMake1.4 and 1.2

1235

- SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )

1236

- SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )

1237

-

1238

- SET( QT_QT_LIBRARY "")

1239

-

1240

-ELSE(QT4_QMAKE_FOUND)

1241

-

1242

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

1243

- IF(Qt4_FIND_REQUIRED)

1244

- IF(QT4_INSTALLED_VERSION_TOO_OLD)

1245

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

1246

- ELSE(QT4_INSTALLED_VERSION_TOO_OLD)

1247

- MESSAGE( FATAL_ERROR "Qt qmake not found!")

1248

- ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)

1249

- ELSE(Qt4_FIND_REQUIRED)

1250

- IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)

1251

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

1252

- ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)

1253

- ENDIF(Qt4_FIND_REQUIRED)

1254

-

1255

-ENDIF (QT4_QMAKE_FOUND)

1256

-ENDIF (QT4_QMAKE_FOUND)

1257

-