No OneTemporary
Actions

Size

48 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/cmake/modules/KDE4Macros.cmake b/cmake/modules/KDE4Macros.cmake
	index 5a449a88e1..e2b71380ce 100644
	--- a/cmake/modules/KDE4Macros.cmake
	+++ b/cmake/modules/KDE4Macros.cmake
	@@ -1,758 +1,623 @@
	# 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_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_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.


	get_filename_component(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH)

	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_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)
	-

	# 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})

	if("${_add_lib_param}" STREQUAL "STATIC")
	add_definitions(-DQT_STATICPLUGIN)
	endif("${_add_lib_param}" STREQUAL "STATIC")

	add_library(${_target_NAME} ${_add_lib_param} ${_SRCS})

	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)

	kde4_add_executable(${_target_NAME} "${_nogui}" ${_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})

	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)

	add_library(kdeinit_${_target_NAME} SHARED ${_SRCS})

	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)

	add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS})

	IF (KDE4_ENABLE_UAC_MANIFEST)
	_kde4_add_manifest(${_target_NAME})
	ENDIF(KDE4_ENABLE_UAC_MANIFEST)

	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)

	include(GenerateExportHeader)

	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})

	add_library(${_target_NAME} ${_add_lib_param} ${_SRCS})

	# 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})
	endmacro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)

	macro(kf5_add_library _target_NAME _lib_TYPE)
	kde4_add_library(${_target_NAME} ${_lib_TYPE} ${ARGN})
	generate_export_header(${_target_NAME})
	endmacro()

	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_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)
	-
	-
	# 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)

	# TODO: Move this to kde4support
	if (_kdeBootStrapping)
	include("${CMAKE_SOURCE_DIR}/kdecore/KDECoreMacros.cmake")
	include("${CMAKE_SOURCE_DIR}/kdeui/KDEUIMacros.cmake")
	+ include("${CMAKE_SOURCE_DIR}/kdoctools/KDocToolsMacros.cmake")
	include("${CMAKE_SOURCE_DIR}/kde3support/KDE3SupportMacros.cmake")
	else()
	include("${KDE4_MODULE_DIR}/KDECoreMacros.cmake")
	include("${KDE4_MODULE_DIR}/KDEUIMacros.cmake")
	+ include("${KDE4_MODULE_DIR}/KDocToolsMacros.cmake")
	include("${KDE4_MODULE_DIR}/KDE3SupportMacros.cmake")
	endif()


	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)
	diff --git a/kdoctools/CMakeLists.txt b/kdoctools/CMakeLists.txt
	index 77568d8fc0..0397c6d8ea 100644
	--- a/kdoctools/CMakeLists.txt
	+++ b/kdoctools/CMakeLists.txt
	@@ -1,219 +1,222 @@
	project(kdoctools)

	find_package(LibXslt)
	macro_log_feature(LIBXSLT_FOUND "LibXSLT" "Required by the KDE help system to process DocBook XML" "http://xmlsoft.org/XSLT" TRUE "" "")

	find_package(LibXml2)
	macro_log_feature(LIBXML2_FOUND "LibXML2" "Required by the KDE help system to process DocBook XML" "http://xmlsoft.org" TRUE "" "")

	macro_log_feature(LIBXML2_XMLLINT_EXECUTABLE "xmllint" "Required by the KDE help system to process DocBook XML" "http://xmlsoft.org" TRUE "" "")

	include_directories( ${KDE4_KIO_INCLUDES}
	${karchive_SOURCE_DIR}/src
	${karchive_BINARY_DIR}/src
	)
	#include_directories( ${CMAKE_SOURCE_DIR}/kioslave ${CMAKE_SOURCE_DIR}/kioslave/bzip2 )

	include_directories( ${LIBXML2_INCLUDE_DIR} ${LIBXSLT_INCLUDE_DIR} )

	configure_file(checkXML.in.cmake ${CMAKE_CURRENT_BINARY_DIR}/checkXML )
	#macro_additional_clean_files( ${CMAKE_CURRENT_BINARY_DIR}/checkXML )

	find_package(DocBookXML)
	set (DOCBOOKXML_VERSIONS "${DOCBOOKXML_CURRENTDTD_VERSION}")
	if (DOCBOOKXML_OLDDTD_VERSION)
	set (DOCBOOKXML_VERSIONS "${DOCBOOKXML_VERSIONS} and ${DOCBOOKXML_OLDDTD_VERSION}")
	endif (DOCBOOKXML_OLDDTD_VERSION)
	macro_log_feature(DOCBOOKXML_FOUND "DocBook XML" "Required by the KDE help system to process DocBook XML" "http://www.oasis-open.org/docbook/xml/${DOCBOOKXML_CURRENTDTD_VERSION}" TRUE "" "XML DTDs for DocBook ${DOCBOOKXML_VERSIONS} are needed")

	find_package(DocBookXSL)
	macro_log_feature(DOCBOOKXSL_FOUND "DocBook XSL" "Required by the KDE help system to process DocBook XML" "http://docbook.sourceforge.net/release/xsl/current/" TRUE "" "")

	set (_custom_dtd_kdex "customization/dtd/kdex.dtd")
	configure_file(${_custom_dtd_kdex}.cmake ${CMAKE_CURRENT_BINARY_DIR}/${_custom_dtd_kdex} )
	install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${_custom_dtd_kdex}
	DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization/dtd )

	configure_file(config-kdoctools.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kdoctools.h )

	########### next target ###############

	set(kio_help_PART_SRCS
	kio_help.cpp
	main.cpp
	xslt.cpp
	xslt_help.cpp
	xslt_kde.cpp
	)


	kde4_add_plugin(kio_help ${kio_help_PART_SRCS})

	target_link_libraries(kio_help ${KDE4_KDECORE_LIBS} karchive kio ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${LIBEXSLT_LIBRARIES} kcoreaddons)

	install(TARGETS kio_help DESTINATION ${PLUGIN_INSTALL_DIR} )


	########### next target ###############

	set(kio_ghelp_PART_SRCS kio_help.cpp main_ghelp.cpp xslt.cpp xslt_help.cpp xslt_kde.cpp )


	kde4_add_plugin(kio_ghelp ${kio_ghelp_PART_SRCS})

	target_link_libraries(kio_ghelp ${KDE4_KDECORE_LIBS} karchive kio ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${LIBEXSLT_LIBRARIES} kcoreaddons)

	install(TARGETS kio_ghelp DESTINATION ${PLUGIN_INSTALL_DIR} )


	########### next target ###############

	set_source_files_properties(xslt.cpp PROPERTIES COMPILE_FLAGS -DSIMPLE_XSLT )

	# The cross compiling parts are commented out on purpose. Alex
	# 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})
	#
	# else (CMAKE_CROSSCOMPILING)

	set(meinproc_SRCS meinproc.cpp meinproc_common.cpp xslt.cpp xslt_kde.cpp )

	kde4_add_executable(meinproc4 NOGUI ${meinproc_SRCS})

	target_link_libraries(meinproc4 ${KDE4_KDECORE_LIBS} karchive ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${LIBEXSLT_LIBRARIES} kcoreaddons)

	add_dependencies(meinproc4 docbookl10nhelper)

	# "export" this target too so we can use the LOCATION property of the imported target in
	# FindKDE4Internal.cmake to get the full path to the installed executable instead of using FIND_PROGRAM(), Alex
	install(TARGETS meinproc4 EXPORT kdelibsToolsTargets ${INSTALL_TARGETS_DEFAULT_ARGS})

	# # export this binary for cross-compilation
	# export(TARGETS meinproc4 FILE ${CMAKE_BINARY_DIR}/ImportMeinProc4Executable.cmake)
	#
	# endif (CMAKE_CROSSCOMPILING)

	########### next target ###############

	set_source_files_properties(xslt.cpp PROPERTIES COMPILE_FLAGS -DSIMPLE_XSLT )

	if (NOT CMAKE_CROSSCOMPILING)
	set(meinproc_qt_SRCS meinproc_simple.cpp meinproc_common.cpp xslt.cpp )

	kde4_add_executable(meinproc4_simple NOGUI ${meinproc_qt_SRCS})

	target_link_libraries(meinproc4_simple ${QT_QTCORE_LIBRARIES} ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${LIBEXSLT_LIBRARIES})

	add_dependencies(meinproc4_simple docbookl10nhelper)

	install(TARGETS meinproc4_simple ${INSTALL_TARGETS_DEFAULT_ARGS})

	endif (NOT CMAKE_CROSSCOMPILING)

	########### next target ###############

	set(genshortcutents_SRCS genshortcutents.cpp )


	kde4_add_executable(genshortcutents NOGUI ${genshortcutents_SRCS})

	target_link_libraries(genshortcutents ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBS} kcoreaddons)


	########### customize includes for xslt ###############

	file( GLOB _kdeincludexslt_ALL "customization/kde-include*.xsl.cmake" )
	foreach( _kdeincludexslt ${_kdeincludexslt_ALL} )
	get_filename_component( _kdeincludexslt_name ${_kdeincludexslt} NAME )
	string( REGEX REPLACE ".cmake$" "" _kdeincludexslt_out "${_kdeincludexslt_name}" )
	set( _kdeincludexslt_binarypath "${CMAKE_CURRENT_BINARY_DIR}/customization/${_kdeincludexslt_out}" )
	configure_file( ${_kdeincludexslt} ${_kdeincludexslt_binarypath} )
	install(FILES ${_kdeincludexslt_binarypath}
	DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization )
	endforeach( _kdeincludexslt ${_kdeincludexslt_ALL} )


	########### install files ###############

	install( FILES help.protocol ghelp.protocol DESTINATION ${SERVICES_INSTALL_DIR} )

	install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/checkXML DESTINATION ${BIN_INSTALL_DIR} )

	if(NOT WIN32)
	install( FILES kio_help.upd DESTINATION ${KCONF_UPDATE_INSTALL_DIR} )
	install( PROGRAMS move_kio_help_cache.sh DESTINATION ${KCONF_UPDATE_INSTALL_DIR} )
	endif(NOT WIN32)

	macro(INSTALL_CUSTOMIZE_DIR _expr _directory)
	FILE(GLOB _file_CUST "${_expr}" )
	foreach(_curentfile ${_file_CUST})
	install(FILES ${_curentfile} DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/${_directory} )
	endforeach(_curentfile ${_file_CUST})
	endmacro(INSTALL_CUSTOMIZE_DIR _expr _directory)

	macro(INSTALL_CUSTOMIZE_L_DIR _expr _directory)
	FILE(GLOB _file_CUST "${_expr}" )
	foreach(_curentfile ${_file_CUST})
	# copy the file also under CMAKE_CURRENT_BINARY_DIR - those
	# files are needed to generate the documentation without installing
	# kdelibs (i.e. when kdelibs itself compiled).
	get_filename_component(_currentfile_name ${_curentfile} NAME)
	set(_currentfile_binary_path ${CMAKE_CURRENT_BINARY_DIR}/${_directory}/${_currentfile_name})
	configure_file(${_curentfile} ${_currentfile_binary_path} COPYONLY)

	install(FILES ${_currentfile_binary_path}
	DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/${_directory} )
	endforeach(_curentfile ${_file_CUST})
	endmacro(INSTALL_CUSTOMIZE_L_DIR _expr _directory)



	set(expr "customization/*.xsl")
	install_customize_l_dir( ${expr} customization/)

	set(expr "customization/README")
	install_customize_l_dir( ${expr} customization/)

	set(expr "customization/catalog.xml")
	install_customize_l_dir( ${expr} customization/)

	set(customizedir af bg ca cs da de dtd el en-GB en entities eo es et fi fo fr gl he hu id it ja ko lt nds nl nn no pl pt-BR pt ro ru sk sl sr sr@latin sr@ijekavian sr@ijekavianlatin sv th tr uk wa xh xsl xx zh-CN zh-TW)

	foreach (_currentcustomizedir ${customizedir})
	set(expr "customization/${_currentcustomizedir}/README")
	install_customize_l_dir( ${expr} customization/${_currentcustomizedir})
	set(expr "customization/${_currentcustomizedir}/*.entities")
	install_customize_l_dir( ${expr} customization/${_currentcustomizedir})
	set(expr "customization/${_currentcustomizedir}/*.xsl")
	install_customize_l_dir( ${expr} customization/${_currentcustomizedir})
	set(expr "customization/${_currentcustomizedir}/entities/*.docbook")
	install_customize_l_dir( ${expr} customization/${_currentcustomizedir}/entities/ )
	set(expr "customization/${_currentcustomizedir}/entities/*.entities")
	install_customize_l_dir( ${expr} customization/${_currentcustomizedir}/entities/ )
	set(expr "customization/${_currentcustomizedir}/*.xml")
	install_customize_l_dir(${expr} customization/${_currentcustomizedir} )
	set(expr "customization/${_currentcustomizedir}/*.dtd")
	install_customize_l_dir(${expr} customization/${_currentcustomizedir}/)
	set(expr "customization/${_currentcustomizedir}/*.elements")
	install_customize_l_dir(${expr} customization/${_currentcustomizedir}/)

	endforeach(_currentcustomizedir ${customizedir})



	########### l10n xml helper ###############

	set( docbookl10nhelper_SRCS docbookl10nhelper.cpp )
	kde4_add_executable( docbookl10nhelper NOGUI ${docbookl10nhelper_SRCS} )
	target_link_libraries( docbookl10nhelper ${QT_QTCORE_LIBRARIES} )

	add_custom_command( TARGET docbookl10nhelper POST_BUILD
	COMMAND ${EXECUTABLE_OUTPUT_PATH}/docbookl10nhelper
	${DOCBOOKXSL_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/customization/xsl
	${CMAKE_CURRENT_BINARY_DIR}/customization/xsl
	)
	# all-l10n.xml is generated by docbookl10nhelper
	install(FILES ${CMAKE_CURRENT_BINARY_DIR}/customization/xsl/all-l10n.xml
	DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization/xsl/ )

	+install( FILES
	+ KDocToolsMacros.cmake
	+ DESTINATION ${DATA_INSTALL_DIR}/cmake/modules COMPONENT Devel )
	diff --git a/kdoctools/KDocToolsMacros.cmake b/kdoctools/KDocToolsMacros.cmake
	new file mode 100644
	index 0000000000..9153cc7c40
	--- /dev/null
	+++ b/kdoctools/KDocToolsMacros.cmake
	@@ -0,0 +1,142 @@
	+# 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.
	+
	+
	+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_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)

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 1, 9:05 AM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 10075506
Default Alt Text: (48 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions