generic: major build system cleanup

the test are broken!

CMakeLists.txt

@@ -103,14 +103,10 @@ set_package_properties(DBusMenuQt PROPERTIES DESCRIPTION "Support for notificati
 
 ################# Disallow in-source build #################
 
-macro_ensure_out_of_source_build("kdelibs requires an out of source build. Please create a separate build directory and run 'cmake path_to_kdelibs [options]' there.")
+if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+    message(SEND_ERROR "kdelibs requires an out of source build")
+endif()
 
-# ... and warn in case of an earlier in-source build
-set(generatedFileInSourceDir EXISTS ${kdelibs_SOURCE_DIR}/kdemacros.h OR EXISTS ${kdelibs_SOURCE_DIR}/config.h)
-if(${generatedFileInSourceDir})
-   message(STATUS "kdemacros.h or config.h exists in your source directory.")
-   message(FATAL_ERROR "Please run svn-clean, it would seem that your source directory has generated files in it.")
-endif(${generatedFileInSourceDir})
 #########################################################################
 
 add_definitions(${QT_DEFINITIONS} ${KDE4_DEFINITIONS})
@@ -121,14 +117,19 @@ add_definitions(-DQT_USE_FAST_CONCATENATION -DQT_USE_FAST_OPERATOR_PLUS)
 ################# setup the include directories #################
 
 # for including config.h and for includes like <kparts/foo.h>
-include_directories( ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/interfaces)
+include_directories(
+    ${CMAKE_SOURCE_DIR}
+    ${CMAKE_BINARY_DIR}
+    ${CMAKE_SOURCE_DIR}/interfaces
+)
 
 # Those variables for  are only valid inside of kdelibs, of course.
 # Use the one variable for the lib you depend upon.
 # E.g. kdeui uses ${KDE4_KDECORE_INCLUDES}. Something that depends on kparts uses ${KDE4_KPARTS_INCLUDES}.
 
 # kdecore depends on Qt
-set(KDE4_KDECORE_INCLUDES ${KDE4_KDECORE_INCLUDES}
+set(KDE4_KDECORE_INCLUDES
+    ${KDE4_KDECORE_INCLUDES}
     ${CMAKE_SOURCE_DIR}/kdecore
     ${CMAKE_BINARY_DIR}/kdecore
     ${CMAKE_SOURCE_DIR}/kdecore/compression
@@ -146,9 +147,12 @@ set(KDE4_KDECORE_INCLUDES ${KDE4_KDECORE_INCLUDES}
     ${CMAKE_SOURCE_DIR}/kdecore/util
     ${CMAKE_SOURCE_DIR}/kdecore/sonnet
     ${QT_INCLUDES}
-                          ${_KDE4_PLATFORM_INCLUDE_DIRS})
+    ${_KDE4_PLATFORM_INCLUDE_DIRS}
+)
+
 # kdeui depends on kdecore
-set(KDE4_KDEUI_INCLUDES ${CMAKE_SOURCE_DIR}/kdeui
+set(KDE4_KDEUI_INCLUDES
+    ${CMAKE_SOURCE_DIR}/kdeui
     ${CMAKE_SOURCE_DIR}/kdeui/actions
     ${CMAKE_SOURCE_DIR}/kdeui/colors
     ${CMAKE_SOURCE_DIR}/kdeui/config
@@ -168,21 +172,29 @@ set(KDE4_KDEUI_INCLUDES ${CMAKE_SOURCE_DIR}/kdeui
     ${CMAKE_SOURCE_DIR}/kdeui/widgets
     ${CMAKE_SOURCE_DIR}/kdeui/windowmanagement
     ${CMAKE_SOURCE_DIR}/kdeui/xmlgui
-                        ${KDE4_KDECORE_INCLUDES})
+    ${KDE4_KDECORE_INCLUDES}
+)
 
 # kio depends on kdeui
-set(KDE4_KIO_INCLUDES ${CMAKE_SOURCE_DIR}/kio
+set(KDE4_KIO_INCLUDES
+    ${CMAKE_SOURCE_DIR}/kio
     ${CMAKE_SOURCE_DIR}/kio/bookmarks
     ${CMAKE_SOURCE_DIR}/kio/kio
     ${CMAKE_SOURCE_DIR}/kio/kfile
-                      ${KDE4_KDEUI_INCLUDES})
+    ${KDE4_KDEUI_INCLUDES}
+)
 
 # kpty
-set(KDE4_KPTY_INCLUDES ${CMAKE_SOURCE_DIR}/kpty ${KDE4_KIO_INCLUDES})
+set(KDE4_KPTY_INCLUDES
+    ${CMAKE_SOURCE_DIR}/kpty
+    ${KDE4_KIO_INCLUDES}
+)
 
 # kparts depends on kio
-set(KDE4_KPARTS_INCLUDES ${CMAKE_SOURCE_DIR}/kparts
+set(KDE4_KPARTS_INCLUDES
-                         ${KDE4_KIO_INCLUDES})
+    ${CMAKE_SOURCE_DIR}/kparts
+    ${KDE4_KIO_INCLUDES}
+)
 
 ################# configure checks and create the configured files #################
 
@@ -268,8 +280,17 @@ install( FILES ${CMAKE_CURRENT_BINARY_DIR}/KDEPlatformProfile.cmake  DESTINATION
 install(CODE "set(EXPORT_FILES KDELibs4LibraryTargets.cmake KDELibs4ToolsTargets.cmake)"
         CODE "set(EXPORT_INSTALL_DIR \"${DATA_INSTALL_DIR}/cmake/modules\")"
         SCRIPT "${CMAKE_SOURCE_DIR}/cmake/modules/check_installed_exports_file.cmake" )
-install( EXPORT kdelibsLibraryTargets DESTINATION ${DATA_INSTALL_DIR}/cmake/modules NAMESPACE ${KDE4_TARGET_PREFIX} FILE KDELibs4LibraryTargets.cmake )
+install(EXPORT kdelibsLibraryTargets
-install( EXPORT kdelibsToolsTargets   DESTINATION ${DATA_INSTALL_DIR}/cmake/modules NAMESPACE ${KDE4_TARGET_PREFIX} FILE KDELibs4ToolsTargets.cmake )
+    DESTINATION ${DATA_INSTALL_DIR}/cmake/modules
+    NAMESPACE ${KDE4_TARGET_PREFIX}
+    FILE KDELibs4LibraryTargets.cmake
+)
+install(EXPORT kdelibsToolsTargets
+    DESTINATION ${DATA_INSTALL_DIR}/cmake/modules
+    NAMESPACE ${KDE4_TARGET_PREFIX}
+    FILE KDELibs4ToolsTargets.cmake
+)
+
 # the following will be the correct locations once cmake has the improved FIND_PACKAGE()
 # install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KDELibsDependencies.cmake DESTINATION ${PLUGIN_INSTALL_DIR}/cmake RENAME KDE4Config.cmake)
 
@@ -277,4 +298,3 @@ feature_summary(WHAT ALL
     INCLUDE_QUIET_PACKAGES
     FATAL_ON_MISSING_REQUIRED_PACKAGES
 )
-

cmake/modules-tests/AGG/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(AGG  AGG  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/Blitz/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(Blitz  BLITZ  INCLUDES LIBRARIES)

cmake/modules-tests/BlueZ/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(BlueZ  BLUEZ  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/ENCHANT/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(ENCHANT  ENCHANT  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/Eigen2/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(Eigen2  EIGEN2  INCLUDE_DIR )

cmake/modules-tests/FFmpeg/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(FFmpeg  FFMPEG  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/Flac/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(Flac  FLAC  INCLUDE_DIR LIBRARIES OGGFLAC_LIBRARIES)

cmake/modules-tests/Flex/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(Flex FLEX VERSION EXECUTABLE)

cmake/modules-tests/GObject/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(GObject  GOBJECT  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/GStreamer/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(GStreamer  GSTREAMER  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/LCMS/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(LCMS  LCMS  INCLUDE_DIR LIBRARIES VERSION)

cmake/modules-tests/LibArt/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(LibArt  LIBART  INCLUDE_DIR LIBRARIES)

cmake/modules-tests/LibXslt/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(LibXslt  LIBXSLT  INCLUDE_DIR LIBRARIES DEFINITIONS XSLTPROC_EXECUTABLE)

cmake/modules-tests/OpenEXR/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(OpenEXR  OPENEXR  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/PCRE/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(PCRE  PCRE  INCLUDE_DIR LIBRARIES)

cmake/modules-tests/QCA2/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(QCA2  QCA2  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/QImageBlitz/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(QImageBlitz  QIMAGEBLITZ  INCLUDES LIBRARIES)

cmake/modules-tests/RunAllModuleTests.cmake

@@ -1,59 +0,0 @@
-# Run this script via "cmake -P RunAllModuletests.cmake" to
-# execute all module tests in one go.
-# Run this script with "cmake -DMODULE=foo -P RunAllModuletests.cmake" to 
-# test only the one specified module.
-# To see only the results and not the other cmake output,
-# you can grep for "::".
-# To have it delete the previous test build dirs, run it with -DCLEAN_DIRS=TRUE
-
-get_filename_component(currentDir "${CMAKE_CURRENT_LIST_FILE}" PATH)
-
-function(execute_one_test name)
-   set(workingDir "${currentDir}/${name}/build")
-   if(CLEAN_DIRS)
-      file(REMOVE_RECURSE "${workingDir}")
-   endif(CLEAN_DIRS)
-   file(MAKE_DIRECTORY "${workingDir}")
-   execute_process(COMMAND ${CMAKE_COMMAND} "${currentDir}/${name}"
-                   WORKING_DIRECTORY "${workingDir}")
-   # now the same with pkg-config disabled
-   set(workingDir "${currentDir}/${name}/build-no-pkgconfig")
-   if(CLEAN_DIRS)
-      file(REMOVE_RECURSE "${workingDir}")
-   endif(CLEAN_DIRS)
-   file(MAKE_DIRECTORY "${workingDir}")
-   execute_process(COMMAND ${CMAKE_COMMAND} -DPKG_CONFIG_EXECUTABLE=echo "${currentDir}/${name}"
-                   WORKING_DIRECTORY "${workingDir}")
-endfunction(execute_one_test)
-
-if(DEFINED MODULE)
-   set(modulesToTest ${MODULE})
-else(DEFINED MODULE)
-   set(modulesToTest AGG 
-                     Blitz 
-                     BlueZ
-                     ENCHANT
-                     Eigen2 
-                     FFmpeg
-                     Flac 
-                     Flex 
-                     GObject 
-                     GStreamer
-                     LCMS 
-                     LibArt 
-                     LibXslt 
-                     OpenEXR 
-                     PCRE 
-                     QCA2 
-                     QImageBlitz
-                     Sqlite 
-                     Strigi 
-                     USB 
-                     Xine 
-                     Xmms)
-endif(DEFINED MODULE)
-
-foreach(currentModule ${modulesToTest})
-   execute_one_test(${currentModule})
-endforeach(currentModule ${modulesToTest})
-

cmake/modules-tests/Sqlite/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(Sqlite  SQLITE  INCLUDE_DIR LIBRARIES DEFINITIONS)

cmake/modules-tests/Strigi/CMakeLists.txt

@@ -1,17 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-set(STRIGI_MIN_VERSION 0.6.0)
-
-#find_package(Strigi 1.2.3)
-
-test_find_package(Strigi  STRIGI  VERSION 
-                                  INCLUDE_DIR 
-                                  STREAMANALYZER_LIBRARY
-                                  STREAMS_LIBRARY 
-                                  STRIGIQTDBUSCLIENT_LIBRARY 
-                                  NEEDS_SIGNED_CHAR 
-                                  NEEDS_CHAR
-                                  LINE_ANALYZER_PREFIX 
-                                  THROUGH_ANALYZER_PREFIX )

cmake/modules-tests/TestFindPackage.cmake

@@ -1,44 +0,0 @@
-# This module provides the macro TEST_FIND_PACKAGE()
-#
-# TEST_FIND_PACKAGE(package prefix var1 .. varN )
-#    It can be used to test a CMake Find-module.
-#    It executes FIND_PACKAGE(<package>) and then prints some results.
-#    <package> is the same as for FIND_PACKAGE() and
-#    prefix should be the prefix which is used in that module for
-#    all variables.
-#    It checks <prefix>_FOUND to decide whether the module was successful or not.
-#
-# Example:
-#   test_find_package(Xine  XINE  VERSION INCLUDE_DIR LIBRARY)
-#
-# This will check XINE_FOUND and then print the variables XINE_VERSION, XINE_INCLUDE_DIR and XINE_LIBRARY.
-
-cmake_minimum_required(VERSION 2.6.2)
-cmake_policy(SET CMP0000 OLD)
-
-macro(TEST_FIND_PACKAGE package prefix )
-   # if PKG_CONFIG_EXECUTABLE is set to "echo", FindPkgConfig.cmake
-   # will not search again for the real pkg-config, as it would if it was set to NOTFOUND
-   # and still the execute_process(${PKG_CONFIG_EXECUTABLE} ) calls will work
-   # but never return success.
-   if("${PKG_CONFIG_EXECUTABLE}" STREQUAL "echo")
-      message(STATUS ":: ***** Testing Find${package}.cmake, with pkg-config disabled *****")
-   else("${PKG_CONFIG_EXECUTABLE}" STREQUAL "echo")
-      message(STATUS ":: ***** Testing Find${package}.cmake *****")
-   endif("${PKG_CONFIG_EXECUTABLE}" STREQUAL "echo")
-
-   find_package(${package})
-   message(STATUS ":: ***** Results from Find${package}.cmake *****")
-
-   if ( ${prefix}_FOUND)
-      message(STATUS ":: Find${package}.cmake: ${package} has been found")
-   else ( ${prefix}_FOUND)
-      message(STATUS ":: Find${package}.cmake: ${package} has NOT been found !")
-   endif ( ${prefix}_FOUND)
-
-   message(STATUS ":: ${prefix}_FOUND: \"${${prefix}_FOUND}\"")
-   foreach(var ${ARGN})
-      message(STATUS ":: ${prefix}_${var}: \"${${prefix}_${var}}\"")
-   endforeach(var)
-   message(STATUS "::")
-endmacro(TEST_FIND_PACKAGE package)

cmake/modules-tests/USB/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(USB  LIBUSB  INCLUDE_DIR LIBRARIES)

cmake/modules-tests/Xine/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(Xine  XINE  VERSION BUGFIX_VERSION INCLUDE_DIR LIBRARY XCB_FOUND)

cmake/modules-tests/Xmms/CMakeLists.txt

@@ -1,5 +0,0 @@
-include("${CMAKE_CURRENT_SOURCE_DIR}/../TestFindPackage.cmake")
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../modules" )
-
-test_find_package(Xmms  XMMS  INCLUDE_DIR LIBRARIES )

cmake/modules-tests/readme.txt

@@ -1,6 +0,0 @@
-in each of the subdirs here is a simple CMakeLists.txt which does a very
-basic test for one of the cmake modules in the modules/ directory.
-To run them, create a build directory, run cmake and check the output.
-(yes, this can of course be enhanced, but it's better than nothing).
-
-Alex

cmake/modules/CMakeLists.txt

@@ -24,7 +24,6 @@ set(cmakeFiles
     FindAGG.cmake
     FindAkode.cmake
     FindAlsa.cmake
-               FindAutomoc4.cmake
     FindAvahi.cmake
     FindBerkeleyDB.cmake
     FindBlueZ.cmake
@@ -66,7 +65,6 @@ set(cmakeFiles
     FindLibLZMA.cmake
     FindLibXslt.cmake
     FindLibintl.cmake
-               FindLibraryWithDebug.cmake
     FindLinuxWirelesstools.cmake
     FindMsgfmt.cmake
     FindMusicBrainz.cmake
@@ -83,12 +81,10 @@ set(cmakeFiles
     FindPyQt4.cmake
     Qt4Macros.cmake
     Qt4ConfigDependentSettings.cmake
-               KatieMacros.cmake
     FindPythonLibrary.cmake
     FindQCA2.cmake
     FindQImageBlitz.cmake
     FindQt4.cmake
-               FindKatie.cmake
     FindRUBY.cmake
     FindSIP.cmake
     FindSamba.cmake
@@ -113,7 +109,6 @@ set(cmakeFiles
     MacroAdditionalCleanFiles.cmake
     MacroAppendIf.cmake
     MacroBoolTo01.cmake
-               MacroEnsureOutOfSourceBuild.cmake
     MacroEnsureVersion.cmake
     MacroLibrary.cmake
     MacroLogFeature.cmake
@@ -127,10 +122,8 @@ set(cmakeFiles
     check_installed_exports_file.cmake
     config-alsa.h.cmake
     create_exe_symlink.cmake
-               kde4_exec_via_sh.cmake
     kde4uic.cmake
     cmake-modules-styleguide.txt
-               kde4init_dummy.cpp.in
     kde4_cmake_uninstall.cmake.in
     BasicFindPackageVersion.cmake.in
     FindLibPython.py
@@ -140,24 +133,4 @@ set(cmakeFiles
     PythonCompile.py
 )
 
-install(FILES ${cmakeFiles}
+install(FILES ${cmakeFiles} DESTINATION ${module_install_dir})
-        DESTINATION ${module_install_dir} )
-
-
-# the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex
-#set(FILES_TO_REMOVE
-#)
-
-#install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake )
-
-#file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, don't edit\n\n")
-#foreach ( _current_FILE ${FILES_TO_REMOVE})
-#   file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${_current_FILE}\" )\n" )
-#   file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${_current_FILE} OUTPUT_VARIABLE _dummy)\n" )
-#endforeach ( _current_FILE)
-
-if(NOT CMAKE_VERSION VERSION_GREATER 2.8.12)
-  # create and install a man page for the kdelibs cmake modules
-  add_custom_target(KDECMakeModulesManPage ALL COMMAND ${CMAKE_COMMAND} -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR} --help-custom-modules ${CMAKE_CURRENT_BINARY_DIR}/kdecmake.1)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/kdecmake.1 DESTINATION "${MAN_INSTALL_DIR}/man1")
-endif()

cmake/modules/FindAutomoc4.cmake

@@ -1,49 +0,0 @@
-# - Try to find automoc4
-# Once done this will define
-#
-#  AUTOMOC4_FOUND - automoc4 has been found
-#  AUTOMOC4_EXECUTABLE - the automoc4 tool
-#  AUTOMOC4_VERSION - the full version of automoc4
-#  AUTOMOC4_VERSION_MAJOR, AUTOMOC4_VERSION_MINOR, AUTOMOC4_VERSION_PATCH - AUTOMOC4_VERSION 
-#                     broken into its components
-#
-# It also adds the following macros
-#  AUTOMOC4(<target> <SRCS_VAR>)
-#    Use this to run automoc4 on all files contained in the list <SRCS_VAR>.
-#
-#  AUTOMOC4_MOC_HEADERS(<target> header1.h header2.h ...)
-#    Use this to add more header files to be processed with automoc4.
-#
-#  AUTOMOC4_ADD_EXECUTABLE(<target_NAME> src1 src2 ...)
-#    This macro does the same as ADD_EXECUTABLE, but additionally
-#    adds automoc4 handling for all source files.
-#
-# AUTOMOC4_ADD_LIBRARY(<target_NAME> src1 src2 ...)
-#    This macro does the same as ADD_LIBRARY, but additionally
-#    adds automoc4 handling for all source files.
-
-# Internal helper macro, may change or be removed anytime:
-# _ADD_AUTOMOC4_TARGET(<target_NAME> <SRCS_VAR>)
-#
-# Since version 0.9.88:
-# The following two macros are only to be used for KDE4 projects
-# and do something which makes sure automoc4 works for KDE. Don't
-# use them anywhere else.
-# _AUTOMOC4_KDE4_PRE_TARGET_HANDLING(<target_NAME> <SRCS_VAR>)
-# _AUTOMOC4_KDE4_POST_TARGET_HANDLING(<target_NAME>)
-
-
-# Copyright (c) 2008-2009, Alexander Neundorf, <neundorf@kde.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-
-# use the new "config-mode" of cmake 2.6, which searches the installed Automoc4Config.cmake file
-# see the man page for details
-set(_Automoc4_FIND_QUIETLY ${Automoc4_FIND_QUIETLY})
-find_package(Automoc4 QUIET NO_MODULE)
-set(Automoc4_FIND_QUIETLY ${_Automoc4_FIND_QUIETLY})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Automoc4 "Did not find automoc4 (Automoc4Config.cmake, install git://anongit.kde.org/automoc)." AUTOMOC4_EXECUTABLE)

cmake/modules/FindKDE4Internal.cmake

@@ -147,9 +147,6 @@
 #
 #  KDE4_BUILD_TESTS  - enable this to build the testcases
 #  KDE4_ENABLE_FPIE  - enable it to use gcc Position Independent Executables feature
-#  KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR - only present for CMake >= 2.6.3, defaults to TRUE
-#                      If enabled, the package should install its <package>Config.cmake file to
-#                      lib/cmake/<package>/ instead to lib/<package>/cmake
 #  KDE4_SERIALIZE_TOOL - wrapper to serialize potentially resource-intensive commands during
 #                      parallel builds (set to 'icecc' when using icecream)
 #
@@ -219,18 +216,6 @@
 #    KGlobal::dirs()->addResourceDir( "data", KDESRCDIR )
 #
 #
-#  KDE4_ADD_APP_ICON (SRCS_VAR pattern)
-#  adds an application icon to target source list.
-#  Make sure you have a 128x128 icon, or the icon won't display on Mac OS X.
-#  Mac OSX notes : the application icon is added to a Mac OS X bundle so that Finder and friends show the right thing.
-#  Win32 notes: the application icon(s) are compiled into the application
-#  There is some workaround in kde4_add_kdeinit_executable to make it possible for those applications as well.
-# Parameters:
-#  SRCS_VAR  - specifies the list of source files
-#  pattern   - regular expression for searching application icons
-#  Example: KDE4_ADD_APP_ICON( myapp_SOURCES "pics/cr*-myapp.png")
-#  Example: KDE4_ADD_APP_ICON( myapp_KDEINIT_SRCS "icons/oxygen/*/apps/myapp.png")
-#
 #  KDE4_UPDATE_ICONCACHE()
 #    Notifies the icon cache that new icons have been installed by updating
 #    mtime of ${ICON_INSTALL_DIR}/hicolor directory.
@@ -438,23 +423,14 @@ if (_kdeBootStrapping)
    set(EXECUTABLE_OUTPUT_PATH ${kdelibs_BINARY_DIR}/bin )
 
    set(LIBRARY_OUTPUT_PATH               ${CMAKE_BINARY_DIR}/lib )
-   set(KDE4_KCFGC_EXECUTABLE             ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler${CMAKE_EXECUTABLE_SUFFIX}.shell )
+   set(KDE4_KCFGC_EXECUTABLE             kconfig_compiler${CMAKE_EXECUTABLE_SUFFIX} )
-   set(KDE4_MAKEKDEWIDGETS_EXECUTABLE    ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets${CMAKE_EXECUTABLE_SUFFIX}.shell )
+   set(KDE4_MAKEKDEWIDGETS_EXECUTABLE    makekdewidgets${CMAKE_EXECUTABLE_SUFFIX} )
 
    set(KDE4_LIB_DIR ${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR})
 
-
-   # when building kdelibs, make the kcfg rules depend on the binaries...
-   set( _KDE4_KCONFIG_COMPILER_DEP kconfig_compiler)
-   set( _KDE4_MAKEKDEWIDGETS_DEP makekdewidgets)
    set(KDE4_INSTALLED_VERSION_OK TRUE)
 
 else (_kdeBootStrapping)
-
-   # ... but NOT otherwise
-   set( _KDE4_KCONFIG_COMPILER_DEP)
-   set( _KDE4_MAKEKDEWIDGETS_DEP)
-
    set(LIBRARY_OUTPUT_PATH  ${CMAKE_BINARY_DIR}/lib )
 
    # These files contain information about the installed kdelibs, Alex
@@ -467,10 +443,10 @@ else (_kdeBootStrapping)
    if(NOT KDE_MIN_VERSION)
       if (KDE4_FIND_VERSION_MAJOR)
          set(KDE_MIN_VERSION "${KDE4_FIND_VERSION_MAJOR}.${KDE4_FIND_VERSION_MINOR}.${KDE4_FIND_VERSION_PATCH}")
-      else (KDE4_FIND_VERSION_MAJOR)
+      else()
          set(KDE_MIN_VERSION "4.14.3")
-      endif (KDE4_FIND_VERSION_MAJOR)
+      endif()
-   endif (NOT KDE_MIN_VERSION)
+   endif()
 
    #message(FATAL_ERROR "KDE_MIN_VERSION=${KDE_MIN_VERSION}  found ${KDE_VERSION} exact: -${KDE4_FIND_VERSION_EXACT}- version: -${KDE4_FIND_VERSION}-")
    macro_ensure_version(${KDE_MIN_VERSION} ${KDE_VERSION} KDE4_INSTALLED_VERSION_OK)
@@ -481,7 +457,6 @@ else (_kdeBootStrapping)
    set(KDE4_LIB_DIR ${KDE4_LIB_INSTALL_DIR})
    set(KDE4_INCLUDE_DIR ${KDE4_INCLUDE_INSTALL_DIR})
 
-
    # This setting is currently not recorded in KDELibsDependencies.cmake:
    find_file(KDE4_PLASMA_OPENGL_FOUND plasma/glapplet.h PATHS ${KDE4_INCLUDE_DIR} NO_DEFAULT_PATH)
 
@@ -563,12 +538,9 @@ _kde4_set_lib_variables(KUNITCONVERSION kunitconversion "${KDE4_TARGET_PREFIX}")
 _kde4_set_lib_variables(PLASMA        plasma        "${KDE4_TARGET_PREFIX}")
 _kde4_set_lib_variables(SOLID         solid         "${KDE4_TARGET_PREFIX}")
 _kde4_set_lib_variables(THREADWEAVER  threadweaver  "${KDE4_TARGET_PREFIX}")
-
-if (UNIX)
 _kde4_set_lib_variables(KDEFAKES      kdefakes      "${KDE4_TARGET_PREFIX}")
 _kde4_set_lib_variables(KDESU         kdesu         "${KDE4_TARGET_PREFIX}")
 _kde4_set_lib_variables(KPTY          kpty          "${KDE4_TARGET_PREFIX}")
-endif (UNIX)
 
 ################### try to find Phonon ############################################
 
@@ -590,17 +562,18 @@ endif(NOT PHONON_FOUND)
 
 #####################  provide some options   ##########################################
 
-option(KDE4_BUILD_TESTS  "Build the tests" ON)
+if(ENABLE_TESTING)
+    enable_testing()
+endif()
 set(KDE4_SERIALIZE_TOOL "" CACHE STRING "Tool to serialize resource-intensive commands in parallel builds")
 
-# if CMake 2.6.3 or above is used, provide an option which should be used by other KDE packages
+# for CMake 2.6.3 or above, provide an option which should be used by other KDE
-# whether to install a CMake FooConfig.cmake into lib/foo/cmake/ or /lib/cmake/foo/
+# packages whether to install a CMake FooConfig.cmake into lib/foo/cmake/ or
-# (with 2.6.3 and above also lib/cmake/foo/ is supported):
+# /lib/cmake/foo/ (with 2.6.3 and above also lib/cmake/foo/ is supported):
-if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} VERSION_GREATER 2.6.2)
+option(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR
-   option(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR "Prefer to install the <package>Config.cmake files to lib/cmake/<package> instead to lib/<package>/cmake" TRUE)
+    "Prefer to install the <package>Config.cmake files to lib/cmake/<package> instead to lib/<package>/cmake"
-else(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} VERSION_GREATER 2.6.2)
+    TRUE
-   set(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR  FALSE)
+)
-endif(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} VERSION_GREATER 2.6.2)
 
 # Position-Independent-Executable is a feature of Binutils, Libc, and GCC that creates an executable
 # which is something between a shared library and a normal executable.
@@ -623,78 +596,44 @@ endif ("${KDE4_LIB_DIR}" MATCHES lib32)
 
 set(LIB_SUFFIX "${_Init_LIB_SUFFIX}" CACHE STRING "Define suffix of directory name (32/64)" )
 
+set(EXEC_INSTALL_PREFIX  "${CMAKE_INSTALL_PREFIX}")
+set(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share")
+set(BIN_INSTALL_DIR      "${EXEC_INSTALL_PREFIX}/bin")
+set(SBIN_INSTALL_DIR     "${EXEC_INSTALL_PREFIX}/sbin")
+set(LIB_INSTALL_DIR      "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
+set(LIBEXEC_INSTALL_DIR  "${LIB_INSTALL_DIR}/kde4/libexec")
+set(INCLUDE_INSTALL_DIR  "${CMAKE_INSTALL_PREFIX}/include")
 
-########## the following are directories where stuff will be installed to  ###########
+set(PLUGIN_INSTALL_DIR       "${LIB_INSTALL_DIR}/kde4")
-#
+set(IMPORTS_INSTALL_DIR      "${PLUGIN_INSTALL_DIR}/imports")
-# this has to be after find_xxx() block above, since there KDELibsDependencies.cmake is included
+set(CONFIG_INSTALL_DIR       "${SHARE_INSTALL_PREFIX}/config")
-# which contains the install dirs from kdelibs, which are reused below
+set(DATA_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/apps")
+set(ICON_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/icons")
+set(KCFG_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/config.kcfg")
+set(LOCALE_INSTALL_DIR       "${SHARE_INSTALL_PREFIX}/locale")
+set(MIME_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/mimelnk")
+set(SERVICES_INSTALL_DIR     "${SHARE_INSTALL_PREFIX}/kde4/services")
+set(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes")
+set(SOUND_INSTALL_DIR        "${SHARE_INSTALL_PREFIX}/sounds")
+set(TEMPLATES_INSTALL_DIR    "${SHARE_INSTALL_PREFIX}/templates")
+set(WALLPAPER_INSTALL_DIR    "${SHARE_INSTALL_PREFIX}/wallpapers")
+set(DEMO_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/demos")
+set(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update")
+set(AUTOSTART_INSTALL_DIR    "${SHARE_INSTALL_PREFIX}/autostart")
 
-# This macro implements some very special logic how to deal with the cache.
+set(XDG_APPS_INSTALL_DIR     "${SHARE_INSTALL_PREFIX}/applications/kde4")
-# By default the various install locations inherit their value from their "parent" variable
+set(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories")
-# so if you set CMAKE_INSTALL_PREFIX, then EXEC_INSTALL_PREFIX, PLUGIN_INSTALL_DIR will
+set(XDG_MIME_INSTALL_DIR     "${SHARE_INSTALL_PREFIX}/mime/packages")
-# calculate their value by appending subdirs to CMAKE_INSTALL_PREFIX .
-# This would work completely without using the cache.
-# But if somebody wants e.g. a different EXEC_INSTALL_PREFIX this value has to go into
-# the cache, otherwise it will be forgotten on the next cmake run.
-# Once a variable is in the cache, it doesn't depend on its "parent" variables
-# anymore and you can only change it by editing it directly.
-# this macro helps in this regard, because as long as you don't set one of the
-# variables explicitly to some location, it will always calculate its value from its
-# parents. So modifying CMAKE_INSTALL_PREFIX later on will have the desired effect.
-# But once you decide to set e.g. EXEC_INSTALL_PREFIX to some special location
-# this will go into the cache and it will no longer depend on CMAKE_INSTALL_PREFIX.
-#
-# additionally if installing to the same location as kdelibs, the other install
-# directories are reused from the installed kdelibs
-macro(_SET_FANCY _var _value _comment)
-    set(predefinedvalue "${_value}")
-    if ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var})
-        set(predefinedvalue "${KDE4_${_var}}")
-    endif ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var})
 
-    if (NOT DEFINED ${_var})
+set(SYSCONF_INSTALL_DIR      "${CMAKE_INSTALL_PREFIX}/etc")
-        set(${_var} ${predefinedvalue})
+set(MAN_INSTALL_DIR          "${SHARE_INSTALL_PREFIX}/man")
-    else (NOT DEFINED ${_var})
+set(INFO_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/info")
-        set(${_var} "${${_var}}" CACHE PATH "${_comment}")
+set(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces")
-    endif (NOT DEFINED ${_var})
+set(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services")
-endmacro(_SET_FANCY)
+set(DBUS_SYSTEM_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/system-services")
-
-_set_fancy(EXEC_INSTALL_PREFIX  "${CMAKE_INSTALL_PREFIX}"                 "Base directory for executables and libraries")
-_set_fancy(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share"           "Base directory for files which go to share/")
-_set_fancy(BIN_INSTALL_DIR      "${EXEC_INSTALL_PREFIX}/bin"              "The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)")
-_set_fancy(SBIN_INSTALL_DIR     "${EXEC_INSTALL_PREFIX}/sbin"             "The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)")
-_set_fancy(LIB_INSTALL_DIR      "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" "The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})")
-_set_fancy(LIBEXEC_INSTALL_DIR  "${LIB_INSTALL_DIR}/kde4/libexec"         "The subdirectory relative to the install prefix where libraries will be installed (default is ${LIB_INSTALL_DIR}/kde4/libexec)")
-_set_fancy(INCLUDE_INSTALL_DIR  "${CMAKE_INSTALL_PREFIX}/include"         "The subdirectory to the header prefix")
-
-_set_fancy(PLUGIN_INSTALL_DIR       "${LIB_INSTALL_DIR}/kde4"                "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4)")
-_set_fancy(IMPORTS_INSTALL_DIR       "${PLUGIN_INSTALL_DIR}/imports"                "The subdirectory relative to the install prefix where imports will be installed")
-_set_fancy(CONFIG_INSTALL_DIR       "${SHARE_INSTALL_PREFIX}/config"         "The config file install dir")
-_set_fancy(DATA_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/apps"           "The parent directory where applications can install their data")
-_set_fancy(ICON_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/icons"          "The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)")
-_set_fancy(KCFG_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/config.kcfg"    "The install dir for kconfig files")
-_set_fancy(LOCALE_INSTALL_DIR       "${SHARE_INSTALL_PREFIX}/locale"         "The install dir for translations")
-_set_fancy(MIME_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/mimelnk"        "The install dir for the mimetype desktop files")
-_set_fancy(SERVICES_INSTALL_DIR     "${SHARE_INSTALL_PREFIX}/kde4/services"  "The install dir for service (desktop, protocol, ...) files")
-_set_fancy(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes" "The install dir for servicestypes desktop files")
-_set_fancy(SOUND_INSTALL_DIR        "${SHARE_INSTALL_PREFIX}/sounds"         "The install dir for sound files")
-_set_fancy(TEMPLATES_INSTALL_DIR    "${SHARE_INSTALL_PREFIX}/templates"      "The install dir for templates (Create new file...)")
-_set_fancy(WALLPAPER_INSTALL_DIR    "${SHARE_INSTALL_PREFIX}/wallpapers"     "The install dir for wallpapers")
-_set_fancy(DEMO_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/demos"          "The install dir for demos")
-_set_fancy(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update"       "The kconf_update install dir")
-_set_fancy(AUTOSTART_INSTALL_DIR    "${SHARE_INSTALL_PREFIX}/autostart"      "The install dir for autostart files")
-
-_set_fancy(XDG_APPS_INSTALL_DIR     "${SHARE_INSTALL_PREFIX}/applications/kde4"         "The XDG apps dir")
-_set_fancy(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories"      "The XDG directory")
-_set_fancy(XDG_MIME_INSTALL_DIR     "${SHARE_INSTALL_PREFIX}/mime/packages"  "The install dir for the xdg mimetypes")
-
-_set_fancy(SYSCONF_INSTALL_DIR      "${CMAKE_INSTALL_PREFIX}/etc"            "The sysconfig install dir (default ${CMAKE_INSTALL_PREFIX}/etc)")
-_set_fancy(MAN_INSTALL_DIR          "${SHARE_INSTALL_PREFIX}/man"            "The man install dir (default ${SHARE_INSTALL_PREFIX}/man/)")
-_set_fancy(INFO_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/info"           "The info install dir (default ${SHARE_INSTALL_PREFIX}/info)")
-_set_fancy(DBUS_INTERFACES_INSTALL_DIR      "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces" "The dbus interfaces install dir (default  ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)")
-_set_fancy(DBUS_SERVICES_INSTALL_DIR      "${SHARE_INSTALL_PREFIX}/dbus-1/services"     "The dbus services install dir (default  ${SHARE_INSTALL_PREFIX}/dbus-1/services)")
-_set_fancy(DBUS_SYSTEM_SERVICES_INSTALL_DIR      "${SHARE_INSTALL_PREFIX}/dbus-1/system-services"     "The dbus system services install dir (default  ${SHARE_INSTALL_PREFIX}/dbus-1/system-services)")
 
+set(KAUTH_HELPER_PLUGIN_DIR  "${PLUGIN_INSTALL_DIR}/plugins/kauth/helper")
+set(KAUTH_BACKEND_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/backend")
 
 # For more documentation see above.
 # Later on it will be possible to extend this for installing OSX frameworks
@@ -729,27 +668,15 @@ set(CMAKE_SYSTEM_LIBRARY_PATH ${CMAKE_SYSTEM_LIBRARY_PATH}
 #  and now the platform specific stuff
 ######################################################
 
-# Set a default build type for single-configuration
-# CMake generators if no build type is set.
-if (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
-   set(CMAKE_BUILD_TYPE RelWithDebInfo)
-endif (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
-
-
 if (WIN32 OR CYGWIN OR APPLE)
     message(FATAL_ERROR "Windows/Cygwin/Apple is NOT supported.")
 endif(WIN32 OR CYGWIN OR APPLE)
 
-# setup default RPATH/install_name handling, may be overridden by KDE4_HANDLE_RPATH_FOR_EXECUTABLE
+# setup default RPATH/install_name handling, it sets up to build with full
-# It sets up to build with full RPATH. When installing, RPATH will be changed to the LIB_INSTALL_DIR
+# RPATH. When installing, RPATH will be changed to the LIB_INSTALL_DIR
 # and all link directories which are not inside the current build dir.
-if (UNIX)
 set(_KDE4_PLATFORM_INCLUDE_DIRS)
 
-    # the rest is RPATH handling
-    # here the defaults are set
-    # which are partly overwritten in kde4_handle_rpath_for_library()
-    # and kde4_handle_rpath_for_executable(), both located in KDE4Macros.cmake, Alex
 # add our LIB_INSTALL_DIR to the RPATH (but only when it is not one of the standard system link
 # directories listed in CMAKE_{PLATFORM,C,CXX}_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured out by cmake when compiling
 
@@ -763,7 +690,6 @@ if (UNIX)
 set(CMAKE_SKIP_BUILD_RPATH FALSE)
 set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-endif (UNIX)
 
 
 if(Q_WS_X11)
@@ -771,7 +697,8 @@ if (Q_WS_X11)
    #find_package(X11 REQUIRED)
    # UNIX has already set _KDE4_PLATFORM_INCLUDE_DIRS, so append
    set(_KDE4_PLATFORM_INCLUDE_DIRS ${_KDE4_PLATFORM_INCLUDE_DIRS} ${X11_INCLUDE_DIR} )
-endif (Q_WS_X11)
+endif()
+
 
 if(CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
     if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
@@ -787,14 +714,16 @@ if (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
         if(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile)
             set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
             set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
-      endif(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile)
+        endif()
-   endif (CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    endif()
+
     if(CMAKE_C_COMPILER MATCHES "icc")
         set(_KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE)
         set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}")
         set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}")
-   endif (CMAKE_C_COMPILER MATCHES "icc")
+    endif()
-endif (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
+endif()
+
 
 if(UNIX)
     set(_KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_LARGEFILE64_SOURCE")
@@ -813,8 +742,8 @@ if (UNIX)
 
     if(NOT _OFFT_IS_64BIT)
         set(_KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_FILE_OFFSET_BITS=64")
-   endif (NOT _OFFT_IS_64BIT)
+    endif()
-endif (UNIX)
+endif()
 
 
 ############################################################
@@ -845,7 +774,7 @@ macro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _result)
         SET(${_result} ${CMAKE_MATCH_1})
         STRING(REPLACE "\n" " " ${_result} "${${_result}}")
         SEPARATE_ARGUMENTS(${_result})
-  ENDIF( "${_gccOutput}" MATCHES "> search starts here[^\n]+\n *(.+) *\n *End of (search) list" )
+    endif()
 ENDMACRO(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang)
 
 if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES Clang)
@@ -1145,7 +1074,14 @@ set(KDE4_INCLUDES
 get_filename_component(_KDE4_CMAKE_TOPLEVEL_DIR "${CMAKE_SOURCE_DIR}/.." ABSOLUTE)
 string(LENGTH "${_KDE4_CMAKE_TOPLEVEL_DIR}" _KDE4_CMAKE_TOPLEVEL_DIR_LENGTH)
 
-set(KDE4_DEFINITIONS ${_KDE4_PLATFORM_DEFINITIONS} -DQT_NO_STL -DQT_NO_CAST_TO_ASCII -D_REENTRANT -DKDE_DEPRECATED_WARNINGS -DKDE4_CMAKE_TOPLEVEL_DIR_LENGTH=${_KDE4_CMAKE_TOPLEVEL_DIR_LENGTH})
+set(KDE4_DEFINITIONS
+    ${_KDE4_PLATFORM_DEFINITIONS}
+    -DQT_NO_STL
+    -DQT_NO_CAST_TO_ASCII
+    -D_REENTRANT
+    -DKDE_DEPRECATED_WARNINGS
+    -DKDE4_CMAKE_TOPLEVEL_DIR_LENGTH=${_KDE4_CMAKE_TOPLEVEL_DIR_LENGTH}
+)
 
 if(NOT _kde4_uninstall_rule_created)
    set(_kde4_uninstall_rule_created TRUE)

cmake/modules/FindKatie.cmake

@@ -1,203 +0,0 @@
-# - Try to find the Katie Toolkit
-#
-# Once done this will define:
-#
-#  KATIE_FOUND - system has libmng
-#  KATIE_INCLUDES - the libmng include directory
-#  KATIE_LIBRARIES - The libraries needed to use libmng
-#
-#  KATIE_<COMPONENT>_INCLUDES
-#  KATIE_<COMPONENT>_LIBRARIES
-#
-#  KATIE_MKSPECS_DIR
-#  KATIE_MOC_EXECUTABLE
-#  KATIE_UIC_EXECUTABLE
-#  KATIE_RCC_EXECUTABLE
-#  KATIE_QDBUSXML2CPP_EXECUTABLE
-#  KATIE_QDBUSCPP2XML_EXECUTABLE
-#  KATIE_QHELPGENERATOR_EXECUTABLE
-#  KATIE_QCOLLECTIONGENERATOR_EXECUTABLE
-#  KATIE_LUPDATE_EXECUTABLE
-#  KATIE_LRELEASE_EXECUTABLE
-#  KATIE_LCONVERT_EXECUTABLE
-#
-# In addition the following macros will be defined:
-#
-#  KATIE_RESOURCES( < source.cpp | header.h | resource.qrc | userinterface.ui > ...)
-#  KATIE_DBUS_INTERFACE()
-#  KATIE_DBUS_ADAPTOR()
-#  KATIE_TRANSLATION()
-#
-# Copyright (c) 2015, Ivailo Monev, <xakepa10@gmail.com>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-
-if(KATIE_INCLUDES AND KATIE_LIBRARIES)
-  set(KATIE_FIND_QUIETLY TRUE)
-endif(KATIE_INCLUDES AND KATIE_LIBRARIES)
-
-if(Katie_FIND_COMPONENTS)
-    # for compat with Qt
-    foreach(comp ${Katie_FIND_COMPONENTS})
-        string(REPLACE REGEX "^Qt" "" modcomp ${comp})
-        set(KATIECOMPONENTS ${modcomp})
-    endforeach()
-else()
-    # TODO: add Multimedia once it builds
-    set(KATIECOMPONENTS Core Gui Network OpenGL Sql Svg Test DBus Xml XmlPatterns Script ScriptTools WebKit Declarative Help UiTools Designer)
-endif()
-# TODO: designer, linguist?
-set(KATIETOOLS moc uic rcc qdbusxml2cpp qdbuscpp2xml qhelpgenerator qcollectiongenerator lupdate lrelease lconvert)
-
-# enable compat by default
-if(NOT "${KATIE_COMPAT}" STREQUAL FALSE AND NOT "${KATIE_COMPAT}" STREQUAL OFF)
-    set(KATIE_COMPAT TRUE)
-endif()
-set(KATIE_FOUND TRUE)
-set(KATIE_INCLUDES ${CMAKE_BINARY_DIR}/_generated_)
-set(KATIE_LIBRARIES)
-
-find_path(KATIE_MKSPECS_DIR
-    NAMES
-    mkspecs
-    PATH_SUFFIXES qt4
-    HINTS
-    /share
-    /usr/share
-    /usr/local/share
-    $ENV{QTDIR}/share
-)
-
-foreach(tool ${KATIETOOLS})
-    string(TOUPPER ${tool} uppertool)
-    find_program(KATIE_${uppertool}_EXECUTABLE
-        NAMES
-        ${tool} ${tool}-qt4 ${tool}-katie
-        HINTS
-        /bin
-        /usr/bin
-        /usr/local/bin
-        $ENV{QTDIR}/bin
-    )
-endforeach()
-
-foreach(component ${KATIECOMPONENTS})
-    string(TOUPPER KATIE_${component} uppercomp)
-    set(component Qt${component})
-
-    if(NOT WIN32)
-        # use pkg-config to get the directories and then use these values
-        # in the FIND_PATH() and FIND_LIBRARY() calls
-        find_package(PkgConfig)
-        pkg_check_modules(PC_${uppercomp} QUIET ${component})
-    endif(NOT WIN32)
-
-    find_path(FIND_${uppercomp}_INCLUDES
-        NAMES
-        ${component}
-        PATH_SUFFIXES ${component}
-        HINTS
-        /include
-        /usr/include
-        /usr/local/include
-        $ENV{QTDIR}/include
-        ${PC_${uppercomp}_INCLUDEDIR}
-        ${INCLUDE_INSTALL_DIR}
-    )
-
-    find_library(FIND_${uppercomp}_LIBRARIES
-        ${component}
-        HINTS
-        /lib
-        /usr/lib
-        /usr/local/lib
-        $ENV{QTDIR}/lib
-        ${PC_${uppercomp}_LIBDIR}
-        ${LIB_INSTALL_DIR}
-    )
-
-    set(COMPONENT_INCLUDES ${FIND_${uppercomp}_INCLUDES})
-    set(COMPONENT_LIBRARIES ${FIND_${uppercomp}_LIBRARIES} ${PC_${uppercomp}_LIBRARIES})
-    set(COMPONENT_VERSION ${PC_${uppercomp}_VERSION})
-    if(NOT COMPONENT_VERSION)
-        set(COMPONENT_VERSION "unknown")
-    endif()
-    if(NOT "${COMPONENT_INCLUDES}" STREQUAL "${uppercomp}_INCLUDES-NOTFOUND"
-        AND NOT "${COMPONENT_LIBRARIES}" STREQUAL "${uppercomp}_LIBRARIES-NOTFOUND")
-        message(STATUS "Found ${component}, version ${COMPONENT_VERSION}")
-        set(${uppercomp}_FOUND TRUE)
-        get_filename_component(parentinclude ${COMPONENT_INCLUDES} DIRECTORY) 
-        set(KATIE_INCLUDES ${KATIE_INCLUDES} ${COMPONENT_INCLUDES} ${parentinclude})
-        set(KATIE_LIBRARIES ${KATIE_LIBRARIES} ${COMPONENT_LIBRARIES})
-        set(${uppercomp}_INCLUDES ${COMPONENT_INCLUDES})
-        set(${uppercomp}_LIBRARIES ${COMPONENT_LIBRARIES})
-    else()
-        message(STATUS "Could not find: ${component}")
-        set(${uppercomp}_FOUND FALSE)
-        set(KATIE_FOUND FALSE)
-    endif()
-endforeach()
-
-include(KatieMacros)
-
-if(KATIE_MKSPECS_DIR)
-    include(${KATIE_MKSPECS_DIR}/mkspecs/mkspecs.cmake)
-endif()
-
-if(KATIE_COMPAT AND KATIE_FOUND)
-    set(Qt4_FOUND TRUE)
-    set(QT_FOUND TRUE)
-    set(QT4_FOUND TRUE)
-    set(QT_VERSION_MAJOR ${KATIE_MAJOR})
-    set(QT_VERSION_MINOR ${KATIE_MINOR})
-    set(QT_VERSION_PATCH ${KATIE_MICRO})
-    set(QT_VERSION ${KATIE_VERSION})
-    set(QT_INCLUDES ${KATIE_INCLUDES})
-    set(QT_INCLUDE_DIR ${KATIE_INCLUDES})
-    set(QT_LIBRARIES ${KATIE_LIBRARIES})
-    set(QT_USE_FILE ${KATIE_MKSPECS_DIR}/mkspecs/mkspecs.cmake)
-
-    set(QT_MOC_EXECUTABLE ${KATIE_MOC_EXECUTABLE})
-    set(QT_UIC_EXECUTABLE ${KATIE_UIC_EXECUTABLE})
-    set(QT_RCC_EXECUTABLE ${KATIE_RCC_EXECUTABLE})
-    set(QT_DBUSXML2CPP_EXECUTABLE ${KATIE_QDBUSXML2CPP_EXECUTABLE})
-    set(QT_DBUSCPP2XML_EXECUTABLE ${KATIE_QDBUSCPP2XML_EXECUTABLE})
-    set(QT_LUPDATE_EXECUTABLE ${KATIE_LUPDATE_EXECUTABLE})
-    set(QT_LRELEASE_EXECUTABLE ${KATIE_LRELEASE_EXECUTABLE})
-    set(QT_MKSPECS_DIR ${KATIE_MKSPECS_DIR})
-
-    if(NOT "${KATIE_FIND_QUIETLY}")
-        foreach(tool ${KATIETOOLS})
-            string(TOUPPER ${tool} uppertool)
-            add_executable(Qt4::${tool} IMPORTED)
-            set_property(TARGET Qt4::${tool} PROPERTY IMPORTED_LOCATION ${KATIE_${uppertool}_EXECUTABLE})
-        endforeach()
-
-        foreach(component ${KATIECOMPONENTS})
-            string(TOUPPER ${component} uppercomp)
-            add_library(Qt4::Qt${component} ${KATIE_TYPE} IMPORTED)
-            set_property(TARGET Qt4::Qt${component} PROPERTY IMPORTED_LOCATION ${FIND_KATIE_${uppercomp}_LIBRARIES})
-        endforeach()
-    endif()
-
-    # bad assumption
-    if(UNIX)
-        set(Q_WS_X11 TRUE)
-        find_package(X11 REQUIRED)
-    endif()
-
-    foreach(component ${KATIECOMPONENTS})
-        string(TOUPPER ${component} uppercomp)
-        set(QT_QT${uppercomp}_FOUND "${KATIE_${uppercomp}_FOUND}")
-        set(QT_QT${uppercomp}_LIBRARY "${KATIE_${uppercomp}_LIBRARIES}")
-    endforeach()
-
-    add_definitions(-DQT_INCLUDE_COMPAT)
-
-    include(Qt4Macros)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Katie DEFAULT_MSG KATIE_MKSPECS_DIR KATIE_INCLUDES KATIE_LIBRARIES)
-
-mark_as_advanced(KATIE_MKSPECS_DIR KATIE_INCLUDES KATIE_LIBRARIES)

cmake/modules/FindLibraryWithDebug.cmake

@@ -1,113 +0,0 @@
-#
-#  FIND_LIBRARY_WITH_DEBUG
-#  -> enhanced FIND_LIBRARY to allow the search for an
-#     optional debug library with a WIN32_DEBUG_POSTFIX similar
-#     to CMAKE_DEBUG_POSTFIX when creating a shared lib
-#     it has to be the second and third argument
-
-# Copyright (c) 2007, Christian Ehrlicher, <ch.ehrlicher@gmx.de>
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-MACRO(FIND_LIBRARY_WITH_DEBUG var_name win32_dbg_postfix_name dgb_postfix libname)
-
-  IF(NOT "${win32_dbg_postfix_name}" STREQUAL "WIN32_DEBUG_POSTFIX")
-
-     # no WIN32_DEBUG_POSTFIX -> simply pass all arguments to FIND_LIBRARY
-     FIND_LIBRARY(${var_name}
-                  ${win32_dbg_postfix_name}
-                  ${dgb_postfix}
-                  ${libname}
-                  ${ARGN}
-     )
-
-  ELSE(NOT "${win32_dbg_postfix_name}" STREQUAL "WIN32_DEBUG_POSTFIX")
-
-    IF(NOT WIN32)
-      # on non-win32 we don't need to take care about WIN32_DEBUG_POSTFIX
-
-      FIND_LIBRARY(${var_name} ${libname} ${ARGN})
-
-    ELSE(NOT WIN32)
-
-      # 1. get all possible libnames
-      SET(args ${ARGN})
-      SET(newargs "")
-      SET(libnames_release "")
-      SET(libnames_debug "")
-
-      LIST(LENGTH args listCount)
-
-      IF("${libname}" STREQUAL "NAMES")
-        SET(append_rest 0)
-        LIST(APPEND args " ")
-
-        FOREACH(i RANGE ${listCount})
-          LIST(GET args ${i} val)
-
-          IF(append_rest)
-            LIST(APPEND newargs ${val})
-          ELSE(append_rest)
-            IF("${val}" STREQUAL "PATHS")
-              LIST(APPEND newargs ${val})
-              SET(append_rest 1)
-            ELSE("${val}" STREQUAL "PATHS")
-              LIST(APPEND libnames_release "${val}")
-              LIST(APPEND libnames_debug   "${val}${dgb_postfix}")
-            ENDIF("${val}" STREQUAL "PATHS")
-          ENDIF(append_rest)
-
-        ENDFOREACH(i)
-
-      ELSE("${libname}" STREQUAL "NAMES")
-
-        # just one name
-        LIST(APPEND libnames_release "${libname}")
-        LIST(APPEND libnames_debug   "${libname}${dgb_postfix}")
-
-        SET(newargs ${args})
-
-      ENDIF("${libname}" STREQUAL "NAMES")
-
-      # search the release lib
-      FIND_LIBRARY(${var_name}_RELEASE
-                   NAMES ${libnames_release}
-                   ${newargs}
-      )
-
-      # search the debug lib
-      FIND_LIBRARY(${var_name}_DEBUG
-                   NAMES ${libnames_debug}
-                   ${newargs}
-      )
-
-      IF(${var_name}_RELEASE AND ${var_name}_DEBUG)
-
-        # both libs found
-        SET(${var_name} optimized ${${var_name}_RELEASE}
-                        debug     ${${var_name}_DEBUG})
-
-      ELSE(${var_name}_RELEASE AND ${var_name}_DEBUG)
-
-        IF(${var_name}_RELEASE)
-
-          # only release found
-          SET(${var_name} ${${var_name}_RELEASE})
-
-        ELSE(${var_name}_RELEASE)
-
-          # only debug (or nothing) found
-          SET(${var_name} ${${var_name}_DEBUG})
-
-        ENDIF(${var_name}_RELEASE)
-       
-      ENDIF(${var_name}_RELEASE AND ${var_name}_DEBUG)
-
-      MARK_AS_ADVANCED(${var_name}_RELEASE)
-      MARK_AS_ADVANCED(${var_name}_DEBUG)
-
-    ENDIF(NOT WIN32)
-
-  ENDIF(NOT "${win32_dbg_postfix_name}" STREQUAL "WIN32_DEBUG_POSTFIX")
-
-ENDMACRO(FIND_LIBRARY_WITH_DEBUG)

cmake/modules/FindPyKDE4.cmake

@@ -141,7 +141,7 @@ ENDMACRO(PYKDE4_INSTALL_PYTHON_FILES)
 ###########################################################################
 # PYKDE4_ADD_EXECUTABLE(py_name exe_name)
 #
-# Creates a smybolic link with name exe_name at install time from the
+# Creates a symbolic link with name exe_name at install time from the
 # install bin directory to the Python file. The Python file is also make
 # executable.
 #

cmake/modules/FindQCA2.cmake

@@ -14,8 +14,6 @@
 # Redistribution and use is allowed according to the terms of the BSD license.
 # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 
-include(FindLibraryWithDebug)
-
 if (QCA2_INCLUDE_DIR AND QCA2_LIBRARIES)
 
   # in cache already
@@ -30,8 +28,7 @@ else (QCA2_INCLUDE_DIR AND QCA2_LIBRARIES)
     set(QCA2_DEFINITIONS ${PC_QCA2_CFLAGS_OTHER})
   endif (NOT WIN32)
 
-  find_library_with_debug(QCA2_LIBRARIES
+  find_library(QCA2_LIBRARIES
-                  WIN32_DEBUG_POSTFIX d
                 NAMES qca
                 HINTS ${PC_QCA2_LIBDIR} ${PC_QCA2_LIBRARY_DIRS}
                 )

cmake/modules/FindQImageBlitz.cmake

@@ -10,8 +10,6 @@
 # Redistribution and use is allowed according to the terms of the BSD license.
 # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 
-include(FindLibraryWithDebug)
-
 if (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES)
   set(QImageBlitz_FIND_QUIETLY TRUE)
 endif (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES)
@@ -34,8 +32,7 @@ find_path(QIMAGEBLITZ_INCLUDES
   ${INCLUDE_INSTALL_DIR}
 )
 
-find_library_with_debug(QIMAGEBLITZ_LIBRARIES
+find_library(QIMAGEBLITZ_LIBRARIES
-  WIN32_DEBUG_POSTFIX d
   qimageblitz
   HINTS
   $ENV{QIMAGEBLITZDIR}/lib

cmake/modules/FindStrigi.cmake

@@ -57,7 +57,6 @@ if (STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
 
 else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
    # this else() branch is for finding strigi versions before November 16th, 2008. Alex
-   include(FindLibraryWithDebug)
    include(MacroPushRequiredVars)
 
    if (WIN32)
@@ -86,8 +85,7 @@ else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
    endif (NOT STRIGI_INCLUDEDIR)
 
 
-   find_library_with_debug(STRIGI_STREAMANALYZER_LIBRARY
+   find_library(STRIGI_STREAMANALYZER_LIBRARY
-     WIN32_DEBUG_POSTFIX d
      NAMES streamanalyzer
      PATHS
      ${strigi_home}/lib
@@ -95,8 +93,7 @@ else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
      ${_program_FILES_DIR}/strigi/lib
    )
 
-   find_library_with_debug(STRIGI_STREAMS_LIBRARY
+   find_library(STRIGI_STREAMS_LIBRARY
-     WIN32_DEBUG_POSTFIX d
      NAMES streams
      PATHS
      ${strigi_home}/lib
@@ -104,8 +101,7 @@ else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
      ${_program_FILES_DIR}/strigi/lib
    )
 
-   find_library_with_debug(STRIGI_STRIGIQTDBUSCLIENT_LIBRARY
+   find_library(STRIGI_STRIGIQTDBUSCLIENT_LIBRARY
-     WIN32_DEBUG_POSTFIX d
      NAMES strigiqtdbusclient
      PATHS
      ${strigi_home}/lib

cmake/modules/FindTaglib.cmake

@@ -14,11 +14,9 @@ if(NOT TAGLIB_MIN_VERSION)
   set(TAGLIB_MIN_VERSION "1.4")
 endif(NOT TAGLIB_MIN_VERSION)
 
-if(NOT WIN32)
 find_program(TAGLIBCONFIG_EXECUTABLE NAMES taglib-config PATHS
     ${BIN_INSTALL_DIR}
 )
-endif(NOT WIN32)
 
 #reset vars
 set(TAGLIB_LIBRARIES)
@@ -48,7 +46,6 @@ if(TAGLIBCONFIG_EXECUTABLE)
 
 else(TAGLIBCONFIG_EXECUTABLE)
 
-  include(FindLibraryWithDebug)
   include(FindPackageHandleStandardArgs)
 
   find_path(TAGLIB_INCLUDES
@@ -60,8 +57,7 @@ else(TAGLIBCONFIG_EXECUTABLE)
     ${INCLUDE_INSTALL_DIR}
   )
 
-  find_library_with_debug(TAGLIB_LIBRARIES
+  find_library(TAGLIB_LIBRARIES
-    WIN32_DEBUG_POSTFIX d
     NAMES tag
     PATHS
     ${KDE4_LIB_DIR}

cmake/modules/KDE4Defaults.cmake

@@ -6,6 +6,8 @@ endif (EXISTS ${CMAKE_SOURCE_DIR}/CTestConfig.cmake)
 # let cmake handle mocking
 # since cmake 2.8.6
 set(CMAKE_AUTOMOC ON)
+# set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOUIC ON)
 
 # Always include srcdir and builddir in include path
 # This saves typing ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} in about every subdir

cmake/modules/KDE4Macros.cmake

@@ -1,21 +1,12 @@
 # for documentation look at FindKDE4Internal.cmake
 
 # this file contains the following macros (or functions):
-# KDE4_ADD_UI_FILES
 # KDE4_ADD_KCFG_FILES
-# _KDE4_SET_CUSTOM_TARGET_PROPERTY
-# _KDE4_GET_CUSTOM_TARGET_PROPERTY
 # KDE4_ADD_PLUGIN
-# KDE4_ADD_KDEINIT_EXECUTABLE
+# KDE4_ADD_TEST
-# KDE4_ADD_UNIT_TEST
-# KDE4_ADD_EXECUTABLE
 # KDE4_ADD_WIDGET_FILES
-# KDE4_UPDATE_ICONCACHE
 # KDE4_INSTALL_ICONS
-# KDE4_REMOVE_OBSOLETE_CMAKE_FILES
-# KDE4_ADD_APP_ICON
 # KDE4_CREATE_MANPAGE
-# KDE4_CREATE_BASIC_CMAKE_VERSION_FILE (function)
 # KDE4_INSTALL_AUTH_HELPER_FILES
 # KDE4_AUTH_INSTALL_ACTIONS
 
@@ -42,11 +33,11 @@ macro (KDE4_ADD_KCFG_FILES _sources )
 
      if(NOT ${_current_FILE} STREQUAL "GENERATE_MOC" AND NOT ${_current_FILE} STREQUAL "USE_RELATIVE_PATH")
        get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
-       get_filename_component(_abs_PATH ${_tmp_FILE} PATH)
+       get_filename_component(_abs_PATH ${_tmp_FILE} DIRECTORY)
 
        if (_kcfg_relativepath) # Process relative path only if the option was set
            # Get relative path
-           get_filename_component(_rel_PATH ${_current_FILE} PATH)
+           get_filename_component(_rel_PATH ${_current_FILE} DIRECTORY)
 
            if (IS_ABSOLUTE ${_rel_PATH})
                # We got an absolute path
@@ -90,7 +81,8 @@ macro (KDE4_ADD_KCFG_FILES _sources )
           COMMAND ${KDE4_KCFGC_EXECUTABLE}
           ARGS ${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}
           MAIN_DEPENDENCY ${_tmp_FILE}
-          DEPENDS ${_kcfg_FILE} ${_KDE4_KCONFIG_COMPILER_DEP} )
+          DEPENDS ${_kcfg_FILE}
+       )
 
        if(_kcfg_generatemoc)
          qt4_generate_moc(${_header_FILE} ${_moc_FILE} )
@@ -105,80 +97,7 @@ macro (KDE4_ADD_KCFG_FILES _sources )
 endmacro (KDE4_ADD_KCFG_FILES)
 
 
-get_filename_component(KDE4_MODULE_DIR  ${CMAKE_CURRENT_LIST_FILE} PATH)
+get_filename_component(KDE4_MODULE_DIR  ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
-
-#create the implementation files from the ui files and add them to the list of sources
-#usage: KDE4_ADD_UI_FILES(foo_SRCS ${ui_files})
-macro (KDE4_ADD_UI_FILES _sources )
-   foreach (_current_FILE ${ARGN})
-
-      get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
-      get_filename_component(_basename ${_tmp_FILE} NAME_WE)
-      set(_header ${CMAKE_CURRENT_BINARY_DIR}/ui_${_basename}.h)
-
-      # we need to run uic and replace some things in the generated file
-      # this is done by executing the cmake script kde4uic.cmake
-      add_custom_command(OUTPUT ${_header}
-         COMMAND ${CMAKE_COMMAND}
-         ARGS
-         -DKDE4_HEADER:BOOL=ON
-         -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE}
-         -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
-         -DKDE_UIC_H_FILE:FILEPATH=${_header}
-         -DKDE_UIC_BASENAME:STRING=${_basename}
-         -P ${KDE4_MODULE_DIR}/kde4uic.cmake
-         MAIN_DEPENDENCY ${_tmp_FILE}
-      )
-      list(APPEND ${_sources} ${_header})
-   endforeach (_current_FILE)
-endmacro (KDE4_ADD_UI_FILES)
-
-
-# this is basically a copy of the qt4_get_moc_flags() macros from FindQt4.cmake
-# which is for internal use only, so we should not use it here:
-macro (_KDE4_GET_MOC_FLAGS _moc_flags)
-   set(${_moc_flags})
-   get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES)
-
-   foreach(_current ${_inc_DIRS})
-      set(${_moc_flags} ${${_moc_flags}} "-I${_current}")
-   endforeach(_current ${_inc_DIRS})
-
-   get_directory_property(_defines COMPILE_DEFINITIONS)
-   foreach(_current ${_defines})
-      set(${_moc_flags} ${${_moc_flags}} "-D${_current}")
-   endforeach(_current ${_defines})
-
-   # if Qt is installed only as framework, add -F /library/Frameworks to the moc arguments
-   # otherwise moc can't find the headers in the framework include dirs
-   if(APPLE  AND  "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
-      set(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-F/Library/Frameworks")
-   endif(APPLE  AND  "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
-
-endmacro(_KDE4_GET_MOC_FLAGS)
-
-
-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_INSTALL_TS_FILES _lang _sdir)
-   file(GLOB_RECURSE _ts_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${_sdir}/*)
-   foreach(_current_TS_FILES ${_ts_files})
-      string(REGEX MATCH "\\.svn/" _in_svn ${_current_TS_FILES})
-      if(NOT _in_svn)
-         get_filename_component(_subpath ${_current_TS_FILES} PATH)
-         install(FILES ${_current_TS_FILES} DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_SCRIPTS/${_subpath})
-      endif(NOT _in_svn)
-   endforeach(_current_TS_FILES)
-endmacro(KDE4_INSTALL_TS_FILES)
 
 macro (KDE4_CREATE_MANPAGE _docbook _section)
    get_filename_component(_input ${_docbook} ABSOLUTE)
@@ -224,19 +143,6 @@ macro (KDE4_CREATE_MANPAGE _docbook _section)
 endmacro (KDE4_CREATE_MANPAGE)
 
 
-macro (KDE4_UPDATE_ICONCACHE)
-    # Update mtime of hicolor icon theme dir.
-    # We don't always have touch command (e.g. on Windows), so instead create
-    #  and delete a temporary file in the theme dir.
-   install(CODE "
-    set(DESTDIR_VALUE \"\$ENV{DESTDIR}\")
-    if (NOT DESTDIR_VALUE)
-        file(WRITE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\" \"update\")
-        file(REMOVE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\")
-    endif (NOT DESTDIR_VALUE)
-    ")
-endmacro (KDE4_UPDATE_ICONCACHE)
-
 # a "map" of short type names to the directories
 # unknown names should give empty results
 # KDE 3 compatibility
@@ -260,29 +166,25 @@ set(_KDE4_ICON_GROUP_intl       "intl")
 
 # a "map" of short theme names to the theme directory
 set(_KDE4_ICON_THEME_ox "ariya")
-set(_KDE4_ICON_THEME_cr "crystalsvg")
 set(_KDE4_ICON_THEME_lo "locolor")
 set(_KDE4_ICON_THEME_hi "hicolor")
 
 
 # only used internally by KDE4_INSTALL_ICONS
 macro(_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME _l10n_SUBDIR)
-
     # if the string doesn't match the pattern, the result is the full string, so all three have the same content
     if(NOT ${_group} STREQUAL ${_install_NAME})
         set(_icon_GROUP  ${_KDE4_ICON_GROUP_${_group}})
         if(NOT _icon_GROUP)
             set(_icon_GROUP "actions")
-      endif(NOT _icon_GROUP)
+        endif()
         # message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name} l10n: ${_l10n_SUBDIR}")
         install(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/${_l10n_SUBDIR}/ RENAME ${_install_NAME} )
-   endif (NOT ${_group} STREQUAL ${_install_NAME} )
+    endif()
-
 endmacro(_KDE4_ADD_ICON_INSTALL_RULE)
 
 
 macro(KDE4_INSTALL_ICONS _defaultpath )
-
     # the l10n-subdir if language given as second argument (localized icon)
     set(_lang ${ARGV1})
     if(_lang)
@@ -303,9 +205,11 @@ macro (KDE4_INSTALL_ICONS _defaultpath )
 
         set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
         if( _theme_GROUP)
-         _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
+            _KDE4_ADD_ICON_INSTALL_RULE(
+                ${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
                 ${_defaultpath}/${_theme_GROUP}/${_size}x${_size}
-                    ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR})
+                ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}
+            )
         endif( _theme_GROUP)
     endforeach(_current_ICON)
 
@@ -321,11 +225,13 @@ macro (KDE4_INSTALL_ICONS _defaultpath )
 
         set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
         if(_theme_GROUP)
-         _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
+            _KDE4_ADD_ICON_INSTALL_RULE(
+                ${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
                 ${_defaultpath}/${_theme_GROUP}/${_size}x${_size}
-                ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR})
+                ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}
-      endif( _theme_GROUP)
+            )
-   endforeach (_current_ICON)
+        endif()
+    endforeach()
 
     # and now the svg icons
     file(GLOB _icons *.svgz)
@@ -338,421 +244,81 @@ macro (KDE4_INSTALL_ICONS _defaultpath )
 
         set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
         if(_theme_GROUP)
-          _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
+            _KDE4_ADD_ICON_INSTALL_RULE(
+                ${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
                 ${_defaultpath}/${_theme_GROUP}/scalable
-                            ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR})
+                ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}
-      endif( _theme_GROUP)
+            )
-   endforeach (_current_ICON)
+        endif()
-
+    endforeach()
-   kde4_update_iconcache()
-
 endmacro(KDE4_INSTALL_ICONS)
 
 
-# This macro doesn't set up the RPATH related options for executables anymore,
+# If "WITH_PREFIX" is in the arugments then the standard "lib" prefix will be
-# since now (wioth cmake 2.6) just the full RPATH is used always for everything.
+# preserved
-# 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
-      if (CMAKE_VERSION VERSION_GREATER 2.8.4)
-         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=$<TARGET_FILE:${_target_NAME}>
-            -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
-            )
-      else ()
-         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
-            )
-      endif ()
-
-      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(_plugin_type MODULE)
-   set(_add_lib_param "MODULE")
+    set(_plugin_prefix)
-   set(_with_pre FALSE)
+    set(_plugin_srcs)
 
     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)
+            set(_plugin_type STATIC)
-      endif (arg STREQUAL "STATIC")
+        elseif(arg STREQUAL "SHARED")
-      if (arg STREQUAL "SHARED")
+            set(_plugin_type SHARED)
-         set(_add_lib_param SHARED)
+        elseif(arg STREQUAL "WITH_PREFIX")
-      endif (arg STREQUAL "SHARED")
+            set(_plugin_prefix TRUE)
-      if (arg STREQUAL "MODULE")
+        else()
-         set(_add_lib_param MODULE)
+            list(APPEND _plugin_srcs ${arg})
-      endif (arg STREQUAL "MODULE")
+        endif()
     endforeach(arg)
 
-   if(_with_pre)
+    add_library(${_target_NAME} ${_plugin_type} ${_plugin_srcs})
-      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("${_plugin_type}" STREQUAL STATIC)
+        target_compile_definitions(${_target_NAME} PRIVATE -DQT_STATICPLUGIN)
+    endif()
 
-   if("${_add_lib_param}" STREQUAL "STATIC")
+    if(NOT "${_plugin_prefix}")
-      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)
+    endif()
+endmacro(KDE4_ADD_PLUGIN)
 
-   # for shared libraries/plugins a -DMAKE_target_LIB is required
+# Add a unit test, which is executed when running make test. The targets are
-   string(TOUPPER ${_target_NAME} _symbol)
+# always created and built unless ENABLE_TESTING is set to negative value.
-   string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
+macro(KDE4_ADD_TEST _targetName)
-   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-
-
-   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 ${_resourcefile})
-   target_link_libraries(${_target_NAME} kdeinit_${_target_NAME})
-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})
+    add_executable(${_targetName} ${_srcList})
-    if( ${ARGV1} STREQUAL "TESTNAME" )
-        set(_targetName ${ARGV2})
-        list(REMOVE_AT _srcList 0 1)
-    endif( ${ARGV1} STREQUAL "TESTNAME" )
 
-    set(_nogui)
+    string(REPLACE "test" "" _testName ${_targetName})
-    list(GET _srcList 0 first_PARAM)
+    add_test(NAME ${_testName} COMMAND ${_targetName})
-    if( ${first_PARAM} STREQUAL "NOGUI" )
-        set(_nogui "NOGUI")
-    endif( ${first_PARAM} STREQUAL "NOGUI" )
 
-    kde4_add_executable( ${_test_NAME} TEST ${_srcList} )
+    target_compile_definitions(${_targetName} PRIVATE -DKDESRCDIR="${CMAKE_CURRENT_SOURCE_DIR}/")
-
+endmacro(KDE4_ADD_TEST)
-    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 (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 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)
-
-endmacro (KDE4_ADD_UNIT_TEST)
-
-macro (KDE4_ADD_EXECUTABLE _target_NAME)
-
-   kde4_check_executable_params( _SRCS _nogui _test ${ARGN})
-
-   set(_add_executable_param)
-
-   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 (_test)
-      set_target_properties(${_target_NAME} PROPERTIES COMPILE_FLAGS -DKDESRCDIR="\\"${CMAKE_CURRENT_SOURCE_DIR}/\\"")
-   endif (_test)
-
-   kde4_handle_rpath_for_executable(${_target_NAME})
-endmacro (KDE4_ADD_EXECUTABLE)
-
-
-macro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
-
-   set(_first_SRC ${_lib_TYPE})
-   set(_add_lib_param)
-
-   if (${_lib_TYPE} STREQUAL "STATIC")
-      set(_first_SRC)
-      set(_add_lib_param STATIC)
-   endif (${_lib_TYPE} STREQUAL "STATIC")
-   if (${_lib_TYPE} STREQUAL "SHARED")
-      set(_first_SRC)
-      set(_add_lib_param SHARED)
-   endif (${_lib_TYPE} STREQUAL "SHARED")
-   if (${_lib_TYPE} STREQUAL "MODULE")
-      set(_first_SRC)
-      set(_add_lib_param MODULE)
-   endif (${_lib_TYPE} STREQUAL "MODULE")
-
-   set(_SRCS ${_first_SRC} ${ARGN})
-
-   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(KDE4_ADD_WIDGET_FILES _sources)
-   foreach (_current_FILE ${ARGN})
+    foreach(_current_FILE ${_sources})
-
         get_filename_component(_input ${_current_FILE} ABSOLUTE)
         get_filename_component(_basename ${_input} NAME_WE)
+        get_filename_component(_extension ${_input} EXT)
+
         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}
+            COMMAND ${KDE4_MAKEKDEWIDGETS_EXECUTABLE} -o ${_source} ${_input}
-        ARGS -o ${_source} ${_input}
+            MAIN_DEPENDENCY ${_input}
-        MAIN_DEPENDENCY ${_input} DEPENDS ${_KDE4_MAKEKDEWIDGETS_DEP} ${KDE4_MAKEKDEWIDGETS_EXECUTABLE})
+        )
 
-      # create moc file
         qt4_generate_moc(${_source} ${_moc})
 
-      list(APPEND ${_sources} ${_source} ${_moc})
+        add_library(${_basename}_autowidgets OBJECT ${_source} ${_moc})
-
     endforeach(_current_FILE)
-
 endmacro(KDE4_ADD_WIDGET_FILES)
 
 
-macro(KDE4_REMOVE_OBSOLETE_CMAKE_FILES)
-# the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex
-   install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake )
-   set(module_install_dir ${DATA_INSTALL_DIR}/cmake/modules )
-
-   file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, don't 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)
-
-# adds application icon to target source list 
-# for detailed documentation see the top of FindKDE4Internal.cmake
-macro (KDE4_ADD_APP_ICON appsources pattern)
-    set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appsources})
-endmacro (KDE4_ADD_APP_ICON)
-
-
-# This macro is only kept around for compatibility, it is not needed/used anymore
-# since CMake 2.6.0. With CMake 2.6.0 it is not necessary anymore link libraries again
-# ("relink") to change their RPATH. Since this is fast now, they are now always built with
-# full RPATH. 
-# Still keep this macro here, since somebody might use it and so that would break
-# if we would just remove it from here.
-# What it does now it sets the target properties of the given target the same way as
-# they were set by the old version of the macro with the option FULL_RPATH enabled.
-# This one may be a candidate for removal. Alex
-macro (KDE4_HANDLE_RPATH_FOR_LIBRARY _target_NAME)
-   message(STATUS "You are using the macro KDE4_HANDLE_RPATH_FOR_LIBRARY(), which is an internal macro and shouldn't be used by external projects. Please remove it.")
-   if (NOT CMAKE_SKIP_RPATH)
-      set_target_properties(${_target_NAME} PROPERTIES  SKIP_BUILD_RPATH FALSE  BUILD_WITH_INSTALL_RPATH FALSE)
-   endif (NOT CMAKE_SKIP_RPATH)
-endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY)
-
 # This macro adds the needed files for an helper executable meant to be used by applications using KAuth.
 # It accepts the helper target, the helper ID (the DBUS name) and the user under which the helper will run on.
 # This macro takes care of generate the needed files, and install them in the right location. This boils down
@@ -776,14 +342,3 @@ function(KDE4_INSTALL_AUTH_HELPER_FILES HELPER_TARGET HELPER_ID HELPER_USER)
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.service
             DESTINATION ${DBUS_SYSTEM_SERVICES_INSTALL_DIR})
 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)
-  message(AUTHOR_WARNING "PolicyKit/Polikt actions are not required")
-endfunction(KDE4_INSTALL_AUTH_ACTIONS)

cmake/modules/KatieMacros.cmake

@@ -1,117 +0,0 @@
-# Copyright (c) 2015, Ivailo Monev, <xakepa10@gmail.com>
-# Redistribution and use is allowed according to the terms of the BSD license.
-
-if(NOT KATIE_UIC_EXECUTABLE)
-    set(KATIE_UIC_EXECUTABLE "uic")
-endif()
-if(NOT KATIE_RCC_EXECUTABLE)
-    set(KATIE_RCC_EXECUTABLE "rcc")
-endif()
-if(NOT KATIE_MOC_EXECUTABLE)
-    set(KATIE_MOC_EXECUTABLE "moc")
-endif()
-if(NOT KATIE_DBUSXML2CPP_EXECUTABLE)
-    set(KATIE_DBUSXML2CPP_EXECUTABLE "qdbusxml2cpp")
-endif()
-if(NOT KATIE_LRELEASE_EXECUTABLE)
-    set(KATIE_LRELEASE_EXECUTABLE "lrelease")
-endif()
-
-macro(KATIE_RESOURCES RESOURCES)
-    foreach(tmpres ${RESOURCES})
-        get_filename_component(resource ${tmpres} ABSOLUTE)
-        get_filename_component(rscext ${resource} EXT)
-        get_filename_component(rscname ${resource} NAME_WE)
-        if(${rscext} STREQUAL ".ui")
-            set(rscout ${CMAKE_BINARY_DIR}/include/ui_${rscname}.h)
-            add_custom_command(
-                OUTPUT ${rscout}
-                COMMAND ${KATIE_UIC_EXECUTABLE} "${resource}" -o "${rscout}"
-                MAIN_DEPENDENCY "${resource}"
-            )
-        elseif(${rscext} STREQUAL ".qrc")
-            set(rscout ${CMAKE_BINARY_DIR}/include/qrc_${rscname}.cpp)
-            add_custom_command(
-                OUTPUT ${rscout}
-                COMMAND ${KATIE_RCC_EXECUTABLE} "${resource}" -o "${rscout}" -name "${rscname}"
-                MAIN_DEPENDENCY ${resource}
-            )
-            set_property(SOURCE ${resource} APPEND PROPERTY OBJECT_DEPENDS ${rscout})
-        elseif(${rscext} MATCHES "(.h|.cpp)")
-            set(rscout ${CMAKE_BINARY_DIR}/include/moc_${rscname}${rscext})
-            get_directory_property(dirdefs COMPILE_DEFINITIONS)
-            get_directory_property(dirincs INCLUDE_DIRECTORIES)
-            set(mocargs)
-            foreach(ddef ${dirdefs})
-                # TODO: filter non -D, support -U too
-                set(mocargs ${mocargs} -D${ddef})
-            endforeach()
-            foreach(incdir ${dirincs})
-                set(mocargs ${mocargs} -I${incdir})
-            endforeach()
-            add_custom_command(
-                OUTPUT "${rscout}"
-                COMMAND ${KATIE_MOC_EXECUTABLE} -nw "${resource}" -o "${rscout}" ${mocargs}
-            )
-            set_property(SOURCE ${resource} APPEND PROPERTY OBJECT_DEPENDS ${rscout})
-        endif()
-    endforeach()
-endmacro()
-
-macro(KATIE_RESOURCE RESOURCES OUTNAME)
-    set(rscout ${CMAKE_BINARY_DIR}/include/qrc_${OUTNAME}.cpp)
-    add_custom_command(
-        OUTPUT ${rscout}
-        COMMAND ${KATIE_RCC_EXECUTABLE} ${RESOURCES} -o "${rscout}" -name "${OUTNAME}"
-        # MAIN_DEPENDENCY ${resource}
-    )
-    foreach(tmpres ${RESOURCES})
-        set_property(SOURCE ${tmpres} APPEND PROPERTY OBJECT_DEPENDS ${rscout})
-    endforeach()
-endmacro()
-
-macro(KATIE_DBUS_ADAPTOR SRCDEP SRCIN SRCOUT)
-    if(${ARG4})
-        set(dbusxmlargs ${ARG4})
-    endif()
-    get_filename_component(resource ${SRCIN} ABSOLUTE)
-    set(rscout ${CMAKE_BINARY_DIR}/include/${SRCOUT}.h)
-    set(mocout ${CMAKE_BINARY_DIR}/include/${SRCOUT}.moc)
-    add_custom_command(
-        OUTPUT "${rscout}"
-        COMMAND "${KATIE_DBUSXML2CPP_EXECUTABLE}" -m "${resource}" -a "${rscout}" -p "${SRCOUT}" ${dbusxmlargs}
-        COMMAND "${KATIE_MOC_EXECUTABLE}" -nw "${rscout}" -o "${mocout}" -i
-    )
-    set_property(SOURCE ${SRCDEP} APPEND PROPERTY OBJECT_DEPENDS ${rscout})
-endmacro()
-
-macro(KATIE_DBUS_INTERFACE SRCIN)
-    if(${ARG4})
-        set(dbusxmlargs ${ARG2})
-    endif()
-    string(REGEX MATCH ".*\\.(.*)\\.xml" ${SRCIN} SRCOUT)
-    string(TOLOWER ${SRCIN} SRCIN)
-    set(rscout ${CMAKE_BINARY_DIR}/include/${SRCOUT}ineterface.h)
-    add_custom_command(
-        OUTPUT "${rscout}"
-        COMMAND "${KATIE_DBUSXML2CPP_EXECUTABLE}" -m "${SRCIN}" -a "${rscout}" -p "${SRCOUT}ineterface" ${dbusxmlargs}
-    )
-    set_property(SOURCE ${SRCIN} APPEND PROPERTY OBJECT_DEPENDS ${rscout})
-endmacro()
-
-# TODO: use add_custom_target()
-macro(KATIE_TRANSLATION TRANSLATIONS)
-    if(NOT QT_TRANSLATIONS_PATH_INST)
-        message(SEND_ERROR "Directory where the translation should be installed is not set")
-    endif()
-    make_directory(${CMAKE_BINARY_DIR}/translations)
-    foreach(translation ${TRANSLATIONS})
-        get_filename_component(trname ${translation} NAME_WE)
-        get_filename_component(trdir ${translation} DIRECTORY)
-        set(trout ${trdir}/${trname}.qm)
-        execute_process(
-            COMMAND ${KATIE_LRELEASE_EXECUTABLE} ${translation}
-        )
-        install(FILES ${trout} DESTINATION ${QT_TRANSLATIONS_PATH_INST})
-    endforeach()
-endmacro() 

cmake/modules/MacroEnsureOutOfSourceBuild.cmake

@@ -1,20 +0,0 @@
-# - MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)
-# MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)
-#    Call this macro in your project if you want to enforce out-of-source builds.
-#    If an in-source build is detected, it will abort with the given error message.
-#    This macro works in any of the CMakeLists.txt of your project, but the recommended
-#    location to call this is close to the beginning of the top level CMakeLists.txt
-
-# Copyright (c) 2006, Alexander Neundorf, <neundorf@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 (MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage)
-
-   STRING(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" insource)
-   IF(insource)
-      MESSAGE(FATAL_ERROR "${_errorMessage}")
-   ENDIF(insource)
-
-ENDMACRO (MACRO_ENSURE_OUT_OF_SOURCE_BUILD)

cmake/modules/MacroLibrary.cmake

@@ -12,7 +12,6 @@ INCLUDE(MacroAddFileDependencies)
 INCLUDE(MacroAddCompileFlags)
 INCLUDE(MacroAddLinkFlags)
 INCLUDE(MacroAppendIf)
-INCLUDE(MacroEnsureOutOfSourceBuild)
 INCLUDE(MacroBoolTo01)
 INCLUDE(MacroPushRequiredVars)
 INCLUDE(MacroLogFeature)

cmake/modules/kde4_exec_via_sh.cmake

@@ -1,31 +0,0 @@
-
-# Copyright (c) 2006, Alexander Neundorf, <neundorf@kde.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-
-if (UNIX)
-
-file(WRITE "${_filename}" 
-"#!/bin/sh
-# created by cmake, don't edit, changes will be lost
-
-${_library_path_variable}=${_ld_library_path}\${${_library_path_variable}:+:\$${_library_path_variable}} \"${_executable}\" \"$@\"
-")
-
-# make it executable
-# since this is only executed on UNIX, it is safe to call chmod
-exec_program(chmod ARGS ug+x \"${_filename}\" OUTPUT_VARIABLE _dummy )
-
-else (UNIX)
-
-file(TO_NATIVE_PATH "${_ld_library_path}" win_path)
-
-file(WRITE "${_filename}" 
-"
-set PATH=${win_path};$ENV{PATH}
-\"${_executable}\" %*
-")
-
-endif (UNIX)

cmake/modules/kde4exportsheader.h.in

@@ -1,12 +0,0 @@
-/* This file is autogenerated by CMake via the macro KDE4_CREATE_EXPORTS_HEADER().
- * Don't edit, changes will be lost. 
- */
-
-#include <kdemacros.h>
-#ifndef ${_libNameUpperCase}_EXPORT
-# ifdef ${_libName}_EXPORTS
-#  define ${_libNameUpperCase}_EXPORT KDE_EXPORT
-# else
-#  define ${_libNameUpperCase}_EXPORT KDE_IMPORT
-# endif
-#endif

cmake/modules/kde4init_dummy.cpp.in

@@ -1,2 +0,0 @@
-extern "C" int kdemain(int argc, char* argv[]);
-int main(int argc, char* argv[]) { return kdemain(argc,argv); }

dnssd/CMakeLists.txt

@@ -32,14 +32,26 @@ if (HAVE_AVAHI)
         avahi_serviceresolver_interface.cpp
         avahi_entrygroup_interface.cpp
     )
-   qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.DomainBrowser.xml avahi_domainbrowser_interface )
+    qt4_add_dbus_interface(
-   qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.ServiceBrowser.xml avahi_servicebrowser_interface )
+        kdnssd_LIB_SRCS
-   qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.ServiceTypeBrowser.xml avahi_servicetypebrowser_interface )
+        org.freedesktop.Avahi.DomainBrowser.xml
+        avahi_domainbrowser_interface
+    )
+    qt4_add_dbus_interface(
+        kdnssd_LIB_SRCS
+        org.freedesktop.Avahi.ServiceBrowser.xml
+        avahi_servicebrowser_interface
+    )
+    qt4_add_dbus_interface(
+        kdnssd_LIB_SRCS
+        org.freedesktop.Avahi.ServiceTypeBrowser.xml
+        avahi_servicetypebrowser_interface
+    )
 else(HAVE_AVAHI)
-
     macro_optional_find_package(DNSSD)
     macro_bool_to_01(DNSSD_FOUND HAVE_DNSSD)
-   set_package_properties(DNSSD PROPERTIES DESCRIPTION "Facilities for service discovery on a local network"
+    set_package_properties(DNSSD PROPERTIES
+        DESCRIPTION "Facilities for service discovery on a local network"
         URL "http://avahi.org"
         TYPE OPTIONAL
         PURPOSE "Either Avahi or DNSSD is required for KDE applications to make use of multicast DNS/DNS-SD service discovery"
@@ -63,15 +75,12 @@ else (HAVE_AVAHI)
             dummy-servicebrowser.cpp
             dummy-servicetypebrowser.cpp
         )
-
    endif(HAVE_DNSSD)
 endif(HAVE_AVAHI)
 
-
 ########### next target ###############
 
-
+add_library(kdnssd ${LIBRARY_TYPE} ${kdnssd_LIB_SRCS})
-kde4_add_library(kdnssd ${LIBRARY_TYPE} ${kdnssd_LIB_SRCS})
 
 # KDE 5: don't link against KDEUI_LIBS (when settings.kfgc is changed)
 if (HAVE_DNSSD)
@@ -86,12 +95,24 @@ set_target_properties(kdnssd PROPERTIES
     VERSION ${GENERIC_LIB_VERSION}
     SOVERSION ${GENERIC_LIB_SOVERSION}
 )
+
 install(TARGETS kdnssd EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 ########### install files ###############
-install( FILES dnssd_export.h domainbrowser.h remoteservice.h servicetypebrowser.h publicservice.h 
+install(FILES
-               servicebase.h servicebrowser.h  servicemodel.h domainmodel.h ${CMAKE_CURRENT_BINARY_DIR}/settings.h
+    dnssd_export.h
-         DESTINATION  ${INCLUDE_INSTALL_DIR}/dnssd COMPONENT Devel)
+    domainbrowser.h
+    remoteservice.h
+    servicetypebrowser.h
+    publicservice.h 
+    servicebase.h
+    servicebrowser.h
+    servicemodel.h
+    domainmodel.h
+    ${CMAKE_CURRENT_BINARY_DIR}/settings.h
+    DESTINATION ${INCLUDE_INSTALL_DIR}/dnssd
+    COMPONENT Devel
+)
 
 
 

experimental/libkdeclarative/CMakeLists.txt

@@ -26,7 +26,7 @@ set(kdeclarative_LIB_SRCS
     bindings/icon.cpp
     bindings/url.cpp)
 
-kde4_add_library(kdeclarative SHARED ${kdeclarative_LIB_SRCS})
+add_library(kdeclarative SHARED ${kdeclarative_LIB_SRCS})
 
 set_target_properties(kdeclarative PROPERTIES VERSION ${KDE_NON_GENERIC_LIB_VERSION} SOVERSION ${KDE_NON_GENERIC_LIB_SOVERSION})
 
@@ -37,7 +37,7 @@ target_link_libraries(kdeclarative ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBS} ${QT_
 set(kdeclarative_TEST_SRCS
     test/test.cpp)
 
-kde4_add_executable(kdeclarativetest ${kdeclarative_TEST_SRCS})
+add_executable(kdeclarativetest ${kdeclarative_TEST_SRCS})
 
 target_link_libraries(kdeclarativetest kdeclarative ${KDE4_KDECORE_LIBS} ${QT_QTGUI_LIBRARY} ${QT_QTSCRIPT_LIBRARY} ${QT_QTDECLARATIVE_LIBRARY})
 

interfaces/kimproxy/CMakeLists.txt

@@ -1,4 +1,48 @@
+add_subdirectory(icons)
 
-add_subdirectory( interface ) 
+include_directories(${KDE4_KIO_INCLUDES})
-add_subdirectory( library ) 
 
+########### next target ###############
+
+set(kimproxy_LIB_SRCS
+    kimproxy.cpp
+)
+
+qt4_add_dbus_adaptor( kimproxy_LIB_SRCS org.kde.KIMIface.xml kimproxy.h KIMProxy)
+
+qt4_add_dbus_interface(kimproxy_LIB_SRCS org.kde.KIMIface.xml kimiface )
+
+add_library(kimproxy ${LIBRARY_TYPE} ${kimproxy_LIB_SRCS})
+
+target_link_libraries(kimproxy PRIVATE ${KDE4_KIO_LIBS})
+target_link_libraries(kimproxy PUBLIC ${QT_QTCORE_LIBRARY})
+
+set_target_properties(kimproxy PROPERTIES
+    VERSION ${GENERIC_LIB_VERSION}
+    SOVERSION ${GENERIC_LIB_SOVERSION}
+)
+
+########### install files ###############
+
+install(TARGETS kimproxy EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
+
+install(FILES
+    kimproxy_export.h
+    kimproxy.h
+    DESTINATION ${INCLUDE_INSTALL_DIR}
+    COMPONENT Devel
+)
+
+install(FILES
+    dbusinstantmessenger.desktop
+    DESTINATION ${SERVICETYPES_INSTALL_DIR}
+)
+install(FILES
+    kcm_instantmessenger.desktop
+    DESTINATION ${DATA_INSTALL_DIR}/kcm_componentchooser
+)
+
+install(FILES
+    org.kde.KIMIface.xml
+    DESTINATION ${DBUS_INTERFACES_INSTALL_DIR}
+)

interfaces/kimproxy/interface/CMakeLists.txt

@@ -1,9 +1 @@
 
-########### install files ###############
-
-install( FILES dbusinstantmessenger.desktop  DESTINATION  ${SERVICETYPES_INSTALL_DIR} )
-install( FILES kcm_instantmessenger.desktop  DESTINATION  ${DATA_INSTALL_DIR}/kcm_componentchooser )
-install( FILES org.kde.KIMIface.xml DESTINATION ${DBUS_INTERFACES_INSTALL_DIR} )
-
-
-

interfaces/kimproxy/library/CMakeLists.txt

@@ -1,30 +0,0 @@
-add_subdirectory( icons )
-
-
-include_directories( ${KDE4_KIO_INCLUDES} )
-
-########### next target ###############
-
-set(kimproxy_LIB_SRCS
-  kimproxy.cpp
-)
-
-qt4_add_dbus_adaptor( kimproxy_LIB_SRCS ../interface/org.kde.KIMIface.xml kimproxy.h  KIMProxy)
-
-qt4_add_dbus_interface(kimproxy_LIB_SRCS ../interface/org.kde.KIMIface.xml kimiface )
-
-
-kde4_add_library(kimproxy ${LIBRARY_TYPE} ${kimproxy_LIB_SRCS})
-
-target_link_libraries(kimproxy PRIVATE ${KDE4_KIO_LIBS} )
-target_link_libraries(kimproxy PUBLIC ${QT_QTCORE_LIBRARY} )
-
-set_target_properties(kimproxy PROPERTIES
-   VERSION ${GENERIC_LIB_VERSION}
-   SOVERSION ${GENERIC_LIB_SOVERSION}
-)
-
-########### install files ###############
-
-install(TARGETS kimproxy  EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
-install( FILES kimproxy_export.h kimproxy.h DESTINATION  ${INCLUDE_INSTALL_DIR} COMPONENT Devel)

interfaces/kmediaplayer/CMakeLists.txt

@@ -1,6 +1,5 @@
 add_subdirectory(kfileaudiopreview)
 
-
 include_directories(${KDE4_KPARTS_INCLUDES})
 
 ########### next target ###############
@@ -11,8 +10,7 @@ view.cpp
     kmediaplayeradaptor.cpp
 )
 
-
+add_library(kmediaplayer ${LIBRARY_TYPE} ${kmediaplayer_LIB_SRCS})
-kde4_add_library(kmediaplayer ${LIBRARY_TYPE} ${kmediaplayer_LIB_SRCS})
 
 target_link_libraries(kmediaplayer PRIVATE ${KDE4_KPARTS_LIBS} )
 target_link_libraries(kmediaplayer PUBLIC ${KDE4_KPARTS_LIBS} ${QT_QTGUI_LIBRARY} )
@@ -26,7 +24,22 @@ install(TARGETS kmediaplayer EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFA
 
 ########### install files ###############
 
-install( FILES kmediaplayer_export.h player.h view.h  DESTINATION  ${INCLUDE_INSTALL_DIR}/kmediaplayer  COMPONENT Devel)
+install(FILES
+    kmediaplayer_export.h
+    player.h
+    view.h
+    DESTINATION ${INCLUDE_INSTALL_DIR}/kmediaplayer
+    COMPONENT Devel
+)
 
-install( FILES kmediaplayerengine.desktop kmediaplayer.desktop  DESTINATION  ${SERVICETYPES_INSTALL_DIR} )
+install(FILES
-install( FILES org.kde.KMediaPlayer.xml DESTINATION ${DBUS_INTERFACES_INSTALL_DIR} )
+    kmediaplayerengine.desktop
+    kmediaplayer.desktop
+    DESTINATION
+    ${SERVICETYPES_INSTALL_DIR}
+)
+
+install(FILES
+    org.kde.KMediaPlayer.xml
+    DESTINATION ${DBUS_INTERFACES_INSTALL_DIR}
+)

interfaces/ktexteditor/CMakeLists.txt

@@ -26,18 +26,20 @@ set(ktexteditor_LIB_SRCS
     movingrange.cpp
     movingrangefeedback.cpp
     messageinterface.cpp
+    editorchooser_ui.ui 
 )
 
+add_library(ktexteditor ${LIBRARY_TYPE} ${ktexteditor_LIB_SRCS})
 
-kde4_add_ui_files(ktexteditor_LIB_SRCS editorchooser_ui.ui )
+target_link_libraries(ktexteditor PRIVATE
-
+    ${KDE4_KDECORE_LIBS}
-kde4_add_library(ktexteditor ${LIBRARY_TYPE} ${ktexteditor_LIB_SRCS})
+    ${QT_QTDBUS_LIBRARY}
-
+    ${KDE4_KPARTS_LIBS}
-target_link_libraries(ktexteditor PRIVATE ${KDE4_KDECORE_LIBS} ${QT_QTDBUS_LIBRARY} ${KDE4_KPARTS_LIBS} )
+)
 target_link_libraries(ktexteditor PUBLIC ${KDE4_KPARTS_LIBS})
 
-set_target_properties(ktexteditor
+set_target_properties(ktexteditor PROPERTIES
-   PROPERTIES VERSION ${GENERIC_LIB_VERSION}
+    VERSION ${GENERIC_LIB_VERSION}
     SOVERSION ${GENERIC_LIB_SOVERSION}
 )
 install(TARGETS ktexteditor EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
@@ -88,9 +90,22 @@ install( FILES
     movingrangefeedback.h
     recoveryinterface.h
     messageinterface.h
-    DESTINATION  ${INCLUDE_INSTALL_DIR}/ktexteditor COMPONENT Devel)
+    DESTINATION ${INCLUDE_INSTALL_DIR}/ktexteditor
+    COMPONENT Devel
+)
 
-install( FILES ktexteditor.desktop ktexteditorplugin.desktop  DESTINATION  ${SERVICETYPES_INSTALL_DIR} )
+install(FILES
-install( FILES kcm_ktexteditor.desktop  DESTINATION  ${DATA_INSTALL_DIR}/kcm_componentchooser )
+    ktexteditor.desktop
+    ktexteditorplugin.desktop
+    DESTINATION ${SERVICETYPES_INSTALL_DIR}
+)
 
-install( FILES ktexteditor_loadsavefiltercheckplugin.desktop  DESTINATION  ${SERVICETYPES_INSTALL_DIR} )
+install(FILES
+    kcm_ktexteditor.desktop
+    DESTINATION ${DATA_INSTALL_DIR}/kcm_componentchooser
+)
+
+install(FILES
+    ktexteditor_loadsavefiltercheckplugin.desktop
+    DESTINATION ${SERVICETYPES_INSTALL_DIR}
+)

interfaces/terminal/example/CMakeLists.txt

@@ -10,7 +10,7 @@ set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 ########### next target ###############
 
 set(hello_SRCS main.cc )
-kde4_add_executable(tetest ${hello_SRCS})
+add_executable(tetest ${hello_SRCS})
 target_link_libraries(tetest ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBS} ${KDE4_KPARTS_LIBS} kdeui )
 
 

kdecore/CMakeLists.txt

@@ -93,42 +93,26 @@ if (HAVE_RESOLV_LIBRARY)
   set(kdecore_OPTIONAL_LIBS ${kdecore_OPTIONAL_LIBS} resolv)
 endif (HAVE_RESOLV_LIBRARY)
 
-if (UNIX)
-   set(kdecore_OPTIONAL_SRCS ${kdecore_OPTIONAL_SRCS}
-      kernel/ktoolinvocation_x11.cpp
-      kernel/kstandarddirs_unix.cpp
-      localization/klocale_unix.cpp
-      network/klocalsocket_unix.cpp
-      network/netsupp.cpp
-      io/klockfile_unix.cpp
-      util/kshell_unix.cpp
-      util/kuser_unix.cpp
-      util/kmacroexpander_unix.cpp
-      fakes.c
-   )
-endif (UNIX)
-
 add_subdirectory( kconfig_compiler )
+if(ENABLE_TESTING)
     add_subdirectory( tests )
     add_subdirectory( sonnet/tests )
+endif()
 add_subdirectory( network/kssld )
 
 ########### next target ###############
 
-if (UNIX)
+add_library(kdefakes ${LIBRARY_TYPE} fakes.c)
-
-   kde4_add_library(kdefakes ${LIBRARY_TYPE} fakes.c)
 set_target_properties(kdefakes PROPERTIES
     VERSION ${KDE_NON_GENERIC_LIB_VERSION}
     SOVERSION ${KDE_NON_GENERIC_LIB_SOVERSION})
 if (NOT HAVE_TRUNC)
     target_link_libraries(kdefakes  m )
 endif (NOT HAVE_TRUNC)
-   install(TARGETS kdefakes EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS} )
-
-endif (UNIX)
-
 
+install(TARGETS kdefakes
+    EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS}
+)
 
 ########### next target ###############
 
@@ -234,9 +218,7 @@ set(kdecore_LIB_SRCS
     sonnet/backgroundchecker.cpp
     sonnet/backgroundengine.cpp
     sonnet/globals.cpp
-)
 
-set(kdecore_LIB_SRCS ${kdecore_LIB_SRCS}
     network/klocalsocket.cpp
     network/ksocketfactory.cpp
     network/ksslcertificatemanager.cpp
@@ -303,6 +285,18 @@ set(kdecore_LIB_SRCS ${kdecore_LIB_SRCS}
     util/krandom.cpp
     util/krandomsequence.cpp
     util/qtest_kde.cpp
+
+    kernel/ktoolinvocation_x11.cpp
+    kernel/kstandarddirs_unix.cpp
+    localization/klocale_unix.cpp
+    network/klocalsocket_unix.cpp
+    network/netsupp.cpp
+    io/klockfile_unix.cpp
+    util/kshell_unix.cpp
+    util/kuser_unix.cpp
+    util/kmacroexpander_unix.cpp
+    fakes.c
+
     ${kdecore_OPTIONAL_SRCS}
     ${KAUTH_BACKEND_SRCS}
     ${KAUTH_HELPER_BACKEND_SRCS}
@@ -320,7 +314,7 @@ if (NOT Q_WS_X11 AND NOT Q_WS_QWS)
    add_definitions(-DNO_DISPLAY)
 endif (NOT Q_WS_X11 AND NOT Q_WS_QWS)
 
-kde4_add_library(kdecore ${LIBRARY_TYPE} ${kdecore_LIB_SRCS})
+add_library(kdecore ${LIBRARY_TYPE} ${kdecore_LIB_SRCS})
 
 target_link_libraries(kdecore PRIVATE ${QT_QTCORE_LIBRARY} ${QT_QTNETWORK_LIBRARY} ${QT_QTDBUS_LIBRARY} ${QT_QTXML_LIBRARY} ${ZLIB_LIBRARY} ${kdecore_OPTIONAL_LIBS})
 
@@ -383,7 +377,7 @@ install(TARGETS kauth_helper_plugin
 
 configure_file(localization/all_languages.desktop ${CMAKE_CURRENT_BINARY_DIR}/all_languages @ONLY)
 
-kde4_add_executable(kde4-config NOGUI kde-config.cpp )
+add_executable(kde4-config kde-config.cpp )
 
 target_link_libraries(kde4-config ${KDE4_KDECORE_LIBS})
 

kdecore/auth/ConfigureChecks.cmake

@@ -35,9 +35,4 @@ if (KAUTH_BACKEND STREQUAL "DBus")
            DESTINATION ${DATA_INSTALL_DIR}/kauth COMPONENT Devel)
 endif()
 
-# Set directories for plugins
-_set_fancy(KAUTH_HELPER_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/helper" "Where KAuth's helper plugin will be installed")
-_set_fancy(KAUTH_BACKEND_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/backend" "Where KAuth's backend plugin will be installed")
-#set(KAUTH_OTHER_PLUGIN_DIR "${QT_PLUGINS_DIR}/kauth/plugins")
-
 ## End

kdecore/kconfig_compiler/CMakeLists.txt

@@ -1,7 +1,7 @@
 
 set(kconfig_compiler_SRCS kconfig_compiler.cpp)
 
-kde4_add_executable(kconfig_compiler NOGUI ${kconfig_compiler_SRCS})
+add_executable(kconfig_compiler ${kconfig_compiler_SRCS})
 
 target_link_libraries(kconfig_compiler ${QT_QTCORE_LIBRARY} ${QT_QTXML_LIBRARY})
 
@@ -9,4 +9,5 @@ target_link_libraries(kconfig_compiler ${QT_QTCORE_LIBRARY} ${QT_QTXML_LIBRARY})
 # target in # FindKDE4Internal.cmake to get the full path to the installed
 # executable instead of using FIND_PROGRAM(), Alex
 install(TARGETS kconfig_compiler
-    EXPORT kdelibsToolsTargets ${INSTALL_TARGETS_DEFAULT_ARGS} )
+    EXPORT kdelibsToolsTargets ${INSTALL_TARGETS_DEFAULT_ARGS}
+)

kded/CMakeLists.txt

@@ -1,6 +1,8 @@
 project(kded)
 
+if(ENABLE_TESTING)
     add_subdirectory(tests)
+endif()
 
 include_directories( ${KDE4_KIO_INCLUDES} )
 
@@ -13,18 +15,19 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kded.h.cmake ${CMAKE_CURRENT_B
 
 ########### next target ###############
 
-set(kded_SRCS kded.cpp kdedadaptor.cpp
+set(kded_SRCS
+    kded.cpp
+    kdedadaptor.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/org.kde.kded.xml # just so that it gets generated
 )
 
 
-kde4_add_executable(kded4  ${kded_SRCS})
+add_executable(kded4 ${kded_SRCS})
 
 target_link_libraries(kded4 ${KDE4_KIO_LIBS} ${X11_LIBRARIES})
 
 install(TARGETS kded4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
-
 qt4_generate_dbus_interface( kdedadaptor.h org.kde.kded.xml )
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.kde.kded.xml DESTINATION ${DBUS_INTERFACES_INSTALL_DIR})
 
@@ -46,13 +49,11 @@ set(kbuildsycoca_SRCS
 
 if(KBUILDSYCOCA_NO_KCRASH)
     set(KBUILDSYCOCA_MAIN_LIBS ${KDE4_KDECORE_LIBS})
-else(KBUILDSYCOCA_NO_KCRASH)
+else()
     set(KBUILDSYCOCA_MAIN_LIBS ${KDE4_KDEUI_LIBS})
-endif(KBUILDSYCOCA_NO_KCRASH)
+endif()
 
-
+add_executable(kbuildsycoca4 ${kbuildsycoca_SRCS})
-# We need to add a '4' so that kde3 apps running kbuildsycoca don't run the kde4 one.
-kde4_add_executable( kbuildsycoca4 NOGUI ${kbuildsycoca_SRCS})
 
 target_link_libraries(kbuildsycoca4 ${KBUILDSYCOCA_MAIN_LIBS} ${QT_QTXML_LIBRARY})
 

kdesu/CMakeLists.txt

@@ -27,14 +27,13 @@ set(kdesu_LIB_SRCS
 )
 
 
-kde4_add_library(kdesu ${LIBRARY_TYPE} ${kdesu_LIB_SRCS})
+add_library(kdesu ${LIBRARY_TYPE} ${kdesu_LIB_SRCS})
 
 target_link_libraries(kdesu PRIVATE ${KDE4_KPTY_LIBS} )
 target_link_libraries(kdesu PUBLIC ${QT_QTCORE_LIBRARY} )
 
 if(SUDO_FOUND)
-   set_source_files_properties(su.cpp PROPERTIES
+    add_definitions(-DKDESU_USE_SUDO_DEFAULT)
-                               COMPILE_FLAGS -DKDESU_USE_SUDO_DEFAULT)
 endif(SUDO_FOUND)
 
 set_target_properties(kdesu PROPERTIES
@@ -49,12 +48,20 @@ install(TARGETS kdesu EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARG
 
 set(kdesu_stub_SRCS kdesu_stub.c )
 
-kde4_add_executable(kdesu_stub NOGUI ${kdesu_stub_SRCS})
+add_executable(kdesu_stub ${kdesu_stub_SRCS})
 
 install(TARGETS kdesu_stub DESTINATION ${LIBEXEC_INSTALL_DIR} )
 
-
 ########### install files ###############
-install( FILES kdesu_export.h client.h process.h su.h ssh.h stub.h defaults.h 
-         DESTINATION  ${INCLUDE_INSTALL_DIR}/kdesu COMPONENT Devel)
 
+install(FILES
+    kdesu_export.h
+    client.h
+    process.h
+    su.h
+    ssh.h
+    stub.h
+    defaults.h 
+    DESTINATION ${INCLUDE_INSTALL_DIR}/kdesu
+    COMPONENT Devel
+)

kdeui/CMakeLists.txt

@@ -45,8 +45,10 @@ configure_file(
 )
 
 add_subdirectory( about )
+if(ENABLE_TESTING)
     add_subdirectory( tests )
     add_subdirectory( sonnet/tests )
+endif()
 
 ########### next target ###############
 set(kdeui_LIB_SRCS
@@ -321,7 +323,8 @@ else (Q_WS_X11 AND X11_Xkb_FOUND)
     set (kdeui_LIB_SRCS ${kdeui_LIB_SRCS} util/kmodifierkeyinfoprovider_dummy.cpp)
 endif (Q_WS_X11 AND X11_Xkb_FOUND)
 
-set( kdeui_UI
+set(kdeui_LIB_SRCS
+    ${kdeui_LIB_SRCS}
     dialogs/kpassworddialog.ui
     dialogs/knewpassworddialog.ui
     dialogs/kshortcutsdialog.ui
@@ -332,14 +335,13 @@ set( kdeui_UI
 )
 
 if (Q_WS_X11)
-    set( kdeui_UI ${kdeui_UI} dialogs/kcupsoptionspageswidget.ui
+    set(kdeui_LIB_SRCS
+        ${kdeui_LIB_SRCS}
+        dialogs/kcupsoptionspageswidget.ui
         dialogs/kcupsoptionsjobwidget.ui
     )
 endif (Q_WS_X11)
 
-kde4_add_ui_files(kdeui_LIB_SRCS ${kdeui_UI} )
-
-
 set(kwallet_xml util/org.kde.KWallet.xml)
 install(FILES ${kwallet_xml} DESTINATION ${DBUS_INTERFACES_INSTALL_DIR})
 
@@ -370,7 +372,7 @@ install(FILES ${kglobalaccel_component_xml} DESTINATION ${DBUS_INTERFACES_INSTAL
 set(knotify_xml ${CMAKE_CURRENT_SOURCE_DIR}/notifications/org.kde.KNotify.xml)
 qt4_add_dbus_interface(kdeui_LIB_SRCS ${knotify_xml} knotify_interface)
 
-kde4_add_library(kdeui ${LIBRARY_TYPE} ${kdeui_LIB_SRCS})
+add_library(kdeui ${LIBRARY_TYPE} ${kdeui_LIB_SRCS})
 
 target_link_libraries(kdeui PRIVATE ${KDE4_KDECORE_LIBS} ${X11_LIBRARIES} ${QT_QTGUI_LIBRARY}
                             ${QT_QTXML_LIBRARY} ${KDEUI_EXTRA_LIBS} ${QT_QTNETWORK_LIBRARY}

kdeui/dialogs/kshortcutschemeseditor.cpp

@@ -33,6 +33,7 @@
 #include <kmessagebox.h>
 #include <kxmlguiclient.h>
 #include <kinputdialog.h>
+#include <klocale.h>
 
 #include "kshortcutsdialog.h"
 #include "kshortcutschemeshelper_p.h"

kdeui/dialogs/kshortcutseditor.cpp

@@ -48,6 +48,7 @@
 #include "kmessagebox.h"
 #include "kshortcut.h"
 #include "kaboutdata.h"
+#include "kconfiggroup.h"
 
 //---------------------------------------------------------------------
 // KShortcutsEditor

kdeui/dialogs/kshortcutseditoritem.cpp

@@ -28,6 +28,7 @@
 #include <kaction.h>
 #include <kdebug.h>
 #include <kstringhandler.h>
+#include <klocale.h>
 
 #include <QtGui/qtreewidget.h>
 

kdewebkit/CMakeLists.txt

@@ -22,7 +22,7 @@ set(kdewebkit_LIB_SRCS
     kwebpluginfactory.cpp
 )
 
-kde4_add_library(kdewebkit ${LIBRARY_TYPE} 
+add_library(kdewebkit ${LIBRARY_TYPE} 
     ${kdewebkit_LIB_SRCS} 
 )
 

kdewebkit/kwebkitpart/kdelauncher/CMakeLists.txt

@@ -3,7 +3,7 @@ project(kdelauncher)
 include_directories(${KDE4_INCLUDES} ${CMAKE_CURRENT_SOURCE_DIR})
 add_definitions(${QT_DEFINITIONS} ${KDE4_DEFINITIONS})
 
-kde4_add_executable(kdelauncher main.cpp )
+add_executable(kdelauncher main.cpp )
 target_link_libraries(kdelauncher
     ${QT_QTWEBKIT_LIBRARY}
     ${QT_QTCORE_LIBRARY}

kdewebkit/kwebkitpart/src/CMakeLists.txt

@@ -24,9 +24,6 @@ set(kwebkit_LIB_SRCS
     settings/webkit_filter.cpp
     ui/searchbar.cpp
     ui/passwordbar.cpp
-)
-
-kde4_add_ui_files(kwebkit_LIB_SRCS
     ui/searchbar.ui
 )
 

kdewidgets/CMakeLists.txt

@@ -1,20 +1,19 @@
-
 project(kdewidgets)
 
-add_subdirectory( pics )
+if(ENABLE_TESTING)
     add_subdirectory(tests)
+endif()
 
-include_directories(
+add_subdirectory(pics)
-  ${KDE4_KIO_INCLUDES}
+
- )
+include_directories(${KDE4_KIO_INCLUDES})
 
 
 ########### next target ###############
 
 set(makekdewidgets_SRCS makekdewidgets.cpp )
 
-
+add_executable(makekdewidgets ${makekdewidgets_SRCS})
-kde4_add_executable(makekdewidgets NOGUI ${makekdewidgets_SRCS})
 
 target_link_libraries(makekdewidgets ${KDE4_KDECORE_LIBS})
 
@@ -26,63 +25,36 @@ install(TARGETS makekdewidgets  EXPORT kdelibsToolsTargets ${INSTALL_TARGETS_DEF
 ########### next target ###############
 
 if(QT_QTDESIGNER_FOUND)
-  # get the name of the generated wrapper script (which sets up LD_LIBRARY_PATH)
+    KDE4_ADD_WIDGET_FILES(kde.widgets)
-  get_target_property(MAKEKDEWIDGETS_EXECUTABLE makekdewidgets WRAPPER_SCRIPT)
-
-  add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp
-    COMMAND "${MAKEKDEWIDGETS_EXECUTABLE}" -o ${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp ${CMAKE_CURRENT_SOURCE_DIR}/kde.widgets
-    MAIN_DEPENDENCY kde.widgets DEPENDS makekdewidgets)
 
     set(kdewidgets_PART_SRCS
         classpreviews.cpp
-     ${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp
+        $<TARGET_OBJECTS:kde_autowidgets>
     )
 
-  qt4_generate_moc(${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp ${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.moc)
-
-
     qt4_add_resources(kdewidgets_PART_SRCS kdewidgets.qrc)
 
     kde4_add_plugin(kdewidgets ${kdewidgets_PART_SRCS})
 
     target_link_libraries(kdewidgets ${KDE4_KIO_LIBS})
-  set_target_properties(kdewidgets PROPERTIES
-                                   INSTALL_RPATH_USE_LINK_PATH TRUE
-                                   SKIP_BUILD_RPATH TRUE
-                                   BUILD_WITH_INSTALL_RPATH TRUE
-                                   INSTALL_RPATH ${LIB_INSTALL_DIR}
-                       )
 
     install(TARGETS kdewidgets  DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer )
 
     # kdewebkit widgets
-  include_directories(
+    include_directories(${CMAKE_SOURCE_DIR}/kdewebkit)
-    ${CMAKE_SOURCE_DIR}/kdewebkit
-  )
 
-  add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp
+    KDE4_ADD_WIDGET_FILES(kdewebkit.widgets)
-    COMMAND "${MAKEKDEWIDGETS_EXECUTABLE}" -o ${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp ${CMAKE_CURRENT_SOURCE_DIR}/kdewebkit.widgets
-    MAIN_DEPENDENCY kdewebkit.widgets DEPENDS makekdewidgets)
 
     set(kdewebkitwidgets_PART_SRCS
         classpreviews.cpp
-     ${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp
+        $<TARGET_OBJECTS:kdewebkit_autowidgets>
     )
 
-  qt4_generate_moc(${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp ${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.moc)
-
-
     qt4_add_resources(kdewebkitwidgets_PART_SRCS kdewebkitwidgets.qrc)
 
     kde4_add_plugin(kdewebkitwidgets ${kdewebkitwidgets_PART_SRCS})
 
     target_link_libraries(kdewebkitwidgets ${KDE4_KDEUI_LIBS} ${KDE4_KDEWEBKIT_LIBS} ${QT_QTWEBKIT_LIBRARY})
-  set_target_properties(kdewebkitwidgets PROPERTIES
-                                     INSTALL_RPATH_USE_LINK_PATH TRUE
-                                     SKIP_BUILD_RPATH TRUE
-                                     BUILD_WITH_INSTALL_RPATH TRUE
-                                     INSTALL_RPATH ${LIB_INSTALL_DIR}
-                       )
 
     install(TARGETS kdewebkitwidgets DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer)
 endif (QT_QTDESIGNER_FOUND)

kfile/CMakeLists.txt

@@ -6,7 +6,9 @@ include_directories(
     ${CMAKE_BINARY_DIR}/solid
 )
 
+if(ENABLE_TESTING)
     add_subdirectory(tests)
+endif()
 
 set(kfile_LIB_SRCS
     kdiroperator.cpp
@@ -35,7 +37,7 @@ set(kfile_LIB_SRCS
     kurlnavigatormenu.cpp
 )
 
-kde4_add_library(kfile ${LIBRARY_TYPE} ${kfile_LIB_SRCS})
+add_library(kfile ${LIBRARY_TYPE} ${kfile_LIB_SRCS})
 target_link_libraries(kfile PRIVATE
    ${KDE4_KIO_LIBS}
    ${ZLIB_LIBRARY}
@@ -69,13 +71,18 @@ install( FILES
     knewfilemenu.h
     knameandurlinputdialog.h
     kfile_export.h
-  DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel )
+    DESTINATION ${INCLUDE_INSTALL_DIR}
+    COMPONENT Devel
+)
 
 ############ module used by KFileDialog ##########
 set(kfilemodule_SRCS
     kfilemodule.cpp
 )
+
 kde4_add_plugin(kfilemodule ${kfilemodule_SRCS})
+
 target_link_libraries(kfilemodule ${KDE4_KFILE_LIBS} ${KDE4_KIO_LIBS})
+
 install(TARGETS kfilemodule DESTINATION ${PLUGIN_INSTALL_DIR})
 install(FILES kfilemodule.desktop DESTINATION ${SERVICES_INSTALL_DIR})

kinit/CMakeLists.txt

@@ -1,6 +1,8 @@
 project(kdeinit)
 
+if(ENABLE_TESTING)
     add_subdirectory(tests)
+endif()
 
 include_directories( ${KDE4_KPARTS_INCLUDES} )
 
@@ -31,9 +33,7 @@ endif(HAVE_SOCKET_LIBRARY)
 set(kdeinit_SRCS kinit.cpp proctitle.cpp klauncher_cmds.cpp )
 set(kdeinit_LIBS "")
 
-# on win32 kdeinit4 has to be a console application 
+add_executable(kdeinit4 ${kdeinit_SRCS})
-# to be able to catch stderr based --verbose output
-kde4_add_executable(kdeinit4 NOGUI ${kdeinit_SRCS})
 
 target_link_libraries(kdeinit4 ${KDE4_KDEUI_LIBS} ${kdeinit_LIBS} ${KINIT_SOCKET_LIBRARY} )
 if (Q_WS_X11)
@@ -46,7 +46,7 @@ install(TARGETS kdeinit4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 set(kwrapper_SRCS kwrapper.c )
 
-kde4_add_executable(kwrapper4 NOGUI ${kwrapper_SRCS})
+add_executable(kwrapper4 ${kwrapper_SRCS})
 
 target_link_libraries(kwrapper4 ${KINIT_SOCKET_LIBRARY})
 
@@ -54,7 +54,7 @@ install(TARGETS kwrapper4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 ########### kdeinit4_wrapper ###############
 
-kde4_add_executable(kdeinit4_wrapper NOGUI wrapper.c)
+add_executable(kdeinit4_wrapper wrapper.c)
 
 target_link_libraries(kdeinit4_wrapper  ${KINIT_SOCKET_LIBRARY})
 
@@ -63,28 +63,21 @@ if (NOT Q_WS_X11 AND NOT Q_WS_QWS)
 endif (NOT Q_WS_X11 AND NOT Q_WS_QWS)
 
 install(TARGETS kdeinit4_wrapper ${INSTALL_TARGETS_DEFAULT_ARGS} )
+install(TARGETS kdeinit4_wrapper ${INSTALL_TARGETS_DEFAULT_ARGS} RENAME kdeinit4_shutdown)
 
 ########### kshell4 ###############
 
-kde4_add_executable(kshell4 NOGUI shell.c)
+add_executable(kshell4 shell.c)
 
 target_link_libraries(kshell4 ${KINIT_SOCKET_LIBRARY})
 
 install(TARGETS kshell4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
-########### kdeinit4_shutdown ###############
-
-kde4_add_executable(kdeinit4_shutdown NOGUI wrapper.c)
-
-target_link_libraries(kdeinit4_shutdown  ${KINIT_SOCKET_LIBRARY})
-
-install(TARGETS kdeinit4_shutdown ${INSTALL_TARGETS_DEFAULT_ARGS} )
-
 ########### lnusertemp ###############
 
 set(lnusertemp_SRCS lnusertemp.c )
 
-kde4_add_executable(lnusertemp NOGUI ${lnusertemp_SRCS})
+add_executable(lnusertemp ${lnusertemp_SRCS})
 
 target_link_libraries(lnusertemp kdefakes)
 
@@ -95,8 +88,7 @@ install(TARGETS lnusertemp DESTINATION ${LIBEXEC_INSTALL_DIR} )
 
 set(kioslave_SRCS kioslave.cpp)
 
-
+add_executable(kioslave ${kioslave_SRCS})
-kde4_add_executable(kioslave NOGUI ${kioslave_SRCS})
 
 target_link_libraries(kioslave ${KDE4_KIO_LIBS} )
 
@@ -116,8 +108,7 @@ set(klauncher_SRCS
 # The adaptor is manually edited, generate the xml from it.
 qt4_generate_dbus_interface(klauncher_adaptor.h org.kde.KLauncher.xml)
 
-
+add_executable( klauncher ${klauncher_SRCS})
-kde4_add_executable( klauncher NOGUI ${klauncher_SRCS})
 set_target_properties(klauncher PROPERTIES DEFINE_SYMBOL MAKE_KLAUNCHER)
 
 target_link_libraries(klauncher  ${KDE4_KIO_LIBS} ${X11_LIBRARIES})

kio/CMakeLists.txt

@@ -46,7 +46,9 @@ configure_file(kssl/ksslconfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/kssl/ksslconf
 
 add_subdirectory( kssl/kcm )
 add_subdirectory( misc )
+if(ENABLE_TESTING)
     add_subdirectory( tests )
+endif()
 if(STRIGI_FOUND)
    add_subdirectory( kio/dummyanalyzers )
 endif(STRIGI_FOUND)
@@ -239,6 +241,12 @@ set(kio_LIB_SRCS
    ${kbookmarks_STAT_SRCS}
    ${kfile_STAT_SRCS}
    ${kssl_STAT_SRCS}
+   kfile/kpropertiesdesktopadvbase.ui
+   kfile/kpropertiesdesktopbase.ui
+   kssl/keygenwizard.ui
+   kssl/keygenwizard2.ui
+   kssl/sslinfo.ui
+   kssl/certificateparty.ui
 )
 
 set(kio_LIB_PRIVATE_SRCS
@@ -252,18 +260,9 @@ set(kfilemetadatareaderprocess_SRCS
     kfile/kfilemetadatareaderprocess.cpp
 )
 
-kde4_add_ui_files(kio_LIB_SRCS
+add_library(kio ${LIBRARY_TYPE} ${kio_LIB_SRCS})
-   kfile/kpropertiesdesktopadvbase.ui
-   kfile/kpropertiesdesktopbase.ui
-   kssl/keygenwizard.ui
-   kssl/keygenwizard2.ui
-   kssl/sslinfo.ui
-   kssl/certificateparty.ui
-)
 
-kde4_add_library(kio ${LIBRARY_TYPE} ${kio_LIB_SRCS})
+add_executable(kfilemetadatareader ${kfilemetadatareaderprocess_SRCS})
-
-kde4_add_executable(kfilemetadatareader ${kfilemetadatareaderprocess_SRCS})
 target_link_libraries(kfilemetadatareader ${KDE4_KIO_LIBS})
 target_link_libraries(kio PRIVATE ${KDE4_KDEUI_LIBS} ${ZLIB_LIBRARY} ${QT_QTNETWORK_LIBRARY} ${QT_QTXML_LIBRARY} ${QT_QTSVG_LIBRARY} ${X11_LIBRARIES} ${KIO_EXTRA_LIBS})
 target_link_libraries(kio PUBLIC kdeui kdecore ${QT_QTNETWORK_LIBRARY} ${QT_QTXML_LIBRARY} ${QT_QTGUI_LIBRARY} )

kio/kio/dummyanalyzers/CMakeLists.txt

@@ -1,6 +1,6 @@
 
 # build the analyzer as a module
-kde4_add_library(dummy MODULE dummyanalyzers.cpp)
+add_library(dummy MODULE dummyanalyzers.cpp)
 
 # link with the required libraries
 target_link_libraries(dummy ${STRIGI_STREAMANALYZER_LIBRARY})

kio/kssl/kcm/CMakeLists.txt

@@ -1,8 +1,12 @@
 ########### next target ###############
 
-set(kcmssl_SRCS kcmssl.cpp cacertificatespage.cpp displaycertdialog.cpp)
+set(kcmssl_SRCS
-
+    kcmssl.cpp
-kde4_add_ui_files(kcmssl_SRCS cacertificates.ui displaycert.ui)
+    cacertificatespage.cpp
+    displaycertdialog.cpp
+    cacertificates.ui
+    displaycert.ui
+)
 
 kde4_add_plugin(kcm_ssl ${kcmssl_SRCS})
 target_link_libraries(kcm_ssl ${KDE4_KIO_LIBS})

kio/kssl/kcm/cacertificatespage.cpp

@@ -25,6 +25,7 @@
 
 #include <kdebug.h>
 #include <kfiledialog.h>
+#include <klocale.h>
 
 #include <QList>
 #include <QSslCertificate>

kio/kssl/kcm/displaycertdialog.cpp

@@ -20,7 +20,7 @@
 #include "displaycertdialog_p.h"
 #include <kpushbutton.h>
 #include <kstandardguiitem.h>
-
+#include <klocale.h>
 
 DisplayCertDialog::DisplayCertDialog(QWidget *parent)
  : KDialog(parent),

kio/kssl/kcm/displaycertdialog_p.h

@@ -21,6 +21,7 @@
 #define DISPLAYCERTDIALOG_P_H
 
 #include "ui_displaycert.h"
+#include <kdialog.h>
 #include <QtNetwork/QSslCertificate>
 
 class DisplayCertDialog : public KDialog

kio/misc/CMakeLists.txt

@@ -11,7 +11,7 @@ add_subdirectory( kntlm )
 set(kmailservice_SRCS kmailservice.cpp )
 
 
-kde4_add_executable(kmailservice NOGUI ${kmailservice_SRCS})
+add_executable(kmailservice ${kmailservice_SRCS})
 
 target_link_libraries(kmailservice  ${KDE4_KDEUI_LIBS})
 
@@ -22,8 +22,7 @@ install(PROGRAMS kmailservice.desktop DESTINATION ${XDG_APPS_INSTALL_DIR})
 
 set(ktelnetservice_SRCS ktelnetservice.cpp )
 
-
+add_executable(ktelnetservice ${ktelnetservice_SRCS})
-kde4_add_executable(ktelnetservice NOGUI ${ktelnetservice_SRCS})
 
 target_link_libraries(ktelnetservice  ${KDE4_KDEUI_LIBS} )
 
@@ -34,8 +33,6 @@ install(PROGRAMS ktelnetservice.desktop DESTINATION ${XDG_APPS_INSTALL_DIR})
 
 install( FILES rtsp.protocol mms.protocol mmst.protocol mmsu.protocol pnm.protocol rtspt.protocol rtspu.protocol  DESTINATION  ${SERVICES_INSTALL_DIR} )
 
-# install the fileshareset and filesharelist scripts, they are not required on windows
-if (UNIX)
 install(PROGRAMS fileshareset DESTINATION ${LIBEXEC_INSTALL_DIR} )
 
 install(CODE "
@@ -47,5 +44,3 @@ if (UNIX)
 file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/make_fileshare_symlink.cmake "exec_program(${CMAKE_COMMAND} ARGS -E create_symlink ${LIBEXEC_INSTALL_DIR}/fileshareset \"\$ENV{DESTDIR}${LIBEXEC_INSTALL_DIR}/filesharelist\")\n")
 # and add it as post-install script to any of the installed targets, so it will be executed during "make install"
 set_target_properties(ktelnetservice PROPERTIES POST_INSTALL_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/make_fileshare_symlink.cmake)
-endif (UNIX)
-

kio/misc/kntlm/CMakeLists.txt

@@ -1,7 +1,7 @@
 
 set(kntlm_LIB_SRCS kntlm.cpp des.cpp )
 
-kde4_add_library(kntlm ${LIBRARY_TYPE} ${kntlm_LIB_SRCS})
+add_library(kntlm ${LIBRARY_TYPE} ${kntlm_LIB_SRCS})
 
 target_link_libraries(kntlm  ${KDE4_KDECORE_LIBS} )
 

kio/misc/kpac/CMakeLists.txt

@@ -39,7 +39,7 @@ install(TARGETS kded_proxyscout  DESTINATION ${PLUGIN_INSTALL_DIR} )
 
 set(kpac_dhcp_helper_SRCS kpac_dhcp_helper.c)
 
-kde4_add_executable(kpac_dhcp_helper NOGUI ${kpac_dhcp_helper_SRCS})
+add_executable(kpac_dhcp_helper ${kpac_dhcp_helper_SRCS})
 
 if (HAVE_NSL_LIBRARY)
   # Assume Solaris

kioslave/http/CMakeLists.txt

@@ -1,7 +1,5 @@
-
 project(kioslave-http)
 
-
 macro_optional_find_package(GSSAPI)
 set_package_properties(GSSAPI PROPERTIES DESCRIPTION "Allows KIO to make use of certain HTTP authentication services"
                        URL "http://web.mit.edu/kerberos/www"
@@ -32,7 +30,9 @@ include_directories( ${KDE4_KIO_INCLUDES} ${ZLIB_INCLUDE_DIR} ${CMAKE_SOURCE_DIR
 include_directories( ${CMAKE_SOURCE_DIR}/interfaces ${CMAKE_SOURCE_DIR}/kio/httpfilter )
 
 add_subdirectory(kcookiejar)
+if(ENABLE_TESTING)
     add_subdirectory(tests)
+endif()
 
 ########### next target ###############
 
@@ -40,8 +40,7 @@ set(kio_http_cache_cleaner_SRCS
     http_cache_cleaner.cpp
 )
 
-
+add_executable(kio_http_cache_cleaner ${kio_http_cache_cleaner_SRCS})
-kde4_add_executable( kio_http_cache_cleaner NOGUI ${kio_http_cache_cleaner_SRCS})
 
 target_link_libraries(kio_http_cache_cleaner  ${KDE4_KIO_LIBS} ${ZLIB_LIBRARY})
 
@@ -49,8 +48,6 @@ install(TARGETS kio_http_cache_cleaner DESTINATION ${LIBEXEC_INSTALL_DIR} )
 
 ########### next target ###############
 
-# kio/httpfilter/Makefile.am: httpfilter
-
 set(kio_http_PART_SRCS
     http.cpp
     httpauthentication.cpp
@@ -68,7 +65,6 @@ endif(GSSAPI_FOUND)
 
 install(TARGETS  kio_http  DESTINATION ${PLUGIN_INSTALL_DIR} )
 
-
 ########### install files ###############
 
 install(FILES
@@ -77,6 +73,7 @@ install( FILES
     https.protocol
     webdav.protocol
     webdavs.protocol
-  DESTINATION  ${SERVICES_INSTALL_DIR} )
+    DESTINATION ${SERVICES_INSTALL_DIR}
+)
 
 

kioslave/http/kcookiejar/CMakeLists.txt

@@ -1,8 +1,6 @@
-
+if(ENABLE_TESTING)
     add_subdirectory(tests)
-
+endif()
-# all done by parent dir
-# include_directories( ${KDE4_KIO_INCLUDES} )
 
 ####### kcookiejar4: command line tool for talking to the kded kcookiejar module #######
 
@@ -19,7 +17,7 @@ set(kcookieserver_xml ${CMAKE_CURRENT_BINARY_DIR}/org.kde.KCookieServer.xml)
 set_source_files_properties(${kcookieserver_xml} PROPERTIES INCLUDE "kcookiejar_include.h")
 qt4_add_dbus_interfaces(kcookiejar_SRCS ${kcookieserver_xml})
 
-kde4_add_executable( kcookiejar4 NOGUI ${kcookiejar_SRCS})
+add_executable(kcookiejar4 ${kcookiejar_SRCS})
 
 target_link_libraries(kcookiejar4 ${KDE4_KDECORE_LIBS})
 

knotify/CMakeLists.txt

@@ -1,9 +1,39 @@
-
 project(knotify)
 
-
 include_directories( ${KDE4_KIO_INCLUDES})
+include_directories(BEFORE ${KDE4_PHONON_INCLUDES})
 
-add_subdirectory( config )
+if(ENABLE_TESTING)
     add_subdirectory(tests)
+endif()
+
+########### next target ###############
+
+set(knotifyconfig_LIB_SRCS
+    knotifyconfigactionswidget.cpp
+    knotifyconfigelement.cpp
+    knotifyeventlist.cpp
+    knotifyconfigwidget.cpp
+    knotifyconfigactionswidgetbase.ui
+)
+
+add_library(knotifyconfig ${LIBRARY_TYPE} ${knotifyconfig_LIB_SRCS})
+
+# Needs KIO for KUrlRequester
+target_link_libraries(knotifyconfig PRIVATE ${KDE4_KIO_LIBS} ${KDE4_PHONON_LIBS}  )
+target_link_libraries(knotifyconfig PUBLIC kdecore ${QT_QTGUI_LIBRARY})
+
+set_target_properties(knotifyconfig PROPERTIES
+   VERSION ${GENERIC_LIB_VERSION}
+   SOVERSION ${GENERIC_LIB_SOVERSION}
+)
+install(TARGETS knotifyconfig EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
+
+########### install files ###############
+install( FILES knotifyconfig_export.h knotifyconfigwidget.h  DESTINATION  ${INCLUDE_INSTALL_DIR}  COMPONENT Devel)
+
+
+
+
+
 

knotify/config/CMakeLists.txt

@@ -1,37 +0,0 @@
-
-include_directories(BEFORE ${KDE4_PHONON_INCLUDES})
-
-########### next target ###############
-
-set(knotifyconfig_LIB_SRCS
-    knotifyconfigactionswidget.cpp
-    knotifyconfigelement.cpp
-    knotifyeventlist.cpp
-    knotifyconfigwidget.cpp
-)
-
-
-set( knotifyconfig_UI knotifyconfigactionswidgetbase.ui )
-
-kde4_add_ui_files(knotifyconfig_LIB_SRCS ${knotifyconfig_UI} )
-
-kde4_add_library(knotifyconfig ${LIBRARY_TYPE} ${knotifyconfig_LIB_SRCS})
-
-# Needs KIO for KUrlRequester
-target_link_libraries(knotifyconfig PRIVATE ${KDE4_KIO_LIBS} ${KDE4_PHONON_LIBS}  )
-target_link_libraries(knotifyconfig PUBLIC kdecore ${QT_QTGUI_LIBRARY})
-
-set_target_properties(knotifyconfig PROPERTIES
-   VERSION ${GENERIC_LIB_VERSION}
-   SOVERSION ${GENERIC_LIB_SOVERSION}
-)
-install(TARGETS knotifyconfig EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
-
-########### install files ###############
-install( FILES knotifyconfig_export.h knotifyconfigwidget.h  DESTINATION  ${INCLUDE_INSTALL_DIR}  COMPONENT Devel)
-
-
-
-
-
-