# for documentation look at FindKDE4Internal.cmake # # this file contains the following macros: # KDE4_ADD_UI_FILES # KDE4_ADD_UI3_FILES # KDE4_ADD_KCFG_FILES # KDE4_AUTOMOC # KDE4_INSTALL_LIBTOOL_FILE # KDE4_CREATE_FINAL_FILES # KDE4_ADD_KDEINIT_EXECUTABLE # KDE4_ADD_EXECUTABLE # KDE4_ADD_WIDGET_FILES # KDE4_INSTALL_ICONS # KDE4_REMOVE_OBSOLETE_CMAKE_FILES # KDE4_NO_ENABLE_FINAL # KDE4_CREATE_HANDBOOK # KDE4_CREATE_HTML_HANDBOOK # KDE4_INSTALL_HANDBOOK # Copyright (c) 2006, 2007, Alexander Neundorf, <neundorf@kde.org> # Copyright (c) 2006, 2007, Laurent Montel, <montel@kde.org> # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. # # Modified by PhobosK <phobosk@mail.kbfx.org> macro (KDE4_ADD_KCFG_FILES _sources ) if( ${ARGV1} STREQUAL "GENERATE_MOC" ) set(_kcfg_generatemoc TRUE) endif( ${ARGV1} STREQUAL "GENERATE_MOC" ) foreach (_current_FILE ${ARGN}) if(NOT ${_current_FILE} STREQUAL "GENERATE_MOC") get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) get_filename_component(_abs_PATH ${_tmp_FILE} PATH) get_filename_component(_basename ${_tmp_FILE} NAME_WE) file(READ ${_tmp_FILE} _contents) string(REGEX REPLACE "^(.*\n)?File=([^\n]+kcfg).*\n.*$" "\\2" _kcfg_FILE "${_contents}") set(_src_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) set(_header_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) set(_moc_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc) # the command for creating the source file from the kcfg file add_custom_command(OUTPUT ${_header_FILE} ${_src_FILE} COMMAND ${KDE4_KCFGC_EXECUTABLE} ARGS ${_abs_PATH}/${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR} MAIN_DEPENDENCY ${_tmp_FILE} DEPENDS ${_abs_PATH}/${_kcfg_FILE} ${_KDE4_KCONFIG_COMPILER_DEP} ) if(_kcfg_generatemoc) qt4_generate_moc(${_header_FILE} ${_moc_FILE} ) set_source_files_properties(${_src_FILE} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file list(APPEND ${_sources} ${_moc_FILE}) endif(_kcfg_generatemoc) # if (KDE4_ENABLE_FINAL) # kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${ARGN}) # macro_add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_src_FILE}) # endif (KDE4_ENABLE_FINAL) list(APPEND ${_sources} ${_src_FILE} ${_header_FILE}) endif(NOT ${_current_FILE} STREQUAL "GENERATE_MOC") endforeach (_current_FILE) endmacro (KDE4_ADD_KCFG_FILES) GET_FILENAME_COMPONENT(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH) #create the implementation files from the ui files and add them to the list of sources #usage: KDE4_ADD_UI_FILES(foo_SRCS ${ui_files}) macro (KDE4_ADD_UI_FILES _sources ) foreach (_current_FILE ${ARGN}) get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) get_filename_component(_basename ${_tmp_FILE} NAME_WE) set(_header ${CMAKE_CURRENT_BINARY_DIR}/ui_${_basename}.h) # we need to run uic and replace some things in the generated file # this is done by executing the cmake script kde4uic.cmake add_custom_command(OUTPUT ${_header} COMMAND ${CMAKE_COMMAND} ARGS -DKDE4_HEADER:BOOL=ON -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE} -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE} -DKDE_UIC_H_FILE:FILEPATH=${_header} -DKDE_UIC_BASENAME:STRING=${_basename} -P ${KDE4_MODULE_DIR}/kde4uic.cmake MAIN_DEPENDENCY ${_tmp_FILE} ) list(APPEND ${_sources} ${_header}) endforeach (_current_FILE) endmacro (KDE4_ADD_UI_FILES) #create the implementation files from the ui files and add them to the list of sources #usage: KDE4_ADD_UI3_FILES(foo_SRCS ${ui_files}) macro (KDE4_ADD_UI3_FILES _sources ) qt4_get_moc_inc_dirs(_moc_INCS) foreach (_current_FILE ${ARGN}) get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) get_filename_component(_basename ${_tmp_FILE} NAME_WE) set(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) set(_src ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc.cpp) add_custom_command(OUTPUT ${_header} COMMAND ${CMAKE_COMMAND} -DKDE3_HEADER:BOOL=ON -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE} -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE} -DKDE_UIC_H_FILE:FILEPATH=${_header} -DKDE_UIC_BASENAME:STRING=${_basename} -DKDE_UIC_PLUGIN_DIR:FILEPATH="." -P ${KDE4_MODULE_DIR}/kde4uic.cmake MAIN_DEPENDENCY ${_tmp_FILE} ) # we need to run uic3 and replace some things in the generated file # this is done by executing the cmake script kde4uic.cmake add_custom_command(OUTPUT ${_src} COMMAND ${CMAKE_COMMAND} ARGS -DKDE3_IMPL:BOOL=ON -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE} -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE} -DKDE_UIC_CPP_FILE:FILEPATH=${_src} -DKDE_UIC_H_FILE:FILEPATH=${_header} -DKDE_UIC_BASENAME:STRING=${_basename} -DKDE_UIC_PLUGIN_DIR:FILEPATH="." -P ${KDE4_MODULE_DIR}/kde4uic.cmake MAIN_DEPENDENCY ${_header} ) add_custom_command(OUTPUT ${_moc} COMMAND ${QT_MOC_EXECUTABLE} ARGS ${_moc_INCS} ${_header} -o ${_moc} MAIN_DEPENDENCY ${_header} ) list(APPEND ${_sources} ${_src} ${_moc} ) endforeach (_current_FILE) endmacro (KDE4_ADD_UI3_FILES) macro (KDE4_AUTOMOC) qt4_get_moc_inc_dirs(_moc_INCS) # iterate over all files foreach (_current_FILE ${ARGN}) get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE) # if "SKIP_AUTOMOC" is set to true, we will not handle this file here. # here. this is required to make bouic work correctly: # we need to add generated .cpp files to the sources (to compile them), # but we cannot let automoc handle them, as the .cpp files don't exist yet when # cmake is run for the very first time on them -> however the .cpp files might # exist at a later run. at that time we need to skip them, so that we don't add two # different rules for the same moc file get_source_file_property(_skip ${_abs_FILE} SKIP_AUTOMOC) # if the file exists and should not be skipped read it completely into memory # and grep for all include <foo.moc> lines # for each found moc file generate a custom_target and collect # the generated moc files in a list which will be set as a source files property # and later be queried in kde4_add_library/executable/plugin() if (EXISTS ${_abs_FILE} AND NOT _skip) set(_moc_FILES_PROPERTY) file(READ ${_abs_FILE} _contents) get_filename_component(_abs_PATH ${_abs_FILE} PATH) string(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}") if (_match) foreach (_current_MOC_INC ${_match}) string(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}") get_filename_component(_basename ${_current_MOC} NAME_WE) set(_header ${_abs_PATH}/${_basename}.h) set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC}) if (NOT EXISTS ${_abs_PATH}/${_basename}.h) message(FATAL_ERROR "In the file \"${_abs_FILE}\" the moc file \"${_current_MOC}\" is included, but \"${_abs_PATH}/${_basename}.h\" doesn't exist.") endif (NOT EXISTS ${_abs_PATH}/${_basename}.h) add_custom_command(OUTPUT ${_moc} COMMAND ${QT_MOC_EXECUTABLE} ARGS ${_moc_INCS} ${_header} -o ${_moc} MAIN_DEPENDENCY ${_header} ) list(APPEND _moc_FILES_PROPERTY ${_moc}) # if (KDE4_ENABLE_FINAL) # kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${ARGN}) # macro_add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_moc}) # else (KDE4_ENABLE_FINAL) # macro_add_file_dependencies(${_abs_FILE} ${_moc}) # endif (KDE4_ENABLE_FINAL) endforeach (_current_MOC_INC) endif (_match) set_source_files_properties(${_abs_FILE} PROPERTIES AUTOMOC_FILES "${_moc_FILES_PROPERTY}") endif (EXISTS ${_abs_FILE} AND NOT _skip) endforeach (_current_FILE) endmacro (KDE4_AUTOMOC) macro(KDE4_GET_AUTOMOC_FILES _list) set(${_list}) foreach (_current_FILE ${ARGN}) set(_automoc_FILES_PROPERTY) get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE) get_source_file_property(_automoc_FILES_PROPERTY ${_abs_FILE} AUTOMOC_FILES) if (_automoc_FILES_PROPERTY) foreach (_current_MOC_FILE ${_automoc_FILES_PROPERTY}) list(APPEND ${_list} ${_current_MOC_FILE}) endforeach (_current_MOC_FILE) endif (_automoc_FILES_PROPERTY) endforeach (_current_FILE) endmacro(KDE4_GET_AUTOMOC_FILES) macro (KDE4_INSTALL_HANDBOOK ) get_filename_component(_tmp_FILE ${CMAKE_CURRENT_SOURCE_DIR} ABSOLUTE) get_filename_component(_basename ${_tmp_FILE} NAME_WE) file(GLOB _books *.docbook) file(GLOB _images *.png) set(relative ${ARGV0}) set( dirname ${relative}/${_basename}) FILE(MAKE_DIRECTORY ${HTML_INSTALL_DIR}/en/${dirname}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2 ${_books} ${_images} DESTINATION ${HTML_INSTALL_DIR}/en/${dirname}) # TODO symlinks on non-unix platforms if (UNIX) ADD_CUSTOM_COMMAND(OUTPUT "${HTML_INSTALL_DIR}/en/${dirname}/common" DEPENDS "${HTML_INSTALL_DIR}/en/common" COMMAND /bin/ln ARGS -s "${HTML_INSTALL_DIR}/en/common" "${HTML_INSTALL_DIR}/en/${dirname}/common" COMMENT "Symlink") ADD_CUSTOM_TARGET(CreateSymlinks ALL DEPENDS ${HTML_INSTALL_DIR}/en/${dirname}/common) endif (UNIX) endmacro (KDE4_INSTALL_HANDBOOK ) macro (KDE4_CREATE_HANDBOOK _docbook) get_filename_component(_input ${_docbook} ABSOLUTE) set(_doc ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2) set(_ssheet ${DATA_INSTALL_DIR}/ksgmltools2/customization/kde-chunk.xsl) add_custom_command(OUTPUT ${_doc} COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check --cache ${_doc} ${_input} DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} ) add_custom_target(handbook ALL DEPENDS ${_doc}) endmacro (KDE4_CREATE_HANDBOOK) macro (KDE4_CREATE_HTML_HANDBOOK _docbook) get_filename_component(_input ${_docbook} ABSOLUTE) set(_doc ${CMAKE_CURRENT_SOURCE_DIR}/index.html) set(_ssheet ${DATA_INSTALL_DIR}/ksgmltools2/customization/kde-chunk.xsl) add_custom_command(OUTPUT ${_doc} COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check -o ${_doc} ${_input} DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} ) add_custom_target(htmlhandbook ALL DEPENDS ${_doc}) endmacro (KDE4_CREATE_HTML_HANDBOOK) # only used internally by KDE4_INSTALL_ICONS MACRO (_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME) # if the string doesn't match the pattern, the result is the full string, so all three have the same content IF (NOT ${_group} STREQUAL ${_install_NAME} ) SET(_icon_GROUP "actions") IF (${_group} STREQUAL "mime") SET(_icon_GROUP "mimetypes") ENDIF (${_group} STREQUAL "mime") IF (${_group} STREQUAL "filesys") SET(_icon_GROUP "filesystems") ENDIF (${_group} STREQUAL "filesys") IF (${_group} STREQUAL "device") SET(_icon_GROUP "devices") ENDIF (${_group} STREQUAL "device") IF (${_group} STREQUAL "app") SET(_icon_GROUP "apps") ENDIF (${_group} STREQUAL "app") IF (${_group} STREQUAL "action") SET(_icon_GROUP "actions") ENDIF (${_group} STREQUAL "action") # message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name}" ) INSTALL(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/ RENAME ${_install_NAME} ) ENDIF (NOT ${_group} STREQUAL ${_install_NAME} ) ENDMACRO (_KDE4_ADD_ICON_INSTALL_RULE) macro (KDE4_INSTALL_ICONS _defaultpath ) # first the png icons file(GLOB _icons *.png) foreach (_current_ICON ${_icons} ) string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\1" _type "${_current_ICON}") string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\2" _size "${_current_ICON}") string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\3" _group "${_current_ICON}") string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\4" _name "${_current_ICON}") set(_theme_GROUP "nogroup") if( ${_type} STREQUAL "ox" ) set(_theme_GROUP "oxygen") endif(${_type} STREQUAL "ox" ) if( ${_type} STREQUAL "cr" ) set(_theme_GROUP "crystalsvg") endif(${_type} STREQUAL "cr" ) if( ${_type} STREQUAL "lo" ) set(_theme_GROUP "locolor") endif(${_type} STREQUAL "lo" ) if( ${_type} STREQUAL "hi" ) set(_theme_GROUP "hicolor") endif(${_type} STREQUAL "hi" ) if( NOT ${_theme_GROUP} STREQUAL "nogroup") _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} ${_group} ${_current_ICON} ${_name}) endif( NOT ${_theme_GROUP} STREQUAL "nogroup") endforeach (_current_ICON) # mng icons file(GLOB _icons *.mng) foreach (_current_ICON ${_icons} ) STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\1" _type "${_current_ICON}") STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\2" _size "${_current_ICON}") STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\3" _group "${_current_ICON}") STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\4" _name "${_current_ICON}") SET(_theme_GROUP "nogroup") if( ${_type} STREQUAL "ox" ) SET(_theme_GROUP "oxygen") endif(${_type} STREQUAL "ox" ) if( ${_type} STREQUAL "cr" ) SET(_theme_GROUP "crystalsvg") endif(${_type} STREQUAL "cr" ) if( ${_type} STREQUAL "lo" ) set(_theme_GROUP "locolor") endif(${_type} STREQUAL "lo" ) if( ${_type} STREQUAL "hi" ) set(_theme_GROUP "hicolor") endif(${_type} STREQUAL "hi" ) if( NOT ${_theme_GROUP} STREQUAL "nogroup") _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} ${_group} ${_current_ICON} ${_name}) endif( NOT ${_theme_GROUP} STREQUAL "nogroup") endforeach (_current_ICON) # and now the svg icons file(GLOB _icons *.svgz) foreach (_current_ICON ${_icons} ) STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\1" _type "${_current_ICON}") STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\2" _group "${_current_ICON}") STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\3" _name "${_current_ICON}") SET(_theme_GROUP "nogroup") if(${_type} STREQUAL "ox" ) SET(_theme_GROUP "oxygen") endif(${_type} STREQUAL "ox" ) if(${_type} STREQUAL "cr" ) SET(_theme_GROUP "crystalsvg") endif(${_type} STREQUAL "cr" ) if(${_type} STREQUAL "hi" ) SET(_theme_GROUP "hicolor") endif(${_type} STREQUAL "hi" ) if(${_type} STREQUAL "lo" ) SET(_theme_GROUP "locolor") endif(${_type} STREQUAL "lo" ) if( NOT ${_theme_GROUP} STREQUAL "nogroup") _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake ${_defaultpath}/${_theme_GROUP}/scalable ${_group} ${_current_ICON} ${_name}) endif( NOT ${_theme_GROUP} STREQUAL "nogroup") endforeach (_current_ICON) endmacro (KDE4_INSTALL_ICONS) MACRO (KDE4_INSTALL_LIBTOOL_FILE _target _dir) GET_TARGET_PROPERTY(_target_location ${_target} LOCATION) GET_FILENAME_COMPONENT(_laname ${_target_location} NAME_WE) GET_FILENAME_COMPONENT(_soname ${_target_location} NAME) set(_laname ${LIBRARY_OUTPUT_PATH}/${_laname}.la) FILE(WRITE ${_laname} "# ${_laname} - a libtool library file, generated by cmake \n") FILE(APPEND ${_laname} "# The name that we can dlopen(3).\n") FILE(APPEND ${_laname} "dlname='${_soname}'\n") FILE(APPEND ${_laname} "# Names of this library\n") FILE(APPEND ${_laname} "library_names='${_soname} ${_soname} ${_soname}'\n") FILE(APPEND ${_laname} "# The name of the static archive\n") FILE(APPEND ${_laname} "old_library=''\n") FILE(APPEND ${_laname} "# Libraries that this one depends upon.\n") FILE(APPEND ${_laname} "dependency_libs=''\n") # FILE(APPEND ${_laname} "dependency_libs='${${_target}_LIB_DEPENDS}'\n") FILE(APPEND ${_laname} "# Version information.\ncurrent=0\nage=0\nrevision=0\n") FILE(APPEND ${_laname} "# Is this an already installed library?\ninstalled=yes\n") FILE(APPEND ${_laname} "# Should we warn about portability when linking against -modules?\nshouldnotlink=yes\n") FILE(APPEND ${_laname} "# Files to dlopen/dlpreopen\ndlopen=''\ndlpreopen=''\n") FILE(APPEND ${_laname} "# Directory that this library needs to be installed in:\n") FILE(APPEND ${_laname} "libdir='${_dir}'\n") INSTALL(FILES ${_laname} DESTINATION ${_dir}) ENDMACRO (KDE4_INSTALL_LIBTOOL_FILE) # For all C++ sources a big source file which includes all the files # is created. # This is not done for the C sources, they are just gathered in a separate list # because they are usually not written by KDE and as such not intended to be # compiled all-in-one. macro (KDE4_CREATE_FINAL_FILES _filenameCPP _filesExcludedFromFinalFile ) set(${_filesExcludedFromFinalFile}) file(WRITE ${_filenameCPP} "//autogenerated file\n") foreach (_current_FILE ${ARGN}) get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE) # don't include any generated files in the final-file # because then cmake will not know the dependencies get_source_file_property(_isGenerated ${_abs_FILE} GENERATED) if (_isGenerated) list(APPEND ${_filesExcludedFromFinalFile} ${_abs_FILE}) else (_isGenerated) # don't include c-files in the final-file, because they usually come # from a 3rd party and as such are not intended to be compiled all-in-one string(REGEX MATCH ".+\\.c$" _isCFile ${_abs_FILE}) if (_isCFile) list(APPEND ${_filesExcludedFromFinalFile} ${_abs_FILE}) else (_isCFile) file(APPEND ${_filenameCPP} "#include \"${_abs_FILE}\"\n") endif (_isCFile) endif (_isGenerated) endforeach (_current_FILE) endmacro (KDE4_CREATE_FINAL_FILES) # This macro sets the RPATH related options for libraries, plugins and tdeinit executables. # It overrides the defaults set in FindKDE4Internal.cmake. # If RPATH is not explicitely disabled, libraries and plugins are built without RPATH, in # the hope that the RPATH which is compiled into the executable is good enough. macro (KDE4_HANDLE_RPATH_FOR_LIBRARY _target_NAME) if (NOT CMAKE_SKIP_RPATH AND NOT KDE4_USE_ALWAYS_FULL_RPATH) set_target_properties(${_target_NAME} PROPERTIES INSTALL_RPATH_USE_LINK_PATH FALSE SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE INSTALL_RPATH "") endif (NOT CMAKE_SKIP_RPATH AND NOT KDE4_USE_ALWAYS_FULL_RPATH) endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY) # This macro sets the RPATH related options for executables # and creates wrapper shell scripts for the executables. # It overrides the defaults set in FindKDE4Internal.cmake. # For every executable a wrapper script is created, which sets the appropriate # environment variable for the platform (LD_LIBRARY_PATH on most UNIX systems, # DYLD_LIBRARY_PATH on OS X and PATH in Windows) so that it points to the built # but not yet installed versions of the libraries. So if RPATH is disabled, the executables # can be run via these scripts from the build tree and will find the correct libraries. # If RPATH is not disabled, these scripts are also used but only for consistency, because # they don't really influence anything then, because the compiled-in RPATH overrides # the LD_LIBRARY_PATH env. variable. # Executables with the RUN_UNINSTALLED option will be built with the RPATH pointing to the # build dir, so that they can be run safely without being installed, e.g. as code generators # for other stuff during the build. These executables will be relinked during "make install". # All other executables are built with the RPATH with which they will be installed. macro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE _target_NAME _type) if (UNIX) # set the RPATH related properties if (NOT CMAKE_SKIP_RPATH) if (${_type} STREQUAL "GUI") set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE) endif (${_type} STREQUAL "GUI") if (${_type} STREQUAL "NOGUI") set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE) endif (${_type} STREQUAL "NOGUI") if (${_type} STREQUAL "RUN_UNINSTALLED") set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE) endif (${_type} STREQUAL "RUN_UNINSTALLED") endif (NOT CMAKE_SKIP_RPATH) if (APPLE) set(_library_path_variable "DYLD_LIBRARY_PATH") else (APPLE) set(_library_path_variable "LD_LIBRARY_PATH") endif (APPLE) set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${LIB_INSTALL_DIR}:${KDE4_LIB_DIR}:${QT_LIBRARY_DIR}") get_target_property(_executable ${_target_NAME} LOCATION ) # use add_custom_target() to have the sh-wrapper generated during build time instead of cmake time add_custom_command(TARGET ${_target_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable} -D_ld_library_path="${_ld_library_path}" -D_executable=${_executable} -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake ) macro_additional_clean_files(${_executable}.shell) # under UNIX, set the property WRAPPER_SCRIPT to the name of the generated shell script # so it can be queried and used later on easily set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}.shell) else (UNIX) # under windows, set the property WRAPPER_SCRIPT just to the name of the executable # maybe later this will change to a generated batch file (for setting the PATH so that the Qt libs are found) get_target_property(_executable ${_target_NAME} LOCATION ) set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}) set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}\;${LIB_INSTALL_DIR}\;${KDE4_LIB_DIR}\;${QT_LIBRARY_DIR}") get_target_property(_executable ${_target_NAME} LOCATION ) # use add_custom_target() to have the batch-file-wrapper generated during build time instead of cmake time add_custom_command(TARGET ${_target_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -D_filename="${_executable}.bat" -D_ld_library_path="${_ld_library_path}" -D_executable="${_executable}" -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake ) endif (UNIX) endmacro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE) macro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX) #is the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, otherwise set the prefix empty if (${_with_PREFIX} STREQUAL "WITH_PREFIX") set(_first_SRC) else (${_with_PREFIX} STREQUAL "WITH_PREFIX") set(_first_SRC ${_with_PREFIX}) endif (${_with_PREFIX} STREQUAL "WITH_PREFIX") kde4_get_automoc_files(_automoc_FILES ${_first_SRC} ${ARGN}) if (KDE4_ENABLE_FINAL) kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_first_SRC} ${ARGN}) add_library(${_target_NAME} MODULE ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) else (KDE4_ENABLE_FINAL) add_library(${_target_NAME} MODULE ${_first_SRC} ${ARGN} ${_automoc_FILES}) endif (KDE4_ENABLE_FINAL) if (_first_SRC) set_target_properties(${_target_NAME} PROPERTIES PREFIX "") endif (_first_SRC) kde4_handle_rpath_for_library(${_target_NAME}) if (WIN32) # for shared libraries/plugins a -DMAKE_target_LIB is required string(TOUPPER ${_target_NAME} _symbol) set(_symbol "MAKE_${_symbol}_LIB") set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) endif (WIN32) endmacro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX) # this macro checks is intended to check whether a list of source # files has the "NOGUI" or "RUN_UNINSTALLED" keywords at the beginning # in _output_LIST the list of source files is returned with the "NOGUI" # and "RUN_UNINSTALLED" keywords removed # if "NOGUI" is in the list of files, the _nogui argument is set to # "NOGUI" (which evaluates to TRUE in cmake), otherwise it is set empty # (which evaluates to FALSE in cmake) # if "RUN_UNINSTALLED" is in the list of files, the _uninst argument is set to # "RUN_UNINSTALLED" (which evaluates to TRUE in cmake), otherwise it is set empty # (which evaluates to FALSE in cmake) macro(KDE4_CHECK_EXECUTABLE_PARAMS _output_LIST _nogui _uninst) set(${_nogui}) set(${_uninst}) set(${_output_LIST} ${ARGN}) list(LENGTH ${_output_LIST} count) list(GET ${_output_LIST} 0 first_PARAM) set(second_PARAM "NOTFOUND") if (${count} GREATER 1) list(GET ${_output_LIST} 1 second_PARAM) endif (${count} GREATER 1) set(remove "NOTFOUND") if (${first_PARAM} STREQUAL "NOGUI") set(${_nogui} "NOGUI") set(remove 0) endif (${first_PARAM} STREQUAL "NOGUI") if (${second_PARAM} STREQUAL "NOGUI") set(${_nogui} "NOGUI") set(remove 0;1) endif (${second_PARAM} STREQUAL "NOGUI") if (${first_PARAM} STREQUAL "RUN_UNINSTALLED") set(${_uninst} "RUN_UNINSTALLED") set(remove 0) endif (${first_PARAM} STREQUAL "RUN_UNINSTALLED") if (${second_PARAM} STREQUAL "RUN_UNINSTALLED") set(${_uninst} "RUN_UNINSTALLED") set(remove 0;1) endif (${second_PARAM} STREQUAL "RUN_UNINSTALLED") if (NOT "${remove}" STREQUAL "NOTFOUND") list(REMOVE_AT ${_output_LIST} ${remove}) endif (NOT "${remove}" STREQUAL "NOTFOUND") endmacro(KDE4_CHECK_EXECUTABLE_PARAMS) macro (KDE4_ADD_KDEINIT_EXECUTABLE _target_NAME ) kde4_check_executable_params(_SRCS _nogui _uninst ${ARGN}) # if (WIN32) # # under windows, just build a normal executable # KDE4_ADD_EXECUTABLE(${_target_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${ARGN} ) # else (WIN32) # under UNIX, create a shared library and a small executable, which links to this library kde4_get_automoc_files(_automoc_FILES ${_SRCS}) if (KDE4_ENABLE_FINAL) kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/tdeinit_${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) add_library(tdeinit_${_target_NAME} SHARED ${CMAKE_CURRENT_BINARY_DIR}/tdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) else (KDE4_ENABLE_FINAL) add_library(tdeinit_${_target_NAME} SHARED ${_SRCS} ${_automoc_FILES}) endif (KDE4_ENABLE_FINAL) kde4_handle_rpath_for_library(tdeinit_${_target_NAME}) configure_file(${KDE4_MODULE_DIR}/kde4init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) kde4_add_executable(${_target_NAME} "${_nogui}" "${_uninst}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) target_link_libraries(${_target_NAME} tdeinit_${_target_NAME}) # endif (WIN32) if (WIN32) target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY}) endif (WIN32) endmacro (KDE4_ADD_KDEINIT_EXECUTABLE) macro (KDE4_ADD_EXECUTABLE _target_NAME) kde4_check_executable_params( _SRCS _nogui _uninst ${ARGN}) set(_add_executable_param) set(_type "GUI") # determine additional parameters for add_executable() # for GUI apps, create a bundle on OSX if (APPLE) set(_add_executable_param MACOSX_BUNDLE) endif (APPLE) # for GUI apps, this disables the additional console under Windows if (WIN32) set(_add_executable_param WIN32) endif (WIN32) if (_nogui) set(_type "NOGUI") set(_add_executable_param) endif (_nogui) if (_uninst) set(_type "RUN_UNINSTALLED") endif (_uninst) kde4_get_automoc_files(_automoc_FILES ${_SRCS}) if (KDE4_ENABLE_FINAL) kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) add_executable(${_target_NAME} ${_add_executable_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) else (KDE4_ENABLE_FINAL) add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS} ${_automoc_FILES}) endif (KDE4_ENABLE_FINAL) kde4_handle_rpath_for_executable(${_target_NAME} ${_type}) if (WIN32) target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY}) endif (WIN32) endmacro (KDE4_ADD_EXECUTABLE) MACRO (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE) #is the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, otherwise set the prefix empty set(_first_SRC ${_lib_TYPE}) set(_add_lib_param) if (${_lib_TYPE} STREQUAL "STATIC") set(_first_SRC) set(_add_lib_param STATIC) endif (${_lib_TYPE} STREQUAL "STATIC") if (${_lib_TYPE} STREQUAL "SHARED") set(_first_SRC) set(_add_lib_param SHARED) endif (${_lib_TYPE} STREQUAL "SHARED") if (${_lib_TYPE} STREQUAL "MODULE") set(_first_SRC) set(_add_lib_param MODULE) endif (${_lib_TYPE} STREQUAL "MODULE") kde4_get_automoc_files(_automoc_FILES ${_first_SRC} ${ARGN}) if (KDE4_ENABLE_FINAL) kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_first_SRC} ${ARGN}) add_library(${_target_NAME} ${_add_lib_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) else (KDE4_ENABLE_FINAL) add_library(${_target_NAME} ${_add_lib_param} ${_first_SRC} ${ARGN} ${_automoc_FILES}) endif (KDE4_ENABLE_FINAL) kde4_handle_rpath_for_library(${_target_NAME}) if (WIN32) # for shared libraries a -DMAKE_target_LIB is required string(TOUPPER ${_target_NAME} _symbol) set(_symbol "MAKE_${_symbol}_LIB") set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) endif (WIN32) ENDMACRO (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE) macro (KDE4_ADD_WIDGET_FILES _sources) foreach (_current_FILE ${ARGN}) get_filename_component(_input ${_current_FILE} ABSOLUTE) get_filename_component(_basename ${_input} NAME_WE) set(_source ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.cpp) set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.moc) # create source file from the .widgets file add_custom_command(OUTPUT ${_source} COMMAND ${KDE4_MAKEKDEWIDGETS_EXECUTABLE} ARGS -o ${_source} ${_input} MAIN_DEPENDENCY ${_input} DEPENDS ${_KDE4_MAKEKDEWIDGETS_DEP}) # create moc file qt4_generate_moc(${_source} ${_moc} ) list(APPEND ${_sources} ${_source} ${_moc}) endforeach (_current_FILE) endmacro (KDE4_ADD_WIDGET_FILES) MACRO(KDE4_ADD_DCOP_SKELS) MESSAGE(FATAL_ERROR "There is a call to KDE4_ADD_DCOP_SKELS() in the CMakeLists.txt for '${ARGV0}', but DCOP is no longer supported by KDE4. Please remove it and port to DBUS.") ENDMACRO(KDE4_ADD_DCOP_SKELS) MACRO(KDE4_ADD_DCOP_STUBS) MESSAGE(FATAL_ERROR "There is a call to KDE4_ADD_DCOP_STUBS() in the CMakeLists.txt for '${ARGV0}', but DCOP is no longer supported by KDE4. Please remove it and port to DBUS.") ENDMACRO(KDE4_ADD_DCOP_STUBS) MACRO(KDE4_REMOVE_OBSOLETE_CMAKE_FILES) # the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake ) set(module_install_dir ${DATA_INSTALL_DIR}/cmake/modules ) file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, dont edit\n\n") foreach ( _current_FILE ${ARGN}) file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${module_install_dir}/${_current_FILE}\" )\n" ) file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${module_install_dir}/${_current_FILE} OUTPUT_VARIABLE _dummy)\n" ) endforeach ( _current_FILE) ENDMACRO(KDE4_REMOVE_OBSOLETE_CMAKE_FILES) MACRO(KDE4_NO_ENABLE_FINAL _project_name) if(KDE4_ENABLE_FINAL) set(KDE4_ENABLE_FINAL OFF) REMOVE_DEFINITIONS(-DKDE_USE_FINAL) MESSAGE(STATUS "You used enable-final argument but \"${_project_name}\" doesn't support it. Try to fix compile it and remove KDE4_NO_ENABLE_FINAL macro. Thanks") endif(KDE4_ENABLE_FINAL) ENDMACRO(KDE4_NO_ENABLE_FINAL _project_name) FIND_PROGRAM(MSGFMT NAMES gmsgfmt msgfmt PATHS ${BIN_SEARCH_PATHES}) IF(MSGFMT) EXECUTE_PROCESS(COMMAND ${MSGFMT} "--version" "2>&1" OUTPUT_VARIABLE _msgout) STRING(REGEX MATCH "GNU[\t ]gettext" _isgnu "${_msgout}") IF (NOT _isgnu) MESSAGE(STATUS "No gnu msgfmt found!") SET(MSGFMT ":" CACHE STRING "Msgfmt program") ELSE(NOT _isgnu) MESSAGE(STATUS "Found gnu msgfmt: ${MSGFMT}") ENDIF (NOT _isgnu) ELSE(MSGFMT) SET(MSGFMT ":" CACHE STRING "Msgfmt program") MESSAGE( FATAL_ERROR "Could NOT find Msgfmt program") ENDIF(MSGFMT) MACRO(ADD_POFILES packagename) SET(_gmofiles) FILE(GLOB _pofiles *.po) FOREACH(_current_po ${_pofiles}) GET_FILENAME_COMPONENT(_name ${_current_po} NAME_WE) STRING(REGEX REPLACE "^.*/([a-zA-Z]+)(\\.po)" "\\1" _lang "${_current_po}") SET(_gmofile "${CMAKE_CURRENT_BINARY_DIR}/${_name}.gmo") ADD_CUSTOM_COMMAND(OUTPUT ${_gmofile} COMMAND ${MSGFMT} ARGS "-o" "${_gmofile}" "${_current_po}" DEPENDS ${_current_po} ) SET(_gmofiles ${_gmofiles} ${_gmofile}) INSTALL(FILES ${_gmofile} DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_MESSAGES RENAME ${packagename}.mo) ENDFOREACH(_current_po ${_pofiles}) ADD_CUSTOM_TARGET(translations ALL DEPENDS ${_gmofiles}) ENDMACRO(ADD_POFILES)