TDE
/
kbfx
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/kbfx
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5661d90024'
${ noResults }
kbfx/cmakemodules/KDE4Macros.cmake

855 lines
35 KiB
Raw Blame History

# 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_TDEINIT_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_TDEINIT_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_TDEINIT_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)
View Git Blame Copy Permalink