cmake/modules/Qt4Macros.cmake

   1 # This file is included by FindQt4.cmake, don't include it directly.
   2
   3 #=============================================================================
   4 # Copyright 2005-2009 Kitware, Inc.
   5 #
   6 # Distributed under the OSI-approved BSD License (the "License");
   7 # see accompanying file Copyright.txt for details.
   8 #
   9 # This software is distributed WITHOUT ANY WARRANTY; without even the
  10 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11 # See the License for more information.
  12 #=============================================================================
  13 # (To distributed this file outside of CMake, substitute the full
  14 #  License text for the above reference.)
  15
  16
  17 ######################################
  18 #
  19 #       Macros for building Qt files
  20 #
  21 ######################################
  22
  23
  24 MACRO (QT4_EXTRACT_OPTIONS _qt4_files _qt4_options)
  25   SET(${_qt4_files})
  26   SET(${_qt4_options})
  27   SET(_QT4_DOING_OPTIONS FALSE)
  28   FOREACH(_currentArg ${ARGN})
  29     IF ("${_currentArg}" STREQUAL "OPTIONS")
  30       SET(_QT4_DOING_OPTIONS TRUE)
  31     ELSE ("${_currentArg}" STREQUAL "OPTIONS")
  32       IF(_QT4_DOING_OPTIONS)
  33         LIST(APPEND ${_qt4_options} "${_currentArg}")
  34       ELSE(_QT4_DOING_OPTIONS)
  35         LIST(APPEND ${_qt4_files} "${_currentArg}")
  36       ENDIF(_QT4_DOING_OPTIONS)
  37     ENDIF ("${_currentArg}" STREQUAL "OPTIONS")
  38   ENDFOREACH(_currentArg)
  39 ENDMACRO (QT4_EXTRACT_OPTIONS)
  40
  41
  42 # macro used to create the names of output files preserving relative dirs
  43 MACRO (QT4_MAKE_OUTPUT_FILE infile prefix ext outfile )
  44   STRING(LENGTH ${CMAKE_CURRENT_BINARY_DIR} _binlength)
  45   STRING(LENGTH ${infile} _infileLength)
  46   SET(_checkinfile ${CMAKE_CURRENT_SOURCE_DIR})
  47   IF(_infileLength GREATER _binlength)
  48     STRING(SUBSTRING "${infile}" 0 ${_binlength} _checkinfile)
  49     IF(_checkinfile STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
  50       FILE(RELATIVE_PATH rel ${CMAKE_CURRENT_BINARY_DIR} ${infile})
  51     ELSE(_checkinfile STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
  52       FILE(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile})
  53     ENDIF(_checkinfile STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
  54   ELSE(_infileLength GREATER _binlength)
  55     FILE(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile})
  56   ENDIF(_infileLength GREATER _binlength)
  57   IF(WIN32 AND rel MATCHES "^[a-zA-Z]:") # absolute path
  58     STRING(REGEX REPLACE "^([a-zA-Z]):(.*)$" "\\1_\\2" rel "${rel}")
  59   ENDIF(WIN32 AND rel MATCHES "^[a-zA-Z]:")
  60   SET(_outfile "${CMAKE_CURRENT_BINARY_DIR}/${rel}")
  61   STRING(REPLACE ".." "__" _outfile ${_outfile})
  62   GET_FILENAME_COMPONENT(outpath ${_outfile} PATH)
  63   GET_FILENAME_COMPONENT(_outfile ${_outfile} NAME_WE)
  64   FILE(MAKE_DIRECTORY ${outpath})
  65   SET(${outfile} ${outpath}/${prefix}${_outfile}.${ext})
  66 ENDMACRO (QT4_MAKE_OUTPUT_FILE )
  67
  68
  69 MACRO (QT4_GET_MOC_FLAGS _moc_flags)
  70   SET(${_moc_flags})
  71   GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)
  72
  73   FOREACH(_current ${_inc_DIRS})
  74     IF("${_current}" MATCHES ".framework/?$")
  75       STRING(REGEX REPLACE "/[^/]+.framework" "" framework_path "${_current}")
  76       SET(${_moc_flags} ${${_moc_flags}} "-F${framework_path}")
  77     ELSE("${_current}" MATCHES ".framework/?$")
  78       SET(${_moc_flags} ${${_moc_flags}} "-I${_current}")
  79     ENDIF("${_current}" MATCHES ".framework/?$")
  80   ENDFOREACH(_current ${_inc_DIRS})
  81
  82   GET_DIRECTORY_PROPERTY(_defines COMPILE_DEFINITIONS)
  83   FOREACH(_current ${_defines})
  84     SET(${_moc_flags} ${${_moc_flags}} "-D${_current}")
  85   ENDFOREACH(_current ${_defines})
  86
  87   IF(Q_WS_WIN)
  88     SET(${_moc_flags} ${${_moc_flags}} -DWIN32)
  89   ENDIF(Q_WS_WIN)
  90
  91 ENDMACRO(QT4_GET_MOC_FLAGS)
  92
  93
  94 # helper macro to set up a moc rule
  95 MACRO (QT4_CREATE_MOC_COMMAND infile outfile moc_flags moc_options)
  96   # For Windows, create a parameters file to work around command line length limit
  97   IF (WIN32)
  98     # Pass the parameters in a file.  Set the working directory to
  99     # be that containing the parameters file and reference it by
 100     # just the file name.  This is necessary because the moc tool on
 101     # MinGW builds does not seem to handle spaces in the path to the
 102     # file given with the @ syntax.
 103     GET_FILENAME_COMPONENT(_moc_outfile_name "${outfile}" NAME)
 104     GET_FILENAME_COMPONENT(_moc_outfile_dir "${outfile}" PATH)
 105     IF(_moc_outfile_dir)
 106       SET(_moc_working_dir WORKING_DIRECTORY ${_moc_outfile_dir})
 107     ENDIF(_moc_outfile_dir)
 108     SET (_moc_parameters_file ${outfile}_parameters)
 109     SET (_moc_parameters ${moc_flags} ${moc_options} -o "${outfile}" "${infile}")
 110     FILE (REMOVE ${_moc_parameters_file})
 111     FOREACH(arg ${_moc_parameters})
 112       FILE (APPEND ${_moc_parameters_file} "${arg}\n")
 113     ENDFOREACH(arg)
 114     ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
 115                        COMMAND ${QT_MOC_EXECUTABLE} @${_moc_outfile_name}_parameters
 116                        DEPENDS ${infile}
 117                        ${_moc_working_dir}
 118                        VERBATIM)
 119   ELSE (WIN32)
 120     ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
 121                        COMMAND ${QT_MOC_EXECUTABLE}
 122                        ARGS ${moc_flags} ${moc_options} -o ${outfile} ${infile}
 123                        DEPENDS ${infile})
 124   ENDIF (WIN32)
 125 ENDMACRO (QT4_CREATE_MOC_COMMAND)
 126
 127
 128 MACRO (QT4_GENERATE_MOC infile outfile )
 129 # get include dirs and flags
 130    QT4_GET_MOC_FLAGS(moc_flags)
 131    GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE)
 132    QT4_CREATE_MOC_COMMAND(${abs_infile} ${outfile} "${moc_flags}" "")
 133    SET_SOURCE_FILES_PROPERTIES(${outfile} PROPERTIES SKIP_AUTOMOC TRUE)  # dont run automoc on this file
 134
 135    MACRO_ADD_FILE_DEPENDENCIES(${abs_infile} ${outfile})
 136 ENDMACRO (QT4_GENERATE_MOC)
 137
 138
 139 # QT4_WRAP_CPP(outfiles inputfile ... )
 140
 141 MACRO (QT4_WRAP_CPP outfiles )
 142   # get include dirs
 143   QT4_GET_MOC_FLAGS(moc_flags)
 144   QT4_EXTRACT_OPTIONS(moc_files moc_options ${ARGN})
 145
 146   FOREACH (it ${moc_files})
 147     GET_FILENAME_COMPONENT(it ${it} ABSOLUTE)
 148     QT4_MAKE_OUTPUT_FILE(${it} moc_ cxx outfile)
 149     QT4_CREATE_MOC_COMMAND(${it} ${outfile} "${moc_flags}" "${moc_options}")
 150     SET(${outfiles} ${${outfiles}} ${outfile})
 151   ENDFOREACH(it)
 152
 153 ENDMACRO (QT4_WRAP_CPP)
 154
 155
 156 # QT4_WRAP_UI(outfiles inputfile ... )
 157
 158 MACRO (QT4_WRAP_UI outfiles )
 159   QT4_EXTRACT_OPTIONS(ui_files ui_options ${ARGN})
 160
 161   FOREACH (it ${ui_files})
 162     GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)
 163     GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
 164     SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.h)
 165     ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
 166       COMMAND ${QT_UIC_EXECUTABLE}
 167       ARGS ${ui_options} -o ${outfile} ${infile}
 168       MAIN_DEPENDENCY ${infile})
 169     SET(${outfiles} ${${outfiles}} ${outfile})
 170   ENDFOREACH (it)
 171
 172 ENDMACRO (QT4_WRAP_UI)
 173
 174
 175 # QT4_ADD_RESOURCES(outfiles inputfile ... )
 176
 177 MACRO (QT4_ADD_RESOURCES outfiles )
 178   QT4_EXTRACT_OPTIONS(rcc_files rcc_options ${ARGN})
 179
 180   FOREACH (it ${rcc_files})
 181     GET_FILENAME_COMPONENT(outfilename ${it} NAME_WE)
 182     GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)
 183     GET_FILENAME_COMPONENT(rc_path ${infile} PATH)
 184     SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cxx)
 185     #  parse file for dependencies
 186     #  all files are absolute paths or relative to the location of the qrc file
 187     FILE(READ "${infile}" _RC_FILE_CONTENTS)
 188     STRING(REGEX MATCHALL "<file[^<]+" _RC_FILES "${_RC_FILE_CONTENTS}")
 189     SET(_RC_DEPENDS)
 190     FOREACH(_RC_FILE ${_RC_FILES})
 191       STRING(REGEX REPLACE "^<file[^>]*>" "" _RC_FILE "${_RC_FILE}")
 192       STRING(REGEX MATCH "^/|([A-Za-z]:/)" _ABS_PATH_INDICATOR "${_RC_FILE}")
 193       IF(NOT _ABS_PATH_INDICATOR)
 194         SET(_RC_FILE "${rc_path}/${_RC_FILE}")
 195       ENDIF(NOT _ABS_PATH_INDICATOR)
 196       SET(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")
 197     ENDFOREACH(_RC_FILE)
 198     ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
 199       COMMAND ${QT_RCC_EXECUTABLE}
 200       ARGS ${rcc_options} -name ${outfilename} -o ${outfile} ${infile}
 201       MAIN_DEPENDENCY ${infile}
 202       DEPENDS ${_RC_DEPENDS})
 203     SET(${outfiles} ${${outfiles}} ${outfile})
 204   ENDFOREACH (it)
 205
 206 ENDMACRO (QT4_ADD_RESOURCES)
 207
 208
 209 MACRO(QT4_ADD_DBUS_INTERFACE _sources _interface _basename)
 210   GET_FILENAME_COMPONENT(_infile ${_interface} ABSOLUTE)
 211   SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
 212   SET(_impl   ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
 213   SET(_moc    ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
 214
 215   GET_SOURCE_FILE_PROPERTY(_nonamespace ${_interface} NO_NAMESPACE)
 216   IF ( _nonamespace )
 217       SET(_params -N -m)
 218   ELSE ( _nonamespace )
 219       SET(_params -m)
 220   ENDIF ( _nonamespace )
 221
 222   GET_SOURCE_FILE_PROPERTY(_classname ${_interface} CLASSNAME)
 223   IF ( _classname )
 224       SET(_params ${_params} -c ${_classname})
 225   ENDIF ( _classname )
 226
 227   GET_SOURCE_FILE_PROPERTY(_include ${_interface} INCLUDE)
 228   IF ( _include )
 229       SET(_params ${_params} -i ${_include})
 230   ENDIF ( _include )
 231
 232   ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
 233       COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} ${_params} -p ${_basename} ${_infile}
 234       DEPENDS ${_infile})
 235
 236   SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
 237
 238   QT4_GENERATE_MOC(${_header} ${_moc})
 239
 240   SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
 241   MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
 242
 243 ENDMACRO(QT4_ADD_DBUS_INTERFACE)
 244
 245
 246 MACRO(QT4_ADD_DBUS_INTERFACES _sources)
 247   FOREACH (_current_FILE ${ARGN})
 248     GET_FILENAME_COMPONENT(_infile ${_current_FILE} ABSOLUTE)
 249     # get the part before the ".xml" suffix
 250     STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2" _basename ${_current_FILE})
 251     STRING(TOLOWER ${_basename} _basename)
 252     QT4_ADD_DBUS_INTERFACE(${_sources} ${_infile} ${_basename}interface)
 253   ENDFOREACH (_current_FILE)
 254 ENDMACRO(QT4_ADD_DBUS_INTERFACES)
 255
 256
 257 MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName OPTIONS -some -options )
 258   QT4_EXTRACT_OPTIONS(_customName _qt4_dbus_options ${ARGN})
 259
 260   GET_FILENAME_COMPONENT(_in_file ${_header} ABSOLUTE)
 261   GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE)
 262
 263   IF (_customName)
 264     SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})
 265   ELSE (_customName)
 266     SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml)
 267   ENDIF (_customName)
 268
 269   ADD_CUSTOM_COMMAND(OUTPUT ${_target}
 270       COMMAND ${QT_DBUSCPP2XML_EXECUTABLE} ${_qt4_dbus_options} ${_in_file} -o ${_target}
 271       DEPENDS ${_in_file}
 272   )
 273 ENDMACRO(QT4_GENERATE_DBUS_INTERFACE)
 274
 275
 276 MACRO(QT4_ADD_DBUS_ADAPTOR _sources _xml_file _include _parentClass) # _optionalBasename _optionalClassName)
 277   GET_FILENAME_COMPONENT(_infile ${_xml_file} ABSOLUTE)
 278
 279   SET(_optionalBasename "${ARGV4}")
 280   IF (_optionalBasename)
 281     SET(_basename ${_optionalBasename} )
 282   ELSE (_optionalBasename)
 283     STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _basename ${_infile})
 284     STRING(TOLOWER ${_basename} _basename)
 285   ENDIF (_optionalBasename)
 286
 287   SET(_optionalClassName "${ARGV5}")
 288   SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
 289   SET(_impl   ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
 290   SET(_moc    ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
 291
 292   IF(_optionalClassName)
 293     ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
 294        COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -c ${_optionalClassName} -i ${_include} -l ${_parentClass} ${_infile}
 295        DEPENDS ${_infile}
 296     )
 297   ELSE(_optionalClassName)
 298     ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header}
 299        COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -i ${_include} -l ${_parentClass} ${_infile}
 300        DEPENDS ${_infile}
 301      )
 302   ENDIF(_optionalClassName)
 303
 304   QT4_GENERATE_MOC(${_header} ${_moc})
 305   SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE)
 306   MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc})
 307
 308   SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc})
 309 ENDMACRO(QT4_ADD_DBUS_ADAPTOR)
 310
 311
 312 MACRO(QT4_AUTOMOC)
 313   QT4_GET_MOC_FLAGS(_moc_INCS)
 314
 315   SET(_matching_FILES )
 316   FOREACH (_current_FILE ${ARGN})
 317
 318     GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE)
 319     # if "SKIP_AUTOMOC" is set to true, we will not handle this file here.
 320     # This is required to make uic work correctly:
 321     # we need to add generated .cpp files to the sources (to compile them),
 322     # but we cannot let automoc handle them, as the .cpp files don't exist yet when
 323     # cmake is run for the very first time on them -> however the .cpp files might
 324     # exist at a later run. at that time we need to skip them, so that we don't add two
 325     # different rules for the same moc file
 326     GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC)
 327
 328     IF ( NOT _skip AND EXISTS ${_abs_FILE} )
 329
 330       FILE(READ ${_abs_FILE} _contents)
 331
 332       GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH)
 333
 334       STRING(REGEX MATCHALL "# *include +[^ ]+\\.moc[\">]" _match "${_contents}")
 335       IF(_match)
 336         FOREACH (_current_MOC_INC ${_match})
 337           STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}")
 338
 339           GET_FILENAME_COMPONENT(_basename ${_current_MOC} NAME_WE)
 340           IF(EXISTS ${_abs_PATH}/${_basename}.hpp)
 341             SET(_header ${_abs_PATH}/${_basename}.hpp)
 342           ELSE(EXISTS ${_abs_PATH}/${_basename}.hpp)
 343             SET(_header ${_abs_PATH}/${_basename}.h)
 344           ENDIF(EXISTS ${_abs_PATH}/${_basename}.hpp)
 345           SET(_moc    ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC})
 346           QT4_CREATE_MOC_COMMAND(${_header} ${_moc} "${_moc_INCS}" "")
 347           MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc})
 348         ENDFOREACH (_current_MOC_INC)
 349       ENDIF(_match)
 350     ENDIF ( NOT _skip AND EXISTS ${_abs_FILE} )
 351   ENDFOREACH (_current_FILE)
 352 ENDMACRO(QT4_AUTOMOC)
 353
 354
 355 MACRO(QT4_CREATE_TRANSLATION _qm_files)
 356    QT4_EXTRACT_OPTIONS(_lupdate_files _lupdate_options ${ARGN})
 357    SET(_my_sources)
 358    SET(_my_dirs)
 359    SET(_my_tsfiles)
 360    SET(_ts_pro)
 361    FOREACH (_file ${_lupdate_files})
 362      GET_FILENAME_COMPONENT(_ext ${_file} EXT)
 363      GET_FILENAME_COMPONENT(_abs_FILE ${_file} ABSOLUTE)
 364      IF(_ext MATCHES "ts")
 365        LIST(APPEND _my_tsfiles ${_abs_FILE})
 366      ELSE(_ext MATCHES "ts")
 367        IF(NOT _ext)
 368          LIST(APPEND _my_dirs ${_abs_FILE})
 369        ELSE(NOT _ext)
 370          LIST(APPEND _my_sources ${_abs_FILE})
 371        ENDIF(NOT _ext)
 372      ENDIF(_ext MATCHES "ts")
 373    ENDFOREACH(_file)
 374    FOREACH(_ts_file ${_my_tsfiles})
 375      IF(_my_sources)
 376        # make a .pro file to call lupdate on, so we don't make our commands too
 377        # long for some systems
 378        GET_FILENAME_COMPONENT(_ts_name ${_ts_file} NAME_WE)
 379        SET(_ts_pro ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_ts_name}_lupdate.pro)
 380        SET(_pro_srcs)
 381        FOREACH(_pro_src ${_my_sources})
 382          SET(_pro_srcs "${_pro_srcs} \"${_pro_src}\"")
 383        ENDFOREACH(_pro_src ${_my_sources})
 384        FILE(WRITE ${_ts_pro} "SOURCES = ${_pro_srcs}")
 385      ENDIF(_my_sources)
 386      ADD_CUSTOM_COMMAND(OUTPUT ${_ts_file}
 387         COMMAND ${QT_LUPDATE_EXECUTABLE}
 388         ARGS ${_lupdate_options} ${_ts_pro} ${_my_dirs} -ts ${_ts_file}
 389         DEPENDS ${_my_sources} ${_ts_pro})
 390    ENDFOREACH(_ts_file)
 391    QT4_ADD_TRANSLATION(${_qm_files} ${_my_tsfiles})
 392 ENDMACRO(QT4_CREATE_TRANSLATION)
 393
 394
 395 MACRO(QT4_ADD_TRANSLATION _qm_files)
 396   FOREACH (_current_FILE ${ARGN})
 397     GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE)
 398     GET_FILENAME_COMPONENT(qm ${_abs_FILE} NAME_WE)
 399     GET_SOURCE_FILE_PROPERTY(output_location ${_abs_FILE} OUTPUT_LOCATION)
 400     IF(output_location)
 401       FILE(MAKE_DIRECTORY "${output_location}")
 402       SET(qm "${output_location}/${qm}.qm")
 403     ELSE(output_location)
 404       SET(qm "${CMAKE_CURRENT_BINARY_DIR}/${qm}.qm")
 405     ENDIF(output_location)
 406
 407     ADD_CUSTOM_COMMAND(OUTPUT ${qm}
 408        COMMAND ${QT_LRELEASE_EXECUTABLE}
 409        ARGS ${_abs_FILE} -qm ${qm}
 410        DEPENDS ${_abs_FILE}
 411     )
 412     SET(${_qm_files} ${${_qm_files}} ${qm})
 413   ENDFOREACH (_current_FILE)
 414 ENDMACRO(QT4_ADD_TRANSLATION)