These files belong to KDE (kdelibs), so we don't need them here.

Alex

6 files changed, 0 insertions, 2876 deletions

diff --git a/attic/modules/FindKDE4Internal.cmake b/attic/modules/FindKDE4Internal.cmake
deleted file mode 100644
index 7960061b..00000000
--- a/attic/modules/FindKDE4Internal.cmake
+++ /dev/null
@@ -1,1418 +0,0 @@
-# - Find the KDE4 include and library dirs, KDE preprocessors and define a some macros
-#
-# This module defines the following variables:
-#
-#  KDE4_FOUND               - set to TRUE if everything required for building KDE software has been found
-#
-#  KDE4_DEFINITIONS         - compiler definitions required for compiling KDE software
-#  KDE4_INCLUDE_DIR         - the KDE 4 include directory
-#  KDE4_INCLUDES            - all include directories required for KDE, i.e.
-#                             KDE4_INCLUDE_DIR, but also the Qt4 include directories
-#                             and other platform specific include directories
-#  KDE4_LIB_DIR             - the directory where the KDE libraries are installed,
-#                             intended to be used with LINK_DIRECTORIES(). In general, this is not necessary.
-#  KDE4_LIBEXEC_INSTALL_DIR - the directory where libexec executables from kdelibs are installed
-#  KDE4_BIN_INSTALL_DIR     - the directory where executables from kdelibs are installed
-#  KDE4_SBIN_INSTALL_DIR    - the directory where system executables from kdelibs are installed
-#  KDE4_DATA_INSTALL_DIR    - the parent directory where kdelibs applications install their data
-#  KDE4_HTML_INSTALL_DIR    - the directory where HTML documentation from kdelibs is installed
-#  KDE4_CONFIG_INSTALL_DIR  - the directory where config files from kdelibs are installed
-#  KDE4_ICON_INSTALL_DIR    - the directory where icons from kdelibs are
-#  KDE4_IMPORTS_INSTALL_DIR - the directory where imports from kdelibs are
-#  KDE4_KCFG_INSTALL_DIR    - the directory where kconfig files from kdelibs are installed
-#  KDE4_LOCALE_INSTALL_DIR  - the directory where translations from kdelibs are installed
-#  KDE4_MIME_INSTALL_DIR    - the directory where mimetype desktop files from kdelibs are installed
-#  KDE4_SOUND_INSTALL_DIR   - the directory where sound files from kdelibs are installed
-#  KDE4_TEMPLATES_INSTALL_DIR     - the directory where templates (Create new file...) from kdelibs are installed
-#  KDE4_WALLPAPER_INSTALL_DIR     - the directory where wallpapers from kdelibs are installed
-#  KDE4_KCONF_UPDATE_INSTALL_DIR  - the directory where kconf_update files from kdelibs are installed
-#  KDE4_AUTOSTART_INSTALL_DIR     - the directory where autostart from kdelibs are installed
-#  KDE4_XDG_APPS_INSTALL_DIR      - the XDG apps dir from kdelibs
-#  KDE4_XDG_DIRECTORY_INSTALL_DIR - the XDG directory from kdelibs
-#  KDE4_SYSCONF_INSTALL_DIR       - the directory where sysconfig files from kdelibs are installed
-#  KDE4_MAN_INSTALL_DIR           - the directory where man pages from kdelibs are installed
-#  KDE4_INFO_INSTALL_DIR          - the directory where info files from kdelibs are installed
-#  KDE4_DBUS_INTERFACES_DIR       - the directory where dbus interfaces from kdelibs are installed
-#  KDE4_DBUS_SERVICES_DIR         - the directory where dbus service files from kdelibs are installed
-#
-# The following variables are defined for the various tools required to
-# compile KDE software:
-#
-#  KDE4_KCFGC_EXECUTABLE    - the kconfig_compiler executable
-#  KDE4_AUTOMOC_EXECUTABLE  - the kde4automoc executable, deprecated, use AUTOMOC4_EXECUTABLE instead
-#  KDE4_MEINPROC_EXECUTABLE - the meinproc4 executable
-#  KDE4_MAKEKDEWIDGETS_EXECUTABLE - the makekdewidgets executable
-#
-# The following variables point to the location of the KDE libraries,
-# but shouldn't be used directly:
-#
-#  KDE4_KDECORE_LIBRARY     - the kdecore library
-#  KDE4_KDEUI_LIBRARY       - the kdeui library
-#  KDE4_KIO_LIBRARY         - the kio library
-#  KDE4_KPARTS_LIBRARY      - the kparts library
-#  KDE4_KUTILS_LIBRARY      - the kutils library
-#  KDE4_KEMOTICONS_LIBRARY  - the kemoticons library
-#  KDE4_KIDLETIME_LIBRARY   - the kidletime library
-#  KDE4_KCMUTILS_LIBRARY    - the kcmutils library
-#  KDE4_KPRINTUTILS_LIBRARY - the kprintutils library
-#  KDE4_KDE3SUPPORT_LIBRARY - the kde3support library
-#  KDE4_KFILE_LIBRARY       - the kfile library
-#  KDE4_KHTML_LIBRARY       - the khtml library
-#  KDE4_KJS_LIBRARY         - the kjs library
-#  KDE4_KJSAPI_LIBRARY      - the kjs public api library
-#  KDE4_KNEWSTUFF2_LIBRARY  - the knewstuff2 library
-#  KDE4_KNEWSTUFF3_LIBRARY  - the knewstuff3 library
-#  KDE4_KDNSSD_LIBRARY      - the kdnssd library
-#  KDE4_PHONON_LIBRARY      - the phonon library
-#  KDE4_THREADWEAVER_LIBRARY- the threadweaver library
-#  KDE4_SOLID_LIBRARY       - the solid library
-#  KDE4_KNOTIFYCONFIG_LIBRARY- the knotifyconfig library
-#  KDE4_KROSSCORE_LIBRARY   - the krosscore library
-#  KDE4_KTEXTEDITOR_LIBRARY - the ktexteditor library
-#  KDE4_NEPOMUK_LIBRARY     - the nepomuk library
-#  KDE4_PLASMA_LIBRARY      - the plasma library
-#  KDE4_KUNITCONVERSION_LIBRARY - the kunitconversion library
-#  KDE4_KDEWEBKIT_LIBRARY   - the kdewebkit library
-#
-#  KDE4_PLASMA_OPENGL_FOUND  - TRUE if the OpenGL support of Plasma has been found, NOTFOUND otherwise
-#
-# Compared to the variables above, the following variables
-# also contain all of the depending libraries, so the variables below
-# should be used instead of the ones above:
-#
-#  KDE4_KDECORE_LIBS          - the kdecore library and all depending libraries
-#  KDE4_KDEUI_LIBS            - the kdeui library and all depending libraries
-#  KDE4_KIO_LIBS              - the kio library and all depending libraries
-#  KDE4_KPARTS_LIBS           - the kparts library and all depending libraries
-#  KDE4_KUTILS_LIBS           - the kutils library and all depending libraries
-#  KDE4_KEMOTICONS_LIBS       - the kemoticons library and all depending libraries
-#  KDE4_KIDLETIME_LIBS        - the kidletime library and all depending libraries
-#  KDE4_KCMUTILS_LIBS         - the kcmutils library and all depending libraries
-#  KDE4_KPRINTUTILS_LIBS      - the kprintutils library and all depending libraries
-#  KDE4_KDE3SUPPORT_LIBS      - the kde3support library and all depending libraries
-#  KDE4_KFILE_LIBS            - the kfile library and all depending libraries
-#  KDE4_KHTML_LIBS            - the khtml library and all depending libraries
-#  KDE4_KJS_LIBS              - the kjs library and all depending libraries
-#  KDE4_KJSAPI_LIBS           - the kjs public api library and all depending libraries
-#  KDE4_KNEWSTUFF2_LIBS       - the knewstuff2 library and all depending libraries
-#  KDE4_KNEWSTUFF3_LIBS       - the knewstuff3 library and all depending libraries
-#  KDE4_KDNSSD_LIBS           - the kdnssd library and all depending libraries
-#  KDE4_KDESU_LIBS            - the kdesu library and all depending libraries
-#  KDE4_KPTY_LIBS             - the kpty library and all depending libraries
-#  KDE4_PHONON_LIBS           - the phonon library and all depending librairies
-#  KDE4_THREADWEAVER_LIBRARIES- the threadweaver library and all depending libraries
-#  KDE4_SOLID_LIBS            - the solid library and all depending libraries
-#  KDE4_KNOTIFYCONFIG_LIBS    - the knotify config library and all depending libraries
-#  KDE4_KROSSCORE_LIBS        - the kross core library and all depending libraries
-#  KDE4_KROSSUI_LIBS          - the kross ui library which includes core and all depending libraries
-#  KDE4_KTEXTEDITOR_LIBS      - the ktexteditor library and all depending libraries
-#  KDE4_NEPOMUK_LIBS          - the nepomuk library and all depending libraries
-#  KDE4_PLASMA_LIBS           - the plasma library and all depending librairies
-#  KDE4_KUNITCONVERSION_LIBS  - the kunitconversion library and all depending libraries
-#  KDE4_KDEWEBKIT_LIBS        - the kdewebkit library and all depending libraries
-#
-# This module defines also a bunch of variables used as locations for install directories
-# for files of the package which is using this module. These variables don't say
-# anything about the location of the installed KDE.
-# They can be relative (to CMAKE_INSTALL_PREFIX) or absolute.
-# Under Windows they are always relative.
-#
-#  BIN_INSTALL_DIR          - the directory where executables will be installed (default is prefix/bin)
-#  BUNDLE_INSTALL_DIR       - Mac only: the directory where application bundles will be installed (default is /Applications/KDE4 )
-#  SBIN_INSTALL_DIR         - the directory where system executables will be installed (default is prefix/sbin)
-#  LIB_INSTALL_DIR          - the directory where libraries will be installed (default is prefix/lib)
-#  CONFIG_INSTALL_DIR       - the directory where config files will be installed
-#  DATA_INSTALL_DIR         - the parent directory where applications can install their data
-#  HTML_INSTALL_DIR         - the directory where HTML documentation will be installed
-#  ICON_INSTALL_DIR         - the directory where the icons will be installed (default prefix/share/icons/)
-#  INFO_INSTALL_DIR         - the directory where info files will be installed (default prefix/info)
-#  KCFG_INSTALL_DIR         - the directory where kconfig files will be installed
-#  LOCALE_INSTALL_DIR       - the directory where translations will be installed
-#  MAN_INSTALL_DIR          - the directory where man pages will be installed (default prefix/man/)
-#  MIME_INSTALL_DIR         - the directory where mimetype desktop files will be installed
-#  PLUGIN_INSTALL_DIR       - the subdirectory relative to the install prefix where plugins will be installed (default is ${KDE4_LIB_INSTALL_DIR}/kde4)
-#  IMPORTS_INSTALL_DIR      - the subdirectory relative to the install prefix where imports will be installed
-#  SERVICES_INSTALL_DIR     - the directory where service (desktop, protocol, ...) files will be installed
-#  SERVICETYPES_INSTALL_DIR - the directory where servicestypes desktop files will be installed
-#  SOUND_INSTALL_DIR        - the directory where sound files will be installed
-#  TEMPLATES_INSTALL_DIR    - the directory where templates (Create new file...) will be installed
-#  WALLPAPER_INSTALL_DIR    - the directory where wallpapers will be installed
-#  AUTOSTART_INSTALL_DIR    - the directory where autostart files will be installed
-#  DEMO_INSTALL_DIR         - the directory where demos will be installed
-#  KCONF_UPDATE_INSTALL_DIR - the directory where kconf_update files will be installed
-#  SYSCONF_INSTALL_DIR      - the directory where sysconfig files will be installed (default /etc)
-#  XDG_APPS_INSTALL_DIR     - the XDG apps dir
-#  XDG_DIRECTORY_INSTALL_DIR- the XDG directory
-#  XDG_MIME_INSTALL_DIR     - the XDG mimetypes install dir
-#  DBUS_INTERFACES_INSTALL_DIR - the directory where dbus interfaces will be installed (default is prefix/share/dbus-1/interfaces)
-#  DBUS_SERVICES_INSTALL_DIR        - the directory where dbus services will be installed (default is prefix/share/dbus-1/services )
-#  DBUS_SYSTEM_SERVICES_INSTALL_DIR        - the directory where dbus system services will be installed (default is prefix/share/dbus-1/system-services )
-#
-# The variable INSTALL_TARGETS_DEFAULT_ARGS can be used when installing libraries
-# or executables into the default locations.
-# The INSTALL_TARGETS_DEFAULT_ARGS variable should be used when libraries are installed.
-# It should also be used when installing applications, since then
-# on OS X application bundles will be installed to BUNDLE_INSTALL_DIR.
-# The variable MUST NOT be used for installing plugins.
-# It also MUST NOT be used for executables which are intended to go into sbin/ or libexec/.
-#
-# Usage is like this:
-#    install(TARGETS kdecore kdeui ${INSTALL_TARGETS_DEFAULT_ARGS} )
-#
-# This will install libraries correctly under UNIX, OSX and Windows (i.e. dll's go
-# into bin/.
-#
-#
-# The following variable is provided, but seem to be unused:
-#  LIBS_HTML_INSTALL_DIR    /share/doc/HTML            CACHE STRING "Is this still used ?")
-#
-# The following user adjustable options are provided:
-#
-#  KDE4_ENABLE_FINAL - enable KDE-style enable-final all-in-one-compilation
-#  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)
-#
-# It also adds the following macros and functions (from KDE4Macros.cmake)
-#  KDE4_ADD_UI_FILES (SRCS_VAR file1.ui ... fileN.ui)
-#    Use this to add Qt designer ui files to your application/library.
-#
-#  KDE4_ADD_UI3_FILES (SRCS_VAR file1.ui ... fileN.ui)
-#    Use this to add Qt designer ui files from Qt version 3 to your application/library.
-#
-#  KDE4_ADD_KCFG_FILES (SRCS_VAR [GENERATE_MOC] [USE_RELATIVE_PATH] file1.kcfgc ... fileN.kcfgc)
-#    Use this to add KDE config compiler files to your application/library.
-#    Use optional GENERATE_MOC to generate moc if you use signals in your kcfg files.
-#    Use optional USE_RELATIVE_PATH to generate the classes in the build following the given
-#    relative path to the file.
-#
-#  KDE4_ADD_WIDGET_FILES (SRCS_VAR file1.widgets ... fileN.widgets)
-#    Use this to add widget description files for the makekdewidgets code generator
-#    for Qt Designer plugins.
-#
-#  KDE4_CREATE_FINAL_FILES (filename_CXX filename_C file1 ... fileN)
-#    This macro is intended mainly for internal uses.
-#    It is used for enable-final. It will generate two source files,
-#    one for the C files and one for the C++ files.
-#    These files will have the names given in filename_CXX and filename_C.
-#
-#  KDE4_ADD_PLUGIN ( name [WITH_PREFIX] file1 ... fileN )
-#    Create a KDE plugin (KPart, kioslave, etc.) from the given source files.
-#    It supports KDE4_ENABLE_FINAL.
-#    If WITH_PREFIX is given, the resulting plugin will have the prefix "lib", otherwise it won't.
-#
-#  KDE4_ADD_KDEINIT_EXECUTABLE (name [NOGUI] [RUN_UNINSTALLED] file1 ... fileN)
-#    Create a KDE application in the form of a module loadable via kdeinit.
-#    A library named kdeinit_<name> will be created and a small executable which links to it.
-#    It supports KDE4_ENABLE_FINAL
-#    If the executable doesn't have a GUI, use the option NOGUI. By default on OS X
-#    application bundles are created, with the NOGUI option no bundles but simple executables
-#    are created. Under Windows this flag is also necessary to separate between applications
-#    with GUI and without. On other UNIX systems this flag has no effect.
-#    RUN_UNINSTALLED is deprecated and is ignored, for details see the documentation for
-#    KDE4_ADD_EXECUTABLE().
-#
-#  KDE4_ADD_EXECUTABLE (name [NOGUI] [TEST] [RUN_UNINSTALLED] file1 ... fileN)
-#    Equivalent to ADD_EXECUTABLE(), but additionally adds some more features:
-#    -support for KDE4_ENABLE_FINAL
-#    -support for automoc
-#    -automatic RPATH handling
-#    If the executable doesn't have a GUI, use the option NOGUI. By default on OS X
-#    application bundles are created, with the NOGUI option no bundles but simple executables
-#    are created. Under Windows this flag is also necessary to separate between applications
-#    with GUI and without. On other UNIX systems this flag has no effect.
-#    The option TEST is for internal use only.
-#    The option RUN_UNINSTALLED is ignored. It was necessary with KDE 4.0 and 4.1
-#    if the executable had to be run from the build tree. Since KDE 4.2 all
-#    executables can be always run uninstalled (the RPATH of executables which are not
-#    yet installed points since then into the buildtree and is changed
-#    to the proper location when installing, so RUN_UNINSTALLED is not necessary anymore).
-#
-#  KDE4_ADD_LIBRARY (name [STATIC | SHARED | MODULE ] file1 ... fileN)
-#    Equivalent to ADD_LIBRARY(). Additionally it supports KDE4_ENABLE_FINAL,
-#    includes automoc-handling and sets LINK_INTERFACE_LIBRARIES target property empty.
-#    The RPATH is set according to the global RPATH settings as set up by FindKDE4Internal.cmake
-#    (CMAKE_SKIP_BUILD_RPATH=FALSE, CMAKE_BUILD_WITH_INSTALL_RPATH=FALSE, CMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE)
-#    Under Windows it adds a -DMAKE_<name>_LIB definition to the compilation.
-#
-#  KDE4_ADD_UNIT_TEST (testname [TESTNAME targetname] file1 ... fileN)
-#    add a unit test, which is executed when running make test
-#    it will be built with RPATH poiting to the build dir
-#    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 <targetname>, if it is not given
-#    the macro will default to the <testname>
-#    KDESRCDIR is set to the source directory of the test, this can be used with
-#    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.
-#
-#  KDE4_INSTALL_ICONS( path theme)
-#    Installs all png and svgz files in the current directory to the icon
-#    directoy given in path, in the subdirectory for the given icon theme.
-#
-#  KDE4_CREATE_HANDBOOK( docbookfile [INSTALL_DESTINATION installdest] [SUBDIR subdir])
-#   Create the handbook from the docbookfile (using meinproc4)
-#   The resulting handbook will be installed to <installdest> when using
-#   INSTALL_DESTINATION <installdest>, or to <installdest>/<subdir> if
-#   SUBDIR <subdir> is specified.
-#
-#  KDE4_CREATE_MANPAGE( docbookfile section )
-#   Create the manpage for the specified section from the docbookfile (using meinproc4)
-#   The resulting manpage will be installed to <installdest> when using
-#   INSTALL_DESTINATION <installdest>, or to <installdest>/<subdir> if
-#   SUBDIR <subdir> is specified.
-#
-#  KDE4_INSTALL_AUTH_ACTIONS( HELPER_ID ACTIONS_FILE )
-#   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
-#
-#  KDE4_INSTALL_AUTH_HELPER_FILES( HELPER_TARGET HELPER_ID HELPER_USER )
-#   This macro adds the needed files for an helper executable meant to be used by applications using KAuth.
-#   It accepts the helper target, the helper ID (the DBUS name) and the user under which the helper will run on.
-#   This macro takes care of generate the needed files, and install them in the right location. This boils down
-#   to a DBus policy to let the helper register on the system bus, and a service file for letting the helper
-#   being automatically activated by the system bus.
-#   *WARNING* You have to install the helper in ${LIBEXEC_INSTALL_DIR} to make sure everything will work.
-#
-#
-#
-#  A note on the possible values for CMAKE_BUILD_TYPE and how KDE handles
-#  the flags for those buildtypes. FindKDE4Internal supports the values
-#  Debug, Release, RelWithDebInfo, Profile and Debugfull:
-#
-#  Release
-#          optimised for speed, qDebug/kDebug turned off, no debug symbols, no asserts
-#  RelWithDebInfo (Release with debug info)
-#          similar to Release, optimised for speed, but with debugging symbols on (-g)
-#  Debug
-#          optimised but debuggable, debugging on (-g)
-#          (-fno-reorder-blocks -fno-schedule-insns -fno-inline)
-#  DebugFull
-#          no optimisation, full debugging on (-g3)
-#  Profile
-#          DebugFull + -ftest-coverage -fprofile-arcs
-#
-#
-#  The default buildtype is RelWithDebInfo.
-#  It is expected that the "Debug" build type be still debuggable with gdb
-#  without going all over the place, but still produce better performance.
-#  It's also important to note that gcc cannot detect all warning conditions
-#  unless the optimiser is active.
-#
-#
-#  This module allows to depend on a particular minimum version of kdelibs.
-#  To acomplish that one should use the apropriate cmake syntax for
-#  find_package. For example to depend on kdelibs >= 4.1.0 one should use
-#
-#  find_package(KDE4 4.1.0 REQUIRED)
-#
-#  In earlier versions of KDE you could use the variable KDE_MIN_VERSION to
-#  have such a dependency. This variable is deprecated with KDE 4.2.0, but
-#  will still work to make the module backwards-compatible.
-
-#  _KDE4_PLATFORM_INCLUDE_DIRS is used only internally
-#  _KDE4_PLATFORM_DEFINITIONS is used only internally
-
-# Copyright (c) 2006-2009, Alexander Neundorf <neundorf@kde.org>
-# Copyright (c) 2006, Laurent Montel, <montel@kde.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-
-# this is required now by cmake 2.6 and so must not be skipped by if(KDE4_FOUND) below
-cmake_minimum_required(VERSION 2.6.4 FATAL_ERROR)
-# set the cmake policies to the 2.4.x compatibility settings (may change for KDE 4.3)
-cmake_policy(VERSION 2.4.5)
-
-# CMake 2.6, set compatibility behaviour to cmake 2.4
-# this must be executed always, because the CMAKE_MINIMUM_REQUIRED() command above
-# resets the policy settings, so we get a lot of warnings
-
-# CMP0000: don't require cmake_minimum_version() directly in the top level CMakeLists.txt, FindKDE4Internal.cmake is good enough
-cmake_policy(SET CMP0000 OLD)
-# CMP0002: in KDE4 we have multiple targets with the same name for the unit tests
-cmake_policy(SET CMP0002 OLD)
-# CMP0003: add the link paths to the link command as with cmake 2.4
-cmake_policy(SET CMP0003 OLD)
-# CMP0005: keep escaping behaviour for definitions added via add_definitions()
-cmake_policy(SET CMP0005 OLD)
-# since cmake 2.6.3: NEW behaviour is that setting policies doesn't "escape" the file
-# where this is done, macros and functions are executed with the policies as they
-# were when the were defined. Keep the OLD behaviour so we can set the policies here
-# for all KDE software without the big warning
-cmake_policy(SET CMP0011 OLD)
-# since cmake 2.6.4
-if(POLICY CMP0017)
-  cmake_policy(SET CMP0017 NEW)
-endif(POLICY CMP0017)
-
-# Only do something if it hasn't been found yet
-if(NOT KDE4_FOUND)
-
-# get the directory of the current file, used later on in the file
-get_filename_component( kde_cmake_module_dir  ${CMAKE_CURRENT_LIST_FILE} PATH)
-
-
-include (MacroEnsureVersion)
-
-# We may only search for other packages with "REQUIRED" if we are required ourselves.
-# This file can be processed either (usually) included in FindKDE4.cmake or
-# (when building kdelibs) directly via FIND_PACKAGE(KDE4Internal), that's why
-# we have to check for both KDE4_FIND_REQUIRED and KDE4Internal_FIND_REQUIRED.
-if(KDE4_FIND_REQUIRED  OR  KDE4Internal_FIND_REQUIRED)
-  set(_REQ_STRING_KDE4 "REQUIRED")
-  set(_REQ_STRING_KDE4_MESSAGE "FATAL_ERROR")
-else(KDE4_FIND_REQUIRED  OR  KDE4Internal_FIND_REQUIRED)
-  set(_REQ_STRING_KDE4 )
-  set(_REQ_STRING_KDE4_MESSAGE "STATUS")
-endif(KDE4_FIND_REQUIRED  OR  KDE4Internal_FIND_REQUIRED)
-
-
-# Store CMAKE_MODULE_PATH and then append the current dir to it, so we are sure
-# we get the FindQt4.cmake located next to us and not a different one.
-# The original CMAKE_MODULE_PATH is restored later on.
-set(_kde_cmake_module_path_back ${CMAKE_MODULE_PATH})
-set(CMAKE_MODULE_PATH ${kde_cmake_module_dir} ${CMAKE_MODULE_PATH} )
-
-# if the minimum Qt requirement is changed, change all occurrence in the
-# following lines
-if( NOT QT_MIN_VERSION )
-  set(QT_MIN_VERSION "4.5.0")
-endif( NOT QT_MIN_VERSION )
-if( ${QT_MIN_VERSION} VERSION_LESS "4.5.0" )
-  set(QT_MIN_VERSION "4.5.0")
-endif( ${QT_MIN_VERSION} VERSION_LESS "4.5.0" )
-
-# Tell FindQt4.cmake to point the QT_QTFOO_LIBRARY targets at the imported targets
-# for the Qt libraries, so we get full handling of release and debug versions of the
-# Qt libs and are flexible regarding the install location of Qt under Windows:
-set(QT_USE_IMPORTED_TARGETS TRUE)
-
-#this line includes FindQt4.cmake, which searches the Qt library and headers
-# TODO: we should check here that all necessary modules of Qt have been found, e.g. QtDBus
-find_package(Qt4 ${_REQ_STRING_KDE4})
-
-# automoc4 (from kdesupport) is now required, Alex
-find_package(Automoc4 ${_REQ_STRING_KDE4})
-
-# cmake 2.6.0 and automoc4 < 0.9.84 don't work right for -D flags
-if (NOT AUTOMOC4_VERSION)
-   # the version macro was added for 0.9.84
-   set(AUTOMOC4_VERSION "0.9.83")
-endif (NOT AUTOMOC4_VERSION)
-set(_automoc4_min_version "0.9.88")
-macro_ensure_version("${_automoc4_min_version}" "${AUTOMOC4_VERSION}" _automoc4_version_ok)
-
-# for compatibility with KDE 4.0.x
-set(KDE4_AUTOMOC_EXECUTABLE        "${AUTOMOC4_EXECUTABLE}" )
-
-# Perl is not required for building KDE software, but we had that here since 4.0
-find_package(Perl)
-if(NOT PERL_FOUND)
-   message(STATUS "Perl not found")
-endif(NOT PERL_FOUND)
-
-# restore the original CMAKE_MODULE_PATH
-set(CMAKE_MODULE_PATH ${_kde_cmake_module_path_back})
-
-# we check for Phonon not here, but further below, i.e. after KDELibsDependencies.cmake
-# has been loaded, which helps in the case that phonon is installed to the same
-# directory as kdelibs.
-# find_package(Phonon ${_REQ_STRING_KDE4})
-
-
-# Check that we really found everything.
-# If KDE4 was searched with REQUIRED, we error out with FATAL_ERROR if something wasn't found
-# already above in the other FIND_PACKAGE() calls.
-# If KDE4 was searched without REQUIRED and something in the FIND_PACKAGE() calls above wasn't found,
-# then we get here and must check that everything has actually been found. If something is missing,
-# we must not fail with FATAL_ERROR, but only not set KDE4_FOUND.
-
-if(NOT QT4_FOUND)
-   message(STATUS "KDE4 not found, because Qt4 was not found")
-   return()
-endif(NOT QT4_FOUND)
-
-if(NOT AUTOMOC4_FOUND OR NOT _automoc4_version_ok)
-   if(NOT AUTOMOC4_FOUND)
-      message(${_REQ_STRING_KDE4_MESSAGE} "KDE4 not found, because Automoc4 not found.")
-      return()
-   else(NOT AUTOMOC4_FOUND)
-      if(NOT _automoc4_version_ok)
-         message(${_REQ_STRING_KDE4_MESSAGE} "Your version of automoc4 is too old. You have ${AUTOMOC4_VERSION}, you need at least ${_automoc4_min_version}")
-         return()
-      endif(NOT _automoc4_version_ok)
-   endif(NOT AUTOMOC4_FOUND)
-endif(NOT AUTOMOC4_FOUND OR NOT _automoc4_version_ok)
-
-
-# now we are sure we have everything we need
-
-include (MacroLibrary)
-include (CheckCXXCompilerFlag)
-include (CheckCXXSourceCompiles)
-
-
-# are we trying to compile kdelibs ? kdelibs_SOURCE_DIR comes from "project(kdelibs)" in kdelibs/CMakeLists.txt
-# then enter bootstrap mode
-
-if(kdelibs_SOURCE_DIR)
-   set(_kdeBootStrapping TRUE)
-   message(STATUS "Building kdelibs...")
-else(kdelibs_SOURCE_DIR)
-   set(_kdeBootStrapping FALSE)
-endif(kdelibs_SOURCE_DIR)
-
-
-# helper macro, sets both the KDE4_FOO_LIBRARY and KDE4_FOO_LIBS variables to KDE4__foo
-# It is used both in bootstrapping and in normal mode.
-macro(_KDE4_SET_LIB_VARIABLES _var _lib _prefix)
-   set(KDE4_${_var}_LIBRARY ${_prefix}${_lib} )
-   set(KDE4_${_var}_LIBS    ${_prefix}${_lib} )
-endmacro(_KDE4_SET_LIB_VARIABLES _var _lib _prefix)
-
-#######################  #now try to find some kde stuff  ################################
-
-if (_kdeBootStrapping)
-   set(KDE4_INCLUDE_DIR ${kdelibs_SOURCE_DIR})
-
-   set(EXECUTABLE_OUTPUT_PATH ${kdelibs_BINARY_DIR}/bin )
-
-   if (WIN32)
-      set(LIBRARY_OUTPUT_PATH               ${EXECUTABLE_OUTPUT_PATH} )
-      # CMAKE_CFG_INTDIR is the output subdirectory created e.g. by XCode and MSVC
-      if (NOT WINCE)
-        set(KDE4_KCFGC_EXECUTABLE             ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler )
-        set(KDE4_MEINPROC_EXECUTABLE          ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/meinproc4 )
-      else (NOT WINCE)
-        set(KDE4_KCFGC_EXECUTABLE             ${HOST_BINDIR}/${CMAKE_CFG_INTDIR}/kconfig_compiler )
-        set(KDE4_MEINPROC_EXECUTABLE          ${HOST_BINDIR}/${CMAKE_CFG_INTDIR}/meinproc4 )
-      endif(NOT WINCE)
-
-      set(KDE4_MEINPROC_EXECUTABLE          ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/meinproc4 )
-      set(KDE4_KAUTH_POLICY_GEN_EXECUTABLE  ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kauth-policy-gen )
-      set(KDE4_MAKEKDEWIDGETS_EXECUTABLE    ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets )
-   else (WIN32)
-      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_KAUTH_POLICY_GEN_EXECUTABLE  ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kauth-policy-gen${CMAKE_EXECUTABLE_SUFFIX}.shell )
-      set(KDE4_MEINPROC_EXECUTABLE          ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/meinproc4${CMAKE_EXECUTABLE_SUFFIX}.shell )
-      set(KDE4_MAKEKDEWIDGETS_EXECUTABLE    ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets${CMAKE_EXECUTABLE_SUFFIX}.shell )
-   endif (WIN32)
-
-   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_KAUTH_POLICY_GEN_EXECUTABLE_DEP kauth-policy-gen)
-   set( _KDE4_MAKEKDEWIDGETS_DEP makekdewidgets)
-   set( _KDE4_MEINPROC_EXECUTABLE_DEP meinproc4)
-
-   set(KDE4_INSTALLED_VERSION_OK TRUE)
-
-else (_kdeBootStrapping)
-
-  # ... but NOT otherwise
-   set( _KDE4_KCONFIG_COMPILER_DEP)
-   set( _KDE4_MAKEKDEWIDGETS_DEP)
-   set( _KDE4_MEINPROC_EXECUTABLE_DEP)
-   set( _KDE4_KAUTH_POLICY_GEN_EXECUTABLE_DEP)
-
-   set(LIBRARY_OUTPUT_PATH  ${CMAKE_BINARY_DIR}/lib )
-
-   if (WIN32)
-      # we don't want to be forced to set two paths into the build tree
-      set(LIBRARY_OUTPUT_PATH  ${CMAKE_BINARY_DIR}/bin )
-
-      # on win32 the install dir is determined on runtime not install time
-      # KDELIBS_INSTALL_DIR and QT_INSTALL_DIR are used in KDELibsDependencies.cmake to setup
-      # kde install paths and library dependencies
-      get_filename_component(_DIR ${KDE4_KDECONFIG_EXECUTABLE} PATH )
-      get_filename_component(KDE4_INSTALL_DIR ${_DIR} PATH )
-      get_filename_component(_DIR ${QT_QMAKE_EXECUTABLE} PATH )
-      get_filename_component(QT_INSTALL_DIR ${_DIR} PATH )
-   endif (WIN32)
-
-   # These files contain information about the installed kdelibs, Alex
-   include(${kde_cmake_module_dir}/KDELibsDependencies.cmake)
-   include(${kde_cmake_module_dir}/KDEPlatformProfile.cmake)
-
-   # Check the version of KDE. It must be at least KDE_MIN_VERSION as set by the user.
-   # KDE_VERSION is set in KDELibsDependencies.cmake since KDE 4.0.x. Alex
-   # Support for the new-style (>= 2.6.0) support for requiring some version of a package:
-   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)
-         set(KDE_MIN_VERSION "4.0.0")
-      endif (KDE4_FIND_VERSION_MAJOR)
-   endif (NOT KDE_MIN_VERSION)
-
-   #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 )
-
-
-   # KDE4_LIB_INSTALL_DIR and KDE4_INCLUDE_INSTALL_DIR are set in KDELibsDependencies.cmake,
-   # use them to set the KDE4_LIB_DIR and KDE4_INCLUDE_DIR "public interface" variables
-   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)
-
-   # Now include the file with the imported tools (executable targets).
-   # This export-file is generated and installed by the toplevel CMakeLists.txt of kdelibs.
-   # Having the libs and tools in two separate files should help with cross compiling.
-   include(${kde_cmake_module_dir}/KDELibs4ToolsTargets.cmake)
-
-   # get the build CONFIGURATIONS which were exported in this file, and use just the first
-   # of them to get the location of the installed executables
-   get_target_property(_importedConfigurations  ${KDE4_TARGET_PREFIX}kconfig_compiler IMPORTED_CONFIGURATIONS )
-   list(GET _importedConfigurations 0 _firstConfig)
-
-   if(NOT WINCE)
-   get_target_property(KDE4_KCFGC_EXECUTABLE             ${KDE4_TARGET_PREFIX}kconfig_compiler    LOCATION_${_firstConfig})
-   get_target_property(KDE4_MEINPROC_EXECUTABLE          ${KDE4_TARGET_PREFIX}meinproc4           LOCATION_${_firstConfig})
-   else(NOT WINCE)
-    set(KDE4_KCFGC_EXECUTABLE             ${HOST_BINDIR}/${CMAKE_CFG_INTDIR}/kconfig_compiler )
-    set(KDE4_MEINPROC_EXECUTABLE          ${HOST_BINDIR}/${CMAKE_CFG_INTDIR}/meinproc4 )
-   endif(NOT WINCE)
-   get_target_property(KDE4_KAUTH_POLICY_GEN_EXECUTABLE  ${KDE4_TARGET_PREFIX}kauth-policy-gen    LOCATION_${_firstConfig})
-   get_target_property(KDE4_MAKEKDEWIDGETS_EXECUTABLE    ${KDE4_TARGET_PREFIX}makekdewidgets      LOCATION_${_firstConfig})
-
-   # allow searching cmake modules in all given kde install locations (KDEDIRS based)
-   execute_process(COMMAND "${KDE4_KDECONFIG_EXECUTABLE}" --path data OUTPUT_VARIABLE _data_DIR ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-   file(TO_CMAKE_PATH "${_data_DIR}" _data_DIR)
-   foreach(dir ${_data_DIR})
-      set (apath "${dir}/cmake/modules")
-      if (EXISTS "${apath}")
-         set (included 0)
-         string(TOLOWER "${apath}" _apath)
-         # ignore already added pathes, case insensitive
-         foreach(adir ${CMAKE_MODULE_PATH})
-            string(TOLOWER "${adir}" _adir)
-            if ("${_adir}" STREQUAL "${_apath}")
-               set (included 1)
-            endif ("${_adir}" STREQUAL "${_apath}")
-         endforeach(adir)
-         if (NOT included)
-            message(STATUS "Adding ${apath} to CMAKE_MODULE_PATH")
-            set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${apath}")
-         endif (NOT included)
-      endif (EXISTS "${apath}")
-   endforeach(dir)
-
-
-   # This file contains the exported library target from kdelibs (new with cmake 2.6.x), e.g.
-   # the library target "kdeui" is exported as "KDE4__kdeui". The "KDE4__" is used as
-   # "namespace" to separate the imported targets from "normal" targets, it is stored in
-   # KDE4_TARGET_PREFIX, which is set in KDELibsDependencies.cmake .
-   # This export-file is generated and installed by the toplevel CMakeLists.txt of kdelibs.
-   # Include it to "import" the libraries from kdelibs into the current projects as targets.
-   # This makes setting the _LIBRARY and _LIBS variables actually a bit superfluos, since e.g.
-   # the kdeui library could now also be used just as "KDE4__kdeui" and still have all their
-   # dependent libraries handled correctly. But to keep compatibility and not to change
-   # behaviour we set all these variables anyway as seen below. Alex
-   include(${kde_cmake_module_dir}/KDELibs4LibraryTargets.cmake)
-
-   # This one is for compatibility only:
-   set(KDE4_THREADWEAVER_LIBRARIES ${KDE4_TARGET_PREFIX}threadweaver )
-
-endif (_kdeBootStrapping)
-
-
-# Set the various KDE4_FOO_LIBRARY/LIBS variables.
-# In bootstrapping mode KDE4_TARGET_PREFIX is empty, so e.g. KDE4_KDECORE_LIBRARY
-# will be simply set to "kdecore".
-
-# Sorted by names:
-_kde4_set_lib_variables(KCMUTILS      kcmutils      "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KDE3SUPPORT   kde3support   "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KDECORE       kdecore       "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KDEUI         kdeui         "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KDEWEBKIT     kdewebkit     "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KDNSSD        kdnssd        "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KEMOTICONS    kemoticons    "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KFILE         kfile         "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KHTML         khtml         "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KIDLETIME     kidletime     "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KIO           kio           "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KJS           kjs           "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KJSAPI        kjsapi        "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KNEWSTUFF2    knewstuff2    "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KNEWSTUFF3    knewstuff3    "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KNOTIFYCONFIG knotifyconfig "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KPARTS        kparts        "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KPRINTUTILS   kprintutils   "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KROSSCORE     krosscore     "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KROSSUI       krossui       "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KTEXTEDITOR   ktexteditor   "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KUNITCONVERSION kunitconversion "${KDE4_TARGET_PREFIX}")
-_kde4_set_lib_variables(KUTILS        kutils        "${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)
-
-# The nepomuk target does not always exist, since is is built conditionally. When bootstrapping
-# we set it always anyways.
-if(_kdeBootStrapping  OR  TARGET ${KDE4_TARGET_PREFIX}nepomuk)
-   _kde4_set_lib_variables(NEPOMUK nepomuk "${KDE4_TARGET_PREFIX}")
-endif(_kdeBootStrapping  OR  TARGET ${KDE4_TARGET_PREFIX}nepomuk)
-
-
-################### try to find Phonon ############################################
-
-# we do this here instead of above together with the checks for Perl etc.
-# since FindPhonon.cmake also uses ${KDE4_LIB_INSTALL_DIR} to check for Phonon,
-# which helps with finding the phonon installed as part of kdesupport:
-
-# only make Phonon REQUIRED if KDE4 itself is REQUIRED
-find_package(Phonon 4.3.80 ${_REQ_STRING_KDE4})
-set(KDE4_PHONON_LIBRARY ${PHONON_LIBRARY})
-set(KDE4_PHONON_LIBS ${PHONON_LIBS})
-set(KDE4_PHONON_INCLUDES ${PHONON_INCLUDES})
-
-if(NOT PHONON_FOUND)
-   message(STATUS "KDE4 not found, because Phonon was not found")
-   return()
-endif(NOT PHONON_FOUND)
-
-
-#####################  provide some options   ##########################################
-
-option(KDE4_ENABLE_FINAL "Enable final all-in-one compilation")
-option(KDE4_BUILD_TESTS  "Build the tests")
-option(KDE4_ENABLE_HTMLHANDBOOK  "Create targets htmlhandbook for creating the html versions of the docbook docs")
-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
-# whether to install a CMake FooConfig.cmake into lib/foo/cmake/ or /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 "Prefer to install the <package>Config.cmake files to lib/cmake/<package> instead to lib/<package>/cmake" TRUE)
-else(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} VERSION_GREATER 2.6.2)
-   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.
-# Programs compiled with these features appear as ?shared object? with the file command.
-# info from "http://www.linuxfromscratch.org/hlfs/view/unstable/glibc/chapter02/pie.html"
-option(KDE4_ENABLE_FPIE  "Enable platform supports PIE linking")
-
-if (WIN32)
-   find_package(KDEWin REQUIRED)
-   option(KDE4_ENABLE_UAC_MANIFEST "add manifest to make vista uac happy" OFF)
-   if (KDE4_ENABLE_UAC_MANIFEST)
-      find_program(KDE4_MT_EXECUTABLE mt
-         PATHS ${KDEWIN_INCLUDE_DIR}/../bin
-         NO_DEFAULT_PATH
-      )
-      if (KDE4_MT_EXECUTABLE)
-         message(STATUS "Found KDE manifest tool at ${KDE4_MT_EXECUTABLE} ")
-      else (KDE4_MT_EXECUTABLE)
-         message(STATUS "KDE manifest tool not found, manifest generating for Windows Vista disabled")
-         set (KDE4_ENABLE_UAC_MANIFEST OFF)
-      endif (KDE4_MT_EXECUTABLE)
-   endif (KDE4_ENABLE_UAC_MANIFEST)
-endif (WIN32)
-
-#####################  some more settings   ##########################################
-
-if( KDE4_ENABLE_FINAL)
-   add_definitions(-DKDE_USE_FINAL)
-endif(KDE4_ENABLE_FINAL)
-
-if(KDE4_SERIALIZE_TOOL)
-   # parallel build with many meinproc invocations can consume a huge amount of memory
-   set(KDE4_MEINPROC_EXECUTABLE ${KDE4_SERIALIZE_TOOL} ${KDE4_MEINPROC_EXECUTABLE})
-endif(KDE4_SERIALIZE_TOOL)
-
-# If we are building ! kdelibs, check where kdelibs are installed.
-# If they are installed in a directory which contains "lib64", we default to "64" for LIB_SUFFIX,
-# so the current project will by default also go into lib64.
-# The same for lib32. Alex
-set(_Init_LIB_SUFFIX "")
-if ("${KDE4_LIB_DIR}" MATCHES lib64)
-   set(_Init_LIB_SUFFIX 64)
-endif ("${KDE4_LIB_DIR}" MATCHES lib64)
-if ("${KDE4_LIB_DIR}" MATCHES lib32)
-   set(_Init_LIB_SUFFIX 32)
-endif ("${KDE4_LIB_DIR}" MATCHES lib32)
-
-set(LIB_SUFFIX "${_Init_LIB_SUFFIX}" CACHE STRING "Define suffix of directory name (32/64)" )
-
-
-########## the following are directories where stuff will be installed to  ###########
-#
-# this has to be after find_xxx() block above, since there KDELibsDependencies.cmake is included
-# which contains the install dirs from kdelibs, which are reused below
-
-if (WIN32)
-# use relative install prefix to avoid hardcoded install paths in cmake_install.cmake files
-
-   set(LIB_INSTALL_DIR      "lib${LIB_SUFFIX}" )            # The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})
-
-   set(EXEC_INSTALL_PREFIX  "" )        # Base directory for executables and libraries
-   set(SHARE_INSTALL_PREFIX "share" )   # Base directory for files which go to share/
-   set(BIN_INSTALL_DIR      "bin"   )   # The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)
-   set(SBIN_INSTALL_DIR     "sbin"  )   # The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)
-
-   set(LIBEXEC_INSTALL_DIR  "${BIN_INSTALL_DIR}"          ) # The subdirectory relative to the install prefix where libraries will be installed (default is ${BIN_INSTALL_DIR})
-   set(INCLUDE_INSTALL_DIR  "include"                     ) # The subdirectory to the header prefix
-
-   set(PLUGIN_INSTALL_DIR       "lib${LIB_SUFFIX}/kde4"   ) #                "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4)
-   set(IMPORTS_INSTALL_DIR       "${PLUGIN_INSTALL_DIR}/imports"   ) # "The subdirectory relative to the install prefix where imports will be installed
-   set(CONFIG_INSTALL_DIR       "share/config"            ) # The config file install dir
-   set(DATA_INSTALL_DIR         "share/apps"              ) # The parent directory where applications can install their data
-   set(HTML_INSTALL_DIR         "share/doc/HTML"          ) # The HTML install dir for documentation
-   set(ICON_INSTALL_DIR         "share/icons"             ) # The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)
-   set(KCFG_INSTALL_DIR         "share/config.kcfg"       ) # The install dir for kconfig files
-   set(LOCALE_INSTALL_DIR       "share/locale"            ) # The install dir for translations
-   set(MIME_INSTALL_DIR         "share/mimelnk"           ) # The install dir for the mimetype desktop files
-   set(SERVICES_INSTALL_DIR     "share/kde4/services"     ) # The install dir for service (desktop, protocol, ...) files
-   set(SERVICETYPES_INSTALL_DIR "share/kde4/servicetypes" ) # The install dir for servicestypes desktop files
-   set(SOUND_INSTALL_DIR        "share/sounds"            ) # The install dir for sound files
-   set(TEMPLATES_INSTALL_DIR    "share/templates"         ) # The install dir for templates (Create new file...)
-   set(WALLPAPER_INSTALL_DIR    "share/wallpapers"        ) # The install dir for wallpapers
-   set(DEMO_INSTALL_DIR         "share/demos"             ) # The install dir for demos
-   set(KCONF_UPDATE_INSTALL_DIR "share/apps/kconf_update" ) # The kconf_update install dir
-   set(AUTOSTART_INSTALL_DIR    "share/autostart"         ) # The install dir for autostart files
-
-   set(XDG_APPS_INSTALL_DIR      "share/applications/kde4"   ) # The XDG apps dir
-   set(XDG_DIRECTORY_INSTALL_DIR "share/desktop-directories" ) # The XDG directory
-   set(XDG_MIME_INSTALL_DIR      "share/mime/packages"       ) # The install dir for the xdg mimetypes
-
-   set(SYSCONF_INSTALL_DIR       "etc"                       ) # The sysconfig install dir (default /etc)
-   set(MAN_INSTALL_DIR           "share/man"                 ) # The man install dir (default ${SHARE_INSTALL_PREFIX}/man/)
-   set(INFO_INSTALL_DIR          "share/info"                ) # The info install dir (default ${SHARE_INSTALL_PREFIX}/info)")
-   set(DBUS_INTERFACES_INSTALL_DIR "share/dbus-1/interfaces" ) # The dbus interfaces install dir (default  ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)")
-   set(DBUS_SERVICES_INSTALL_DIR "share/dbus-1/services"     ) # The dbus services install dir (default  ${SHARE_INSTALL_PREFIX}/dbus-1/services)")
-   set(DBUS_SYSTEM_SERVICES_INSTALL_DIR "share/dbus-1/system-services"     ) # The dbus system services install dir (default  ${SHARE_INSTALL_PREFIX}/dbus-1/system-services)")
-
-else (WIN32)
-
-   # This macro implements some very special logic how to deal with the cache.
-   # By default the various install locations inherit their value from their "parent" variable
-   # so if you set CMAKE_INSTALL_PREFIX, then EXEC_INSTALL_PREFIX, PLUGIN_INSTALL_DIR will
-   # 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 explicitely 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(${_var} ${predefinedvalue})
-      else (NOT DEFINED ${_var})
-         set(${_var} "${${_var}}" CACHE PATH "${_comment}")
-      endif (NOT DEFINED ${_var})
-   endmacro(_SET_FANCY)
-
-   if(APPLE)
-      set(BUNDLE_INSTALL_DIR "/Applications/KDE4" CACHE PATH "Directory where application bundles will be installed to on OSX" )
-   endif(APPLE)
-
-   _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(HTML_INSTALL_DIR         "${SHARE_INSTALL_PREFIX}/doc/HTML"       "The HTML install dir for documentation")
-   _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)")
-
-endif (WIN32)
-
-
-# For more documentation see above.
-# Later on it will be possible to extend this for installing OSX frameworks
-# The COMPONENT Devel argument has the effect that static libraries belong to the
-# "Devel" install component. If we use this also for all install() commands
-# for header files, it will be possible to install
-#   -everything: make install OR cmake -P cmake_install.cmake
-#   -only the development files: cmake -DCOMPONENT=Devel -P cmake_install.cmake
-#   -everything except the development files: cmake -DCOMPONENT=Unspecified -P cmake_install.cmake
-# This can then also be used for packaging with cpack.
-set(INSTALL_TARGETS_DEFAULT_ARGS  RUNTIME DESTINATION "${BIN_INSTALL_DIR}"
-                                  LIBRARY DESTINATION "${LIB_INSTALL_DIR}"
-                                  ARCHIVE DESTINATION "${LIB_INSTALL_DIR}" COMPONENT Devel )
-
-
-# on the Mac support an extra install directory for application bundles starting with cmake 2.6
-if(APPLE)
-   set(INSTALL_TARGETS_DEFAULT_ARGS  ${INSTALL_TARGETS_DEFAULT_ARGS}
-                               BUNDLE DESTINATION "${BUNDLE_INSTALL_DIR}" )
-endif(APPLE)
-
-
-##############  add some more default search paths  ###############
-#
-# the KDE4_xxx_INSTALL_DIR variables are empty when building kdelibs itself
-# and otherwise point to the kde4 install dirs
-
-set(CMAKE_SYSTEM_INCLUDE_PATH ${CMAKE_SYSTEM_INCLUDE_PATH}
-                              "${KDE4_INCLUDE_INSTALL_DIR}")
-
-set(CMAKE_SYSTEM_PROGRAM_PATH ${CMAKE_SYSTEM_PROGRAM_PATH}
-                              "${KDE4_BIN_INSTALL_DIR}" )
-
-set(CMAKE_SYSTEM_LIBRARY_PATH ${CMAKE_SYSTEM_LIBRARY_PATH}
-                              "${KDE4_LIB_INSTALL_DIR}" )
-
-# under Windows dlls may be also installed in bin/
-if(WIN32)
-  set(CMAKE_SYSTEM_LIBRARY_PATH ${CMAKE_SYSTEM_LIBRARY_PATH}
-                                "${_CMAKE_INSTALL_DIR}/bin"
-                                "${CMAKE_INSTALL_PREFIX}/bin" )
-endif(WIN32)
-
-
-######################################################
-#  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)
-
-   if(CYGWIN)
-      message(FATAL_ERROR "Cygwin is NOT supported, use mingw or MSVC to build KDE4.")
-   endif(CYGWIN)
-
-   # limit win32 packaging to kdelibs at now
-   # don't know if package name, version and notes are always available
-   if(_kdeBootStrapping)
-      find_package(KDEWIN_Packager)
-      if (KDEWIN_PACKAGER_FOUND)
-         kdewin_packager("kdelibs" "${KDE_VERSION}" "KDE base library" "")
-      endif (KDEWIN_PACKAGER_FOUND)
-
-      include(Win32Macros)
-      addExplorerWrapper("kdelibs")
-   endif(_kdeBootStrapping)
-
-   set( _KDE4_PLATFORM_INCLUDE_DIRS ${KDEWIN_INCLUDES})
-
-   # if we are compiling kdelibs, add KDEWIN_LIBRARIES explicitely,
-   # otherwise they come from KDELibsDependencies.cmake, Alex
-   if (_kdeBootStrapping)
-      set( KDE4_KDECORE_LIBS ${KDE4_KDECORE_LIBS} ${KDEWIN_LIBRARIES} )
-   endif (_kdeBootStrapping)
-
-   # we prefer to use a different postfix for debug libs only on Windows
-   # does not work atm
-   set(CMAKE_DEBUG_POSTFIX "")
-
-   # windows, microsoft compiler
-   if(MSVC)
-      set( _KDE4_PLATFORM_DEFINITIONS -DKDE_FULL_TEMPLATE_EXPORT_INSTANTIATION -DWIN32_LEAN_AND_MEAN )
-
-      # C4250: 'class1' : inherits 'class2::member' via dominance
-      set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4250" )
-      # C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
-      set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4251" )
-      # C4396: 'identifier' : 'function' the inline specifier cannot be used when a friend declaration refers to a specialization of a function template
-      set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4396" )
-      # to avoid a lot of deprecated warnings
-      add_definitions( -D_CRT_SECURE_NO_DEPRECATE
-                       -D_CRT_SECURE_NO_WARNINGS
-                       -D_CRT_NONSTDC_NO_DEPRECATE
-                       -D_SCL_SECURE_NO_WARNINGS
-                       )
-      # 'identifier' : no suitable definition provided for explicit template instantiation request
-      set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4661" )
-   endif(MSVC)
-
-
-   # for visual studio IDE set the path correctly for custom commands
-   # maybe under windows bat-files should be generated for running apps during the build
-   if(MSVC_IDE)
-     get_filename_component(PERL_LOCATION "${PERL_EXECUTABLE}" PATH)
-     file(TO_NATIVE_PATH "${PERL_LOCATION}" PERL_PATH_WINDOWS)
-     file(TO_NATIVE_PATH "${QT_BINARY_DIR}" QT_BIN_DIR_WINDOWS)
-     set(CMAKE_MSVCIDE_RUN_PATH "${PERL_PATH_WINDOWS}\;${QT_BIN_DIR_WINDOWS}"
-       CACHE STATIC "MSVC IDE Run path" FORCE)
-   endif(MSVC_IDE)
-
-   # we don't support anything below w2k and all winapi calls are unicodes
-   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_WIN32_WINNT=0x0501 -DWINVER=0x0501 -D_WIN32_IE=0x0501 -DUNICODE" )
-endif (WIN32)
-
-
-# setup default RPATH/install_name handling, may be overridden by KDE4_HANDLE_RPATH_FOR_EXECUTABLE
-# It sets up to build with full 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
-   if (APPLE)
-      set(CMAKE_INSTALL_NAME_DIR ${LIB_INSTALL_DIR})
-   else (APPLE)
-      # 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_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured out by cmake when compiling
-
-      list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemLibDir)
-      if("${_isSystemLibDir}" STREQUAL "-1")
-         set(CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}")
-      endif("${_isSystemLibDir}" STREQUAL "-1")
-
-      set(CMAKE_SKIP_BUILD_RPATH FALSE)
-      set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
-      set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-   endif (APPLE)
-endif (UNIX)
-
-
-if (Q_WS_X11)
-   # Done by FindQt4.cmake already
-   #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)
-
-
-# This will need to be modified later to support either Qt/X11 or Qt/Mac builds
-if (APPLE)
-
-  set ( _KDE4_PLATFORM_DEFINITIONS -D__APPLE_KDE__ )
-
-  # we need to set MACOSX_DEPLOYMENT_TARGET to (I believe) at least 10.2 or maybe 10.3 to allow
-  # -undefined dynamic_lookup; in the future we should do this programmatically
-  # hmm... why doesn't this work?
-  set (ENV{MACOSX_DEPLOYMENT_TARGET} 10.3)
-
-  # "-undefined dynamic_lookup" means we don't care about missing symbols at link-time by default
-  # this is bad, but unavoidable until there is the equivalent of libtool -no-undefined implemented
-  # or perhaps it already is, and I just don't know where to look  ;)
-
-  set (CMAKE_SHARED_LINKER_FLAGS "-single_module -multiply_defined suppress ${CMAKE_SHARED_LINKER_FLAGS}")
-  set (CMAKE_MODULE_LINKER_FLAGS "-multiply_defined suppress ${CMAKE_MODULE_LINKER_FLAGS}")
-  #set(CMAKE_SHARED_LINKER_FLAGS "-single_module -undefined dynamic_lookup -multiply_defined suppress")
-  #set(CMAKE_MODULE_LINKER_FLAGS "-undefined dynamic_lookup -multiply_defined suppress")
-
-  # we profile...
-  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)
-
-  # removed -Os, was there a special reason for using -Os instead of -O2 ?, Alex
-  # optimization flags are set below for the various build types
-  set (CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} -fno-common")
-  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-common")
-endif (APPLE)
-
-
-if (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
-   if (CMAKE_COMPILER_IS_GNUCXX)
-      set ( _KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -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}")
-
-      set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_SHARED_LINKER_FLAGS}")
-      set ( CMAKE_MODULE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_MODULE_LINKER_FLAGS}")
-      set ( CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_EXE_LINKER_FLAGS}")
-
-      # we profile...
-      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 (CMAKE_COMPILER_IS_GNUCXX)
-   if (CMAKE_C_COMPILER MATCHES "icc")
-      set ( _KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -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 (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
-
-if (UNIX)
-   set ( _KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_LARGEFILE64_SOURCE")
-
-   check_cxx_source_compiles("
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
-
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1];
-  int main() { return 0; }
-" _OFFT_IS_64BIT)
-
-   if (NOT _OFFT_IS_64BIT)
-     set ( _KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_FILE_OFFSET_BITS=64")
-   endif (NOT _OFFT_IS_64BIT)
-endif (UNIX)
-
-if (CMAKE_SYSTEM_NAME MATCHES BSD)
-   set ( _KDE4_PLATFORM_DEFINITIONS -D_GNU_SOURCE )
-   set ( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lc")
-   set ( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -lc")
-endif (CMAKE_SYSTEM_NAME MATCHES BSD)
-
-
-############################################################
-# compiler specific settings
-############################################################
-
-
-# this macro is for internal use only.
-macro(KDE_CHECK_FLAG_EXISTS FLAG VAR DOC)
-   if(NOT ${VAR} MATCHES "${FLAG}")
-      set(${VAR} "${${VAR}} ${FLAG}" CACHE STRING "Flags used by the linker during ${DOC} builds." FORCE)
-   endif(NOT ${VAR} MATCHES "${FLAG}")
-endmacro(KDE_CHECK_FLAG_EXISTS FLAG VAR)
-
-if (MSVC)
-   set (KDE4_ENABLE_EXCEPTIONS -EHsc)
-
-   # Qt disables the native wchar_t type, do it too to avoid linking issues
-   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Zc:wchar_t-" )
-
-   # make sure that no header adds libcmt by default using #pragma comment(lib, "libcmt.lib") as done by mfc/afx.h
-   kde_check_flag_exists("/NODEFAULTLIB:libcmt /DEFAULTLIB:msvcrt" CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "Release with Debug Info")
-   kde_check_flag_exists("/NODEFAULTLIB:libcmt /DEFAULTLIB:msvcrt" CMAKE_EXE_LINKER_FLAGS_RELEASE "release")
-   kde_check_flag_exists("/NODEFAULTLIB:libcmt /DEFAULTLIB:msvcrt" CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "release minsize")
-   kde_check_flag_exists("/NODEFAULTLIB:libcmtd /DEFAULTLIB:msvcrtd" CMAKE_EXE_LINKER_FLAGS_DEBUG "debug")
-endif(MSVC)
-
-# This macro is for internal use only
-# Return the directories present in gcc's include path.
-macro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _result)
-  set(${_result})
-  set(_gccOutput)
-  file(WRITE "${CMAKE_BINARY_DIR}/CMakeFiles/dummy" "\n" )
-  execute_process(COMMAND ${CMAKE_C_COMPILER} -v -E -x ${_lang} -dD dummy
-                  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles
-                  ERROR_VARIABLE _gccOutput
-                  OUTPUT_VARIABLE _gccStdout )
-  file(REMOVE "${CMAKE_BINARY_DIR}/CMakeFiles/dummy")
-
-  if( "${_gccOutput}" MATCHES "> search starts here[^\n]+\n *(.+) *\n *End of (search) list" )
-    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" )
-ENDMACRO(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang)
-
-if (CMAKE_COMPILER_IS_GNUCC)
-   _DETERMINE_GCC_SYSTEM_INCLUDE_DIRS(c _dirs)
-   set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES
-       ${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES} ${_dirs})
-endif (CMAKE_COMPILER_IS_GNUCC)
-
-if (CMAKE_COMPILER_IS_GNUCXX)
-   _DETERMINE_GCC_SYSTEM_INCLUDE_DIRS(c++ _dirs)
-   set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES
-       ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES} ${_dirs})
-
-   set (KDE4_ENABLE_EXCEPTIONS "-fexceptions -UQT_NO_EXCEPTIONS")
-   # Select flags.
-   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG -DQT_NO_DEBUG")
-   set(CMAKE_CXX_FLAGS_RELEASE        "-O2 -DNDEBUG -DQT_NO_DEBUG")
-   set(CMAKE_CXX_FLAGS_DEBUG          "-g -O2 -fno-reorder-blocks -fno-schedule-insns -fno-inline")
-   set(CMAKE_CXX_FLAGS_DEBUGFULL      "-g3 -fno-inline")
-   set(CMAKE_CXX_FLAGS_PROFILE        "-g3 -fno-inline -ftest-coverage -fprofile-arcs")
-   set(CMAKE_C_FLAGS_RELWITHDEBINFO   "-O2 -g -DNDEBUG -DQT_NO_DEBUG")
-   set(CMAKE_C_FLAGS_RELEASE          "-O2 -DNDEBUG -DQT_NO_DEBUG")
-   set(CMAKE_C_FLAGS_DEBUG            "-g -O2 -fno-reorder-blocks -fno-schedule-insns -fno-inline")
-   set(CMAKE_C_FLAGS_DEBUGFULL        "-g3 -fno-inline")
-   set(CMAKE_C_FLAGS_PROFILE          "-g3 -fno-inline -ftest-coverage -fprofile-arcs")
-
-   if (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
-     set ( CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} -Wno-long-long -std=iso9899:1990 -Wundef -Wcast-align -Werror-implicit-function-declaration -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-common")
-     # As off Qt 4.6.x we need to override the new exception macros if we want compile with -fno-exceptions
-     set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wno-long-long -ansi -Wundef -Wcast-align -Wchar-subscripts -Wall -W -Wpointer-arith -Wformat-security -fno-exceptions -DQT_NO_EXCEPTIONS -fno-check-new -fno-common")
-     add_definitions (-D_BSD_SOURCE)
-   endif (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
-
-   if (CMAKE_SYSTEM_NAME STREQUAL GNU)
-      set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
-      set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -pthread")
-   endif (CMAKE_SYSTEM_NAME STREQUAL GNU)
-
-   # gcc under Windows
-   if (MINGW)
-      set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--export-all-symbols -Wl,--disable-auto-import")
-      set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--export-all-symbols -Wl,--disable-auto-import")
-   endif (MINGW)
-
-   check_cxx_compiler_flag(-fPIE HAVE_FPIE_SUPPORT)
-   if(KDE4_ENABLE_FPIE)
-       if(HAVE_FPIE_SUPPORT)
-        set (KDE4_CXX_FPIE_FLAGS "-fPIE")
-        set (KDE4_PIE_LDFLAGS "-pie")
-       else(HAVE_FPIE_SUPPORT)
-        message(STATUS "Your compiler doesn't support the PIE flag")
-       endif(HAVE_FPIE_SUPPORT)
-   endif(KDE4_ENABLE_FPIE)
-
-   check_cxx_compiler_flag(-Woverloaded-virtual __KDE_HAVE_W_OVERLOADED_VIRTUAL)
-   if(__KDE_HAVE_W_OVERLOADED_VIRTUAL)
-       set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Woverloaded-virtual")
-   endif(__KDE_HAVE_W_OVERLOADED_VIRTUAL)
-
-   # visibility support
-   check_cxx_compiler_flag(-fvisibility=hidden __KDE_HAVE_GCC_VISIBILITY)
-   set( __KDE_HAVE_GCC_VISIBILITY ${__KDE_HAVE_GCC_VISIBILITY} CACHE BOOL "GCC support for hidden visibility")
-
-   # get the gcc version
-   exec_program(${CMAKE_C_COMPILER} ARGS ${CMAKE_C_COMPILER_ARG1} --version OUTPUT_VARIABLE _gcc_version_info)
-
-   string (REGEX MATCH "[345]\\.[0-9]\\.[0-9]" _gcc_version "${_gcc_version_info}")
-   # gcc on mac just reports: "gcc (GCC) 3.3 20030304 ..." without the patch level, handle this here:
-   if (NOT _gcc_version)
-      string (REGEX MATCH ".*\\(GCC\\).* ([34]\\.[0-9]) .*" "\\1.0" _gcc_version "${gcc_on_macos}")
-      if (gcc_on_macos)
-        string (REGEX REPLACE ".*\\(GCC\\).* ([34]\\.[0-9]) .*" "\\1.0" _gcc_version "${_gcc_version_info}")
-      endif (gcc_on_macos)
-   endif (NOT _gcc_version)
-
-   if (_gcc_version)
-      macro_ensure_version("4.1.0" "${_gcc_version}" GCC_IS_NEWER_THAN_4_1)
-      macro_ensure_version("4.2.0" "${_gcc_version}" GCC_IS_NEWER_THAN_4_2)
-      macro_ensure_version("4.3.0" "${_gcc_version}" GCC_IS_NEWER_THAN_4_3)
-   endif (_gcc_version)
-
-   # save a little by making local statics not threadsafe
-   # ### do not enable it for older compilers, see
-   # ### http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31806
-   if (GCC_IS_NEWER_THAN_4_3)
-       set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-threadsafe-statics")
-   endif (GCC_IS_NEWER_THAN_4_3)
-
-   set(_GCC_COMPILED_WITH_BAD_ALLOCATOR FALSE)
-   if (GCC_IS_NEWER_THAN_4_1)
-      exec_program(${CMAKE_C_COMPILER} ARGS ${CMAKE_C_COMPILER_ARG1} -v OUTPUT_VARIABLE _gcc_alloc_info)
-      string(REGEX MATCH "(--enable-libstdcxx-allocator=mt)" _GCC_COMPILED_WITH_BAD_ALLOCATOR "${_gcc_alloc_info}")
-   endif (GCC_IS_NEWER_THAN_4_1)
-
-   if (__KDE_HAVE_GCC_VISIBILITY AND GCC_IS_NEWER_THAN_4_1 AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR AND NOT WIN32)
-      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
-      set (KDE4_C_FLAGS "-fvisibility=hidden")
-      # check that Qt defines Q_DECL_EXPORT as __attribute__ ((visibility("default")))
-      # if it doesn't and KDE compiles with hidden default visibiltiy plugins will break
-      set(_source "#include <QtCore/QtGlobal>\n int main()\n {\n #ifndef QT_VISIBILITY_AVAILABLE \n #error QT_VISIBILITY_AVAILABLE is not available\n #endif \n }\n")
-      set(_source_file ${CMAKE_BINARY_DIR}/CMakeTmp/check_qt_visibility.cpp)
-      file(WRITE "${_source_file}" "${_source}")
-      set(_include_dirs "-DINCLUDE_DIRECTORIES:STRING=${QT_INCLUDES}")
-
-      try_compile(_compile_result ${CMAKE_BINARY_DIR} ${_source_file} CMAKE_FLAGS "${_include_dirs}" COMPILE_OUTPUT_VARIABLE _compile_output_var)
-
-      if(NOT _compile_result)
-         message(FATAL_ERROR "Qt compiled without support for -fvisibility=hidden. This will break plugins and linking of some applications. Please fix your Qt installation.")
-      endif(NOT _compile_result)
-
-      if (GCC_IS_NEWER_THAN_4_2)
-         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=return-type -fvisibility-inlines-hidden")
-      endif (GCC_IS_NEWER_THAN_4_2)
-   else (__KDE_HAVE_GCC_VISIBILITY AND GCC_IS_NEWER_THAN_4_1 AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR AND NOT WIN32)
-      set (__KDE_HAVE_GCC_VISIBILITY 0)
-   endif (__KDE_HAVE_GCC_VISIBILITY AND GCC_IS_NEWER_THAN_4_1 AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR AND NOT WIN32)
-
-endif (CMAKE_COMPILER_IS_GNUCXX)
-
-
-if (CMAKE_C_COMPILER MATCHES "icc")
-
-   set (KDE4_ENABLE_EXCEPTIONS -fexceptions)
-   # Select flags.
-   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
-   set(CMAKE_CXX_FLAGS_RELEASE        "-O2 -DNDEBUG -DQT_NO_DEBUG")
-   set(CMAKE_CXX_FLAGS_DEBUG          "-O2 -g -fno-inline -noalign")
-   set(CMAKE_CXX_FLAGS_DEBUGFULL      "-g -fno-inline -noalign")
-   set(CMAKE_C_FLAGS_RELWITHDEBINFO   "-O2 -g")
-   set(CMAKE_C_FLAGS_RELEASE          "-O2 -DNDEBUG -DQT_NO_DEBUG")
-   set(CMAKE_C_FLAGS_DEBUG            "-O2 -g -fno-inline -noalign")
-   set(CMAKE_C_FLAGS_DEBUGFULL        "-g -fno-inline -noalign")
-
-   set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -ansi -Wall -w1 -Wpointer-arith -fno-common")
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ansi -Wall -w1 -Wpointer-arith -fno-exceptions -fno-common")
-
-   # visibility support
-   set(__KDE_HAVE_ICC_VISIBILITY)
-#   check_cxx_compiler_flag(-fvisibility=hidden __KDE_HAVE_ICC_VISIBILITY)
-#   if (__KDE_HAVE_ICC_VISIBILITY)
-#      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
-#   endif (__KDE_HAVE_ICC_VISIBILITY)
-
-endif (CMAKE_C_COMPILER MATCHES "icc")
-
-
-###########    end of platform specific stuff  ##########################
-
-
-# KDE4Macros.cmake contains all the KDE specific macros
-include(${kde_cmake_module_dir}/KDE4Macros.cmake)
-
-
-# decide whether KDE4 has been found
-set(KDE4_FOUND FALSE)
-if (KDE4_INCLUDE_DIR AND KDE4_LIB_DIR AND KDE4_KCFGC_EXECUTABLE AND KDE4_INSTALLED_VERSION_OK)
-   set(KDE4_FOUND TRUE)
-endif (KDE4_INCLUDE_DIR AND KDE4_LIB_DIR AND KDE4_KCFGC_EXECUTABLE AND KDE4_INSTALLED_VERSION_OK)
-
-
-macro (KDE4_PRINT_RESULTS)
-
-   # inside kdelibs the include dir and lib dir are internal, not "found"
-   if (NOT _kdeBootStrapping)
-       if(KDE4_INCLUDE_DIR)
-          message(STATUS "Found KDE 4.7 include dir: ${KDE4_INCLUDE_DIR}")
-       else(KDE4_INCLUDE_DIR)
-          message(STATUS "ERROR: unable to find the KDE 4 headers")
-       endif(KDE4_INCLUDE_DIR)
-
-       if(KDE4_LIB_DIR)
-          message(STATUS "Found KDE 4.7 library dir: ${KDE4_LIB_DIR}")
-       else(KDE4_LIB_DIR)
-          message(STATUS "ERROR: unable to find the KDE 4 core library")
-       endif(KDE4_LIB_DIR)
-   endif (NOT _kdeBootStrapping)
-
-   if(KDE4_KCFGC_EXECUTABLE)
-      message(STATUS "Found the KDE4 kconfig_compiler preprocessor: ${KDE4_KCFGC_EXECUTABLE}")
-   else(KDE4_KCFGC_EXECUTABLE)
-      message(STATUS "Didn't find the KDE4 kconfig_compiler preprocessor")
-   endif(KDE4_KCFGC_EXECUTABLE)
-
-   if(AUTOMOC4_EXECUTABLE)
-      message(STATUS "Found automoc4: ${AUTOMOC4_EXECUTABLE}")
-   else(AUTOMOC4_EXECUTABLE)
-      message(STATUS "Didn't find automoc4")
-   endif(AUTOMOC4_EXECUTABLE)
-endmacro (KDE4_PRINT_RESULTS)
-
-
-if (KDE4Internal_FIND_REQUIRED AND NOT KDE4_FOUND)
-   #bail out if something wasn't found
-   kde4_print_results()
-   if (NOT KDE4_INSTALLED_VERSION_OK)
-     message(FATAL_ERROR "ERROR: the installed kdelibs version ${KDE_VERSION} is too old, at least version ${KDE_MIN_VERSION} is required")
-   endif (NOT KDE4_INSTALLED_VERSION_OK)
-
-   if (NOT KDE4_KCFGC_EXECUTABLE)
-     message(FATAL_ERROR "ERROR: could not detect a usable kconfig_compiler")
-   endif (NOT KDE4_KCFGC_EXECUTABLE)
-
-   message(FATAL_ERROR "ERROR: could NOT find everything required for compiling KDE 4 programs")
-endif (KDE4Internal_FIND_REQUIRED AND NOT KDE4_FOUND)
-
-if (NOT KDE4Internal_FIND_QUIETLY)
-   kde4_print_results()
-endif (NOT KDE4Internal_FIND_QUIETLY)
-
-#add the found Qt and KDE include directories to the current include path
-#the ${KDE4_INCLUDE_DIR}/KDE directory is for forwarding includes, eg. #include <KMainWindow>
-set(KDE4_INCLUDES
-   ${KDE4_INCLUDE_DIR}
-   ${KDE4_INCLUDE_DIR}/KDE
-   ${KDE4_PHONON_INCLUDES}
-   ${QT_INCLUDES}
-   ${_KDE4_PLATFORM_INCLUDE_DIRS}
-)
-
-# Used by kdebug.h: the "toplevel dir" is one level above CMAKE_SOURCE_DIR
-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})
-
-if (NOT _kde4_uninstall_rule_created)
-   set(_kde4_uninstall_rule_created TRUE)
-
-   configure_file("${kde_cmake_module_dir}/kde4_cmake_uninstall.cmake.in" "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" @ONLY)
-
-   add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake")
-
-endif (NOT _kde4_uninstall_rule_created)
-
-endif(NOT KDE4_FOUND)
diff --git a/attic/modules/KDE4Defaults.cmake b/attic/modules/KDE4Defaults.cmake
deleted file mode 100644
index d082a813..00000000
--- a/attic/modules/KDE4Defaults.cmake
+++ /dev/null
@@ -1,38 +0,0 @@
-
-enable_testing()
-SET(BUILD_TESTING ON CACHE INTERNAL "Build the testing tree (internal)")
-
-# support for Dart: http://public.kitware.com/dashboard.php?name=kde
-if (EXISTS ${CMAKE_SOURCE_DIR}/CTestConfig.cmake)
-   include(CTest)
-endif (EXISTS ${CMAKE_SOURCE_DIR}/CTestConfig.cmake)
-
-# Always include srcdir and builddir in include path
-# This saves typing ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} in about every subdir
-# since cmake 2.4.0
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
-
-# put the include dirs which are in the source or build tree
-# before all other include dirs, so the headers in the sources
-# are prefered over the already installed ones
-# since cmake 2.4.1
-set(CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE ON)
-
-# define the generic version of the libraries here
-# this makes it easy to advance it when the next KDE release comes
-# Use this version number for libraries which are at version n in KDE version n
-set(GENERIC_LIB_VERSION "4.7.0")
-set(GENERIC_LIB_SOVERSION "4")
-
-# Use this version number for libraries which are already at version n+1 in KDE version n
-set(KDE_NON_GENERIC_LIB_VERSION "5.7.0")
-set(KDE_NON_GENERIC_LIB_SOVERSION "5")
-
-# windows does not support LD_LIBRARY_PATH or similar
-# all searchable directories has to be defined by the PATH environment var
-# to reduce the number of required pathes executables are placed into
-# the build bin dir
-if (WIN32)
- set (EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
-# set (LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
-endif(WIN32)
diff --git a/attic/modules/KDE4Macros.cmake b/attic/modules/KDE4Macros.cmake
deleted file mode 100644
index e1ea80ae..00000000
--- a/attic/modules/KDE4Macros.cmake
+++ /dev/null
@@ -1,1356 +0,0 @@
-# for documentation look at FindKDE4Internal.cmake
-
-# this file contains the following macros (or functions):
-# KDE4_ADD_UI_FILES
-# KDE4_ADD_UI3_FILES
-# KDE4_ADD_KCFG_FILES
-# _KDE4_SET_CUSTOM_TARGET_PROPERTY
-# _KDE4_GET_CUSTOM_TARGET_PROPERTY
-# KDE4_MOC_HEADERS
-# KDE4_HANDLE_AUTOMOC
-# KDE4_CREATE_FINAL_FILES
-# KDE4_ADD_PLUGIN
-# KDE4_ADD_KDEINIT_EXECUTABLE
-# KDE4_ADD_UNIT_TEST
-# KDE4_ADD_EXECUTABLE
-# KDE4_ADD_WIDGET_FILES
-# KDE4_UPDATE_ICONCACHE
-# KDE4_INSTALL_ICONS
-# KDE4_REMOVE_OBSOLETE_CMAKE_FILES
-# KDE4_NO_ENABLE_FINAL
-# KDE4_CREATE_HANDBOOK
-# KDE4_ADD_APP_ICON
-# KDE4_CREATE_MANPAGE
-# KDE4_CREATE_BASIC_CMAKE_VERSION_FILE (function)
-# KDE4_INSTALL_AUTH_HELPER_FILES
-# KDE4_AUTH_INSTALL_ACTIONS
-
-# Copyright (c) 2006-2009 Alexander Neundorf, <neundorf@kde.org>
-# Copyright (c) 2006, 2007, Laurent Montel, <montel@kde.org>
-# Copyright (c) 2007 Matthias Kretz <kretz@kde.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-# This is for versions of automoc4 which don't provide these two macros.
-# If such a version is used, just use the "old" style automoc handling. 
-if(NOT COMMAND _AUTOMOC4_KDE4_PRE_TARGET_HANDLING)
-
-   macro(_AUTOMOC4_KDE4_PRE_TARGET_HANDLING _target _srcs)
-      if(MSVC)
-         add_automoc4_target("${_target}_automoc" ${_srcs})
-      else(MSVC)
-         automoc4(${_target} ${_srcs} )
-      endif(MSVC)
-   endmacro(_AUTOMOC4_KDE4_PRE_TARGET_HANDLING)
-
-
-   macro(_AUTOMOC4_KDE4_POST_TARGET_HANDLING _target)
-      if(MSVC)
-         add_dependencies(${_target} "${_target}_automoc")
-      endif(MSVC)
-   endmacro(_AUTOMOC4_KDE4_POST_TARGET_HANDLING)
-
-endif(NOT COMMAND _AUTOMOC4_KDE4_PRE_TARGET_HANDLING)
-
-
-macro (KDE4_ADD_KCFG_FILES _sources )
-   foreach (_current_ARG ${ARGN})
-       if( ${_current_ARG} STREQUAL "GENERATE_MOC" )
-           set(_kcfg_generatemoc TRUE)
-       endif( ${_current_ARG} STREQUAL "GENERATE_MOC" )
-
-       if( ${_current_ARG} STREQUAL "USE_RELATIVE_PATH" )
-           set(_kcfg_relativepath TRUE)
-       endif( ${_current_ARG} STREQUAL "USE_RELATIVE_PATH" )
-   endforeach (_current_ARG ${ARGN})
-
-   foreach (_current_FILE ${ARGN})
-
-     if(NOT ${_current_FILE} STREQUAL "GENERATE_MOC" AND NOT ${_current_FILE} STREQUAL "USE_RELATIVE_PATH")
-       get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
-       get_filename_component(_abs_PATH ${_tmp_FILE} PATH)
-
-       if (_kcfg_relativepath) # Process relative path only if the option was set
-           # Get relative path
-           get_filename_component(_rel_PATH ${_current_FILE} PATH)
-
-           if (IS_ABSOLUTE ${_rel_PATH})
-               # We got an absolute path
-               set(_rel_PATH "")
-           endif (IS_ABSOLUTE ${_rel_PATH})
-       endif (_kcfg_relativepath)
-
-       get_filename_component(_basename ${_tmp_FILE} NAME_WE)
-       # If we had a relative path and we're asked to use it, then change the basename accordingly
-       if(NOT ${_rel_PATH} STREQUAL "")
-           set(_basename ${_rel_PATH}/${_basename})
-       endif(NOT ${_rel_PATH} STREQUAL "")
-
-       file(READ ${_tmp_FILE} _contents)
-       string(REGEX REPLACE "^(.*\n)?File=([^\n]+kcfg).*\n.*$" "\\2"  _kcfg_FILENAME "${_contents}")
-       set(_src_FILE    ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
-       set(_header_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
-       set(_moc_FILE    ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc)
-       set(_kcfg_FILE   ${_abs_PATH}/${_kcfg_FILENAME})
-       # Maybe the .kcfg is a generated file?
-       if(NOT EXISTS "${_kcfg_FILE}")
-           set(_kcfg_FILE   ${CMAKE_CURRENT_BINARY_DIR}/${_kcfg_FILENAME})
-       endif(NOT EXISTS "${_kcfg_FILE}")
-       if(NOT EXISTS "${_kcfg_FILE}")
-           message(ERROR "${_kcfg_FILENAME} not found; tried in ${_abs_PATH} and ${CMAKE_CURRENT_BINARY_DIR}")
-       endif(NOT EXISTS "${_kcfg_FILE}")
-
-       # make sure the directory exist in the build directory
-       if(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}")
-           file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH})
-       endif(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}")
-
-#       if (CMAKE_CROSSCOMPILING)
-#           set(IMPORT_KCONFIG_COMPILER_EXECUTABLE "${KDE_HOST_TOOLS_PATH}/ImportKConfigCompilerExecutable.cmake" CACHE FILEPATH "Point it to the export file of kconfig_compiler from a native build")
-#           include(${IMPORT_KCONFIG_COMPILER_EXECUTABLE})
-#           set(KDE4_KCFGC_EXECUTABLE kconfig_compiler)
-#       endif (CMAKE_CROSSCOMPILING)
-
-       # the command for creating the source file from the kcfg file
-       add_custom_command(OUTPUT ${_header_FILE} ${_src_FILE}
-          COMMAND ${KDE4_KCFGC_EXECUTABLE}
-          ARGS ${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}
-          MAIN_DEPENDENCY ${_tmp_FILE}
-          DEPENDS ${_kcfg_FILE} ${_KDE4_KCONFIG_COMPILER_DEP} )
-
-       if(_kcfg_generatemoc)
-         qt4_generate_moc(${_header_FILE} ${_moc_FILE} )
-         set_source_files_properties(${_src_FILE} PROPERTIES SKIP_AUTOMOC TRUE)  # don't run automoc on this file
-         list(APPEND ${_sources} ${_moc_FILE})
-       endif(_kcfg_generatemoc)
-
-       list(APPEND ${_sources} ${_src_FILE} ${_header_FILE})
-     endif(NOT ${_current_FILE} STREQUAL "GENERATE_MOC" AND NOT ${_current_FILE} STREQUAL "USE_RELATIVE_PATH")
-   endforeach (_current_FILE)
-
-endmacro (KDE4_ADD_KCFG_FILES)
-
-
-get_filename_component(KDE4_MODULE_DIR  ${CMAKE_CURRENT_LIST_FILE} PATH)
-
-#create the implementation files from the ui files and add them to the list of sources
-#usage: KDE4_ADD_UI_FILES(foo_SRCS ${ui_files})
-macro (KDE4_ADD_UI_FILES _sources )
-   foreach (_current_FILE ${ARGN})
-
-      get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
-      get_filename_component(_basename ${_tmp_FILE} NAME_WE)
-      set(_header ${CMAKE_CURRENT_BINARY_DIR}/ui_${_basename}.h)
-
-      # we need to run uic and replace some things in the generated file
-      # this is done by executing the cmake script kde4uic.cmake
-      add_custom_command(OUTPUT ${_header}
-         COMMAND ${CMAKE_COMMAND}
-         ARGS
-         -DKDE4_HEADER:BOOL=ON
-         -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE}
-         -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
-         -DKDE_UIC_H_FILE:FILEPATH=${_header}
-         -DKDE_UIC_BASENAME:STRING=${_basename}
-         -P ${KDE4_MODULE_DIR}/kde4uic.cmake
-         MAIN_DEPENDENCY ${_tmp_FILE}
-      )
-      list(APPEND ${_sources} ${_header})
-   endforeach (_current_FILE)
-endmacro (KDE4_ADD_UI_FILES)
-
-
-# this is basically a copy of the qt4_get_moc_flags() macros from FindQt4.cmake
-# which is for internal use only, so we should not use it here:
-macro (_KDE4_GET_MOC_FLAGS _moc_flags)
-   set(${_moc_flags})
-   get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES)
-
-   foreach(_current ${_inc_DIRS})
-      set(${_moc_flags} ${${_moc_flags}} "-I${_current}")
-   endforeach(_current ${_inc_DIRS})
-
-   get_directory_property(_defines COMPILE_DEFINITIONS)
-   foreach(_current ${_defines})
-      set(${_moc_flags} ${${_moc_flags}} "-D${_current}")
-   endforeach(_current ${_defines})
-
-   if(Q_WS_WIN)
-      set(${_moc_flags} ${${_moc_flags}} -DWIN32)
-   endif(Q_WS_WIN)
-
-   # if Qt is installed only as framework, add -F /library/Frameworks to the moc arguments
-   # otherwise moc can't find the headers in the framework include dirs
-   if(APPLE  AND  "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
-      set(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-F/Library/Frameworks")
-   endif(APPLE  AND  "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
-
-endmacro(_KDE4_GET_MOC_FLAGS)
-
-
-#create the implementation files from the ui files and add them to the list of sources
-#usage: KDE4_ADD_UI3_FILES(foo_SRCS ${ui_files})
-macro (KDE4_ADD_UI3_FILES _sources )
-
-   _kde4_get_moc_flags(_moc_INCS)
-
-   foreach (_current_FILE ${ARGN})
-
-      get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
-      get_filename_component(_basename ${_tmp_FILE} NAME_WE)
-      set(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
-      set(_src ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
-      set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc.cpp)
-
-      add_custom_command(OUTPUT ${_header}
-         COMMAND ${CMAKE_COMMAND}
-         -DKDE3_HEADER:BOOL=ON
-         -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE}
-         -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
-         -DKDE_UIC_H_FILE:FILEPATH=${_header}
-         -DKDE_UIC_BASENAME:STRING=${_basename}
-         -DKDE_UIC_PLUGIN_DIR:FILEPATH="."
-         -P ${KDE4_MODULE_DIR}/kde4uic.cmake
-         MAIN_DEPENDENCY ${_tmp_FILE}
-      )
-
-# we need to run uic3 and replace some things in the generated file
-      # this is done by executing the cmake script kde4uic.cmake
-      add_custom_command(OUTPUT ${_src}
-         COMMAND ${CMAKE_COMMAND}
-         ARGS
-         -DKDE3_IMPL:BOOL=ON
-         -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE}
-         -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
-         -DKDE_UIC_CPP_FILE:FILEPATH=${_src}
-         -DKDE_UIC_H_FILE:FILEPATH=${_header}
-         -DKDE_UIC_BASENAME:STRING=${_basename}
-         -DKDE_UIC_PLUGIN_DIR:FILEPATH="."
-         -P ${KDE4_MODULE_DIR}/kde4uic.cmake
-         MAIN_DEPENDENCY ${_header}
-      )
-
-      add_custom_command(OUTPUT ${_moc}
-         COMMAND ${QT_MOC_EXECUTABLE}
-         ARGS ${_moc_INCS} ${_header} -o ${_moc}
-         MAIN_DEPENDENCY ${_header}
-      )
-      list(APPEND ${_sources} ${_src} ${_moc} )
-
-   endforeach (_current_FILE)
-endmacro (KDE4_ADD_UI3_FILES)
-
-macro (_KDE4_SET_CUSTOM_TARGET_PROPERTY _target_name _property_name _property)
-   string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}")
-   set(_kde4_${_dir}_${_target_name}_${_property_name} "${_property}")
-endmacro (_KDE4_SET_CUSTOM_TARGET_PROPERTY)
-
-
-macro (_KDE4_GET_CUSTOM_TARGET_PROPERTY _var _target_name _property_name)
-   string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}")
-   set(${_var} "${_kde4_${_dir}_${_target_name}_${_property_name}}")
-endmacro (_KDE4_GET_CUSTOM_TARGET_PROPERTY)
-
-
-macro (KDE4_MOC_HEADERS _target_NAME)
-   # if automoc4 from kdesupport has been found, use the macro provided there
-   automoc4_moc_headers(${_target_NAME} ${ARGN})
-endmacro (KDE4_MOC_HEADERS)
-
-macro(KDE4_HANDLE_AUTOMOC _target_NAME _SRCS)
-   # if automoc4 from kdesupport has been found, use the macro provided there
-   automoc4(${_target_NAME} ${_SRCS})
-endmacro(KDE4_HANDLE_AUTOMOC)
-
-macro(KDE4_INSTALL_TS_FILES _lang _sdir)
-   file(GLOB_RECURSE _ts_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${_sdir}/*)
-   foreach(_current_TS_FILES ${_ts_files})
-      string(REGEX MATCH "\\.svn/" _in_svn ${_current_TS_FILES})
-      if(NOT _in_svn)
-         get_filename_component(_subpath ${_current_TS_FILES} PATH)
-         install(FILES ${_current_TS_FILES} DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_SCRIPTS/${_subpath})
-      endif(NOT _in_svn)
-   endforeach(_current_TS_FILES)
-endmacro(KDE4_INSTALL_TS_FILES)
-
-
-macro (KDE4_CREATE_HANDBOOK _docbook)
-   get_filename_component(_input ${_docbook} ABSOLUTE)
-   set(_doc ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2)
-
-   #Bootstrap
-   if (_kdeBootStrapping)
-      set(_ssheet "${CMAKE_BINARY_DIR}/kdoctools/customization/kde-chunk.xsl")
-      set(_bootstrapOption "--srcdir=${CMAKE_BINARY_DIR}/kdoctools/")
-   else (_kdeBootStrapping)
-      set(_ssheet "${KDE4_DATA_INSTALL_DIR}/ksgmltools2/customization/kde-chunk.xsl")
-      set(_bootstrapOption)
-   endif (_kdeBootStrapping)
-
-   file(GLOB _docs *.docbook)
-
-#   if (CMAKE_CROSSCOMPILING)
-#      set(IMPORT_MEINPROC4_EXECUTABLE "${KDE_HOST_TOOLS_PATH}/ImportMeinProc4Executable.cmake" CACHE FILEPATH "Point it to the export file of meinproc4 from a native build")
-#      include(${IMPORT_MEINPROC4_EXECUTABLE})
-#      set(KDE4_MEINPROC_EXECUTABLE meinproc4)
-#   endif (CMAKE_CROSSCOMPILING)
-
-   add_custom_command(OUTPUT ${_doc}
-      COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check ${_bootstrapOption} --cache ${_doc} ${_input}
-      DEPENDS ${_docs} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet}
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-   )
-   get_filename_component(_targ ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-   set(_targ "${_targ}-handbook")
-   add_custom_target(${_targ} ALL DEPENDS ${_doc})
-
-   if(KDE4_ENABLE_HTMLHANDBOOK)
-      set(_htmlDoc ${CMAKE_CURRENT_SOURCE_DIR}/index.html)
-      add_custom_command(OUTPUT ${_htmlDoc}
-         COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check ${_bootstrapOption} -o ${_htmlDoc} ${_input}
-         DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet}
-         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      )
-      add_custom_target(htmlhandbook DEPENDS ${_htmlDoc})
-   endif(KDE4_ENABLE_HTMLHANDBOOK)
-
-   set(_args ${ARGN})
-
-   set(_installDest)
-   if(_args)
-      list(GET _args 0 _tmp)
-      if("${_tmp}" STREQUAL "INSTALL_DESTINATION")
-         list(GET _args 1 _installDest )
-         list(REMOVE_AT _args 0 1)
-      endif("${_tmp}" STREQUAL "INSTALL_DESTINATION")
-   endif(_args)
-
-   get_filename_component(dirname ${CMAKE_CURRENT_SOURCE_DIR} NAME_WE)
-   if(_args)
-      list(GET _args 0 _tmp)
-      if("${_tmp}" STREQUAL "SUBDIR")
-         list(GET _args 1 dirname )
-         list(REMOVE_AT _args 0 1)
-      endif("${_tmp}" STREQUAL "SUBDIR")
-   endif(_args)
-
-   if(_installDest)
-      file(GLOB _images *.png)
-      install(FILES ${_doc} ${_docs} ${_images} DESTINATION ${_installDest}/${dirname})
-      # TODO symlinks on non-unix platforms
-      if (UNIX)
-         # execute some cmake code on make install which creates the symlink
-         install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink \"${_installDest}/common\"  \"\$ENV{DESTDIR}${_installDest}/${dirname}/common\" )" )
-      endif (UNIX)
-   endif(_installDest)
-
-endmacro (KDE4_CREATE_HANDBOOK)
-
-
-macro (KDE4_CREATE_MANPAGE _docbook _section)
-   get_filename_component(_input ${_docbook} ABSOLUTE)
-   get_filename_component(_base ${_input} NAME)
-
-   string(REGEX REPLACE "\\.${_section}\\.docbook$" "" _base ${_base})
-
-   set(_doc ${CMAKE_CURRENT_BINARY_DIR}/${_base}.${_section})
-   # sometimes we have "man-" prepended
-   string(REGEX REPLACE "/man-" "/" _outdoc ${_doc})
-
-   #Bootstrap
-   if (_kdeBootStrapping)
-      set(_ssheet "${CMAKE_BINARY_DIR}/kdoctools/customization/kde-include-man.xsl")
-      set(_bootstrapOption "--srcdir=${CMAKE_BINARY_DIR}/kdoctools/")
-   else (_kdeBootStrapping)
-      set(_ssheet "${KDE4_DATA_INSTALL_DIR}/ksgmltools2/customization/kde-include-man.xsl")
-      set(_bootstrapOption)
-   endif (_kdeBootStrapping)
-
-#   if (CMAKE_CROSSCOMPILING)
-#      set(IMPORT_MEINPROC4_EXECUTABLE "${KDE_HOST_TOOLS_PATH}/ImportMeinProc4Executable.cmake" CACHE FILEPATH "Point it to the export file of meinproc4 from a native build")
-#      include(${IMPORT_MEINPROC4_EXECUTABLE})
-#      set(KDE4_MEINPROC_EXECUTABLE meinproc4)
-#   endif (CMAKE_CROSSCOMPILING)
-
-   add_custom_command(OUTPUT ${_outdoc}
-      COMMAND ${KDE4_MEINPROC_EXECUTABLE} --stylesheet ${_ssheet} --check ${_bootstrapOption} ${_input}
-      DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet}
-   )
-   get_filename_component(_targ ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-   set(_targ "${_targ}-manpage-${_base}")
-   add_custom_target(${_targ} ALL DEPENDS "${_outdoc}")
-
-   set(_args ${ARGN})
-
-   set(_installDest)
-   if(_args)
-      list(GET _args 0 _tmp)
-      if("${_tmp}" STREQUAL "INSTALL_DESTINATION")
-         list(GET _args 1 _installDest )
-         list(REMOVE_AT _args 0 1)
-      endif("${_tmp}" STREQUAL "INSTALL_DESTINATION")
-   endif(_args)
-
-   get_filename_component(dirname ${CMAKE_CURRENT_SOURCE_DIR} NAME_WE)
-   if(_args)
-      list(GET _args 0 _tmp)
-      if("${_tmp}" STREQUAL "SUBDIR")
-         list(GET _args 1 dirname )
-         list(REMOVE_AT _args 0 1)
-      endif("${_tmp}" STREQUAL "SUBDIR")
-   endif(_args)
-
-   if(_installDest)
-      install(FILES ${_outdoc} DESTINATION ${_installDest}/man${_section})
-   endif(_installDest)
-endmacro (KDE4_CREATE_MANPAGE)
-
-
-macro (KDE4_UPDATE_ICONCACHE)
-    # Update mtime of hicolor icon theme dir.
-    # We don't always have touch command (e.g. on Windows), so instead create
-    #  and delete a temporary file in the theme dir.
-   install(CODE "
-    set(DESTDIR_VALUE \"\$ENV{DESTDIR}\")
-    if (NOT DESTDIR_VALUE)
-        file(WRITE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\" \"update\")
-        file(REMOVE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\")
-    endif (NOT DESTDIR_VALUE)
-    ")
-endmacro (KDE4_UPDATE_ICONCACHE)
-
-# a "map" of short type names to the directories
-# unknown names should give empty results
-# KDE 3 compatibility
-set(_KDE4_ICON_GROUP_mime       "mimetypes")
-set(_KDE4_ICON_GROUP_filesys    "places")
-set(_KDE4_ICON_GROUP_device     "devices")
-set(_KDE4_ICON_GROUP_app        "apps")
-set(_KDE4_ICON_GROUP_action     "actions")
-# KDE 4 / icon naming specification compatibility
-set(_KDE4_ICON_GROUP_mimetypes  "mimetypes")
-set(_KDE4_ICON_GROUP_places     "places")
-set(_KDE4_ICON_GROUP_devices    "devices")
-set(_KDE4_ICON_GROUP_apps       "apps")
-set(_KDE4_ICON_GROUP_actions    "actions")
-set(_KDE4_ICON_GROUP_categories "categories")
-set(_KDE4_ICON_GROUP_status     "status")
-set(_KDE4_ICON_GROUP_emblems    "emblems")
-set(_KDE4_ICON_GROUP_emotes     "emotes")
-set(_KDE4_ICON_GROUP_animations "animations")
-set(_KDE4_ICON_GROUP_intl       "intl")
-
-# a "map" of short theme names to the theme directory
-set(_KDE4_ICON_THEME_ox "oxygen")
-set(_KDE4_ICON_THEME_cr "crystalsvg")
-set(_KDE4_ICON_THEME_lo "locolor")
-set(_KDE4_ICON_THEME_hi "hicolor")
-
-
-# only used internally by KDE4_INSTALL_ICONS
-macro (_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME _l10n_SUBDIR)
-
-   # if the string doesn't match the pattern, the result is the full string, so all three have the same content
-   if (NOT ${_group} STREQUAL ${_install_NAME} )
-      set(_icon_GROUP  ${_KDE4_ICON_GROUP_${_group}})
-      if(NOT _icon_GROUP)
-         set(_icon_GROUP "actions")
-      endif(NOT _icon_GROUP)
-#      message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name} l10n: ${_l10n_SUBDIR}")
-      install(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/${_l10n_SUBDIR}/ RENAME ${_install_NAME} )
-   endif (NOT ${_group} STREQUAL ${_install_NAME} )
-
-endmacro (_KDE4_ADD_ICON_INSTALL_RULE)
-
-
-macro (KDE4_INSTALL_ICONS _defaultpath )
-
-   # the l10n-subdir if language given as second argument (localized icon)
-   set(_lang ${ARGV1})
-   if(_lang)
-      set(_l10n_SUBDIR l10n/${_lang})
-   else(_lang)
-      set(_l10n_SUBDIR ".")
-   endif(_lang)
-
-   # first the png icons
-   file(GLOB _icons *.png)
-   foreach (_current_ICON ${_icons} )
-      # since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty
-      string(REGEX MATCH "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" _dummy  "${_current_ICON}")
-      set(_type  "${CMAKE_MATCH_1}")
-      set(_size  "${CMAKE_MATCH_2}")
-      set(_group "${CMAKE_MATCH_3}")
-      set(_name  "${CMAKE_MATCH_4}")
-
-      set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
-      if( _theme_GROUP)
-         _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
-                    ${_defaultpath}/${_theme_GROUP}/${_size}x${_size}
-                    ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR})
-      endif( _theme_GROUP)
-   endforeach (_current_ICON)
-
-   # mng icons
-   file(GLOB _icons *.mng)
-   foreach (_current_ICON ${_icons} )
-      # since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty
-      string(REGEX MATCH "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" _dummy  "${_current_ICON}")
-      set(_type  "${CMAKE_MATCH_1}")
-      set(_size  "${CMAKE_MATCH_2}")
-      set(_group "${CMAKE_MATCH_3}")
-      set(_name  "${CMAKE_MATCH_4}")
-
-      set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
-      if( _theme_GROUP)
-         _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
-                ${_defaultpath}/${_theme_GROUP}/${_size}x${_size}
-                ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR})
-      endif( _theme_GROUP)
-   endforeach (_current_ICON)
-
-   # and now the svg icons
-   file(GLOB _icons *.svgz)
-   foreach (_current_ICON ${_icons} )
-      # since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty
-      string(REGEX MATCH "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" _dummy "${_current_ICON}")
-      set(_type  "${CMAKE_MATCH_1}")
-      set(_group "${CMAKE_MATCH_2}")
-      set(_name  "${CMAKE_MATCH_3}")
-
-      set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
-      if( _theme_GROUP)
-          _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
-                            ${_defaultpath}/${_theme_GROUP}/scalable
-                            ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR})
-      endif( _theme_GROUP)
-   endforeach (_current_ICON)
-
-   kde4_update_iconcache()
-
-endmacro (KDE4_INSTALL_ICONS)
-
-
-# For all C++ sources a big source file which includes all the files
-# is created.
-# This is not done for the C sources, they are just gathered in a separate list
-# because they are usually not written by KDE and as such not intended to be
-# compiled all-in-one.
-macro (KDE4_CREATE_FINAL_FILES _filenameCPP _filesExcludedFromFinalFile )
-   set(${_filesExcludedFromFinalFile})
-   file(WRITE "${_filenameCPP}" "//autogenerated file\n")
-   foreach (_current_FILE ${ARGN})
-      get_filename_component(_abs_FILE "${_current_FILE}" ABSOLUTE)
-      # don't include any generated files in the final-file
-      # because then cmake will not know the dependencies
-      get_source_file_property(_isGenerated "${_abs_FILE}" GENERATED)
-      if (_isGenerated)
-         list(APPEND ${_filesExcludedFromFinalFile} "${_abs_FILE}")
-      else (_isGenerated)
-         # only put C++ files in the final-file
-         if("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$")
-            file(APPEND "${_filenameCPP}" "#include \"${_abs_FILE}\"\n")
-         else("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$")
-            list(APPEND ${_filesExcludedFromFinalFile} "${_abs_FILE}")
-         endif("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$")
-      endif (_isGenerated)
-   endforeach (_current_FILE)
-
-endmacro (KDE4_CREATE_FINAL_FILES)
-
-# This macro doesn't set up the RPATH related options for executables anymore,
-# since now (wioth cmake 2.6) just the full RPATH is used always for everything.
-# It does create wrapper shell scripts for the executables.
-# It overrides the defaults set in FindKDE4Internal.cmake.
-# For every executable a wrapper script is created, which sets the appropriate
-# environment variable for the platform (LD_LIBRARY_PATH on most UNIX systems,
-# DYLD_LIBRARY_PATH on OS X and PATH in Windows) so  that it points to the built
-# but not yet installed versions of the libraries. So if RPATH is disabled, the executables
-# can be run via these scripts from the build tree and will find the correct libraries.
-# If RPATH is not disabled, these scripts are also used but only for consistency, because
-# they don't really influence anything then, because the compiled-in RPATH overrides
-# the LD_LIBRARY_PATH env. variable.
-macro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE _target_NAME)
-   if (UNIX)
-      if (APPLE)
-         set(_library_path_variable "DYLD_LIBRARY_PATH")
-      elseif (CYGWIN)
-         set(_library_path_variable "PATH")
-      else (APPLE)
-         set(_library_path_variable "LD_LIBRARY_PATH")
-      endif (APPLE)
-
-      if (APPLE)
-         # DYLD_LIBRARY_PATH does not work like LD_LIBRARY_PATH
-         # OSX already has the RPATH in libraries and executables, putting runtime directories in
-         # DYLD_LIBRARY_PATH actually breaks things
-         set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${KDE4_LIB_DIR}")
-      else (APPLE)
-         set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${LIB_INSTALL_DIR}:${KDE4_LIB_DIR}:${QT_LIBRARY_DIR}")
-      endif (APPLE)
-      get_target_property(_executable ${_target_NAME} LOCATION )
-
-      # use add_custom_target() to have the sh-wrapper generated during build time instead of cmake time
-      add_custom_command(TARGET ${_target_NAME} POST_BUILD
-         COMMAND ${CMAKE_COMMAND}
-         -D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable}
-         -D_ld_library_path="${_ld_library_path}" -D_executable=${_executable}
-         -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
-         )
-
-      macro_additional_clean_files(${_executable}.shell)
-
-      # under UNIX, set the property WRAPPER_SCRIPT to the name of the generated shell script
-      # so it can be queried and used later on easily
-      set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}.shell)
-
-   else (UNIX)
-      # under windows, set the property WRAPPER_SCRIPT just to the name of the executable
-      # maybe later this will change to a generated batch file (for setting the PATH so that the Qt libs are found)
-      get_target_property(_executable ${_target_NAME} LOCATION )
-      set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable})
-
-      set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}\;${LIB_INSTALL_DIR}\;${KDE4_LIB_DIR}\;${QT_LIBRARY_DIR}")
-      get_target_property(_executable ${_target_NAME} LOCATION )
-
-      # use add_custom_target() to have the batch-file-wrapper generated during build time instead of cmake time
-      add_custom_command(TARGET ${_target_NAME} POST_BUILD
-         COMMAND ${CMAKE_COMMAND}
-         -D_filename="${_executable}.bat"
-         -D_ld_library_path="${_ld_library_path}" -D_executable="${_executable}"
-         -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
-         )
-
-   endif (UNIX)
-endmacro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE)
-
-
-macro (KDE4_ADD_PLUGIN _target_NAME )
-#if the first argument is "WITH_PREFIX" then keep the standard "lib" prefix,
-#otherwise set the prefix empty
-
-   set(_args ${ARGN})
-   # default to module
-   set(_add_lib_param "MODULE")
-   set(_with_pre FALSE)
-   
-   foreach(arg ${_args})
-      if (arg STREQUAL "WITH_PREFIX")
-         set(_with_pre TRUE)
-      endif (arg STREQUAL "WITH_PREFIX")
-      if (arg STREQUAL "STATIC")
-         set(_add_lib_param STATIC)
-      endif (arg STREQUAL "STATIC")
-      if (arg STREQUAL "SHARED")
-         set(_add_lib_param SHARED)
-      endif (arg STREQUAL "SHARED")
-      if (arg STREQUAL "MODULE")
-         set(_add_lib_param MODULE)
-      endif (arg STREQUAL "MODULE")
-   endforeach(arg)
-
-   if(_with_pre)
-      list(REMOVE_ITEM _args "WITH_PREFIX")
-   endif(_with_pre)
-   if(_add_lib_param STREQUAL "STATIC")
-      list(REMOVE_ITEM _args "STATIC")
-   endif(_add_lib_param STREQUAL "STATIC")
-   if (_add_lib_param STREQUAL "SHARED")
-      list(REMOVE_ITEM _args "SHARED")
-   endif (_add_lib_param STREQUAL "SHARED")
-   if (_add_lib_param STREQUAL "MODULE")
-       list(REMOVE_ITEM _args "MODULE")
-   endif (_add_lib_param STREQUAL "MODULE")
-
-   set(_SRCS ${_args})
-
-   _automoc4_kde4_pre_target_handling(${_target_NAME} _SRCS)
-
-   if("${_add_lib_param}" STREQUAL "STATIC")
-      add_definitions(-DQT_STATICPLUGIN)
-   endif("${_add_lib_param}" STREQUAL "STATIC")
-
-   if (KDE4_ENABLE_FINAL)
-      kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
-      add_library(${_target_NAME} ${_add_lib_param}   ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files})
-   else (KDE4_ENABLE_FINAL)
-      add_library(${_target_NAME} ${_add_lib_param}  ${_SRCS})
-   endif (KDE4_ENABLE_FINAL)
-
-   _automoc4_kde4_post_target_handling(${_target_NAME})
-
-   if (NOT _with_pre)
-      set_target_properties(${_target_NAME} PROPERTIES PREFIX "")
-   endif (NOT _with_pre)
-
-   # for shared libraries/plugins a -DMAKE_target_LIB is required
-   string(TOUPPER ${_target_NAME} _symbol)
-   string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
-   set(_symbol "MAKE_${_symbol}_LIB")
-   set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol})
-
-endmacro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX)
-
-
-# this macro is intended to check whether a list of source
-# files has the "NOGUI" or "RUN_UNINSTALLED" keywords at the beginning
-# in _output_LIST the list of source files is returned with the "NOGUI"
-# and "RUN_UNINSTALLED" keywords removed
-# if "NOGUI" is in the list of files, the _nogui argument is set to
-# "NOGUI" (which evaluates to TRUE in cmake), otherwise it is set empty
-# (which evaluates to FALSE in cmake)
-# "RUN_UNINSTALLED" in the list of files is ignored, it is not necessary anymore
-# since KDE 4.2 (with cmake 2.6.2), since then all executables are always built
-# with RPATH pointing into the build dir.
-# if "TEST" is in the list of files, the _test argument is set to
-# "TEST" (which evaluates to TRUE in cmake), otherwise it is set empty
-# (which evaluates to FALSE in cmake)
-macro(KDE4_CHECK_EXECUTABLE_PARAMS _output_LIST _nogui _test)
-   set(${_nogui})
-   set(${_test})
-   set(${_output_LIST} ${ARGN})
-   list(LENGTH ${_output_LIST} count)
-
-   list(GET ${_output_LIST} 0 first_PARAM)
-
-   set(second_PARAM "NOTFOUND")
-   if (${count} GREATER 1)
-      list(GET ${_output_LIST} 1 second_PARAM)
-   endif (${count} GREATER 1)
-
-   set(remove "NOTFOUND")
-
-   if (${first_PARAM} STREQUAL "NOGUI")
-      set(${_nogui} "NOGUI")
-      set(remove 0)
-   endif (${first_PARAM} STREQUAL "NOGUI")
-
-   if (${first_PARAM} STREQUAL "RUN_UNINSTALLED")
-      set(remove 0)
-   endif (${first_PARAM} STREQUAL "RUN_UNINSTALLED")
-
-   if (${first_PARAM} STREQUAL "TEST")
-      set(${_test} "TEST")
-      set(remove 0)
-   endif (${first_PARAM} STREQUAL "TEST")
-
-   if (${second_PARAM} STREQUAL "NOGUI")
-      set(${_nogui} "NOGUI")
-      set(remove 0;1)
-   endif (${second_PARAM} STREQUAL "NOGUI")
-
-   if (${second_PARAM} STREQUAL "RUN_UNINSTALLED")
-      set(remove 0;1)
-   endif (${second_PARAM} STREQUAL "RUN_UNINSTALLED")
-
-   if (${second_PARAM} STREQUAL "TEST")
-      set(${_test} "TEST")
-      set(remove 0;1)
-   endif (${second_PARAM} STREQUAL "TEST")
-
-
-   if (NOT "${remove}" STREQUAL "NOTFOUND")
-      list(REMOVE_AT ${_output_LIST} ${remove})
-   endif (NOT "${remove}" STREQUAL "NOTFOUND")
-
-endmacro(KDE4_CHECK_EXECUTABLE_PARAMS)
-
-
-macro (KDE4_ADD_KDEINIT_EXECUTABLE _target_NAME )
-
-   kde4_check_executable_params(_SRCS _nogui _test ${ARGN})
-
-   configure_file(${KDE4_MODULE_DIR}/kde4init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp)
-   set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp PROPERTIES SKIP_AUTOMOC TRUE)
-   # under Windows, build a normal executable and additionally a dummy kdeinit4_foo.lib, whose only purpose on windows is to 
-   # keep the linking logic from the CMakeLists.txt on UNIX working (under UNIX all necessary libs are linked against the kdeinit
-   # library instead against the executable, under windows we want to have everything in the executable, but for compatibility we have to 
-   # keep the library there-
-   if(WIN32)
-      if (MINGW)
-         list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_res.o _res_position)
-      else(MINGW)
-         list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}.rc _res_position)
-      endif(MINGW)
-      if(NOT _res_position EQUAL -1)
-         list(GET _SRCS ${_res_position} _resourcefile)
-         list(REMOVE_AT _SRCS ${_res_position})
-      endif(NOT _res_position EQUAL -1)
-
-      set(_KDEINIT4_TARGET_NAME_ ${_target_NAME})
-      string(REGEX REPLACE "[-]" "_" _KDEINIT4_TARGET_NAME_ "${_KDEINIT4_TARGET_NAME_}")
-      configure_file(${KDE4_MODULE_DIR}/kde4init_win32lib_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp)
-      add_library(kdeinit_${_target_NAME} STATIC ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp)
-
-      if (KDE4_ENABLE_FINAL)
-         kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
-         kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
-
-      else (KDE4_ENABLE_FINAL)
-         kde4_add_executable(${_target_NAME} "${_nogui}" ${_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
-      endif (KDE4_ENABLE_FINAL)
-
-      set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME})
-
-      target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY} kdeinit_${_target_NAME})
-   else(WIN32)
-      _automoc4_kde4_pre_target_handling(kdeinit_${_target_NAME} _SRCS)
-
-      if (KDE4_ENABLE_FINAL)
-         kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
-         add_library(kdeinit_${_target_NAME} SHARED  ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files})
-
-      else (KDE4_ENABLE_FINAL)
-         add_library(kdeinit_${_target_NAME} SHARED ${_SRCS})
-      endif (KDE4_ENABLE_FINAL)
-
-      _automoc4_kde4_post_target_handling(kdeinit_${_target_NAME})
-
-      set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME})
-
-      kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp)
-      target_link_libraries(${_target_NAME} kdeinit_${_target_NAME})
-   endif(WIN32)
-
-endmacro (KDE4_ADD_KDEINIT_EXECUTABLE)
-
-# Add a unit test, which is executed when running make test .
-# The targets are always created, but only built for the "all"
-# target if the option KDE4_BUILD_TESTS is enabled. Otherwise the rules for the target
-# are created but not built by default. You can build them by manually building the target.
-# The name of the target can be specified using TESTNAME <testname>, if it is not given
-# the macro will default to the <name>
-macro (KDE4_ADD_UNIT_TEST _test_NAME)
-    set(_srcList ${ARGN})
-    set(_targetName ${_test_NAME})
-    if( ${ARGV1} STREQUAL "TESTNAME" )
-        set(_targetName ${ARGV2})
-        list(REMOVE_AT _srcList 0 1)
-    endif( ${ARGV1} STREQUAL "TESTNAME" )
-    
-    set(_nogui)
-    list(GET ${_srcList} 0 first_PARAM)
-    if( ${first_PARAM} STREQUAL "NOGUI" )
-        set(_nogui "NOGUI")
-    endif( ${first_PARAM} STREQUAL "NOGUI" )
-
-    kde4_add_executable( ${_test_NAME} TEST ${_srcList} )
-
-    if(NOT KDE4_TEST_OUTPUT)
-        set(KDE4_TEST_OUTPUT plaintext)
-    endif(NOT KDE4_TEST_OUTPUT)
-    set(KDE4_TEST_OUTPUT ${KDE4_TEST_OUTPUT} CACHE STRING "The output to generate when running the QTest unit tests")
-
-    set(using_qtest "")
-    foreach(_filename ${_srcList})
-        if(NOT using_qtest)
-            if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}")
-                file(READ ${_filename} file_CONTENT)
-                string(REGEX MATCH "QTEST_(KDE)?MAIN" using_qtest "${file_CONTENT}")
-            endif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}")
-        endif(NOT using_qtest)
-    endforeach(_filename)
-
-    get_target_property( loc ${_test_NAME} LOCATION )
-    if(WIN32)
-      if(MSVC_IDE)
-        STRING(REGEX REPLACE "\\$\\(.*\\)" "\${CTEST_CONFIGURATION_TYPE}" loc "${loc}")
-      endif()
-      # .bat because of rpath handling
-      set(_executable "${loc}.bat")
-    else(WIN32)
-      if (Q_WS_MAC AND NOT _nogui)
-        set(_executable ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME}.app/Contents/MacOS/${_test_NAME})
-      else (Q_WS_MAC AND NOT _nogui)
-        # .shell because of rpath handling
-        set(_executable "${loc}.shell")
-      endif (Q_WS_MAC AND NOT _nogui)
-    endif(WIN32)
-    
-    if (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
-        #MESSAGE(STATUS "${_targetName} : Using QTestLib, can produce XML report.")
-        add_test( ${_targetName} ${_executable} -xml -o ${_targetName}.tml)
-    else (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
-        #MESSAGE(STATUS "${_targetName} : NOT using QTestLib, can't produce XML report, please use QTestLib to write your unit tests.")
-        add_test( ${_targetName} ${_executable} )
-    endif (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
-
-#    add_test( ${_targetName} ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME} -xml -o ${_test_NAME}.tml )
-
-    if (NOT MSVC_IDE)   #not needed for the ide
-        # if the tests are EXCLUDE_FROM_ALL, add a target "buildtests" to build all tests
-        if (NOT KDE4_BUILD_TESTS)
-           get_directory_property(_buildtestsAdded BUILDTESTS_ADDED)
-           if(NOT _buildtestsAdded)
-              add_custom_target(buildtests)
-              set_directory_properties(PROPERTIES BUILDTESTS_ADDED TRUE)
-           endif(NOT _buildtestsAdded)
-           add_dependencies(buildtests ${_test_NAME})
-        endif (NOT KDE4_BUILD_TESTS)
-    endif (NOT MSVC_IDE)
-
-endmacro (KDE4_ADD_UNIT_TEST)
-
-
-# add a  manifest file to executables. 
-# 
-# There is a henn-egg problem when a target runtime part is renamed using 
-# the OUTPUT_NAME option of cmake's set_target_properties command. 
-#
-# At now the Makefiles rules creating for manifest adding are performed 
-# *after* the cmake's add_executable command but *before* an optional 
-# set_target_properties command. 
-# This means that in KDE4_ADD_MANIFEST the LOCATION property contains 
-#  the unchanged runtime part name of the target. :-(
-# 
-# The recently used workaround is to specify a variable build off the target name followed 
-# by _OUTPUT_NAME before calling kde4_add_executable as shown in the following example: 
-# 
-# set(xyz_OUTPUT_NAME test)
-# kde4_add_executable( xyz <source>)
-# set_target_properties( xyz PROPERTIES OUTPUT_NAME ${xyz_OUTPUT_NAME} )  
-#
-# The full solution would be to introduce a kde4_target_link_libraries macro and to 
-# call KDE4_ADD_MANIFEST inside instead of calling in kde4_add_executable. 
-# This would require patching of *all* places in the KDE sources where target_link_libraries 
-# is used and to change the related docs.
-# 
-# Because yet I found only 2 locations where this problem occurs (kjs, k3b), the workaround 
-# seems to be a pragmatically solution. 
-# 
-# This macro is an internal macro only used by kde4_add_executable
-#
-macro (_KDE4_ADD_MANIFEST _target_NAME)
-    set(x ${_target_NAME}_OUTPUT_NAME)
-    if (${x})
-        get_target_property(_var ${_target_NAME} LOCATION )
-        string(REPLACE "${_target_NAME}" "${${x}}" _executable ${_var})
-    else(${x})
-        get_target_property(_executable ${_target_NAME} LOCATION )
-    endif(${x})
-        
-    if (_kdeBootStrapping)
-        set(_cmake_module_path ${CMAKE_SOURCE_DIR}/cmake/modules)
-    else (_kdeBootStrapping)
-        set(_cmake_module_path ${KDE4_INSTALL_DIR}/share/apps/cmake/modules)
-    endif (_kdeBootStrapping)
-       
-    set(_manifest ${_cmake_module_path}/Win32.Manifest.in)
-    #message(STATUS ${_executable} ${_manifest})
-    add_custom_command(
-        TARGET ${_target_NAME}
-        POST_BUILD
-        COMMAND ${KDE4_MT_EXECUTABLE}
-        ARGS
-           -manifest ${_manifest}
-           -updateresource:${_executable}
-        COMMENT "adding vista trustInfo manifest to ${_target_NAME}"
-   )
-endmacro(_KDE4_ADD_MANIFEST) 
-
-
-macro (KDE4_ADD_EXECUTABLE _target_NAME)
-
-   kde4_check_executable_params( _SRCS _nogui _test ${ARGN})
-
-   set(_add_executable_param)
-
-   # determine additional parameters for add_executable()
-   # for GUI apps, create a bundle on OSX
-   if (Q_WS_MAC)
-      set(_add_executable_param MACOSX_BUNDLE)
-   endif (Q_WS_MAC)
-
-   # for GUI apps, this disables the additional console under Windows
-   if (WIN32)
-      set(_add_executable_param WIN32)
-   endif (WIN32)
-
-   if (_nogui)
-      set(_add_executable_param)
-   endif (_nogui)
-
-   if (_test AND NOT KDE4_BUILD_TESTS)
-      set(_add_executable_param ${_add_executable_param} EXCLUDE_FROM_ALL)
-   endif (_test AND NOT KDE4_BUILD_TESTS)
-
-   _automoc4_kde4_pre_target_handling(${_target_NAME} _SRCS)
-   
-   if (KDE4_ENABLE_FINAL)
-      kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
-      add_executable(${_target_NAME} ${_add_executable_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files})
-   else (KDE4_ENABLE_FINAL)
-      add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS})
-   endif (KDE4_ENABLE_FINAL)
-
-   IF (KDE4_ENABLE_UAC_MANIFEST)
-       _kde4_add_manifest(${_target_NAME})
-   ENDIF(KDE4_ENABLE_UAC_MANIFEST)
-
-   _automoc4_kde4_post_target_handling(${_target_NAME})
-
-   if (_test)
-      set_target_properties(${_target_NAME} PROPERTIES COMPILE_FLAGS -DKDESRCDIR="\\"${CMAKE_CURRENT_SOURCE_DIR}/\\"")
-   endif (_test)
-
-   kde4_handle_rpath_for_executable(${_target_NAME})
-
-   if (WIN32)
-      target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY})
-   endif (WIN32)
-
-endmacro (KDE4_ADD_EXECUTABLE)
-
-
-macro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
-
-   set(_first_SRC ${_lib_TYPE})
-   set(_add_lib_param)
-
-   if (${_lib_TYPE} STREQUAL "STATIC")
-      set(_first_SRC)
-      set(_add_lib_param STATIC)
-   endif (${_lib_TYPE} STREQUAL "STATIC")
-   if (${_lib_TYPE} STREQUAL "SHARED")
-      set(_first_SRC)
-      set(_add_lib_param SHARED)
-   endif (${_lib_TYPE} STREQUAL "SHARED")
-   if (${_lib_TYPE} STREQUAL "MODULE")
-      set(_first_SRC)
-      set(_add_lib_param MODULE)
-   endif (${_lib_TYPE} STREQUAL "MODULE")
-
-   set(_SRCS ${_first_SRC} ${ARGN})
-
-   _automoc4_kde4_pre_target_handling(${_target_NAME} _SRCS)
-
-   if (KDE4_ENABLE_FINAL)
-      kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
-      add_library(${_target_NAME} ${_add_lib_param}  ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files})
-   else (KDE4_ENABLE_FINAL)
-      add_library(${_target_NAME} ${_add_lib_param} ${_SRCS})
-   endif (KDE4_ENABLE_FINAL)
-
-   _automoc4_kde4_post_target_handling(${_target_NAME})
-
-   # for shared libraries a -DMAKE_target_LIB is required
-   string(TOUPPER ${_target_NAME} _symbol)
-   string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
-   set(_symbol "MAKE_${_symbol}_LIB")
-   set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol})
-
-   # By default don't add any linked libraries to the "exported"
-   # link interfaces, so that executables linking against this library
-   # will not automatically add implicit dependencies to their link list.
-   #
-   # This reduces inter-package dependencies and makes it easier to remove
-   # dependencies of shared libraries without breaking binary compatibility.
-   if(NOT "${_add_lib_param}" STREQUAL "STATIC")
-      set_target_properties(${_target_NAME} PROPERTIES LINK_INTERFACE_LIBRARIES "" )
-   endif(NOT "${_add_lib_param}" STREQUAL "STATIC")
-
-endmacro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
-
-macro (KDE4_ADD_WIDGET_FILES _sources)
-   foreach (_current_FILE ${ARGN})
-
-      get_filename_component(_input ${_current_FILE} ABSOLUTE)
-      get_filename_component(_basename ${_input} NAME_WE)
-      set(_source ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.cpp)
-      set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.moc)
-
-      # create source file from the .widgets file
-      add_custom_command(OUTPUT ${_source}
-        COMMAND ${KDE4_MAKEKDEWIDGETS_EXECUTABLE}
-        ARGS -o ${_source} ${_input}
-        MAIN_DEPENDENCY ${_input} DEPENDS ${_KDE4_MAKEKDEWIDGETS_DEP})
-
-      # create moc file
-      qt4_generate_moc(${_source} ${_moc} )
-
-      list(APPEND ${_sources} ${_source} ${_moc})
-
-   endforeach (_current_FILE)
-
-endmacro (KDE4_ADD_WIDGET_FILES)
-
-
-macro(KDE4_REMOVE_OBSOLETE_CMAKE_FILES)
-# the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex
-   install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake )
-   set(module_install_dir ${DATA_INSTALL_DIR}/cmake/modules )
-
-   file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, dont edit\n\n")
-   foreach ( _current_FILE ${ARGN})
-      file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${module_install_dir}/${_current_FILE}\" )\n" )
-      file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${module_install_dir}/${_current_FILE} OUTPUT_VARIABLE _dummy)\n" )
-   endforeach ( _current_FILE)
-
-endmacro(KDE4_REMOVE_OBSOLETE_CMAKE_FILES)
-
-
-macro(KDE4_NO_ENABLE_FINAL _project_name)
-   if(KDE4_ENABLE_FINAL)
-      set(KDE4_ENABLE_FINAL OFF)
-      remove_definitions(-DKDE_USE_FINAL)
-      message(STATUS "You used enable-final argument but \"${_project_name}\" doesn't support it. Try to fix compile it and remove KDE4_NO_ENABLE_FINAL macro. Thanks")
-
-   endif(KDE4_ENABLE_FINAL)
-endmacro(KDE4_NO_ENABLE_FINAL _project_name)
-
-
-macro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName)
-   string(TOUPPER ${_libName} _libNameUpperCase)
-   string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _libNameUpperCase ${_libNameUpperCase})
-   # the next line is is required, because in CMake arguments to macros are not real
-   # variables, but handled differently. The next line create a real CMake variable,
-   # so configure_file() will replace it correctly.
-   set(_libName ${_libName})
-   # compared to write(FILE) configure_file() only really writes the file if the
-   # contents have changed. Otherwise we would have a lot of recompiles.
-   configure_file(${KDE4_MODULE_DIR}/kde4exportsheader.h.in ${_outputFile})
-endmacro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName)
-
-
-macro (KDE4_CREATE_HTML_HANDBOOK _docbook)
-   message(STATUS "KDE4_CREATE_HTML_HANDBOOK() is deprecated. Enable the option KDE4_ENABLE_HTMLHANDBOOK instead, this will give you targets htmlhandbook for creating the html help.")
-endmacro (KDE4_CREATE_HTML_HANDBOOK)
-
-
-# adds application icon to target source list
-# 'appsources' - the sources of the application
-# 'pngfiles' - specifies the list of icon files
-# example: KDE4_ADD_WIN32_APP_ICON(myapp_SRCS "pics/cr16-myapp.png;pics/cr32-myapp.png")
-
-macro (KDE4_ADD_WIN32_APP_ICON appsources)
-    message(STATUS "KDE4_ADD_WIN32_APP_ICON() is deprecated, use KDE4_ADD_APP_ICON() instead")
-    if (WIN32)
-        if(NOT WINCE)
-        find_program(PNG2ICO_EXECUTABLE NAMES png2ico)
-        else(NOT WINCE)
-        find_program(PNG2ICO_EXECUTABLE NAMES png2ico PATHS ${HOST_BINDIR} NO_DEFAULT_PATH )
-        endif(NOT WINCE)
-        find_program(WINDRES_EXECUTABLE NAMES windres)
-        if(MSVC)
-            set(WINDRES_EXECUTABLE TRUE)
-        endif(MSVC)
-        string(REPLACE _SRCS "" appname ${appsources})
-        if (PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE)
-            set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appname})
-
-            # png2ico is found by the above find_program
-#            message("png2ico ${_outfilename}.ico ${ARGN}")
-            exec_program(png2ico ARGS ${_outfilename}.ico ${ARGN})
-
-            # now make rc file for adding it to the sources
-            file(WRITE ${_outfilename}.rc "IDI_ICON1        ICON        DISCARDABLE    \"${_outfilename}.ico\"\n")
-            if (MINGW)
-                exec_program(windres
-                    ARGS "-i ${_outfilename}.rc -o ${_outfilename}_res.o --include-dir=${CMAKE_CURRENT_SOURCE_DIR}")
-                list(APPEND ${appsources} ${CMAKE_CURRENT_BINARY_DIR}/${appname}_res.o)
-            else(MINGW)
-                list(APPEND ${appsources} ${CMAKE_CURRENT_BINARY_DIR}/${appname}.rc)
-            endif(MINGW)
-        endif(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE)
-    endif(WIN32)
-endmacro (KDE4_ADD_WIN32_APP_ICON)
-
-# adds application icon to target source list 
-# for detailed documentation see the top of FindKDE4Internal.cmake
-macro (KDE4_ADD_APP_ICON appsources pattern)
-    set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appsources})
-
-    if (WIN32)
-        if(NOT WINCE)
-        find_program(PNG2ICO_EXECUTABLE NAMES png2ico)
-        else(NOT WINCE)
-        find_program(PNG2ICO_EXECUTABLE NAMES png2ico PATHS ${HOST_BINDIR} NO_DEFAULT_PATH )
-        endif(NOT WINCE)
-        find_program(WINDRES_EXECUTABLE NAMES windres)
-        if(MSVC)
-            set(WINDRES_EXECUTABLE TRUE)
-        endif(MSVC)
-        if (PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE)
-            string(REPLACE "*" "(.*)" pattern_rx "${pattern}")
-            file(GLOB files  "${pattern}")
-            foreach (it ${files})
-                string(REGEX REPLACE "${pattern_rx}" "\\1" fn "${it}")
-                if (fn MATCHES ".*16.*" )
-                    list (APPEND _icons ${it})
-                endif (fn MATCHES ".*16.*")
-                if (fn MATCHES ".*32.*" )
-                    list (APPEND _icons ${it})
-                endif (fn MATCHES ".*32.*")
-                if (fn MATCHES ".*48.*" )
-                    list (APPEND _icons ${it})
-                endif (fn MATCHES ".*48.*")
-                if (fn MATCHES ".*64.*" )
-                    list (APPEND _icons ${it})
-                endif (fn MATCHES ".*64.*")
-                if (fn MATCHES ".*128.*" )
-                    list (APPEND _icons ${it})
-                endif (fn MATCHES ".*128.*")
-            endforeach (it)
-            if (_icons)
-                add_custom_command(OUTPUT ${_outfilename}.ico ${_outfilename}.rc
-                                   COMMAND ${PNG2ICO_EXECUTABLE} ARGS --rcfile ${_outfilename}.rc ${_outfilename}.ico ${_icons}
-                                   DEPENDS ${PNG2ICO_EXECUTABLE} ${_icons}
-                                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-                                  )
-                if (MINGW)
-                    add_custom_command(OUTPUT ${_outfilename}_res.o
-                                       COMMAND ${WINDRES_EXECUTABLE} ARGS -i ${_outfilename}.rc -o ${_outfilename}_res.o --include-dir=${CMAKE_CURRENT_SOURCE_DIR}
-                                       DEPENDS ${WINDRES_EXECUTABLE} ${_outfilename}.rc
-                                       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-                                      )
-                    list(APPEND ${appsources} ${_outfilename}_res.o)
-                else(MINGW)
-                    list(APPEND ${appsources} ${_outfilename}.rc)
-                endif(MINGW)
-            else(_icons)
-                message(STATUS "Unable to find a related icon that matches pattern ${pattern} for variable ${appsources} - application will not have an application icon!")
-            endif(_icons)
-        else(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE)
-            message(STATUS "Unable to find the png2ico or windres utilities - application will not have an application icon!")
-        endif(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE)
-    endif(WIN32)
-    if (Q_WS_MAC)
-        # first convert image to a tiff using the Mac OS X "sips" utility,
-        # then use tiff2icns to convert to an icon
-        find_program(SIPS_EXECUTABLE NAMES sips)
-        find_program(TIFF2ICNS_EXECUTABLE NAMES tiff2icns)
-        if (SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE)
-            file(GLOB_RECURSE files  "${pattern}")
-            # we can only test for the 128-icon like that - we don't use patterns anymore
-            foreach (it ${files})
-                if (it MATCHES ".*128.*" )
-                    set (_icon ${it})
-                endif (it MATCHES ".*128.*")
-            endforeach (it)
-
-            if (_icon)
-                
-                # first, get the basename of our app icon
-                add_custom_command(OUTPUT ${_outfilename}.icns ${outfilename}.tiff
-                                   COMMAND ${SIPS_EXECUTABLE} -s format tiff ${_icon} --out ${outfilename}.tiff
-                                   COMMAND ${TIFF2ICNS_EXECUTABLE} ${outfilename}.tiff ${_outfilename}.icns
-                                   DEPENDS ${_icon}
-                                   )
-
-                # This will register the icon into the bundle
-                set(MACOSX_BUNDLE_ICON_FILE ${appsources}.icns)
-
-                # Append the icns file to the sources list so it will be a dependency to the
-                # main target
-                list(APPEND ${appsources} ${_outfilename}.icns)
-
-                # Install the icon into the Resources dir in the bundle
-                set_source_files_properties(${_outfilename}.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
-
-            else(_icon)
-                # TODO - try to scale a non-128 icon...? Try to convert an SVG on the fly?
-                message(STATUS "Unable to find an 128x128 icon that matches pattern ${pattern} for variable ${appsources} - application will not have an application icon!")
-            endif(_icon)
-
-        else(SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE)
-            message(STATUS "Unable to find the sips and tiff2icns utilities - application will not have an application icon!")
-        endif(SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE)
-    endif(Q_WS_MAC)
-endmacro (KDE4_ADD_APP_ICON)
-
-
-# This macro is only kept around for compatibility, it is not needed/used anymore
-# since CMake 2.6.0. With CMake 2.6.0 it is not necessary anymore link libraries again
-# ("relink") to change their RPATH. Since this is fast now, they are now always built with
-# full RPATH. 
-# Still keep this macro here, since somebody might use it and so that would break
-# if we would just remove it from here.
-# What it does now it sets the target properties of the given target the same way as
-# they were set by the old version of the macro with the option FULL_RPATH enabled.
-# This one may be a candidate for removal. Alex
-macro (KDE4_HANDLE_RPATH_FOR_LIBRARY _target_NAME)
-   message(STATUS "You are using the macro KDE4_HANDLE_RPATH_FOR_LIBRARY(), which is an internal macro and shouldn't be used by external projects. Please remove it.")
-   if (NOT CMAKE_SKIP_RPATH)
-      set_target_properties(${_target_NAME} PROPERTIES  SKIP_BUILD_RPATH FALSE  BUILD_WITH_INSTALL_RPATH FALSE)
-   endif (NOT CMAKE_SKIP_RPATH)
-endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY)
-
-# This macro adds the needed files for an helper executable meant to be used by applications using KAuth.
-# It accepts the helper target, the helper ID (the DBUS name) and the user under which the helper will run on.
-# This macro takes care of generate the needed files, and install them in the right location. This boils down
-# to a DBus policy to let the helper register on the system bus, and a service file for letting the helper
-# being automatically activated by the system bus.
-# *WARNING* You have to install the helper in ${LIBEXEC_INSTALL_DIR} to make sure everything will work.
-function(KDE4_INSTALL_AUTH_HELPER_FILES HELPER_TARGET HELPER_ID HELPER_USER)
-    if(KDE4_AUTH_HELPER_BACKEND_NAME STREQUAL "DBUS")
-        if (_kdeBootStrapping)
-            set(_stubFilesDir  ${CMAKE_SOURCE_DIR}/kdecore/auth/backends/dbus/ )
-        else (_kdeBootStrapping)
-            set(_stubFilesDir  ${KDE4_DATA_INSTALL_DIR}/kauth/ )
-        endif (_kdeBootStrapping)
-
-        configure_file(${_stubFilesDir}/dbus_policy.stub
-                        ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.conf)
-        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.conf
-                DESTINATION ${SYSCONF_INSTALL_DIR}/dbus-1/system.d/)
-
-        configure_file(${_stubFilesDir}/dbus_service.stub
-                        ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.service)
-        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.service
-                DESTINATION ${DBUS_SYSTEM_SERVICES_INSTALL_DIR})
-    endif(KDE4_AUTH_HELPER_BACKEND_NAME STREQUAL "DBUS")
-endfunction(KDE4_INSTALL_AUTH_HELPER_FILES)
-
-# This macro generates an action file, depending on the backend used, for applications using KAuth.
-# It accepts the helper id (the DBUS name) and a file containing the actions (check kdelibs/kdecore/auth/example
-# for file format). The macro will take care of generating the file according to the backend specified, 
-# and to install it in the right location. This (at the moment) means that on Linux (PolicyKit) a .policy
-# file will be generated and installed into the policykit action directory (usually /usr/share/PolicyKit/policy/),
-# and on Mac (Authorization Services) will be added to the system action registry using the native MacOS API during
-# the install phase
-function(KDE4_INSTALL_AUTH_ACTIONS HELPER_ID ACTIONS_FILE)
-
-  if(KDE4_AUTH_BACKEND_NAME STREQUAL "APPLE")
-    install(CODE "execute_process(COMMAND ${KDE4_KAUTH_POLICY_GEN_EXECUTABLE} ${ACTIONS_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})")
-  elseif(KDE4_AUTH_BACKEND_NAME STREQUAL "POLKITQT" OR KDE4_AUTH_BACKEND_NAME STREQUAL "POLKITQT-1")
-    set(_output ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.policy)
-    get_filename_component(_input ${ACTIONS_FILE} ABSOLUTE)
-
-    add_custom_command(OUTPUT ${_output} 
-                       COMMAND ${KDE4_KAUTH_POLICY_GEN_EXECUTABLE} ${_input} > ${_output} 
-                       MAIN_DEPENDENCY ${_input}
-                       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                       COMMENT "Generating ${HELPER_ID}.policy"
-                       DEPENDS ${_KDE4_KAUTH_POLICY_GEN_EXECUTABLE_DEP})
-    add_custom_target("actions for ${HELPER_ID}" ALL DEPENDS ${_output})
-
-    install(FILES ${_output} DESTINATION ${KDE4_AUTH_POLICY_FILES_INSTALL_DIR})
-  endif()
-
-endfunction(KDE4_INSTALL_AUTH_ACTIONS)
-
-
-macro(_KDE4_EXPORT_LIBRARY_DEPENDENCIES _append_or_write _filename)
-   message(FATAL_ERROR "_KDE4_EXPORT_LIBRARY_DEPENDENCIES() was an internal macro and has been removed again. Just remove the code which calls it, there is no substitute.")
-endmacro(_KDE4_EXPORT_LIBRARY_DEPENDENCIES)
-
-macro (_KDE4_TARGET_LINK_INTERFACE_LIBRARIES _target _interface_libs)
-   message(FATAL_ERROR "_KDE4_TARGET_LINK_INTERFACE_LIBRARIES() doesn't exist anymore. Set the LINK_INTERFACE_LIBRARIES target property instead. See kdelibs/kdecore/CMakeLists.txt for an example.")
-endmacro (_KDE4_TARGET_LINK_INTERFACE_LIBRARIES)
-
-macro (KDE4_TARGET_LINK_INTERFACE_LIBRARIES _target _interface_libs)
-   message(FATAL_ERROR "KDE4_TARGET_LINK_INTERFACE_LIBRARIES() doesn't exist anymore. Set the LINK_INTERFACE_LIBRARIES target property instead. See kdelibs/kdecore/CMakeLists.txt for an example.")
-endmacro (KDE4_TARGET_LINK_INTERFACE_LIBRARIES _target _interface_libs)
-
-macro (KDE4_INSTALL_HANDBOOK _lang)
-   message(STATUS "KDE4_INSTALL_HANDBOOK() is deprecated. Remove it please. Now all is done in KDE4_CREATE_HANDBOOK.")
-endmacro (KDE4_INSTALL_HANDBOOK )
-
-macro (KDE4_SET_CUSTOM_TARGET_PROPERTY)
-   message(FATAL_ERROR "KDE4_SET_CUSTOM_TARGET_PROPERTY() is deprecated, just use a simple variable instead")
-endmacro (KDE4_SET_CUSTOM_TARGET_PROPERTY)
-
-macro (KDE4_GET_CUSTOM_TARGET_PROPERTY)
-   message(FATAL_ERROR "KDE4_GET_CUSTOM_TARGET_PROPERTY() is deprecated, just use a simple variable instead")
-endmacro (KDE4_GET_CUSTOM_TARGET_PROPERTY)
diff --git a/attic/modules/kde4init_dummy.cpp.in b/attic/modules/kde4init_dummy.cpp.in
deleted file mode 100644
index f0cd3488..00000000
--- a/attic/modules/kde4init_dummy.cpp.in
+++ /dev/null
@@ -1,3 +0,0 @@
-extern "C" int kdemain(int argc, char* argv[]);
-extern "C" int kdeinitmain(int argc, char* argv[]) { return kdemain(argc,argv); }
-int main(int argc, char* argv[]) { return kdemain(argc,argv); }
diff --git a/attic/modules/kde4init_win32lib_dummy.cpp.in b/attic/modules/kde4init_win32lib_dummy.cpp.in
deleted file mode 100644
index 0aa704bc..00000000
--- a/attic/modules/kde4init_win32lib_dummy.cpp.in
+++ /dev/null
@@ -1,5 +0,0 @@
-/* dummy file, used by KDE4_ADD_KDEINIT_EXECUTABLE() under Windows, 
- * so that the created static library is not completely empty */
-
-extern "C" int kdeinit_${_KDEINIT4_TARGET_NAME_}_dummy(void) { return 42; }
-
diff --git a/attic/modules/kde4uic.cmake b/attic/modules/kde4uic.cmake
deleted file mode 100644
index ed328b40..00000000
--- a/attic/modules/kde4uic.cmake
+++ /dev/null
@@ -1,56 +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.
-
-#using a ui3 file with uic3
-if (KDE3_IMPL)
-
-  EXECUTE_PROCESS(COMMAND ${KDE_UIC_EXECUTABLE}
-    -nounload -tr tr2i18n
-    -impl ${KDE_UIC_H_FILE}
-    ${KDE_UIC_FILE}
-    OUTPUT_VARIABLE _uic_CONTENTS
-    ERROR_QUIET
-  )
-endif (KDE3_IMPL)
-
-
-if (KDE3_HEADER)
-
-  EXECUTE_PROCESS(COMMAND ${KDE_UIC_EXECUTABLE}
-    -nounload -tr tr2i18n
-    ${KDE_UIC_FILE}
-    OUTPUT_VARIABLE _uic_CONTENTS
-    ERROR_QUIET
-  )
-   set(KDE_UIC_CPP_FILE ${KDE_UIC_H_FILE})
-endif (KDE3_HEADER)
-
-# the kde4 branch
-if (KDE4_HEADER)
-
-  EXECUTE_PROCESS(COMMAND ${KDE_UIC_EXECUTABLE}
-    -tr tr2i18n
-    ${KDE_UIC_FILE}
-    OUTPUT_VARIABLE _uic_CONTENTS
-  )
-
-   set(KDE_UIC_CPP_FILE ${KDE_UIC_H_FILE})
-endif (KDE4_HEADER)
-
-
-IF (_uic_CONTENTS)
-  #replace tr218n("") with QString::null to avoid warning from KLocale
-  STRING(REGEX REPLACE "tr2i18n\\(\"\"\\)" "QString::null" _uic_CONTENTS "${_uic_CONTENTS}" )
-  STRING(REGEX REPLACE "tr2i18n\\(\"\", \"\"\\)" "QString::null" _uic_CONTENTS "${_uic_CONTENTS}" )
-  #replace image15_data with img15_filename to make enable_final work
-  STRING(REGEX REPLACE "image([0-9]+)_data" "img\\1_${KDE_UIC_BASENAME}" _uic_CONTENTS "${_uic_CONTENTS}")
-  #fixup include guard
-  STRING(REGEX REPLACE "#ifndef " "#ifndef UI_" _uic_CONTENTS "${_uic_CONTENTS}")
-  STRING(REGEX REPLACE "#define " "#define UI_" _uic_CONTENTS "${_uic_CONTENTS}")
-
-  FILE(WRITE ${KDE_UIC_CPP_FILE} "#include <kdialog.h>\n#include <klocale.h>\n\n${_uic_CONTENTS}\n")
-ENDIF()
-