cmake/modules/KDE4Macros.cmake

0001 # for documentation look at FindKDE4Internal.cmake
0002
0003 # this file contains the following macros (or functions):
0004 # KDE4_ADD_UI_FILES
0005 # KDE4_ADD_UI3_FILES
0006 # KDE4_ADD_KCFG_FILES
0007 # _KDE4_SET_CUSTOM_TARGET_PROPERTY
0008 # _KDE4_GET_CUSTOM_TARGET_PROPERTY
0009 # KDE4_ADD_PLUGIN
0010 # KDE4_ADD_KDEINIT_EXECUTABLE
0011 # KDE4_ADD_UNIT_TEST
0012 # KDE4_ADD_EXECUTABLE
0013 # KDE4_ADD_WIDGET_FILES
0014 # KDE4_UPDATE_ICONCACHE
0015 # KDE4_INSTALL_ICONS
0016 # KDE4_REMOVE_OBSOLETE_CMAKE_FILES
0017 # KDE4_CREATE_HANDBOOK
0018 # KDE4_ADD_APP_ICON
0019 # KDE4_CREATE_MANPAGE
0020 # KDE4_CREATE_BASIC_CMAKE_VERSION_FILE (function)
0021 # KDE4_INSTALL_AUTH_HELPER_FILES
0022 # KDE4_AUTH_INSTALL_ACTIONS
0023
0024 # Copyright (c) 2006-2009 Alexander Neundorf, <neundorf@kde.org>
0025 # Copyright (c) 2006, 2007, Laurent Montel, <montel@kde.org>
0026 # Copyright (c) 2007 Matthias Kretz <kretz@kde.org>
0027 #
0028 # Redistribution and use is allowed according to the terms of the BSD license.
0029 # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
0030
0031
0032 set(KDE4_MODULE_DIR  ${CMAKE_CURRENT_LIST_DIR} )
0033
0034 # This macro doesn't set up the RPATH related options for executables anymore,
0035 # since now (wioth cmake 2.6) just the full RPATH is used always for everything.
0036 # It does create wrapper shell scripts for the executables.
0037 # It overrides the defaults set in FindKDE4Internal.cmake.
0038 # For every executable a wrapper script is created, which sets the appropriate
0039 # environment variable for the platform (LD_LIBRARY_PATH on most UNIX systems,
0040 # DYLD_LIBRARY_PATH on OS X and PATH in Windows) so  that it points to the built
0041 # but not yet installed versions of the libraries. So if RPATH is disabled, the executables
0042 # can be run via these scripts from the build tree and will find the correct libraries.
0043 # If RPATH is not disabled, these scripts are also used but only for consistency, because
0044 # they don't really influence anything then, because the compiled-in RPATH overrides
0045 # the LD_LIBRARY_PATH env. variable.
0046 macro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE _target_NAME)
0047    if (UNIX)
0048       if (APPLE)
0049          set(_library_path_variable "DYLD_LIBRARY_PATH")
0050       elseif (CYGWIN)
0051          set(_library_path_variable "PATH")
0052       else (APPLE)
0053          set(_library_path_variable "LD_LIBRARY_PATH")
0054       endif (APPLE)
0055
0056       if (APPLE)
0057          # DYLD_LIBRARY_PATH does not work like LD_LIBRARY_PATH
0058          # OSX already has the RPATH in libraries and executables, putting runtime directories in
0059          # DYLD_LIBRARY_PATH actually breaks things
0060          set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${KDE4_LIB_DIR}")
0061       else (APPLE)
0062          set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${LIB_INSTALL_DIR}:${KDE4_LIB_DIR}:${QT_LIBRARY_DIR}")
0063       endif (APPLE)
0064       get_target_property(_executable ${_target_NAME} LOCATION )
0065
0066       # use add_custom_target() to have the sh-wrapper generated during build time instead of cmake time
0067       add_custom_command(TARGET ${_target_NAME} POST_BUILD
0068          COMMAND ${CMAKE_COMMAND}
0069          -D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable}
0070          -D_ld_library_path="${_ld_library_path}" -D_executable=$<TARGET_FILE:${_target_NAME}>
0071          -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
0072          )
0073
0074       set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${_executable}.shell)
0075
0076       # under UNIX, set the property WRAPPER_SCRIPT to the name of the generated shell script
0077       # so it can be queried and used later on easily
0078       set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}.shell)
0079
0080    else (UNIX)
0081       # under windows, set the property WRAPPER_SCRIPT just to the name of the executable
0082       # maybe later this will change to a generated batch file (for setting the PATH so that the Qt libs are found)
0083       get_target_property(_executable ${_target_NAME} LOCATION )
0084       set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable})
0085
0086       set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}\;${LIB_INSTALL_DIR}\;${KDE4_LIB_DIR}\;${QT_LIBRARY_DIR}")
0087       get_target_property(_executable ${_target_NAME} LOCATION )
0088
0089       # use add_custom_target() to have the batch-file-wrapper generated during build time instead of cmake time
0090       add_custom_command(TARGET ${_target_NAME} POST_BUILD
0091          COMMAND ${CMAKE_COMMAND}
0092          -D_filename="${_executable}.bat"
0093          -D_ld_library_path="${_ld_library_path}" -D_executable="${_executable}"
0094          -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
0095          )
0096
0097    endif (UNIX)
0098 endmacro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE)
0099
0100
0101 macro (KDE4_ADD_PLUGIN _target_NAME )
0102 #if the first argument is "WITH_PREFIX" then keep the standard "lib" prefix,
0103 #otherwise set the prefix empty
0104
0105    set(_args ${ARGN})
0106    # default to module
0107    set(_add_lib_param "MODULE")
0108    set(_with_pre FALSE)
0109
0110    foreach(arg ${_args})
0111       if (arg STREQUAL "WITH_PREFIX")
0112          set(_with_pre TRUE)
0113       endif (arg STREQUAL "WITH_PREFIX")
0114       if (arg STREQUAL "STATIC")
0115          set(_add_lib_param STATIC)
0116       endif (arg STREQUAL "STATIC")
0117       if (arg STREQUAL "SHARED")
0118          set(_add_lib_param SHARED)
0119       endif (arg STREQUAL "SHARED")
0120       if (arg STREQUAL "MODULE")
0121          set(_add_lib_param MODULE)
0122       endif (arg STREQUAL "MODULE")
0123    endforeach(arg)
0124
0125    if(_with_pre)
0126       list(REMOVE_ITEM _args "WITH_PREFIX")
0127    endif(_with_pre)
0128    if(_add_lib_param STREQUAL "STATIC")
0129       list(REMOVE_ITEM _args "STATIC")
0130    endif(_add_lib_param STREQUAL "STATIC")
0131    if (_add_lib_param STREQUAL "SHARED")
0132       list(REMOVE_ITEM _args "SHARED")
0133    endif (_add_lib_param STREQUAL "SHARED")
0134    if (_add_lib_param STREQUAL "MODULE")
0135        list(REMOVE_ITEM _args "MODULE")
0136    endif (_add_lib_param STREQUAL "MODULE")
0137
0138    set(_SRCS ${_args})
0139
0140    if("${_add_lib_param}" STREQUAL "STATIC")
0141       add_definitions(-DQT_STATICPLUGIN)
0142    endif("${_add_lib_param}" STREQUAL "STATIC")
0143
0144    add_library(${_target_NAME} ${_add_lib_param}  ${_SRCS})
0145
0146    if (NOT _with_pre)
0147       set_target_properties(${_target_NAME} PROPERTIES PREFIX "")
0148    endif (NOT _with_pre)
0149
0150    # for shared libraries/plugins a -DMAKE_target_LIB is required
0151    string(TOUPPER ${_target_NAME} _symbol)
0152    string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
0153    set(_symbol "MAKE_${_symbol}_LIB")
0154    set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol})
0155
0156 endmacro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX)
0157
0158
0159 # this macro is intended to check whether a list of source
0160 # files has the "NOGUI" or "RUN_UNINSTALLED" keywords at the beginning
0161 # in _output_LIST the list of source files is returned with the "NOGUI"
0162 # and "RUN_UNINSTALLED" keywords removed
0163 # if "NOGUI" is in the list of files, the _nogui argument is set to
0164 # "NOGUI" (which evaluates to TRUE in cmake), otherwise it is set empty
0165 # (which evaluates to FALSE in cmake)
0166 # "RUN_UNINSTALLED" in the list of files is ignored, it is not necessary anymore
0167 # since KDE 4.2 (with cmake 2.6.2), since then all executables are always built
0168 # with RPATH pointing into the build dir.
0169 # if "TEST" is in the list of files, the _test argument is set to
0170 # "TEST" (which evaluates to TRUE in cmake), otherwise it is set empty
0171 # (which evaluates to FALSE in cmake)
0172 macro(KDE4_CHECK_EXECUTABLE_PARAMS _output_LIST _nogui _test)
0173
0174    if(POLICY CMP0054)
0175       cmake_policy(PUSH)
0176       cmake_policy(SET CMP0054 NEW)
0177    endif()
0178
0179    set(${_nogui})
0180    set(${_test})
0181    set(${_output_LIST} ${ARGN})
0182    list(LENGTH ${_output_LIST} count)
0183
0184    list(GET ${_output_LIST} 0 first_PARAM)
0185
0186    set(second_PARAM "NOTFOUND")
0187    if (${count} GREATER 1)
0188       list(GET ${_output_LIST} 1 second_PARAM)
0189    endif (${count} GREATER 1)
0190
0191    set(remove "NOTFOUND")
0192
0193    if ("${first_PARAM}" STREQUAL "NOGUI")
0194       set(${_nogui} "NOGUI")
0195       set(remove 0)
0196    endif ()
0197
0198    if ("${first_PARAM}" STREQUAL "RUN_UNINSTALLED")
0199       set(remove 0)
0200    endif ()
0201
0202    if ("${first_PARAM}" STREQUAL "TEST")
0203       set(${_test} "TEST")
0204       set(remove 0)
0205    endif ()
0206
0207    if ("${second_PARAM}" STREQUAL "NOGUI")
0208       set(${_nogui} "NOGUI")
0209       set(remove 0;1)
0210    endif ()
0211
0212    if ("${second_PARAM}" STREQUAL "RUN_UNINSTALLED")
0213       set(remove 0;1)
0214    endif ()
0215
0216    if ("${second_PARAM}" STREQUAL "TEST")
0217       set(${_test} "TEST")
0218       set(remove 0;1)
0219    endif ()
0220
0221
0222    if (NOT "${remove}" STREQUAL "NOTFOUND")
0223       list(REMOVE_AT ${_output_LIST} ${remove})
0224    endif (NOT "${remove}" STREQUAL "NOTFOUND")
0225
0226    if(POLICY CMP0054)
0227       cmake_policy(POP)
0228    endif()
0229
0230 endmacro(KDE4_CHECK_EXECUTABLE_PARAMS)
0231
0232 #deprecated now, use the macro in KInitMacros.cmake
0233 macro (KDE4_ADD_KDEINIT_EXECUTABLE _target_NAME )
0234
0235    kde4_check_executable_params(_SRCS _nogui _test ${ARGN})
0236
0237    configure_file(${KF5Init_DIR}/kde5init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp)
0238    set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp PROPERTIES SKIP_AUTOMOC TRUE)
0239    # under Windows, build a normal executable and additionally a dummy kdeinit5_foo.lib, whose only purpose on windows is to
0240    # keep the linking logic from the CMakeLists.txt on UNIX working (under UNIX all necessary libs are linked against the kdeinit
0241    # library instead against the executable, under windows we want to have everything in the executable, but for compatibility we have to
0242    # keep the library there-
0243    if(WIN32)
0244       if (MINGW)
0245          list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_res.o _res_position)
0246       else(MINGW)
0247          list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}.rc _res_position)
0248       endif(MINGW)
0249       if(NOT _res_position EQUAL -1)
0250          list(GET _SRCS ${_res_position} _resourcefile)
0251          list(REMOVE_AT _SRCS ${_res_position})
0252       endif(NOT _res_position EQUAL -1)
0253
0254       set(_KDEINIT4_TARGET_NAME_ ${_target_NAME})
0255       string(REGEX REPLACE "[-]" "_" _KDEINIT4_TARGET_NAME_ "${_KDEINIT4_TARGET_NAME_}")
0256       configure_file(${KDE4_MODULE_DIR}/../KF5Init/kde5init_win32lib_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp)
0257       add_library(kdeinit_${_target_NAME} STATIC ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp)
0258
0259       kde4_add_executable(${_target_NAME} "${_nogui}" ${_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
0260
0261       set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit5_${_target_NAME})
0262
0263       target_link_libraries(${_target_NAME} kdeinit_${_target_NAME})
0264    else(WIN32)
0265
0266       add_library(kdeinit_${_target_NAME} SHARED ${_SRCS})
0267
0268       set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit5_${_target_NAME})
0269
0270       if (Q_WS_MAC)
0271               list(FIND _SRCS *.icns _icon_position)
0272               if(NOT _res_position EQUAL -1)
0273                       list(GET _SRCS ${_icon_position} _resourcefile)
0274               endif(NOT _res_position EQUAL -1)
0275       endif (Q_WS_MAC)
0276       kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
0277       target_link_libraries(${_target_NAME} kdeinit_${_target_NAME})
0278    endif(WIN32)
0279
0280 endmacro (KDE4_ADD_KDEINIT_EXECUTABLE)
0281
0282 # Add a unit test, which is executed when running make test .
0283 # The targets are always created, but only built for the "all"
0284 # target if the option KDE4_BUILD_TESTS is enabled. Otherwise the rules for the target
0285 # are created but not built by default. You can build them by manually building the target.
0286 # The name of the target can be specified using TESTNAME <testname>, if it is not given
0287 # the macro will default to the <name>
0288 macro (KDE4_ADD_UNIT_TEST _test_NAME)
0289     set(_srcList ${ARGN})
0290     set(_targetName ${_test_NAME})
0291     if( ${ARGV1} STREQUAL "TESTNAME" )
0292         set(_targetName ${ARGV2})
0293         list(REMOVE_AT _srcList 0 1)
0294     endif( ${ARGV1} STREQUAL "TESTNAME" )
0295
0296     set(_nogui)
0297     list(GET _srcList 0 first_PARAM)
0298     if( ${first_PARAM} STREQUAL "NOGUI" )
0299         set(_nogui "NOGUI")
0300     endif( ${first_PARAM} STREQUAL "NOGUI" )
0301
0302     kde4_add_executable( ${_test_NAME} TEST ${_srcList} )
0303
0304     if(NOT KDE4_TEST_OUTPUT)
0305         set(KDE4_TEST_OUTPUT plaintext)
0306     endif(NOT KDE4_TEST_OUTPUT)
0307     set(KDE4_TEST_OUTPUT ${KDE4_TEST_OUTPUT} CACHE STRING "The output to generate when running the QTest unit tests")
0308
0309     set(using_qtest "")
0310     foreach(_filename ${_srcList})
0311         if(NOT using_qtest)
0312             if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}")
0313                 file(READ ${_filename} file_CONTENT)
0314                 string(REGEX MATCH "QTEST_(KDE)?MAIN" using_qtest "${file_CONTENT}")
0315             endif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}")
0316         endif(NOT using_qtest)
0317     endforeach(_filename)
0318
0319     get_target_property( loc ${_test_NAME} LOCATION )
0320     if(WIN32)
0321       if(MSVC_IDE)
0322         STRING(REGEX REPLACE "\\$\\(.*\\)" "\${CTEST_CONFIGURATION_TYPE}" loc "${loc}")
0323       endif()
0324       # .bat because of rpath handling
0325       set(_executable "${loc}.bat")
0326     else(WIN32)
0327       if (Q_WS_MAC AND NOT _nogui)
0328         set(_executable ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME}.app/Contents/MacOS/${_test_NAME})
0329       else (Q_WS_MAC AND NOT _nogui)
0330         # .shell because of rpath handling
0331         set(_executable "${loc}.shell")
0332       endif (Q_WS_MAC AND NOT _nogui)
0333     endif(WIN32)
0334
0335     if (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
0336         #MESSAGE(STATUS "${_targetName} : Using QTestLib, can produce XML report.")
0337         add_test( ${_targetName} ${_executable} -xml -o ${_targetName}.tml)
0338     else (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
0339         #MESSAGE(STATUS "${_targetName} : NOT using QTestLib, can't produce XML report, please use QTestLib to write your unit tests.")
0340         add_test( ${_targetName} ${_executable} )
0341     endif (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
0342
0343 #    add_test( ${_targetName} ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME} -xml -o ${_test_NAME}.tml )
0344
0345     if (NOT MSVC_IDE)   #not needed for the ide
0346         # if the tests are EXCLUDE_FROM_ALL, add a target "buildtests" to build all tests
0347         if (NOT KDE4_BUILD_TESTS)
0348            if(NOT TARGET buildtests)
0349               add_custom_target(buildtests)
0350            endif()
0351            add_dependencies(buildtests ${_test_NAME})
0352         endif (NOT KDE4_BUILD_TESTS)
0353     endif (NOT MSVC_IDE)
0354
0355 endmacro (KDE4_ADD_UNIT_TEST)
0356
0357
0358 # add a  manifest file to executables.
0359 #
0360 # There is a henn-egg problem when a target runtime part is renamed using
0361 # the OUTPUT_NAME option of cmake's set_target_properties command.
0362 #
0363 # At now the Makefiles rules creating for manifest adding are performed
0364 # *after* the cmake's add_executable command but *before* an optional
0365 # set_target_properties command.
0366 # This means that in KDE4_ADD_MANIFEST the LOCATION property contains
0367 #  the unchanged runtime part name of the target. :-(
0368 #
0369 # The recently used workaround is to specify a variable build off the target name followed
0370 # by _OUTPUT_NAME before calling kde4_add_executable as shown in the following example:
0371 #
0372 # set(xyz_OUTPUT_NAME test)
0373 # kde4_add_executable( xyz <source>)
0374 # set_target_properties( xyz PROPERTIES OUTPUT_NAME ${xyz_OUTPUT_NAME} )
0375 #
0376 # The full solution would be to introduce a kde4_target_link_libraries macro and to
0377 # call KDE4_ADD_MANIFEST inside instead of calling in kde4_add_executable.
0378 # This would require patching of *all* places in the KDE sources where target_link_libraries
0379 # is used and to change the related docs.
0380 #
0381 # Because yet I found only 2 locations where this problem occurs (kjs, k3b), the workaround
0382 # seems to be a pragmatically solution.
0383 #
0384 # This macro is an internal macro only used by kde4_add_executable
0385 #
0386 macro (_KDE4_ADD_MANIFEST _target_NAME)
0387     set(x ${_target_NAME}_OUTPUT_NAME)
0388     if (${x})
0389         get_target_property(_var ${_target_NAME} LOCATION )
0390         string(REPLACE "${_target_NAME}" "${${x}}" _executable ${_var})
0391     else(${x})
0392         get_target_property(_executable ${_target_NAME} LOCATION )
0393     endif(${x})
0394
0395     if (_kdeBootStrapping)
0396         set(_cmake_module_path ${CMAKE_SOURCE_DIR}/cmake/modules)
0397     else (_kdeBootStrapping)
0398         set(_cmake_module_path ${KDE4_INSTALL_DIR}/share/apps/cmake/modules)
0399     endif (_kdeBootStrapping)
0400
0401     set(_manifest ${KDE4_MODULE_DIR}/Win32.Manifest.in)
0402     #message(STATUS ${_executable} ${_manifest})
0403     add_custom_command(
0404         TARGET ${_target_NAME}
0405         POST_BUILD
0406         COMMAND ${KDE4_MT_EXECUTABLE}
0407         ARGS
0408            -manifest ${_manifest}
0409            -updateresource:${_executable}
0410         COMMENT "adding vista trustInfo manifest to ${_target_NAME}"
0411    )
0412 endmacro(_KDE4_ADD_MANIFEST)
0413
0414
0415 macro (KDE4_ADD_EXECUTABLE _target_NAME)
0416
0417    kde4_check_executable_params( _SRCS _nogui _test ${ARGN})
0418
0419    set(_add_executable_param)
0420
0421    # determine additional parameters for add_executable()
0422    # for GUI apps, create a bundle on OSX
0423    if (Q_WS_MAC)
0424       set(_add_executable_param MACOSX_BUNDLE)
0425    endif (Q_WS_MAC)
0426
0427    # for GUI apps, this disables the additional console under Windows
0428    if (WIN32)
0429       set(_add_executable_param WIN32)
0430    endif (WIN32)
0431
0432    if (_nogui)
0433       set(_add_executable_param)
0434    endif (_nogui)
0435
0436    if (_test AND NOT KDE4_BUILD_TESTS)
0437       set(_add_executable_param ${_add_executable_param} EXCLUDE_FROM_ALL)
0438    endif (_test AND NOT KDE4_BUILD_TESTS)
0439
0440    add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS})
0441
0442    IF (KDE4_ENABLE_UAC_MANIFEST)
0443        _kde4_add_manifest(${_target_NAME})
0444    ENDIF(KDE4_ENABLE_UAC_MANIFEST)
0445
0446    if (_test)
0447       set_target_properties(${_target_NAME} PROPERTIES COMPILE_FLAGS -DKDESRCDIR="\\"${CMAKE_CURRENT_SOURCE_DIR}/\\"")
0448    endif (_test)
0449
0450    kde4_handle_rpath_for_executable(${_target_NAME})
0451
0452 endmacro (KDE4_ADD_EXECUTABLE)
0453
0454 include(GenerateExportHeader)
0455
0456 macro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
0457
0458    set(_first_SRC ${_lib_TYPE})
0459    set(_add_lib_param)
0460
0461    if (${_lib_TYPE} STREQUAL "STATIC")
0462       set(_first_SRC)
0463       set(_add_lib_param STATIC)
0464    endif (${_lib_TYPE} STREQUAL "STATIC")
0465    if (${_lib_TYPE} STREQUAL "SHARED")
0466       set(_first_SRC)
0467       set(_add_lib_param SHARED)
0468    endif (${_lib_TYPE} STREQUAL "SHARED")
0469    if (${_lib_TYPE} STREQUAL "MODULE")
0470       set(_first_SRC)
0471       set(_add_lib_param MODULE)
0472    endif (${_lib_TYPE} STREQUAL "MODULE")
0473
0474    set(_SRCS ${_first_SRC} ${ARGN})
0475
0476    add_library(${_target_NAME} ${_add_lib_param} ${_SRCS})
0477
0478    # for shared libraries a -DMAKE_target_LIB is required
0479    string(TOUPPER ${_target_NAME} _symbol)
0480    string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
0481    set(_symbol "MAKE_${_symbol}_LIB")
0482    set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol})
0483 endmacro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
0484
0485 include("${KF5Auth_DIR}/KF5AuthMacros.cmake")
0486 include("${CMAKE_CURRENT_LIST_DIR}/KDECoreMacros.cmake")
0487 include("${CMAKE_CURRENT_LIST_DIR}/KDEUIMacros.cmake")
0488 include("${KF5DocTools_DIR}/KF5DocToolsMacros.cmake")
0489 include("${KF5DesignerPlugin_DIR}/KF5DesignerPluginMacros.cmake")
0490
0491 # functions deprecated, they still should work
0492 macro (KDE4_AUTH_INSTALL_ACTIONS)
0493     message(WARNING "KDE4_AUTH_INSTALL_ACTIONS is deprecated, use KAUTH_INSTALL_ACTIONS instead")
0494     KAUTH_INSTALL_ACTIONS(${ARGN})
0495 endmacro()
0496
0497 macro (KDE4_INSTALL_AUTH_HELPER_FILES)
0498     message(WARNING "KDE4_INSTALL_AUTH_HELPER_FILES is deprecated, use KAUTH_INSTALL_HELPER_FILES instead")
0499     KAUTH_INSTALL_HELPER_FILES(${ARGN})
0500 endmacro()
0501
0502 macro (KDE4_CREATE_HANDBOOK)
0503     message(WARNING "KDE4_CREATE_HANDBOOK() is deprecated. Call the macro KDOCTOOLS_CREATE_HANDBOOK instead, this will give you a target <dirname>-handbook for creating the html help.")
0504     KDOCTOOLS_CREATE_HANDBOOK(${ARGN})
0505 endmacro()