diff options
Diffstat (limited to 'modules/KDE4Macros.cmake')
| -rw-r--r-- | modules/KDE4Macros.cmake | 1356 |
1 files changed, 1356 insertions, 0 deletions
diff --git a/modules/KDE4Macros.cmake b/modules/KDE4Macros.cmake new file mode 100644 index 00000000..e1ea80ae --- /dev/null +++ b/modules/KDE4Macros.cmake @@ -0,0 +1,1356 @@ +# for documentation look at FindKDE4Internal.cmake + +# this file contains the following macros (or functions): +# KDE4_ADD_UI_FILES +# KDE4_ADD_UI3_FILES +# KDE4_ADD_KCFG_FILES +# _KDE4_SET_CUSTOM_TARGET_PROPERTY +# _KDE4_GET_CUSTOM_TARGET_PROPERTY +# KDE4_MOC_HEADERS +# KDE4_HANDLE_AUTOMOC +# KDE4_CREATE_FINAL_FILES +# KDE4_ADD_PLUGIN +# KDE4_ADD_KDEINIT_EXECUTABLE +# KDE4_ADD_UNIT_TEST +# KDE4_ADD_EXECUTABLE +# KDE4_ADD_WIDGET_FILES +# KDE4_UPDATE_ICONCACHE +# KDE4_INSTALL_ICONS +# KDE4_REMOVE_OBSOLETE_CMAKE_FILES +# KDE4_NO_ENABLE_FINAL +# KDE4_CREATE_HANDBOOK +# KDE4_ADD_APP_ICON +# KDE4_CREATE_MANPAGE +# KDE4_CREATE_BASIC_CMAKE_VERSION_FILE (function) +# KDE4_INSTALL_AUTH_HELPER_FILES +# KDE4_AUTH_INSTALL_ACTIONS + +# Copyright (c) 2006-2009 Alexander Neundorf, <neundorf@kde.org> +# Copyright (c) 2006, 2007, Laurent Montel, <montel@kde.org> +# Copyright (c) 2007 Matthias Kretz <kretz@kde.org> +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +# This is for versions of automoc4 which don't provide these two macros. +# If such a version is used, just use the "old" style automoc handling. +if(NOT COMMAND _AUTOMOC4_KDE4_PRE_TARGET_HANDLING) + + macro(_AUTOMOC4_KDE4_PRE_TARGET_HANDLING _target _srcs) + if(MSVC) + add_automoc4_target("${_target}_automoc" ${_srcs}) + else(MSVC) + automoc4(${_target} ${_srcs} ) + endif(MSVC) + endmacro(_AUTOMOC4_KDE4_PRE_TARGET_HANDLING) + + + macro(_AUTOMOC4_KDE4_POST_TARGET_HANDLING _target) + if(MSVC) + add_dependencies(${_target} "${_target}_automoc") + endif(MSVC) + endmacro(_AUTOMOC4_KDE4_POST_TARGET_HANDLING) + +endif(NOT COMMAND _AUTOMOC4_KDE4_PRE_TARGET_HANDLING) + + +macro (KDE4_ADD_KCFG_FILES _sources ) + foreach (_current_ARG ${ARGN}) + if( ${_current_ARG} STREQUAL "GENERATE_MOC" ) + set(_kcfg_generatemoc TRUE) + endif( ${_current_ARG} STREQUAL "GENERATE_MOC" ) + + if( ${_current_ARG} STREQUAL "USE_RELATIVE_PATH" ) + set(_kcfg_relativepath TRUE) + endif( ${_current_ARG} STREQUAL "USE_RELATIVE_PATH" ) + endforeach (_current_ARG ${ARGN}) + + foreach (_current_FILE ${ARGN}) + + if(NOT ${_current_FILE} STREQUAL "GENERATE_MOC" AND NOT ${_current_FILE} STREQUAL "USE_RELATIVE_PATH") + get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) + get_filename_component(_abs_PATH ${_tmp_FILE} PATH) + + if (_kcfg_relativepath) # Process relative path only if the option was set + # Get relative path + get_filename_component(_rel_PATH ${_current_FILE} PATH) + + if (IS_ABSOLUTE ${_rel_PATH}) + # We got an absolute path + set(_rel_PATH "") + endif (IS_ABSOLUTE ${_rel_PATH}) + endif (_kcfg_relativepath) + + get_filename_component(_basename ${_tmp_FILE} NAME_WE) + # If we had a relative path and we're asked to use it, then change the basename accordingly + if(NOT ${_rel_PATH} STREQUAL "") + set(_basename ${_rel_PATH}/${_basename}) + endif(NOT ${_rel_PATH} STREQUAL "") + + file(READ ${_tmp_FILE} _contents) + string(REGEX REPLACE "^(.*\n)?File=([^\n]+kcfg).*\n.*$" "\\2" _kcfg_FILENAME "${_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) + set(_kcfg_FILE ${_abs_PATH}/${_kcfg_FILENAME}) + # Maybe the .kcfg is a generated file? + if(NOT EXISTS "${_kcfg_FILE}") + set(_kcfg_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_kcfg_FILENAME}) + endif(NOT EXISTS "${_kcfg_FILE}") + if(NOT EXISTS "${_kcfg_FILE}") + message(ERROR "${_kcfg_FILENAME} not found; tried in ${_abs_PATH} and ${CMAKE_CURRENT_BINARY_DIR}") + endif(NOT EXISTS "${_kcfg_FILE}") + + # make sure the directory exist in the build directory + if(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}") + file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}) + endif(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}") + +# if (CMAKE_CROSSCOMPILING) +# set(IMPORT_KCONFIG_COMPILER_EXECUTABLE "${KDE_HOST_TOOLS_PATH}/ImportKConfigCompilerExecutable.cmake" CACHE FILEPATH "Point it to the export file of kconfig_compiler from a native build") +# include(${IMPORT_KCONFIG_COMPILER_EXECUTABLE}) +# set(KDE4_KCFGC_EXECUTABLE kconfig_compiler) +# endif (CMAKE_CROSSCOMPILING) + + # the command for creating the source file from the kcfg file + add_custom_command(OUTPUT ${_header_FILE} ${_src_FILE} + COMMAND ${KDE4_KCFGC_EXECUTABLE} + ARGS ${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH} + MAIN_DEPENDENCY ${_tmp_FILE} + DEPENDS ${_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) # don't run automoc on this file + list(APPEND ${_sources} ${_moc_FILE}) + endif(_kcfg_generatemoc) + + list(APPEND ${_sources} ${_src_FILE} ${_header_FILE}) + endif(NOT ${_current_FILE} STREQUAL "GENERATE_MOC" AND NOT ${_current_FILE} STREQUAL "USE_RELATIVE_PATH") + 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) + + +# this is basically a copy of the qt4_get_moc_flags() macros from FindQt4.cmake +# which is for internal use only, so we should not use it here: +macro (_KDE4_GET_MOC_FLAGS _moc_flags) + set(${_moc_flags}) + get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES) + + foreach(_current ${_inc_DIRS}) + set(${_moc_flags} ${${_moc_flags}} "-I${_current}") + endforeach(_current ${_inc_DIRS}) + + get_directory_property(_defines COMPILE_DEFINITIONS) + foreach(_current ${_defines}) + set(${_moc_flags} ${${_moc_flags}} "-D${_current}") + endforeach(_current ${_defines}) + + if(Q_WS_WIN) + set(${_moc_flags} ${${_moc_flags}} -DWIN32) + endif(Q_WS_WIN) + + # if Qt is installed only as framework, add -F /library/Frameworks to the moc arguments + # otherwise moc can't find the headers in the framework include dirs + if(APPLE AND "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/") + set(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-F/Library/Frameworks") + endif(APPLE AND "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/") + +endmacro(_KDE4_GET_MOC_FLAGS) + + +#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 ) + + _kde4_get_moc_flags(_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_SET_CUSTOM_TARGET_PROPERTY _target_name _property_name _property) + string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}") + set(_kde4_${_dir}_${_target_name}_${_property_name} "${_property}") +endmacro (_KDE4_SET_CUSTOM_TARGET_PROPERTY) + + +macro (_KDE4_GET_CUSTOM_TARGET_PROPERTY _var _target_name _property_name) + string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}") + set(${_var} "${_kde4_${_dir}_${_target_name}_${_property_name}}") +endmacro (_KDE4_GET_CUSTOM_TARGET_PROPERTY) + + +macro (KDE4_MOC_HEADERS _target_NAME) + # if automoc4 from kdesupport has been found, use the macro provided there + automoc4_moc_headers(${_target_NAME} ${ARGN}) +endmacro (KDE4_MOC_HEADERS) + +macro(KDE4_HANDLE_AUTOMOC _target_NAME _SRCS) + # if automoc4 from kdesupport has been found, use the macro provided there + automoc4(${_target_NAME} ${_SRCS}) +endmacro(KDE4_HANDLE_AUTOMOC) + +macro(KDE4_INSTALL_TS_FILES _lang _sdir) + file(GLOB_RECURSE _ts_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${_sdir}/*) + foreach(_current_TS_FILES ${_ts_files}) + string(REGEX MATCH "\\.svn/" _in_svn ${_current_TS_FILES}) + if(NOT _in_svn) + get_filename_component(_subpath ${_current_TS_FILES} PATH) + install(FILES ${_current_TS_FILES} DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_SCRIPTS/${_subpath}) + endif(NOT _in_svn) + endforeach(_current_TS_FILES) +endmacro(KDE4_INSTALL_TS_FILES) + + +macro (KDE4_CREATE_HANDBOOK _docbook) + get_filename_component(_input ${_docbook} ABSOLUTE) + set(_doc ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2) + + #Bootstrap + if (_kdeBootStrapping) + set(_ssheet "${CMAKE_BINARY_DIR}/kdoctools/customization/kde-chunk.xsl") + set(_bootstrapOption "--srcdir=${CMAKE_BINARY_DIR}/kdoctools/") + else (_kdeBootStrapping) + set(_ssheet "${KDE4_DATA_INSTALL_DIR}/ksgmltools2/customization/kde-chunk.xsl") + set(_bootstrapOption) + endif (_kdeBootStrapping) + + file(GLOB _docs *.docbook) + +# if (CMAKE_CROSSCOMPILING) +# set(IMPORT_MEINPROC4_EXECUTABLE "${KDE_HOST_TOOLS_PATH}/ImportMeinProc4Executable.cmake" CACHE FILEPATH "Point it to the export file of meinproc4 from a native build") +# include(${IMPORT_MEINPROC4_EXECUTABLE}) +# set(KDE4_MEINPROC_EXECUTABLE meinproc4) +# endif (CMAKE_CROSSCOMPILING) + + add_custom_command(OUTPUT ${_doc} + COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check ${_bootstrapOption} --cache ${_doc} ${_input} + DEPENDS ${_docs} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + ) + get_filename_component(_targ ${CMAKE_CURRENT_SOURCE_DIR} NAME) + set(_targ "${_targ}-handbook") + add_custom_target(${_targ} ALL DEPENDS ${_doc}) + + if(KDE4_ENABLE_HTMLHANDBOOK) + set(_htmlDoc ${CMAKE_CURRENT_SOURCE_DIR}/index.html) + add_custom_command(OUTPUT ${_htmlDoc} + COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check ${_bootstrapOption} -o ${_htmlDoc} ${_input} + DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + ) + add_custom_target(htmlhandbook DEPENDS ${_htmlDoc}) + endif(KDE4_ENABLE_HTMLHANDBOOK) + + set(_args ${ARGN}) + + set(_installDest) + if(_args) + list(GET _args 0 _tmp) + if("${_tmp}" STREQUAL "INSTALL_DESTINATION") + list(GET _args 1 _installDest ) + list(REMOVE_AT _args 0 1) + endif("${_tmp}" STREQUAL "INSTALL_DESTINATION") + endif(_args) + + get_filename_component(dirname ${CMAKE_CURRENT_SOURCE_DIR} NAME_WE) + if(_args) + list(GET _args 0 _tmp) + if("${_tmp}" STREQUAL "SUBDIR") + list(GET _args 1 dirname ) + list(REMOVE_AT _args 0 1) + endif("${_tmp}" STREQUAL "SUBDIR") + endif(_args) + + if(_installDest) + file(GLOB _images *.png) + install(FILES ${_doc} ${_docs} ${_images} DESTINATION ${_installDest}/${dirname}) + # TODO symlinks on non-unix platforms + if (UNIX) + # execute some cmake code on make install which creates the symlink + install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink \"${_installDest}/common\" \"\$ENV{DESTDIR}${_installDest}/${dirname}/common\" )" ) + endif (UNIX) + endif(_installDest) + +endmacro (KDE4_CREATE_HANDBOOK) + + +macro (KDE4_CREATE_MANPAGE _docbook _section) + get_filename_component(_input ${_docbook} ABSOLUTE) + get_filename_component(_base ${_input} NAME) + + string(REGEX REPLACE "\\.${_section}\\.docbook$" "" _base ${_base}) + + set(_doc ${CMAKE_CURRENT_BINARY_DIR}/${_base}.${_section}) + # sometimes we have "man-" prepended + string(REGEX REPLACE "/man-" "/" _outdoc ${_doc}) + + #Bootstrap + if (_kdeBootStrapping) + set(_ssheet "${CMAKE_BINARY_DIR}/kdoctools/customization/kde-include-man.xsl") + set(_bootstrapOption "--srcdir=${CMAKE_BINARY_DIR}/kdoctools/") + else (_kdeBootStrapping) + set(_ssheet "${KDE4_DATA_INSTALL_DIR}/ksgmltools2/customization/kde-include-man.xsl") + set(_bootstrapOption) + endif (_kdeBootStrapping) + +# if (CMAKE_CROSSCOMPILING) +# set(IMPORT_MEINPROC4_EXECUTABLE "${KDE_HOST_TOOLS_PATH}/ImportMeinProc4Executable.cmake" CACHE FILEPATH "Point it to the export file of meinproc4 from a native build") +# include(${IMPORT_MEINPROC4_EXECUTABLE}) +# set(KDE4_MEINPROC_EXECUTABLE meinproc4) +# endif (CMAKE_CROSSCOMPILING) + + add_custom_command(OUTPUT ${_outdoc} + COMMAND ${KDE4_MEINPROC_EXECUTABLE} --stylesheet ${_ssheet} --check ${_bootstrapOption} ${_input} + DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} + ) + get_filename_component(_targ ${CMAKE_CURRENT_SOURCE_DIR} NAME) + set(_targ "${_targ}-manpage-${_base}") + add_custom_target(${_targ} ALL DEPENDS "${_outdoc}") + + set(_args ${ARGN}) + + set(_installDest) + if(_args) + list(GET _args 0 _tmp) + if("${_tmp}" STREQUAL "INSTALL_DESTINATION") + list(GET _args 1 _installDest ) + list(REMOVE_AT _args 0 1) + endif("${_tmp}" STREQUAL "INSTALL_DESTINATION") + endif(_args) + + get_filename_component(dirname ${CMAKE_CURRENT_SOURCE_DIR} NAME_WE) + if(_args) + list(GET _args 0 _tmp) + if("${_tmp}" STREQUAL "SUBDIR") + list(GET _args 1 dirname ) + list(REMOVE_AT _args 0 1) + endif("${_tmp}" STREQUAL "SUBDIR") + endif(_args) + + if(_installDest) + install(FILES ${_outdoc} DESTINATION ${_installDest}/man${_section}) + endif(_installDest) +endmacro (KDE4_CREATE_MANPAGE) + + +macro (KDE4_UPDATE_ICONCACHE) + # Update mtime of hicolor icon theme dir. + # We don't always have touch command (e.g. on Windows), so instead create + # and delete a temporary file in the theme dir. + install(CODE " + set(DESTDIR_VALUE \"\$ENV{DESTDIR}\") + if (NOT DESTDIR_VALUE) + file(WRITE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\" \"update\") + file(REMOVE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\") + endif (NOT DESTDIR_VALUE) + ") +endmacro (KDE4_UPDATE_ICONCACHE) + +# a "map" of short type names to the directories +# unknown names should give empty results +# KDE 3 compatibility +set(_KDE4_ICON_GROUP_mime "mimetypes") +set(_KDE4_ICON_GROUP_filesys "places") +set(_KDE4_ICON_GROUP_device "devices") +set(_KDE4_ICON_GROUP_app "apps") +set(_KDE4_ICON_GROUP_action "actions") +# KDE 4 / icon naming specification compatibility +set(_KDE4_ICON_GROUP_mimetypes "mimetypes") +set(_KDE4_ICON_GROUP_places "places") +set(_KDE4_ICON_GROUP_devices "devices") +set(_KDE4_ICON_GROUP_apps "apps") +set(_KDE4_ICON_GROUP_actions "actions") +set(_KDE4_ICON_GROUP_categories "categories") +set(_KDE4_ICON_GROUP_status "status") +set(_KDE4_ICON_GROUP_emblems "emblems") +set(_KDE4_ICON_GROUP_emotes "emotes") +set(_KDE4_ICON_GROUP_animations "animations") +set(_KDE4_ICON_GROUP_intl "intl") + +# a "map" of short theme names to the theme directory +set(_KDE4_ICON_THEME_ox "oxygen") +set(_KDE4_ICON_THEME_cr "crystalsvg") +set(_KDE4_ICON_THEME_lo "locolor") +set(_KDE4_ICON_THEME_hi "hicolor") + + +# only used internally by KDE4_INSTALL_ICONS +macro (_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME _l10n_SUBDIR) + + # 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 ${_KDE4_ICON_GROUP_${_group}}) + if(NOT _icon_GROUP) + set(_icon_GROUP "actions") + endif(NOT _icon_GROUP) +# message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name} l10n: ${_l10n_SUBDIR}") + install(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/${_l10n_SUBDIR}/ RENAME ${_install_NAME} ) + endif (NOT ${_group} STREQUAL ${_install_NAME} ) + +endmacro (_KDE4_ADD_ICON_INSTALL_RULE) + + +macro (KDE4_INSTALL_ICONS _defaultpath ) + + # the l10n-subdir if language given as second argument (localized icon) + set(_lang ${ARGV1}) + if(_lang) + set(_l10n_SUBDIR l10n/${_lang}) + else(_lang) + set(_l10n_SUBDIR ".") + endif(_lang) + + # first the png icons + file(GLOB _icons *.png) + foreach (_current_ICON ${_icons} ) + # since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty + string(REGEX MATCH "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" _dummy "${_current_ICON}") + set(_type "${CMAKE_MATCH_1}") + set(_size "${CMAKE_MATCH_2}") + set(_group "${CMAKE_MATCH_3}") + set(_name "${CMAKE_MATCH_4}") + + set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}}) + if( _theme_GROUP) + _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} + ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}) + endif( _theme_GROUP) + endforeach (_current_ICON) + + # mng icons + file(GLOB _icons *.mng) + foreach (_current_ICON ${_icons} ) + # since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty + string(REGEX MATCH "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" _dummy "${_current_ICON}") + set(_type "${CMAKE_MATCH_1}") + set(_size "${CMAKE_MATCH_2}") + set(_group "${CMAKE_MATCH_3}") + set(_name "${CMAKE_MATCH_4}") + + set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}}) + if( _theme_GROUP) + _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} + ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}) + endif( _theme_GROUP) + endforeach (_current_ICON) + + # and now the svg icons + file(GLOB _icons *.svgz) + foreach (_current_ICON ${_icons} ) + # since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty + string(REGEX MATCH "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" _dummy "${_current_ICON}") + set(_type "${CMAKE_MATCH_1}") + set(_group "${CMAKE_MATCH_2}") + set(_name "${CMAKE_MATCH_3}") + + set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}}) + if( _theme_GROUP) + _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme_GROUP}/scalable + ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}) + endif( _theme_GROUP) + endforeach (_current_ICON) + + kde4_update_iconcache() + +endmacro (KDE4_INSTALL_ICONS) + + +# 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) + # only put C++ files in the final-file + if("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$") + file(APPEND "${_filenameCPP}" "#include \"${_abs_FILE}\"\n") + else("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$") + list(APPEND ${_filesExcludedFromFinalFile} "${_abs_FILE}") + endif("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$") + endif (_isGenerated) + endforeach (_current_FILE) + +endmacro (KDE4_CREATE_FINAL_FILES) + +# This macro doesn't set up the RPATH related options for executables anymore, +# since now (wioth cmake 2.6) just the full RPATH is used always for everything. +# It does create 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. +macro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE _target_NAME) + if (UNIX) + if (APPLE) + set(_library_path_variable "DYLD_LIBRARY_PATH") + elseif (CYGWIN) + set(_library_path_variable "PATH") + else (APPLE) + set(_library_path_variable "LD_LIBRARY_PATH") + endif (APPLE) + + if (APPLE) + # DYLD_LIBRARY_PATH does not work like LD_LIBRARY_PATH + # OSX already has the RPATH in libraries and executables, putting runtime directories in + # DYLD_LIBRARY_PATH actually breaks things + set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${KDE4_LIB_DIR}") + else (APPLE) + set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${LIB_INSTALL_DIR}:${KDE4_LIB_DIR}:${QT_LIBRARY_DIR}") + endif (APPLE) + 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 ) +#if the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, +#otherwise set the prefix empty + + set(_args ${ARGN}) + # default to module + set(_add_lib_param "MODULE") + set(_with_pre FALSE) + + foreach(arg ${_args}) + if (arg STREQUAL "WITH_PREFIX") + set(_with_pre TRUE) + endif (arg STREQUAL "WITH_PREFIX") + if (arg STREQUAL "STATIC") + set(_add_lib_param STATIC) + endif (arg STREQUAL "STATIC") + if (arg STREQUAL "SHARED") + set(_add_lib_param SHARED) + endif (arg STREQUAL "SHARED") + if (arg STREQUAL "MODULE") + set(_add_lib_param MODULE) + endif (arg STREQUAL "MODULE") + endforeach(arg) + + if(_with_pre) + list(REMOVE_ITEM _args "WITH_PREFIX") + endif(_with_pre) + if(_add_lib_param STREQUAL "STATIC") + list(REMOVE_ITEM _args "STATIC") + endif(_add_lib_param STREQUAL "STATIC") + if (_add_lib_param STREQUAL "SHARED") + list(REMOVE_ITEM _args "SHARED") + endif (_add_lib_param STREQUAL "SHARED") + if (_add_lib_param STREQUAL "MODULE") + list(REMOVE_ITEM _args "MODULE") + endif (_add_lib_param STREQUAL "MODULE") + + set(_SRCS ${_args}) + + _automoc4_kde4_pre_target_handling(${_target_NAME} _SRCS) + + if("${_add_lib_param}" STREQUAL "STATIC") + add_definitions(-DQT_STATICPLUGIN) + endif("${_add_lib_param}" STREQUAL "STATIC") + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) + add_library(${_target_NAME} ${_add_lib_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files}) + else (KDE4_ENABLE_FINAL) + add_library(${_target_NAME} ${_add_lib_param} ${_SRCS}) + endif (KDE4_ENABLE_FINAL) + + _automoc4_kde4_post_target_handling(${_target_NAME}) + + if (NOT _with_pre) + set_target_properties(${_target_NAME} PROPERTIES PREFIX "") + endif (NOT _with_pre) + + # for shared libraries/plugins a -DMAKE_target_LIB is required + string(TOUPPER ${_target_NAME} _symbol) + string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol}) + set(_symbol "MAKE_${_symbol}_LIB") + set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) + +endmacro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX) + + +# this macro 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) +# "RUN_UNINSTALLED" in the list of files is ignored, it is not necessary anymore +# since KDE 4.2 (with cmake 2.6.2), since then all executables are always built +# with RPATH pointing into the build dir. +# if "TEST" is in the list of files, the _test argument is set to +# "TEST" (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 _test) + set(${_nogui}) + set(${_test}) + 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 (${first_PARAM} STREQUAL "RUN_UNINSTALLED") + set(remove 0) + endif (${first_PARAM} STREQUAL "RUN_UNINSTALLED") + + if (${first_PARAM} STREQUAL "TEST") + set(${_test} "TEST") + set(remove 0) + endif (${first_PARAM} STREQUAL "TEST") + + if (${second_PARAM} STREQUAL "NOGUI") + set(${_nogui} "NOGUI") + set(remove 0;1) + endif (${second_PARAM} STREQUAL "NOGUI") + + if (${second_PARAM} STREQUAL "RUN_UNINSTALLED") + set(remove 0;1) + endif (${second_PARAM} STREQUAL "RUN_UNINSTALLED") + + if (${second_PARAM} STREQUAL "TEST") + set(${_test} "TEST") + set(remove 0;1) + endif (${second_PARAM} STREQUAL "TEST") + + + 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 _test ${ARGN}) + + configure_file(${KDE4_MODULE_DIR}/kde4init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) + set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp PROPERTIES SKIP_AUTOMOC TRUE) + # under Windows, build a normal executable and additionally a dummy kdeinit4_foo.lib, whose only purpose on windows is to + # keep the linking logic from the CMakeLists.txt on UNIX working (under UNIX all necessary libs are linked against the kdeinit + # library instead against the executable, under windows we want to have everything in the executable, but for compatibility we have to + # keep the library there- + if(WIN32) + if (MINGW) + list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_res.o _res_position) + else(MINGW) + list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}.rc _res_position) + endif(MINGW) + if(NOT _res_position EQUAL -1) + list(GET _SRCS ${_res_position} _resourcefile) + list(REMOVE_AT _SRCS ${_res_position}) + endif(NOT _res_position EQUAL -1) + + set(_KDEINIT4_TARGET_NAME_ ${_target_NAME}) + string(REGEX REPLACE "[-]" "_" _KDEINIT4_TARGET_NAME_ "${_KDEINIT4_TARGET_NAME_}") + configure_file(${KDE4_MODULE_DIR}/kde4init_win32lib_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp) + add_library(kdeinit_${_target_NAME} STATIC ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp) + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) + kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile}) + + else (KDE4_ENABLE_FINAL) + kde4_add_executable(${_target_NAME} "${_nogui}" ${_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile}) + endif (KDE4_ENABLE_FINAL) + + set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME}) + + target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY} kdeinit_${_target_NAME}) + else(WIN32) + _automoc4_kde4_pre_target_handling(kdeinit_${_target_NAME} _SRCS) + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) + add_library(kdeinit_${_target_NAME} SHARED ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files}) + + else (KDE4_ENABLE_FINAL) + add_library(kdeinit_${_target_NAME} SHARED ${_SRCS}) + endif (KDE4_ENABLE_FINAL) + + _automoc4_kde4_post_target_handling(kdeinit_${_target_NAME}) + + set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME}) + + kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) + target_link_libraries(${_target_NAME} kdeinit_${_target_NAME}) + endif(WIN32) + +endmacro (KDE4_ADD_KDEINIT_EXECUTABLE) + +# Add a unit test, which is executed when running make test . +# The targets are always created, but only built for the "all" +# target if the option KDE4_BUILD_TESTS is enabled. Otherwise the rules for the target +# are created but not built by default. You can build them by manually building the target. +# The name of the target can be specified using TESTNAME <testname>, if it is not given +# the macro will default to the <name> +macro (KDE4_ADD_UNIT_TEST _test_NAME) + set(_srcList ${ARGN}) + set(_targetName ${_test_NAME}) + if( ${ARGV1} STREQUAL "TESTNAME" ) + set(_targetName ${ARGV2}) + list(REMOVE_AT _srcList 0 1) + endif( ${ARGV1} STREQUAL "TESTNAME" ) + + set(_nogui) + list(GET ${_srcList} 0 first_PARAM) + if( ${first_PARAM} STREQUAL "NOGUI" ) + set(_nogui "NOGUI") + endif( ${first_PARAM} STREQUAL "NOGUI" ) + + kde4_add_executable( ${_test_NAME} TEST ${_srcList} ) + + if(NOT KDE4_TEST_OUTPUT) + set(KDE4_TEST_OUTPUT plaintext) + endif(NOT KDE4_TEST_OUTPUT) + set(KDE4_TEST_OUTPUT ${KDE4_TEST_OUTPUT} CACHE STRING "The output to generate when running the QTest unit tests") + + set(using_qtest "") + foreach(_filename ${_srcList}) + if(NOT using_qtest) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}") + file(READ ${_filename} file_CONTENT) + string(REGEX MATCH "QTEST_(KDE)?MAIN" using_qtest "${file_CONTENT}") + endif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}") + endif(NOT using_qtest) + endforeach(_filename) + + get_target_property( loc ${_test_NAME} LOCATION ) + if(WIN32) + if(MSVC_IDE) + STRING(REGEX REPLACE "\\$\\(.*\\)" "\${CTEST_CONFIGURATION_TYPE}" loc "${loc}") + endif() + # .bat because of rpath handling + set(_executable "${loc}.bat") + else(WIN32) + if (Q_WS_MAC AND NOT _nogui) + set(_executable ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME}.app/Contents/MacOS/${_test_NAME}) + else (Q_WS_MAC AND NOT _nogui) + # .shell because of rpath handling + set(_executable "${loc}.shell") + endif (Q_WS_MAC AND NOT _nogui) + endif(WIN32) + + if (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml") + #MESSAGE(STATUS "${_targetName} : Using QTestLib, can produce XML report.") + add_test( ${_targetName} ${_executable} -xml -o ${_targetName}.tml) + else (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml") + #MESSAGE(STATUS "${_targetName} : NOT using QTestLib, can't produce XML report, please use QTestLib to write your unit tests.") + add_test( ${_targetName} ${_executable} ) + endif (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml") + +# add_test( ${_targetName} ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME} -xml -o ${_test_NAME}.tml ) + + if (NOT MSVC_IDE) #not needed for the ide + # if the tests are EXCLUDE_FROM_ALL, add a target "buildtests" to build all tests + if (NOT KDE4_BUILD_TESTS) + get_directory_property(_buildtestsAdded BUILDTESTS_ADDED) + if(NOT _buildtestsAdded) + add_custom_target(buildtests) + set_directory_properties(PROPERTIES BUILDTESTS_ADDED TRUE) + endif(NOT _buildtestsAdded) + add_dependencies(buildtests ${_test_NAME}) + endif (NOT KDE4_BUILD_TESTS) + endif (NOT MSVC_IDE) + +endmacro (KDE4_ADD_UNIT_TEST) + + +# add a manifest file to executables. +# +# There is a henn-egg problem when a target runtime part is renamed using +# the OUTPUT_NAME option of cmake's set_target_properties command. +# +# At now the Makefiles rules creating for manifest adding are performed +# *after* the cmake's add_executable command but *before* an optional +# set_target_properties command. +# This means that in KDE4_ADD_MANIFEST the LOCATION property contains +# the unchanged runtime part name of the target. :-( +# +# The recently used workaround is to specify a variable build off the target name followed +# by _OUTPUT_NAME before calling kde4_add_executable as shown in the following example: +# +# set(xyz_OUTPUT_NAME test) +# kde4_add_executable( xyz <source>) +# set_target_properties( xyz PROPERTIES OUTPUT_NAME ${xyz_OUTPUT_NAME} ) +# +# The full solution would be to introduce a kde4_target_link_libraries macro and to +# call KDE4_ADD_MANIFEST inside instead of calling in kde4_add_executable. +# This would require patching of *all* places in the KDE sources where target_link_libraries +# is used and to change the related docs. +# +# Because yet I found only 2 locations where this problem occurs (kjs, k3b), the workaround +# seems to be a pragmatically solution. +# +# This macro is an internal macro only used by kde4_add_executable +# +macro (_KDE4_ADD_MANIFEST _target_NAME) + set(x ${_target_NAME}_OUTPUT_NAME) + if (${x}) + get_target_property(_var ${_target_NAME} LOCATION ) + string(REPLACE "${_target_NAME}" "${${x}}" _executable ${_var}) + else(${x}) + get_target_property(_executable ${_target_NAME} LOCATION ) + endif(${x}) + + if (_kdeBootStrapping) + set(_cmake_module_path ${CMAKE_SOURCE_DIR}/cmake/modules) + else (_kdeBootStrapping) + set(_cmake_module_path ${KDE4_INSTALL_DIR}/share/apps/cmake/modules) + endif (_kdeBootStrapping) + + set(_manifest ${_cmake_module_path}/Win32.Manifest.in) + #message(STATUS ${_executable} ${_manifest}) + add_custom_command( + TARGET ${_target_NAME} + POST_BUILD + COMMAND ${KDE4_MT_EXECUTABLE} + ARGS + -manifest ${_manifest} + -updateresource:${_executable} + COMMENT "adding vista trustInfo manifest to ${_target_NAME}" + ) +endmacro(_KDE4_ADD_MANIFEST) + + +macro (KDE4_ADD_EXECUTABLE _target_NAME) + + kde4_check_executable_params( _SRCS _nogui _test ${ARGN}) + + set(_add_executable_param) + + # determine additional parameters for add_executable() + # for GUI apps, create a bundle on OSX + if (Q_WS_MAC) + set(_add_executable_param MACOSX_BUNDLE) + endif (Q_WS_MAC) + + # for GUI apps, this disables the additional console under Windows + if (WIN32) + set(_add_executable_param WIN32) + endif (WIN32) + + if (_nogui) + set(_add_executable_param) + endif (_nogui) + + if (_test AND NOT KDE4_BUILD_TESTS) + set(_add_executable_param ${_add_executable_param} EXCLUDE_FROM_ALL) + endif (_test AND NOT KDE4_BUILD_TESTS) + + _automoc4_kde4_pre_target_handling(${_target_NAME} _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}) + else (KDE4_ENABLE_FINAL) + add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS}) + endif (KDE4_ENABLE_FINAL) + + IF (KDE4_ENABLE_UAC_MANIFEST) + _kde4_add_manifest(${_target_NAME}) + ENDIF(KDE4_ENABLE_UAC_MANIFEST) + + _automoc4_kde4_post_target_handling(${_target_NAME}) + + if (_test) + set_target_properties(${_target_NAME} PROPERTIES COMPILE_FLAGS -DKDESRCDIR="\\"${CMAKE_CURRENT_SOURCE_DIR}/\\"") + endif (_test) + + kde4_handle_rpath_for_executable(${_target_NAME}) + + if (WIN32) + target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY}) + endif (WIN32) + +endmacro (KDE4_ADD_EXECUTABLE) + + +macro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE) + + 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") + + set(_SRCS ${_first_SRC} ${ARGN}) + + _automoc4_kde4_pre_target_handling(${_target_NAME} _SRCS) + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) + add_library(${_target_NAME} ${_add_lib_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files}) + else (KDE4_ENABLE_FINAL) + add_library(${_target_NAME} ${_add_lib_param} ${_SRCS}) + endif (KDE4_ENABLE_FINAL) + + _automoc4_kde4_post_target_handling(${_target_NAME}) + + # for shared libraries a -DMAKE_target_LIB is required + string(TOUPPER ${_target_NAME} _symbol) + string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol}) + set(_symbol "MAKE_${_symbol}_LIB") + set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) + + # By default don't add any linked libraries to the "exported" + # link interfaces, so that executables linking against this library + # will not automatically add implicit dependencies to their link list. + # + # This reduces inter-package dependencies and makes it easier to remove + # dependencies of shared libraries without breaking binary compatibility. + if(NOT "${_add_lib_param}" STREQUAL "STATIC") + set_target_properties(${_target_NAME} PROPERTIES LINK_INTERFACE_LIBRARIES "" ) + endif(NOT "${_add_lib_param}" STREQUAL "STATIC") + +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_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) + + +macro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName) + string(TOUPPER ${_libName} _libNameUpperCase) + string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _libNameUpperCase ${_libNameUpperCase}) + # the next line is is required, because in CMake arguments to macros are not real + # variables, but handled differently. The next line create a real CMake variable, + # so configure_file() will replace it correctly. + set(_libName ${_libName}) + # compared to write(FILE) configure_file() only really writes the file if the + # contents have changed. Otherwise we would have a lot of recompiles. + configure_file(${KDE4_MODULE_DIR}/kde4exportsheader.h.in ${_outputFile}) +endmacro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName) + + +macro (KDE4_CREATE_HTML_HANDBOOK _docbook) + message(STATUS "KDE4_CREATE_HTML_HANDBOOK() is deprecated. Enable the option KDE4_ENABLE_HTMLHANDBOOK instead, this will give you targets htmlhandbook for creating the html help.") +endmacro (KDE4_CREATE_HTML_HANDBOOK) + + +# adds application icon to target source list +# 'appsources' - the sources of the application +# 'pngfiles' - specifies the list of icon files +# example: KDE4_ADD_WIN32_APP_ICON(myapp_SRCS "pics/cr16-myapp.png;pics/cr32-myapp.png") + +macro (KDE4_ADD_WIN32_APP_ICON appsources) + message(STATUS "KDE4_ADD_WIN32_APP_ICON() is deprecated, use KDE4_ADD_APP_ICON() instead") + if (WIN32) + if(NOT WINCE) + find_program(PNG2ICO_EXECUTABLE NAMES png2ico) + else(NOT WINCE) + find_program(PNG2ICO_EXECUTABLE NAMES png2ico PATHS ${HOST_BINDIR} NO_DEFAULT_PATH ) + endif(NOT WINCE) + find_program(WINDRES_EXECUTABLE NAMES windres) + if(MSVC) + set(WINDRES_EXECUTABLE TRUE) + endif(MSVC) + string(REPLACE _SRCS "" appname ${appsources}) + if (PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) + set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appname}) + + # png2ico is found by the above find_program +# message("png2ico ${_outfilename}.ico ${ARGN}") + exec_program(png2ico ARGS ${_outfilename}.ico ${ARGN}) + + # now make rc file for adding it to the sources + file(WRITE ${_outfilename}.rc "IDI_ICON1 ICON DISCARDABLE \"${_outfilename}.ico\"\n") + if (MINGW) + exec_program(windres + ARGS "-i ${_outfilename}.rc -o ${_outfilename}_res.o --include-dir=${CMAKE_CURRENT_SOURCE_DIR}") + list(APPEND ${appsources} ${CMAKE_CURRENT_BINARY_DIR}/${appname}_res.o) + else(MINGW) + list(APPEND ${appsources} ${CMAKE_CURRENT_BINARY_DIR}/${appname}.rc) + endif(MINGW) + endif(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) + endif(WIN32) +endmacro (KDE4_ADD_WIN32_APP_ICON) + +# adds application icon to target source list +# for detailed documentation see the top of FindKDE4Internal.cmake +macro (KDE4_ADD_APP_ICON appsources pattern) + set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appsources}) + + if (WIN32) + if(NOT WINCE) + find_program(PNG2ICO_EXECUTABLE NAMES png2ico) + else(NOT WINCE) + find_program(PNG2ICO_EXECUTABLE NAMES png2ico PATHS ${HOST_BINDIR} NO_DEFAULT_PATH ) + endif(NOT WINCE) + find_program(WINDRES_EXECUTABLE NAMES windres) + if(MSVC) + set(WINDRES_EXECUTABLE TRUE) + endif(MSVC) + if (PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) + string(REPLACE "*" "(.*)" pattern_rx "${pattern}") + file(GLOB files "${pattern}") + foreach (it ${files}) + string(REGEX REPLACE "${pattern_rx}" "\\1" fn "${it}") + if (fn MATCHES ".*16.*" ) + list (APPEND _icons ${it}) + endif (fn MATCHES ".*16.*") + if (fn MATCHES ".*32.*" ) + list (APPEND _icons ${it}) + endif (fn MATCHES ".*32.*") + if (fn MATCHES ".*48.*" ) + list (APPEND _icons ${it}) + endif (fn MATCHES ".*48.*") + if (fn MATCHES ".*64.*" ) + list (APPEND _icons ${it}) + endif (fn MATCHES ".*64.*") + if (fn MATCHES ".*128.*" ) + list (APPEND _icons ${it}) + endif (fn MATCHES ".*128.*") + endforeach (it) + if (_icons) + add_custom_command(OUTPUT ${_outfilename}.ico ${_outfilename}.rc + COMMAND ${PNG2ICO_EXECUTABLE} ARGS --rcfile ${_outfilename}.rc ${_outfilename}.ico ${_icons} + DEPENDS ${PNG2ICO_EXECUTABLE} ${_icons} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + ) + if (MINGW) + add_custom_command(OUTPUT ${_outfilename}_res.o + COMMAND ${WINDRES_EXECUTABLE} ARGS -i ${_outfilename}.rc -o ${_outfilename}_res.o --include-dir=${CMAKE_CURRENT_SOURCE_DIR} + DEPENDS ${WINDRES_EXECUTABLE} ${_outfilename}.rc + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + ) + list(APPEND ${appsources} ${_outfilename}_res.o) + else(MINGW) + list(APPEND ${appsources} ${_outfilename}.rc) + endif(MINGW) + else(_icons) + message(STATUS "Unable to find a related icon that matches pattern ${pattern} for variable ${appsources} - application will not have an application icon!") + endif(_icons) + else(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) + message(STATUS "Unable to find the png2ico or windres utilities - application will not have an application icon!") + endif(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) + endif(WIN32) + if (Q_WS_MAC) + # first convert image to a tiff using the Mac OS X "sips" utility, + # then use tiff2icns to convert to an icon + find_program(SIPS_EXECUTABLE NAMES sips) + find_program(TIFF2ICNS_EXECUTABLE NAMES tiff2icns) + if (SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE) + file(GLOB_RECURSE files "${pattern}") + # we can only test for the 128-icon like that - we don't use patterns anymore + foreach (it ${files}) + if (it MATCHES ".*128.*" ) + set (_icon ${it}) + endif (it MATCHES ".*128.*") + endforeach (it) + + if (_icon) + + # first, get the basename of our app icon + add_custom_command(OUTPUT ${_outfilename}.icns ${outfilename}.tiff + COMMAND ${SIPS_EXECUTABLE} -s format tiff ${_icon} --out ${outfilename}.tiff + COMMAND ${TIFF2ICNS_EXECUTABLE} ${outfilename}.tiff ${_outfilename}.icns + DEPENDS ${_icon} + ) + + # This will register the icon into the bundle + set(MACOSX_BUNDLE_ICON_FILE ${appsources}.icns) + + # Append the icns file to the sources list so it will be a dependency to the + # main target + list(APPEND ${appsources} ${_outfilename}.icns) + + # Install the icon into the Resources dir in the bundle + set_source_files_properties(${_outfilename}.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources) + + else(_icon) + # TODO - try to scale a non-128 icon...? Try to convert an SVG on the fly? + message(STATUS "Unable to find an 128x128 icon that matches pattern ${pattern} for variable ${appsources} - application will not have an application icon!") + endif(_icon) + + else(SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE) + message(STATUS "Unable to find the sips and tiff2icns utilities - application will not have an application icon!") + endif(SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE) + endif(Q_WS_MAC) +endmacro (KDE4_ADD_APP_ICON) + + +# This macro is only kept around for compatibility, it is not needed/used anymore +# since CMake 2.6.0. With CMake 2.6.0 it is not necessary anymore link libraries again +# ("relink") to change their RPATH. Since this is fast now, they are now always built with +# full RPATH. +# Still keep this macro here, since somebody might use it and so that would break +# if we would just remove it from here. +# What it does now it sets the target properties of the given target the same way as +# they were set by the old version of the macro with the option FULL_RPATH enabled. +# This one may be a candidate for removal. Alex +macro (KDE4_HANDLE_RPATH_FOR_LIBRARY _target_NAME) + message(STATUS "You are using the macro KDE4_HANDLE_RPATH_FOR_LIBRARY(), which is an internal macro and shouldn't be used by external projects. Please remove it.") + if (NOT CMAKE_SKIP_RPATH) + set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE) + endif (NOT CMAKE_SKIP_RPATH) +endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY) + +# This macro adds the needed files for an helper executable meant to be used by applications using KAuth. +# It accepts the helper target, the helper ID (the DBUS name) and the user under which the helper will run on. +# This macro takes care of generate the needed files, and install them in the right location. This boils down +# to a DBus policy to let the helper register on the system bus, and a service file for letting the helper +# being automatically activated by the system bus. +# *WARNING* You have to install the helper in ${LIBEXEC_INSTALL_DIR} to make sure everything will work. +function(KDE4_INSTALL_AUTH_HELPER_FILES HELPER_TARGET HELPER_ID HELPER_USER) + if(KDE4_AUTH_HELPER_BACKEND_NAME STREQUAL "DBUS") + if (_kdeBootStrapping) + set(_stubFilesDir ${CMAKE_SOURCE_DIR}/kdecore/auth/backends/dbus/ ) + else (_kdeBootStrapping) + set(_stubFilesDir ${KDE4_DATA_INSTALL_DIR}/kauth/ ) + endif (_kdeBootStrapping) + + configure_file(${_stubFilesDir}/dbus_policy.stub + ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.conf) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.conf + DESTINATION ${SYSCONF_INSTALL_DIR}/dbus-1/system.d/) + + configure_file(${_stubFilesDir}/dbus_service.stub + ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.service) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.service + DESTINATION ${DBUS_SYSTEM_SERVICES_INSTALL_DIR}) + endif(KDE4_AUTH_HELPER_BACKEND_NAME STREQUAL "DBUS") +endfunction(KDE4_INSTALL_AUTH_HELPER_FILES) + +# This macro generates an action file, depending on the backend used, for applications using KAuth. +# It accepts the helper id (the DBUS name) and a file containing the actions (check kdelibs/kdecore/auth/example +# for file format). The macro will take care of generating the file according to the backend specified, +# and to install it in the right location. This (at the moment) means that on Linux (PolicyKit) a .policy +# file will be generated and installed into the policykit action directory (usually /usr/share/PolicyKit/policy/), +# and on Mac (Authorization Services) will be added to the system action registry using the native MacOS API during +# the install phase +function(KDE4_INSTALL_AUTH_ACTIONS HELPER_ID ACTIONS_FILE) + + if(KDE4_AUTH_BACKEND_NAME STREQUAL "APPLE") + install(CODE "execute_process(COMMAND ${KDE4_KAUTH_POLICY_GEN_EXECUTABLE} ${ACTIONS_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})") + elseif(KDE4_AUTH_BACKEND_NAME STREQUAL "POLKITQT" OR KDE4_AUTH_BACKEND_NAME STREQUAL "POLKITQT-1") + set(_output ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.policy) + get_filename_component(_input ${ACTIONS_FILE} ABSOLUTE) + + add_custom_command(OUTPUT ${_output} + COMMAND ${KDE4_KAUTH_POLICY_GEN_EXECUTABLE} ${_input} > ${_output} + MAIN_DEPENDENCY ${_input} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMENT "Generating ${HELPER_ID}.policy" + DEPENDS ${_KDE4_KAUTH_POLICY_GEN_EXECUTABLE_DEP}) + add_custom_target("actions for ${HELPER_ID}" ALL DEPENDS ${_output}) + + install(FILES ${_output} DESTINATION ${KDE4_AUTH_POLICY_FILES_INSTALL_DIR}) + endif() + +endfunction(KDE4_INSTALL_AUTH_ACTIONS) + + +macro(_KDE4_EXPORT_LIBRARY_DEPENDENCIES _append_or_write _filename) + message(FATAL_ERROR "_KDE4_EXPORT_LIBRARY_DEPENDENCIES() was an internal macro and has been removed again. Just remove the code which calls it, there is no substitute.") +endmacro(_KDE4_EXPORT_LIBRARY_DEPENDENCIES) + +macro (_KDE4_TARGET_LINK_INTERFACE_LIBRARIES _target _interface_libs) + message(FATAL_ERROR "_KDE4_TARGET_LINK_INTERFACE_LIBRARIES() doesn't exist anymore. Set the LINK_INTERFACE_LIBRARIES target property instead. See kdelibs/kdecore/CMakeLists.txt for an example.") +endmacro (_KDE4_TARGET_LINK_INTERFACE_LIBRARIES) + +macro (KDE4_TARGET_LINK_INTERFACE_LIBRARIES _target _interface_libs) + message(FATAL_ERROR "KDE4_TARGET_LINK_INTERFACE_LIBRARIES() doesn't exist anymore. Set the LINK_INTERFACE_LIBRARIES target property instead. See kdelibs/kdecore/CMakeLists.txt for an example.") +endmacro (KDE4_TARGET_LINK_INTERFACE_LIBRARIES _target _interface_libs) + +macro (KDE4_INSTALL_HANDBOOK _lang) + message(STATUS "KDE4_INSTALL_HANDBOOK() is deprecated. Remove it please. Now all is done in KDE4_CREATE_HANDBOOK.") +endmacro (KDE4_INSTALL_HANDBOOK ) + +macro (KDE4_SET_CUSTOM_TARGET_PROPERTY) + message(FATAL_ERROR "KDE4_SET_CUSTOM_TARGET_PROPERTY() is deprecated, just use a simple variable instead") +endmacro (KDE4_SET_CUSTOM_TARGET_PROPERTY) + +macro (KDE4_GET_CUSTOM_TARGET_PROPERTY) + message(FATAL_ERROR "KDE4_GET_CUSTOM_TARGET_PROPERTY() is deprecated, just use a simple variable instead") +endmacro (KDE4_GET_CUSTOM_TARGET_PROPERTY) |