Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-23 10:22:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

generic: major build system cleanup

Browse source 
the test are broken!
This commit is contained in:
Ivailo Monev 2015-09-01 01:05:33 +03:00
parent 3a19bdd9bb
commit 007a44cd2f
131 changed files with 1259 additions and 2527 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

146
CMakeLists.txt
View file

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

5
cmake/modules-tests/AGG/CMakeLists.txt
View file

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

5
cmake/modules-tests/Blitz/CMakeLists.txt
View file

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

5
cmake/modules-tests/BlueZ/CMakeLists.txt
View file

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

5
cmake/modules-tests/ENCHANT/CMakeLists.txt
View file

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

5
cmake/modules-tests/Eigen2/CMakeLists.txt
View file

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

5
cmake/modules-tests/FFmpeg/CMakeLists.txt
View file

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

5
cmake/modules-tests/Flac/CMakeLists.txt
View file

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

5
cmake/modules-tests/Flex/CMakeLists.txt
View file

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

5
cmake/modules-tests/GObject/CMakeLists.txt
View file

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

5
cmake/modules-tests/GStreamer/CMakeLists.txt
View file

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

5
cmake/modules-tests/LCMS/CMakeLists.txt
View file

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

5
cmake/modules-tests/LibArt/CMakeLists.txt
View file

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

5
cmake/modules-tests/LibXslt/CMakeLists.txt
View file

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

5
cmake/modules-tests/OpenEXR/CMakeLists.txt
View file

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

5
cmake/modules-tests/PCRE/CMakeLists.txt
View file

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

5
cmake/modules-tests/QCA2/CMakeLists.txt
View file

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

5
cmake/modules-tests/QImageBlitz/CMakeLists.txt
View file

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

59
cmake/modules-tests/RunAllModuleTests.cmake
View file

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

5
cmake/modules-tests/Sqlite/CMakeLists.txt
View file

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

17
cmake/modules-tests/Strigi/CMakeLists.txt
View file

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

44
cmake/modules-tests/TestFindPackage.cmake
View file

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

5
cmake/modules-tests/USB/CMakeLists.txt
View file

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

5
cmake/modules-tests/Xine/CMakeLists.txt
View file

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

5
cmake/modules-tests/Xmms/CMakeLists.txt
View file

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

6
cmake/modules-tests/readme.txt
View file

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

265
cmake/modules/CMakeLists.txt
View file

@ -7,9 +7,9 @@ set(module_install_dir ${DATA_INSTALL_DIR}/cmake/modules )
# to have it around, so there is a place where the modules which are not installed
# are listed explicitly:
set(cmakeFilesDontInstall
FindHUpnp.cmake
FindUDev.cmake
)
FindHUpnp.cmake
FindUDev.cmake
)
# Explicitly list all files which will be installed.
# We don't use a GLOB anymore so we can have also cmake files here
@ -17,147 +17,120 @@ set(cmakeFilesDontInstall
# so become part of the public interface of kdelibs which has to be kept
# compatible).
set(cmakeFiles
CheckPointerMember.cmake
CheckPrototypeExists.cmake
CheckStructMember.cmake
FindACL.cmake
FindAGG.cmake
FindAkode.cmake
FindAlsa.cmake
FindAutomoc4.cmake
FindAvahi.cmake
FindBerkeleyDB.cmake
FindBlueZ.cmake
FindCarbon.cmake
FindDBusMenuQt.cmake
FindDNSSD.cmake
FindENCHANT.cmake
FindEigen.cmake
FindEigen2.cmake
FindExiv2.cmake
FindFAM.cmake
FindFFmpeg.cmake
FindFlac.cmake
FindFlex.cmake
FindFontconfig.cmake
FindGLIB2.cmake
FindGMP.cmake
FindGObject.cmake
FindGSSAPI.cmake
FindGStreamer.cmake
FindGettext.cmake
FindGphoto2.cmake
FindHUNSPELL.cmake
FindKDE4Internal.cmake
FindKDE4Workspace.cmake
FindKDevPlatform.cmake
FindKdcraw.cmake
FindKdeMultimedia.cmake
FindKdepim.cmake
FindKdepimLibs.cmake
FindKexiv2.cmake
FindKipi.cmake
FindKopete.cmake
FindKorundum.cmake
FindLCMS.cmake
FindLibArt.cmake
FindLibAttica.cmake
FindLibKonq.cmake
FindLibLZMA.cmake
FindLibXslt.cmake
FindLibintl.cmake
FindLibraryWithDebug.cmake
FindLinuxWirelesstools.cmake
FindMsgfmt.cmake
FindMusicBrainz.cmake
FindMySQL.cmake
FindNetworkManager.cmake
FindOggVorbis.cmake
FindOpenEXR.cmake
FindPCRE.cmake
FindPhonon.cmake
FindPopplerQt4.cmake
FindPostgreSQL.cmake
FindPulseAudio.cmake
FindPyKDE4.cmake
FindPyQt4.cmake
Qt4Macros.cmake
Qt4ConfigDependentSettings.cmake
KatieMacros.cmake
FindPythonLibrary.cmake
FindQCA2.cmake
FindQImageBlitz.cmake
FindQt4.cmake
FindKatie.cmake
FindRUBY.cmake
FindSIP.cmake
FindSamba.cmake
FindSane.cmake
FindSasl2.cmake
FindSharedMimeInfo.cmake
FindSqlite.cmake
FindStrigi.cmake
FindTaglib.cmake
FindUDisks2.cmake
FindUSB.cmake
FindWcecompat.cmake
FindX11.cmake
FindXKB.cmake
FindXine.cmake
FindXmms.cmake
HandleImportedTargetsInCMakeRequiredLibraries.cmake
KDE4Defaults.cmake
KDE4Macros.cmake
MacroAddCompileFlags.cmake
MacroAddLinkFlags.cmake
MacroAdditionalCleanFiles.cmake
MacroAppendIf.cmake
MacroBoolTo01.cmake
MacroEnsureOutOfSourceBuild.cmake
MacroEnsureVersion.cmake
MacroLibrary.cmake
MacroLogFeature.cmake
MacroOptionalAddSubdirectory.cmake
MacroOptionalDependPackage.cmake
MacroOptionalFindPackage.cmake
MacroPushRequiredVars.cmake
MacroWriteBasicCMakeVersionFile.cmake
PythonMacros.cmake
SIPMacros.cmake
check_installed_exports_file.cmake
config-alsa.h.cmake
create_exe_symlink.cmake
kde4_exec_via_sh.cmake
kde4uic.cmake
cmake-modules-styleguide.txt
kde4init_dummy.cpp.in
kde4_cmake_uninstall.cmake.in
BasicFindPackageVersion.cmake.in
FindLibPython.py
FindPyKDE4.py
FindPyQt.py
FindSIP.py
PythonCompile.py
)
CheckPointerMember.cmake
CheckPrototypeExists.cmake
CheckStructMember.cmake
FindACL.cmake
FindAGG.cmake
FindAkode.cmake
FindAlsa.cmake
FindAvahi.cmake
FindBerkeleyDB.cmake
FindBlueZ.cmake
FindCarbon.cmake
FindDBusMenuQt.cmake
FindDNSSD.cmake
FindENCHANT.cmake
FindEigen.cmake
FindEigen2.cmake
FindExiv2.cmake
FindFAM.cmake
FindFFmpeg.cmake
FindFlac.cmake
FindFlex.cmake
FindFontconfig.cmake
FindGLIB2.cmake
FindGMP.cmake
FindGObject.cmake
FindGSSAPI.cmake
FindGStreamer.cmake
FindGettext.cmake
FindGphoto2.cmake
FindHUNSPELL.cmake
FindKDE4Internal.cmake
FindKDE4Workspace.cmake
FindKDevPlatform.cmake
FindKdcraw.cmake
FindKdeMultimedia.cmake
FindKdepim.cmake
FindKdepimLibs.cmake
FindKexiv2.cmake
FindKipi.cmake
FindKopete.cmake
FindKorundum.cmake
FindLCMS.cmake
FindLibArt.cmake
FindLibAttica.cmake
FindLibKonq.cmake
FindLibLZMA.cmake
FindLibXslt.cmake
FindLibintl.cmake
FindLinuxWirelesstools.cmake
FindMsgfmt.cmake
FindMusicBrainz.cmake
FindMySQL.cmake
FindNetworkManager.cmake
FindOggVorbis.cmake
FindOpenEXR.cmake
FindPCRE.cmake
FindPhonon.cmake
FindPopplerQt4.cmake
FindPostgreSQL.cmake
FindPulseAudio.cmake
FindPyKDE4.cmake
FindPyQt4.cmake
Qt4Macros.cmake
Qt4ConfigDependentSettings.cmake
FindPythonLibrary.cmake
FindQCA2.cmake
FindQImageBlitz.cmake
FindQt4.cmake
FindRUBY.cmake
FindSIP.cmake
FindSamba.cmake
FindSane.cmake
FindSasl2.cmake
FindSharedMimeInfo.cmake
FindSqlite.cmake
FindStrigi.cmake
FindTaglib.cmake
FindUDisks2.cmake
FindUSB.cmake
FindWcecompat.cmake
FindX11.cmake
FindXKB.cmake
FindXine.cmake
FindXmms.cmake
HandleImportedTargetsInCMakeRequiredLibraries.cmake
KDE4Defaults.cmake
KDE4Macros.cmake
MacroAddCompileFlags.cmake
MacroAddLinkFlags.cmake
MacroAdditionalCleanFiles.cmake
MacroAppendIf.cmake
MacroBoolTo01.cmake
MacroEnsureVersion.cmake
MacroLibrary.cmake
MacroLogFeature.cmake
MacroOptionalAddSubdirectory.cmake
MacroOptionalDependPackage.cmake
MacroOptionalFindPackage.cmake
MacroPushRequiredVars.cmake
MacroWriteBasicCMakeVersionFile.cmake
PythonMacros.cmake
SIPMacros.cmake
check_installed_exports_file.cmake
config-alsa.h.cmake
create_exe_symlink.cmake
kde4uic.cmake
cmake-modules-styleguide.txt
kde4_cmake_uninstall.cmake.in
BasicFindPackageVersion.cmake.in
FindLibPython.py
FindPyKDE4.py
FindPyQt.py
FindSIP.py
PythonCompile.py
)
install(FILES ${cmakeFiles}
DESTINATION ${module_install_dir} )
# the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex
#set(FILES_TO_REMOVE
#)
#install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake )
#file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, don't edit\n\n")
#foreach ( _current_FILE ${FILES_TO_REMOVE})
# file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${_current_FILE}\" )\n" )
# file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${_current_FILE} OUTPUT_VARIABLE _dummy)\n" )
#endforeach ( _current_FILE)
if(NOT CMAKE_VERSION VERSION_GREATER 2.8.12)
# create and install a man page for the kdelibs cmake modules
add_custom_target(KDECMakeModulesManPage ALL COMMAND ${CMAKE_COMMAND} -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR} --help-custom-modules ${CMAKE_CURRENT_BINARY_DIR}/kdecmake.1)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/kdecmake.1 DESTINATION "${MAN_INSTALL_DIR}/man1")
endif()
install(FILES ${cmakeFiles} DESTINATION ${module_install_dir})

49
cmake/modules/FindAutomoc4.cmake
View file

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

326
cmake/modules/FindKDE4Internal.cmake
View file

@ -147,9 +147,6 @@
#
# KDE4_BUILD_TESTS - enable this to build the testcases
# KDE4_ENABLE_FPIE - enable it to use gcc Position Independent Executables feature
# KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR - only present for CMake >= 2.6.3, defaults to TRUE
# If enabled, the package should install its <package>Config.cmake file to
# lib/cmake/<package>/ instead to lib/<package>/cmake
# KDE4_SERIALIZE_TOOL - wrapper to serialize potentially resource-intensive commands during
# parallel builds (set to 'icecc' when using icecream)
#
@ -219,18 +216,6 @@
# KGlobal::dirs()->addResourceDir( "data", KDESRCDIR )
#
#
# KDE4_ADD_APP_ICON (SRCS_VAR pattern)
# adds an application icon to target source list.
# Make sure you have a 128x128 icon, or the icon won't display on Mac OS X.
# Mac OSX notes : the application icon is added to a Mac OS X bundle so that Finder and friends show the right thing.
# Win32 notes: the application icon(s) are compiled into the application
# There is some workaround in kde4_add_kdeinit_executable to make it possible for those applications as well.
# Parameters:
# SRCS_VAR - specifies the list of source files
# pattern - regular expression for searching application icons
# Example: KDE4_ADD_APP_ICON( myapp_SOURCES "pics/cr*-myapp.png")
# Example: KDE4_ADD_APP_ICON( myapp_KDEINIT_SRCS "icons/oxygen/*/apps/myapp.png")
#
# KDE4_UPDATE_ICONCACHE()
# Notifies the icon cache that new icons have been installed by updating
# mtime of ${ICON_INSTALL_DIR}/hicolor directory.
@ -438,23 +423,14 @@ if (_kdeBootStrapping)
set(EXECUTABLE_OUTPUT_PATH ${kdelibs_BINARY_DIR}/bin )
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib )
set(KDE4_KCFGC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler${CMAKE_EXECUTABLE_SUFFIX}.shell )
set(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets${CMAKE_EXECUTABLE_SUFFIX}.shell )
set(KDE4_KCFGC_EXECUTABLE kconfig_compiler${CMAKE_EXECUTABLE_SUFFIX} )
set(KDE4_MAKEKDEWIDGETS_EXECUTABLE makekdewidgets${CMAKE_EXECUTABLE_SUFFIX} )
set(KDE4_LIB_DIR ${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR})
# when building kdelibs, make the kcfg rules depend on the binaries...
set( _KDE4_KCONFIG_COMPILER_DEP kconfig_compiler)
set( _KDE4_MAKEKDEWIDGETS_DEP makekdewidgets)
set(KDE4_INSTALLED_VERSION_OK TRUE)
else (_kdeBootStrapping)
# ... but NOT otherwise
set( _KDE4_KCONFIG_COMPILER_DEP)
set( _KDE4_MAKEKDEWIDGETS_DEP)
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib )
# These files contain information about the installed kdelibs, Alex
@ -464,23 +440,22 @@ else (_kdeBootStrapping)
# 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(NOT KDE_MIN_VERSION)
if (KDE4_FIND_VERSION_MAJOR)
set(KDE_MIN_VERSION "${KDE4_FIND_VERSION_MAJOR}.${KDE4_FIND_VERSION_MINOR}.${KDE4_FIND_VERSION_PATCH}")
else (KDE4_FIND_VERSION_MAJOR)
else()
set(KDE_MIN_VERSION "4.14.3")
endif (KDE4_FIND_VERSION_MAJOR)
endif (NOT KDE_MIN_VERSION)
endif()
endif()
#message(FATAL_ERROR "KDE_MIN_VERSION=${KDE_MIN_VERSION} found ${KDE_VERSION} exact: -${KDE4_FIND_VERSION_EXACT}- version: -${KDE4_FIND_VERSION}-")
macro_ensure_version( ${KDE_MIN_VERSION} ${KDE_VERSION} KDE4_INSTALLED_VERSION_OK )
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} )
set(KDE4_LIB_DIR ${KDE4_LIB_INSTALL_DIR})
set(KDE4_INCLUDE_DIR ${KDE4_INCLUDE_INSTALL_DIR})
# This setting is currently not recorded in KDELibsDependencies.cmake:
find_file(KDE4_PLASMA_OPENGL_FOUND plasma/glapplet.h PATHS ${KDE4_INCLUDE_DIR} NO_DEFAULT_PATH)
@ -563,12 +538,9 @@ _kde4_set_lib_variables(KUNITCONVERSION kunitconversion "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(PLASMA plasma "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(SOLID solid "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(THREADWEAVER threadweaver "${KDE4_TARGET_PREFIX}")
if (UNIX)
_kde4_set_lib_variables(KDEFAKES kdefakes "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(KDESU kdesu "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(KPTY kpty "${KDE4_TARGET_PREFIX}")
endif (UNIX)
_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}")
################### try to find Phonon ############################################
@ -583,24 +555,25 @@ 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()
message(STATUS "KDE4 not found, because Phonon was not found")
return()
endif(NOT PHONON_FOUND)
##################### provide some options ##########################################
option(KDE4_BUILD_TESTS "Build the tests" ON)
if(ENABLE_TESTING)
enable_testing()
endif()
set(KDE4_SERIALIZE_TOOL "" CACHE STRING "Tool to serialize resource-intensive commands in parallel builds")
# if CMake 2.6.3 or above is used, provide an option which should be used by other KDE packages
# 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)
# for CMake 2.6.3 or above, 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):
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
)
# Position-Independent-Executable is a feature of Binutils, Libc, and GCC that creates an executable
# which is something between a shared library and a normal executable.
@ -623,78 +596,44 @@ endif ("${KDE4_LIB_DIR}" MATCHES lib32)
set(LIB_SUFFIX "${_Init_LIB_SUFFIX}" CACHE STRING "Define suffix of directory name (32/64)" )
set(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
set(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share")
set(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin")
set(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin")
set(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
set(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec")
set(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include")
########## the following are directories where stuff will be installed to ###########
#
# 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
set(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4")
set(IMPORTS_INSTALL_DIR "${PLUGIN_INSTALL_DIR}/imports")
set(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config")
set(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps")
set(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons")
set(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg")
set(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale")
set(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk")
set(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/services")
set(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes")
set(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds")
set(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates")
set(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers")
set(DEMO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/demos")
set(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update")
set(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart")
# This macro implements some very special logic how to deal with the cache.
# 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 explicitly to some location, it will always calculate its value from its
# parents. So modifying CMAKE_INSTALL_PREFIX later on will have the desired effect.
# But once you decide to set e.g. EXEC_INSTALL_PREFIX to some special location
# this will go into the cache and it will no longer depend on CMAKE_INSTALL_PREFIX.
#
# additionally if installing to the same location as kdelibs, the other install
# directories are reused from the installed kdelibs
macro(_SET_FANCY _var _value _comment)
set(predefinedvalue "${_value}")
if ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var})
set(predefinedvalue "${KDE4_${_var}}")
endif ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var})
set(XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/kde4")
set(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories")
set(XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages")
if (NOT DEFINED ${_var})
set(${_var} ${predefinedvalue})
else (NOT DEFINED ${_var})
set(${_var} "${${_var}}" CACHE PATH "${_comment}")
endif (NOT DEFINED ${_var})
endmacro(_SET_FANCY)
_set_fancy(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" "Base directory for executables and libraries")
_set_fancy(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share" "Base directory for files which go to share/")
_set_fancy(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" "The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)")
_set_fancy(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" "The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)")
_set_fancy(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" "The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})")
_set_fancy(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec" "The subdirectory relative to the install prefix where libraries will be installed (default is ${LIB_INSTALL_DIR}/kde4/libexec)")
_set_fancy(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" "The subdirectory to the header prefix")
_set_fancy(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4" "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4)")
_set_fancy(IMPORTS_INSTALL_DIR "${PLUGIN_INSTALL_DIR}/imports" "The subdirectory relative to the install prefix where imports will be installed")
_set_fancy(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config" "The config file install dir")
_set_fancy(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps" "The parent directory where applications can install their data")
_set_fancy(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons" "The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)")
_set_fancy(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg" "The install dir for kconfig files")
_set_fancy(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" "The install dir for translations")
_set_fancy(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk" "The install dir for the mimetype desktop files")
_set_fancy(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/services" "The install dir for service (desktop, protocol, ...) files")
_set_fancy(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes" "The install dir for servicestypes desktop files")
_set_fancy(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds" "The install dir for sound files")
_set_fancy(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates" "The install dir for templates (Create new file...)")
_set_fancy(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers" "The install dir for wallpapers")
_set_fancy(DEMO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/demos" "The install dir for demos")
_set_fancy(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update" "The kconf_update install dir")
_set_fancy(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart" "The install dir for autostart files")
_set_fancy(XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/kde4" "The XDG apps dir")
_set_fancy(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" "The XDG directory")
_set_fancy(XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages" "The install dir for the xdg mimetypes")
_set_fancy(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc" "The sysconfig install dir (default ${CMAKE_INSTALL_PREFIX}/etc)")
_set_fancy(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man" "The man install dir (default ${SHARE_INSTALL_PREFIX}/man/)")
_set_fancy(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info" "The info install dir (default ${SHARE_INSTALL_PREFIX}/info)")
_set_fancy(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces" "The dbus interfaces install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)")
_set_fancy(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services" "The dbus services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/services)")
_set_fancy(DBUS_SYSTEM_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/system-services" "The dbus system services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/system-services)")
set(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc")
set(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man")
set(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info")
set(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces")
set(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services")
set(DBUS_SYSTEM_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/system-services")
set(KAUTH_HELPER_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/helper")
set(KAUTH_BACKEND_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/backend")
# For more documentation see above.
# Later on it will be possible to extend this for installing OSX frameworks
@ -729,77 +668,67 @@ set(CMAKE_SYSTEM_LIBRARY_PATH ${CMAKE_SYSTEM_LIBRARY_PATH}
# and now the platform specific stuff
######################################################
# Set a default build type for single-configuration
# CMake generators if no build type is set.
if (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE RelWithDebInfo)
endif (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
if (WIN32 OR CYGWIN OR APPLE)
message(FATAL_ERROR "Windows/Cygwin/Apple is NOT supported.")
message(FATAL_ERROR "Windows/Cygwin/Apple is NOT supported.")
endif(WIN32 OR CYGWIN OR APPLE)
# setup default RPATH/install_name handling, may be overridden by KDE4_HANDLE_RPATH_FOR_EXECUTABLE
# It sets up to build with full RPATH. When installing, RPATH will be changed to the LIB_INSTALL_DIR
# setup default RPATH/install_name handling, 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)
set(_KDE4_PLATFORM_INCLUDE_DIRS)
# the rest is RPATH handling
# here the defaults are set
# which are partly overwritten in kde4_handle_rpath_for_library()
# and kde4_handle_rpath_for_executable(), both located in KDE4Macros.cmake, Alex
# add our LIB_INSTALL_DIR to the RPATH (but only when it is not one of the standard system link
# directories listed in CMAKE_{PLATFORM,C,CXX}_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured out by cmake when compiling
# add our LIB_INSTALL_DIR to the RPATH (but only when it is not one of the standard system link
# directories listed in CMAKE_{PLATFORM,C,CXX}_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured out by cmake when compiling
list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemPlatformLibDir)
list(FIND CMAKE_C_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCLibDir)
list(FIND CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCxxLibDir)
if("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1")
set(CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}")
endif("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1")
list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemPlatformLibDir)
list(FIND CMAKE_C_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCLibDir)
list(FIND CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCxxLibDir)
if("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1")
set(CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}")
endif("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1")
set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
endif (UNIX)
set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
if (Q_WS_X11)
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)
endif()
if (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
if (CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
set ( _KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE)
set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}")
set ( CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}")
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}")
if(CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
set(_KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE)
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}")
# 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 OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
if (CMAKE_C_COMPILER MATCHES "icc")
set ( _KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE)
set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}")
set ( CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}")
endif (CMAKE_C_COMPILER MATCHES "icc")
endif (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
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}")
if (UNIX)
set ( _KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_LARGEFILE64_SOURCE")
# 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()
endif()
check_cxx_source_compiles("
if(CMAKE_C_COMPILER MATCHES "icc")
set(_KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE)
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}")
endif()
endif()
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,
@ -811,10 +740,10 @@ if (UNIX)
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(NOT _OFFT_IS_64BIT)
set(_KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_FILE_OFFSET_BITS=64")
endif()
endif()
############################################################
@ -832,20 +761,20 @@ endmacro(KDE_CHECK_FLAG_EXISTS FLAG VAR)
# 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
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")
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" )
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()
ENDMACRO(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang)
if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES Clang)
@ -876,18 +805,18 @@ if (CMAKE_COMPILER_IS_GNUCXX)
# As of 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 -Wundef -Wcast-align -Wchar-subscripts -Wall -W -Wpointer-arith -Wformat-security -fno-exceptions -DQT_NO_EXCEPTIONS -fno-check-new -fno-common")
if (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
if(CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
# This should not be needed, as it is also part of _KDE4_PLATFORM_DEFINITIONS below.
# It is kept here nonetheless both for backwards compatibility in case one does not use add_definitions(${KDE4_DEFINITIONS})
# and also because it is/was needed by glibc for snprintf to be available when building C files.
# See commit 4a44862b2d178c1d2e1eb4da90010d19a1e4a42c.
add_definitions (-D_DEFAULT_SOURCE -D_BSD_SOURCE)
endif (CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
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)
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)
@ -1145,15 +1074,22 @@ set(KDE4_INCLUDES
get_filename_component(_KDE4_CMAKE_TOPLEVEL_DIR "${CMAKE_SOURCE_DIR}/.." ABSOLUTE)
string(LENGTH "${_KDE4_CMAKE_TOPLEVEL_DIR}" _KDE4_CMAKE_TOPLEVEL_DIR_LENGTH)
set(KDE4_DEFINITIONS ${_KDE4_PLATFORM_DEFINITIONS} -DQT_NO_STL -DQT_NO_CAST_TO_ASCII -D_REENTRANT -DKDE_DEPRECATED_WARNINGS -DKDE4_CMAKE_TOPLEVEL_DIR_LENGTH=${_KDE4_CMAKE_TOPLEVEL_DIR_LENGTH})
set(KDE4_DEFINITIONS
${_KDE4_PLATFORM_DEFINITIONS}
-DQT_NO_STL
-DQT_NO_CAST_TO_ASCII
-D_REENTRANT
-DKDE_DEPRECATED_WARNINGS
-DKDE4_CMAKE_TOPLEVEL_DIR_LENGTH=${_KDE4_CMAKE_TOPLEVEL_DIR_LENGTH}
)
if (NOT _kde4_uninstall_rule_created)
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_uninstall_rule_created)
endif(NOT KDE4_FOUND)

203
cmake/modules/FindKatie.cmake
View file

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

113
cmake/modules/FindLibraryWithDebug.cmake
View file

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

2
cmake/modules/FindPyKDE4.cmake
View file

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

11
cmake/modules/FindQCA2.cmake
View file

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

5
cmake/modules/FindQImageBlitz.cmake
View file

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

10
cmake/modules/FindStrigi.cmake
View file

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

14
cmake/modules/FindTaglib.cmake
View file

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

2
cmake/modules/KDE4Defaults.cmake
View file

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

705
cmake/modules/KDE4Macros.cmake
View file

@ -1,21 +1,12 @@
# for documentation look at FindKDE4Internal.cmake
# this file contains the following macros (or functions):
# KDE4_ADD_UI_FILES
# KDE4_ADD_KCFG_FILES
# _KDE4_SET_CUSTOM_TARGET_PROPERTY
# _KDE4_GET_CUSTOM_TARGET_PROPERTY
# KDE4_ADD_PLUGIN
# KDE4_ADD_KDEINIT_EXECUTABLE
# KDE4_ADD_UNIT_TEST
# KDE4_ADD_EXECUTABLE
# KDE4_ADD_TEST
# KDE4_ADD_WIDGET_FILES
# KDE4_UPDATE_ICONCACHE
# KDE4_INSTALL_ICONS
# KDE4_REMOVE_OBSOLETE_CMAKE_FILES
# KDE4_ADD_APP_ICON
# KDE4_CREATE_MANPAGE
# KDE4_CREATE_BASIC_CMAKE_VERSION_FILE (function)
# KDE4_INSTALL_AUTH_HELPER_FILES
# KDE4_AUTH_INSTALL_ACTIONS
@ -42,11 +33,11 @@ macro (KDE4_ADD_KCFG_FILES _sources )
if(NOT ${_current_FILE} STREQUAL "GENERATE_MOC" AND NOT ${_current_FILE} STREQUAL "USE_RELATIVE_PATH")
get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
get_filename_component(_abs_PATH ${_tmp_FILE} PATH)
get_filename_component(_abs_PATH ${_tmp_FILE} DIRECTORY)
if (_kcfg_relativepath) # Process relative path only if the option was set
# Get relative path
get_filename_component(_rel_PATH ${_current_FILE} PATH)
get_filename_component(_rel_PATH ${_current_FILE} DIRECTORY)
if (IS_ABSOLUTE ${_rel_PATH})
# We got an absolute path
@ -90,7 +81,8 @@ macro (KDE4_ADD_KCFG_FILES _sources )
COMMAND ${KDE4_KCFGC_EXECUTABLE}
ARGS ${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}
MAIN_DEPENDENCY ${_tmp_FILE}
DEPENDS ${_kcfg_FILE} ${_KDE4_KCONFIG_COMPILER_DEP} )
DEPENDS ${_kcfg_FILE}
)
if(_kcfg_generatemoc)
qt4_generate_moc(${_header_FILE} ${_moc_FILE} )
@ -105,80 +97,7 @@ macro (KDE4_ADD_KCFG_FILES _sources )
endmacro (KDE4_ADD_KCFG_FILES)
get_filename_component(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH)
#create the implementation files from the ui files and add them to the list of sources
#usage: KDE4_ADD_UI_FILES(foo_SRCS ${ui_files})
macro (KDE4_ADD_UI_FILES _sources )
foreach (_current_FILE ${ARGN})
get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
get_filename_component(_basename ${_tmp_FILE} NAME_WE)
set(_header ${CMAKE_CURRENT_BINARY_DIR}/ui_${_basename}.h)
# we need to run uic and replace some things in the generated file
# this is done by executing the cmake script kde4uic.cmake
add_custom_command(OUTPUT ${_header}
COMMAND ${CMAKE_COMMAND}
ARGS
-DKDE4_HEADER:BOOL=ON
-DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE}
-DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
-DKDE_UIC_H_FILE:FILEPATH=${_header}
-DKDE_UIC_BASENAME:STRING=${_basename}
-P ${KDE4_MODULE_DIR}/kde4uic.cmake
MAIN_DEPENDENCY ${_tmp_FILE}
)
list(APPEND ${_sources} ${_header})
endforeach (_current_FILE)
endmacro (KDE4_ADD_UI_FILES)
# this is basically a copy of the qt4_get_moc_flags() macros from FindQt4.cmake
# which is for internal use only, so we should not use it here:
macro (_KDE4_GET_MOC_FLAGS _moc_flags)
set(${_moc_flags})
get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES)
foreach(_current ${_inc_DIRS})
set(${_moc_flags} ${${_moc_flags}} "-I${_current}")
endforeach(_current ${_inc_DIRS})
get_directory_property(_defines COMPILE_DEFINITIONS)
foreach(_current ${_defines})
set(${_moc_flags} ${${_moc_flags}} "-D${_current}")
endforeach(_current ${_defines})
# if Qt is installed only as framework, add -F /library/Frameworks to the moc arguments
# otherwise moc can't find the headers in the framework include dirs
if(APPLE AND "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
set(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-F/Library/Frameworks")
endif(APPLE AND "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
endmacro(_KDE4_GET_MOC_FLAGS)
macro (_KDE4_SET_CUSTOM_TARGET_PROPERTY _target_name _property_name _property)
string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}")
set(_kde4_${_dir}_${_target_name}_${_property_name} "${_property}")
endmacro (_KDE4_SET_CUSTOM_TARGET_PROPERTY)
macro (_KDE4_GET_CUSTOM_TARGET_PROPERTY _var _target_name _property_name)
string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}")
set(${_var} "${_kde4_${_dir}_${_target_name}_${_property_name}}")
endmacro (_KDE4_GET_CUSTOM_TARGET_PROPERTY)
macro(KDE4_INSTALL_TS_FILES _lang _sdir)
file(GLOB_RECURSE _ts_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${_sdir}/*)
foreach(_current_TS_FILES ${_ts_files})
string(REGEX MATCH "\\.svn/" _in_svn ${_current_TS_FILES})
if(NOT _in_svn)
get_filename_component(_subpath ${_current_TS_FILES} PATH)
install(FILES ${_current_TS_FILES} DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_SCRIPTS/${_subpath})
endif(NOT _in_svn)
endforeach(_current_TS_FILES)
endmacro(KDE4_INSTALL_TS_FILES)
get_filename_component(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
macro (KDE4_CREATE_MANPAGE _docbook _section)
get_filename_component(_input ${_docbook} ABSOLUTE)
@ -224,19 +143,6 @@ macro (KDE4_CREATE_MANPAGE _docbook _section)
endmacro (KDE4_CREATE_MANPAGE)
macro (KDE4_UPDATE_ICONCACHE)
# Update mtime of hicolor icon theme dir.
# We don't always have touch command (e.g. on Windows), so instead create
# and delete a temporary file in the theme dir.
install(CODE "
set(DESTDIR_VALUE \"\$ENV{DESTDIR}\")
if (NOT DESTDIR_VALUE)
file(WRITE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\" \"update\")
file(REMOVE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\")
endif (NOT DESTDIR_VALUE)
")
endmacro (KDE4_UPDATE_ICONCACHE)
# a "map" of short type names to the directories
# unknown names should give empty results
# KDE 3 compatibility
@ -260,498 +166,158 @@ set(_KDE4_ICON_GROUP_intl "intl")
# a "map" of short theme names to the theme directory
set(_KDE4_ICON_THEME_ox "ariya")
set(_KDE4_ICON_THEME_cr "crystalsvg")
set(_KDE4_ICON_THEME_lo "locolor")
set(_KDE4_ICON_THEME_hi "hicolor")
# only used internally by KDE4_INSTALL_ICONS
macro (_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME _l10n_SUBDIR)
# if the string doesn't match the pattern, the result is the full string, so all three have the same content
if (NOT ${_group} STREQUAL ${_install_NAME} )
set(_icon_GROUP ${_KDE4_ICON_GROUP_${_group}})
if(NOT _icon_GROUP)
set(_icon_GROUP "actions")
endif(NOT _icon_GROUP)
# 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_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()
# 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()
endmacro(_KDE4_ADD_ICON_INSTALL_RULE)
macro (KDE4_INSTALL_ICONS _defaultpath )
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)
# 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}")
# 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
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)
# 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
if (CMAKE_VERSION VERSION_GREATER 2.8.4)
add_custom_command(TARGET ${_target_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND}
-D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable}
-D_ld_library_path="${_ld_library_path}" -D_executable=$<TARGET_FILE:${_target_NAME}>
-P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}
)
else ()
add_custom_command(TARGET ${_target_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND}
-D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable}
-D_ld_library_path="${_ld_library_path}" -D_executable=${_executable}
-P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
endif( _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 ()
endif()
endforeach()
macro_additional_clean_files(${_executable}.shell)
# 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}")
# 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)
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()
endforeach()
endmacro(KDE4_INSTALL_ICONS)
macro (KDE4_ADD_PLUGIN _target_NAME )
#if the first argument is "WITH_PREFIX" then keep the standard "lib" prefix,
#otherwise set the prefix empty
# If "WITH_PREFIX" is in the arugments then the standard "lib" prefix will be
# preserved
macro(KDE4_ADD_PLUGIN _target_NAME)
set(_args ${ARGN})
set(_plugin_type MODULE)
set(_plugin_prefix)
set(_plugin_srcs)
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)
foreach(arg ${_args})
if(arg STREQUAL "STATIC")
set(_plugin_type STATIC)
elseif(arg STREQUAL "SHARED")
set(_plugin_type SHARED)
elseif(arg STREQUAL "WITH_PREFIX")
set(_plugin_prefix TRUE)
else()
list(APPEND _plugin_srcs ${arg})
endif()
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")
add_library(${_target_NAME} ${_plugin_type} ${_plugin_srcs})
set(_SRCS ${_args})
if("${_plugin_type}" STREQUAL STATIC)
target_compile_definitions(${_target_NAME} PRIVATE -DQT_STATICPLUGIN)
endif()
if("${_add_lib_param}" STREQUAL "STATIC")
add_definitions(-DQT_STATICPLUGIN)
endif("${_add_lib_param}" STREQUAL "STATIC")
if(NOT "${_plugin_prefix}")
set_target_properties(${_target_NAME} PROPERTIES PREFIX "")
endif()
endmacro(KDE4_ADD_PLUGIN)
add_library(${_target_NAME} ${_add_lib_param} ${_SRCS})
if (NOT _with_pre)
set_target_properties(${_target_NAME} PROPERTIES PREFIX "")
endif (NOT _with_pre)
# for shared libraries/plugins a -DMAKE_target_LIB is required
string(TOUPPER ${_target_NAME} _symbol)
string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
set(_symbol "MAKE_${_symbol}_LIB")
set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol})
endmacro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX)
# this macro is intended to check whether a list of source
# files has the "NOGUI" or "RUN_UNINSTALLED" keywords at the beginning
# in _output_LIST the list of source files is returned with the "NOGUI"
# and "RUN_UNINSTALLED" keywords removed
# if "NOGUI" is in the list of files, the _nogui argument is set to
# "NOGUI" (which evaluates to TRUE in cmake), otherwise it is set empty
# (which evaluates to FALSE in cmake)
# "RUN_UNINSTALLED" in the list of files is ignored, it is not necessary anymore
# since KDE 4.2 (with cmake 2.6.2), since then all executables are always built
# with RPATH pointing into the build dir.
# if "TEST" is in the list of files, the _test argument is set to
# "TEST" (which evaluates to TRUE in cmake), otherwise it is set empty
# (which evaluates to FALSE in cmake)
macro(KDE4_CHECK_EXECUTABLE_PARAMS _output_LIST _nogui _test)
set(${_nogui})
set(${_test})
set(${_output_LIST} ${ARGN})
list(LENGTH ${_output_LIST} count)
list(GET ${_output_LIST} 0 first_PARAM)
set(second_PARAM "NOTFOUND")
if (${count} GREATER 1)
list(GET ${_output_LIST} 1 second_PARAM)
endif (${count} GREATER 1)
set(remove "NOTFOUND")
if (${first_PARAM} STREQUAL "NOGUI")
set(${_nogui} "NOGUI")
set(remove 0)
endif (${first_PARAM} STREQUAL "NOGUI")
if (${first_PARAM} STREQUAL "RUN_UNINSTALLED")
set(remove 0)
endif (${first_PARAM} STREQUAL "RUN_UNINSTALLED")
if (${first_PARAM} STREQUAL "TEST")
set(${_test} "TEST")
set(remove 0)
endif (${first_PARAM} STREQUAL "TEST")
if (${second_PARAM} STREQUAL "NOGUI")
set(${_nogui} "NOGUI")
set(remove 0;1)
endif (${second_PARAM} STREQUAL "NOGUI")
if (${second_PARAM} STREQUAL "RUN_UNINSTALLED")
set(remove 0;1)
endif (${second_PARAM} STREQUAL "RUN_UNINSTALLED")
if (${second_PARAM} STREQUAL "TEST")
set(${_test} "TEST")
set(remove 0;1)
endif (${second_PARAM} STREQUAL "TEST")
if (NOT "${remove}" STREQUAL "NOTFOUND")
list(REMOVE_AT ${_output_LIST} ${remove})
endif (NOT "${remove}" STREQUAL "NOTFOUND")
endmacro(KDE4_CHECK_EXECUTABLE_PARAMS)
macro (KDE4_ADD_KDEINIT_EXECUTABLE _target_NAME )
kde4_check_executable_params(_SRCS _nogui _test ${ARGN})
configure_file(${KDE4_MODULE_DIR}/kde4init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp PROPERTIES SKIP_AUTOMOC TRUE)
# under Windows, build a normal executable and additionally a dummy kdeinit4_foo.lib, whose only purpose on windows is to
# keep the linking logic from the CMakeLists.txt on UNIX working (under UNIX all necessary libs are linked against the kdeinit
# library instead against the executable, under windows we want to have everything in the executable, but for compatibility we have to
# keep the library there-
add_library(kdeinit_${_target_NAME} SHARED ${_SRCS})
set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME})
kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
target_link_libraries(${_target_NAME} kdeinit_${_target_NAME})
endmacro (KDE4_ADD_KDEINIT_EXECUTABLE)
# Add a unit test, which is executed when running make test .
# The targets are always created, but only built for the "all"
# target if the option KDE4_BUILD_TESTS is enabled. Otherwise the rules for the target
# are created but not built by default. You can build them by manually building the target.
# The name of the target can be specified using TESTNAME <testname>, if it is not given
# the macro will default to the <name>
macro (KDE4_ADD_UNIT_TEST _test_NAME)
# Add a unit test, which is executed when running make test. The targets are
# always created and built unless ENABLE_TESTING is set to negative value.
macro(KDE4_ADD_TEST _targetName)
set(_srcList ${ARGN})
set(_targetName ${_test_NAME})
if( ${ARGV1} STREQUAL "TESTNAME" )
set(_targetName ${ARGV2})
list(REMOVE_AT _srcList 0 1)
endif( ${ARGV1} STREQUAL "TESTNAME" )
add_executable(${_targetName} ${_srcList})
set(_nogui)
list(GET _srcList 0 first_PARAM)
if( ${first_PARAM} STREQUAL "NOGUI" )
set(_nogui "NOGUI")
endif( ${first_PARAM} STREQUAL "NOGUI" )
string(REPLACE "test" "" _testName ${_targetName})
add_test(NAME ${_testName} COMMAND ${_targetName})
kde4_add_executable( ${_test_NAME} TEST ${_srcList} )
target_compile_definitions(${_targetName} PRIVATE -DKDESRCDIR="${CMAKE_CURRENT_SOURCE_DIR}/")
endmacro(KDE4_ADD_TEST)
if(NOT KDE4_TEST_OUTPUT)
set(KDE4_TEST_OUTPUT plaintext)
endif(NOT KDE4_TEST_OUTPUT)
set(KDE4_TEST_OUTPUT ${KDE4_TEST_OUTPUT} CACHE STRING "The output to generate when running the QTest unit tests")
macro(KDE4_ADD_WIDGET_FILES _sources)
foreach(_current_FILE ${_sources})
get_filename_component(_input ${_current_FILE} ABSOLUTE)
get_filename_component(_basename ${_input} NAME_WE)
get_filename_component(_extension ${_input} EXT)
set(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)
set(_source ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.cpp)
set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.moc)
get_target_property( loc ${_test_NAME} LOCATION )
# create source file from the .widgets file
add_custom_command(OUTPUT ${_source}
COMMAND ${KDE4_MAKEKDEWIDGETS_EXECUTABLE} -o ${_source} ${_input}
MAIN_DEPENDENCY ${_input}
)
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")
qt4_generate_moc(${_source} ${_moc})
# add_test( ${_targetName} ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME} -xml -o ${_test_NAME}.tml )
add_library(${_basename}_autowidgets OBJECT ${_source} ${_moc})
endforeach(_current_FILE)
endmacro(KDE4_ADD_WIDGET_FILES)
# if the tests are EXCLUDE_FROM_ALL, add a target "buildtests" to build all tests
if (NOT KDE4_BUILD_TESTS)
get_directory_property(_buildtestsAdded BUILDTESTS_ADDED)
if(NOT _buildtestsAdded)
add_custom_target(buildtests)
set_directory_properties(PROPERTIES BUILDTESTS_ADDED TRUE)
endif(NOT _buildtestsAdded)
add_dependencies(buildtests ${_test_NAME})
endif (NOT KDE4_BUILD_TESTS)
endmacro (KDE4_ADD_UNIT_TEST)
macro (KDE4_ADD_EXECUTABLE _target_NAME)
kde4_check_executable_params( _SRCS _nogui _test ${ARGN})
set(_add_executable_param)
if (_nogui)
set(_add_executable_param)
endif (_nogui)
if (_test AND NOT KDE4_BUILD_TESTS)
set(_add_executable_param ${_add_executable_param} EXCLUDE_FROM_ALL)
endif (_test AND NOT KDE4_BUILD_TESTS)
add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS})
if (_test)
set_target_properties(${_target_NAME} PROPERTIES COMPILE_FLAGS -DKDESRCDIR="\\"${CMAKE_CURRENT_SOURCE_DIR}/\\"")
endif (_test)
kde4_handle_rpath_for_executable(${_target_NAME})
endmacro (KDE4_ADD_EXECUTABLE)
macro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
set(_first_SRC ${_lib_TYPE})
set(_add_lib_param)
if (${_lib_TYPE} STREQUAL "STATIC")
set(_first_SRC)
set(_add_lib_param STATIC)
endif (${_lib_TYPE} STREQUAL "STATIC")
if (${_lib_TYPE} STREQUAL "SHARED")
set(_first_SRC)
set(_add_lib_param SHARED)
endif (${_lib_TYPE} STREQUAL "SHARED")
if (${_lib_TYPE} STREQUAL "MODULE")
set(_first_SRC)
set(_add_lib_param MODULE)
endif (${_lib_TYPE} STREQUAL "MODULE")
set(_SRCS ${_first_SRC} ${ARGN})
add_library(${_target_NAME} ${_add_lib_param} ${_SRCS})
# for shared libraries a -DMAKE_target_LIB is required
string(TOUPPER ${_target_NAME} _symbol)
string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
set(_symbol "MAKE_${_symbol}_LIB")
set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol})
endmacro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
macro (KDE4_ADD_WIDGET_FILES _sources)
foreach (_current_FILE ${ARGN})
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} ${KDE4_MAKEKDEWIDGETS_EXECUTABLE})
# 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, don't edit\n\n")
foreach ( _current_FILE ${ARGN})
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${module_install_dir}/${_current_FILE}\" )\n" )
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${module_install_dir}/${_current_FILE} OUTPUT_VARIABLE _dummy)\n" )
endforeach ( _current_FILE)
endmacro(KDE4_REMOVE_OBSOLETE_CMAKE_FILES)
macro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName)
string(TOUPPER ${_libName} _libNameUpperCase)
string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _libNameUpperCase ${_libNameUpperCase})
# the next line is is required, because in CMake arguments to macros are not real
# variables, but handled differently. The next line create a real CMake variable,
# so configure_file() will replace it correctly.
set(_libName ${_libName})
# compared to write(FILE) configure_file() only really writes the file if the
# contents have changed. Otherwise we would have a lot of recompiles.
configure_file(${KDE4_MODULE_DIR}/kde4exportsheader.h.in ${_outputFile})
endmacro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName)
# adds application icon to target source list
# for detailed documentation see the top of FindKDE4Internal.cmake
macro (KDE4_ADD_APP_ICON appsources pattern)
set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appsources})
endmacro (KDE4_ADD_APP_ICON)
# This macro is only kept around for compatibility, it is not needed/used anymore
# since CMake 2.6.0. With CMake 2.6.0 it is not necessary anymore link libraries again
# ("relink") to change their RPATH. Since this is fast now, they are now always built with
# full RPATH.
# Still keep this macro here, since somebody might use it and so that would break
# if we would just remove it from here.
# What it does now it sets the target properties of the given target the same way as
# they were set by the old version of the macro with the option FULL_RPATH enabled.
# This one may be a candidate for removal. Alex
macro (KDE4_HANDLE_RPATH_FOR_LIBRARY _target_NAME)
message(STATUS "You are using the macro KDE4_HANDLE_RPATH_FOR_LIBRARY(), which is an internal macro and shouldn't be used by external projects. Please remove it.")
if (NOT CMAKE_SKIP_RPATH)
set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE)
endif (NOT CMAKE_SKIP_RPATH)
endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY)
# This macro adds the needed files for an helper executable meant to be used by applications using KAuth.
# It accepts the helper target, the helper ID (the DBUS name) and the user under which the helper will run on.
@ -761,9 +327,9 @@ endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY)
# *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 (_kdeBootStrapping)
set(_stubFilesDir ${CMAKE_SOURCE_DIR}/kdecore/auth/backends/dbus/ )
set(_stubFilesDir ${CMAKE_SOURCE_DIR}/kdecore/auth/backends/dbus/)
else (_kdeBootStrapping)
set(_stubFilesDir ${KDE4_DATA_INSTALL_DIR}/kauth/ )
set(_stubFilesDir ${KDE4_DATA_INSTALL_DIR}/kauth/)
endif (_kdeBootStrapping)
configure_file(${_stubFilesDir}/dbus_policy.stub
@ -776,14 +342,3 @@ function(KDE4_INSTALL_AUTH_HELPER_FILES HELPER_TARGET HELPER_ID HELPER_USER)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.service
DESTINATION ${DBUS_SYSTEM_SERVICES_INSTALL_DIR})
endfunction(KDE4_INSTALL_AUTH_HELPER_FILES)
# This macro generates an action file, depending on the backend used, for applications using KAuth.
# It accepts the helper id (the DBUS name) and a file containing the actions (check kdelibs/kdecore/auth/example
# for file format). The macro will take care of generating the file according to the backend specified,
# and to install it in the right location. This (at the moment) means that on Linux (PolicyKit) a .policy
# file will be generated and installed into the policykit action directory (usually /usr/share/PolicyKit/policy/),
# and on Mac (Authorization Services) will be added to the system action registry using the native MacOS API during
# the install phase
function(KDE4_INSTALL_AUTH_ACTIONS HELPER_ID ACTIONS_FILE)
message(AUTHOR_WARNING "PolicyKit/Polikt actions are not required")
endfunction(KDE4_INSTALL_AUTH_ACTIONS)

117
cmake/modules/KatieMacros.cmake
View file

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

20
cmake/modules/MacroEnsureOutOfSourceBuild.cmake
View file

@ -1,20 +0,0 @@
# - MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)
# MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)
# Call this macro in your project if you want to enforce out-of-source builds.
# If an in-source build is detected, it will abort with the given error message.
# This macro works in any of the CMakeLists.txt of your project, but the recommended
# location to call this is close to the beginning of the top level CMakeLists.txt
# Copyright (c) 2006, Alexander Neundorf, <neundorf@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
MACRO (MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage)
STRING(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" insource)
IF(insource)
MESSAGE(FATAL_ERROR "${_errorMessage}")
ENDIF(insource)
ENDMACRO (MACRO_ENSURE_OUT_OF_SOURCE_BUILD)

1
cmake/modules/MacroLibrary.cmake
View file

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

31
cmake/modules/kde4_exec_via_sh.cmake
View file

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

12
cmake/modules/kde4exportsheader.h.in
View file

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

2
cmake/modules/kde4init_dummy.cpp.in
View file

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

129
dnssd/CMakeLists.txt
View file

@ -20,58 +20,67 @@ include(CreateKcfgFiles.cmake)
set(kdnssd_LIB_SRCS servicebase.cpp servicemodel.cpp domainmodel.cpp)
kde4_add_kcfg_files(kdnssd_LIB_SRCS ${CMAKE_CURRENT_BINARY_DIR}/settings.kcfgc )
if (HAVE_AVAHI)
include_directories( ${AVAHI_INCLUDE_DIR} )
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS}
avahi-domainbrowser.cpp
avahi-servicebrowser.cpp
avahi-remoteservice.cpp
avahi-publicservice.cpp
avahi-servicetypebrowser.cpp
avahi_server_interface.cpp
avahi_serviceresolver_interface.cpp
avahi_entrygroup_interface.cpp
)
qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.DomainBrowser.xml avahi_domainbrowser_interface )
qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.ServiceBrowser.xml avahi_servicebrowser_interface )
qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.ServiceTypeBrowser.xml avahi_servicetypebrowser_interface )
else (HAVE_AVAHI)
macro_optional_find_package(DNSSD)
macro_bool_to_01(DNSSD_FOUND HAVE_DNSSD)
set_package_properties(DNSSD PROPERTIES DESCRIPTION "Facilities for service discovery on a local network"
URL "http://avahi.org"
TYPE OPTIONAL
PURPOSE "Either Avahi or DNSSD is required for KDE applications to make use of multicast DNS/DNS-SD service discovery"
)
if (HAVE_DNSSD)
include_directories( ${DNSSD_INCLUDE_DIR} )
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS}
mdnsd-domainbrowser.cpp
mdnsd-remoteservice.cpp
mdnsd-publicservice.cpp
mdnsd-responder.cpp
mdnsd-servicebrowser.cpp
mdnsd-servicetypebrowser.cpp
)
else (HAVE_DNSSD)
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS}
dummy-domainbrowser.cpp
dummy-remoteservice.cpp
dummy-publicservice.cpp
dummy-servicebrowser.cpp
dummy-servicetypebrowser.cpp
)
endif (HAVE_DNSSD)
endif (HAVE_AVAHI)
if(HAVE_AVAHI)
include_directories( ${AVAHI_INCLUDE_DIR} )
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS}
avahi-domainbrowser.cpp
avahi-servicebrowser.cpp
avahi-remoteservice.cpp
avahi-publicservice.cpp
avahi-servicetypebrowser.cpp
avahi_server_interface.cpp
avahi_serviceresolver_interface.cpp
avahi_entrygroup_interface.cpp
)
qt4_add_dbus_interface(
kdnssd_LIB_SRCS
org.freedesktop.Avahi.DomainBrowser.xml
avahi_domainbrowser_interface
)
qt4_add_dbus_interface(
kdnssd_LIB_SRCS
org.freedesktop.Avahi.ServiceBrowser.xml
avahi_servicebrowser_interface
)
qt4_add_dbus_interface(
kdnssd_LIB_SRCS
org.freedesktop.Avahi.ServiceTypeBrowser.xml
avahi_servicetypebrowser_interface
)
else(HAVE_AVAHI)
macro_optional_find_package(DNSSD)
macro_bool_to_01(DNSSD_FOUND HAVE_DNSSD)
set_package_properties(DNSSD PROPERTIES
DESCRIPTION "Facilities for service discovery on a local network"
URL "http://avahi.org"
TYPE OPTIONAL
PURPOSE "Either Avahi or DNSSD is required for KDE applications to make use of multicast DNS/DNS-SD service discovery"
)
if(HAVE_DNSSD)
include_directories( ${DNSSD_INCLUDE_DIR} )
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS}
mdnsd-domainbrowser.cpp
mdnsd-remoteservice.cpp
mdnsd-publicservice.cpp
mdnsd-responder.cpp
mdnsd-servicebrowser.cpp
mdnsd-servicetypebrowser.cpp
)
else(HAVE_DNSSD)
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS}
dummy-domainbrowser.cpp
dummy-remoteservice.cpp
dummy-publicservice.cpp
dummy-servicebrowser.cpp
dummy-servicetypebrowser.cpp
)
endif(HAVE_DNSSD)
endif(HAVE_AVAHI)
########### next target ###############
kde4_add_library(kdnssd ${LIBRARY_TYPE} ${kdnssd_LIB_SRCS})
add_library(kdnssd ${LIBRARY_TYPE} ${kdnssd_LIB_SRCS})
# KDE 5: don't link against KDEUI_LIBS (when settings.kfgc is changed)
if (HAVE_DNSSD)
@ -80,18 +89,30 @@ else (HAVE_DNSSD)
target_link_libraries(kdnssd PRIVATE ${KDNSSD_BASE_LIBS} ${QT_QTNETWORK_LIBRARY})
endif (HAVE_DNSSD)
target_link_libraries(kdnssd PUBLIC kdecore ${QT_QTCORE_LIBRARY} )
target_link_libraries(kdnssd PUBLIC kdecore ${QT_QTCORE_LIBRARY} )
set_target_properties(kdnssd PROPERTIES
VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION}
VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION}
)
install(TARGETS kdnssd EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
########### install files ###############
install( FILES dnssd_export.h domainbrowser.h remoteservice.h servicetypebrowser.h publicservice.h
servicebase.h servicebrowser.h servicemodel.h domainmodel.h ${CMAKE_CURRENT_BINARY_DIR}/settings.h
DESTINATION ${INCLUDE_INSTALL_DIR}/dnssd COMPONENT Devel)
install(FILES
dnssd_export.h
domainbrowser.h
remoteservice.h
servicetypebrowser.h
publicservice.h
servicebase.h
servicebrowser.h
servicemodel.h
domainmodel.h
${CMAKE_CURRENT_BINARY_DIR}/settings.h
DESTINATION ${INCLUDE_INSTALL_DIR}/dnssd
COMPONENT Devel
)

4
experimental/libkdeclarative/CMakeLists.txt
View file

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

48
interfaces/kimproxy/CMakeLists.txt
View file

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

0
interfaces/kimproxy/library/Messages.sh → interfaces/kimproxy/Messages.sh
View file

0
interfaces/kimproxy/interface/dbusinstantmessenger.desktop → interfaces/kimproxy/dbusinstantmessenger.desktop
View file

0
interfaces/kimproxy/library/icons/CMakeLists.txt → interfaces/kimproxy/icons/CMakeLists.txt
View file

0
interfaces/kimproxy/library/icons/hi16-action-presence_away.png → interfaces/kimproxy/icons/hi16-action-presence_away.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 775 B

After

Width:  |  Height:  |  Size: 775 B

0
interfaces/kimproxy/library/icons/hi16-action-presence_offline.png → interfaces/kimproxy/icons/hi16-action-presence_offline.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 470 B

After

Width:  |  Height:  |  Size: 470 B

0
interfaces/kimproxy/library/icons/hi16-action-presence_online.png → interfaces/kimproxy/icons/hi16-action-presence_online.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 845 B

After

Width:  |  Height:  |  Size: 845 B

0
interfaces/kimproxy/library/icons/hi16-action-presence_unknown.png → interfaces/kimproxy/icons/hi16-action-presence_unknown.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 759 B

After

Width:  |  Height:  |  Size: 759 B

0
interfaces/kimproxy/library/icons/hi32-action-presence_away.png → interfaces/kimproxy/icons/hi32-action-presence_away.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.3 KiB

After

Width:  |  Height:  |  Size: 2.3 KiB

0
interfaces/kimproxy/library/icons/hi32-action-presence_offline.png → interfaces/kimproxy/icons/hi32-action-presence_offline.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.3 KiB

After

Width:  |  Height:  |  Size: 1.3 KiB

0
interfaces/kimproxy/library/icons/hi32-action-presence_online.png → interfaces/kimproxy/icons/hi32-action-presence_online.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.4 KiB

After

Width:  |  Height:  |  Size: 2.4 KiB

0
interfaces/kimproxy/library/icons/hi32-action-presence_unknown.png → interfaces/kimproxy/icons/hi32-action-presence_unknown.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.3 KiB

After

Width:  |  Height:  |  Size: 2.3 KiB

0
interfaces/kimproxy/library/icons/hi48-action-presence_away.png → interfaces/kimproxy/icons/hi48-action-presence_away.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.1 KiB

After

Width:  |  Height:  |  Size: 3.1 KiB

0
interfaces/kimproxy/library/icons/hi48-action-presence_offline.png → interfaces/kimproxy/icons/hi48-action-presence_offline.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.6 KiB

After

Width:  |  Height:  |  Size: 1.6 KiB

0
interfaces/kimproxy/library/icons/hi48-action-presence_online.png → interfaces/kimproxy/icons/hi48-action-presence_online.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.1 KiB

After

Width:  |  Height:  |  Size: 3.1 KiB

8
interfaces/kimproxy/interface/CMakeLists.txt
View file

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

0
interfaces/kimproxy/interface/kcm_instantmessenger.desktop → interfaces/kimproxy/kcm_instantmessenger.desktop
View file

0
interfaces/kimproxy/library/kimproxy.cpp → interfaces/kimproxy/kimproxy.cpp
View file

0
interfaces/kimproxy/library/kimproxy.h → interfaces/kimproxy/kimproxy.h
View file

0
interfaces/kimproxy/library/kimproxy_export.h → interfaces/kimproxy/kimproxy_export.h
View file

30
interfaces/kimproxy/library/CMakeLists.txt
View file

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

0
interfaces/kimproxy/interface/org.kde.KIMIface.xml → interfaces/kimproxy/org.kde.KIMIface.xml
View file

39
interfaces/kmediaplayer/CMakeLists.txt
View file

@ -1,32 +1,45 @@
add_subdirectory( kfileaudiopreview )
add_subdirectory(kfileaudiopreview)
include_directories( ${KDE4_KPARTS_INCLUDES} )
include_directories(${KDE4_KPARTS_INCLUDES})
########### next target ###############
set(kmediaplayer_LIB_SRCS
player.cpp
view.cpp
kmediaplayeradaptor.cpp
player.cpp
view.cpp
kmediaplayeradaptor.cpp
)
kde4_add_library(kmediaplayer ${LIBRARY_TYPE} ${kmediaplayer_LIB_SRCS})
add_library(kmediaplayer ${LIBRARY_TYPE} ${kmediaplayer_LIB_SRCS})
target_link_libraries(kmediaplayer PRIVATE ${KDE4_KPARTS_LIBS} )
target_link_libraries(kmediaplayer PUBLIC ${KDE4_KPARTS_LIBS} ${QT_QTGUI_LIBRARY} )
set_target_properties(kmediaplayer PROPERTIES
VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION}
VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION}
)
install(TARGETS kmediaplayer EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
########### install files ###############
install( FILES kmediaplayer_export.h player.h view.h DESTINATION ${INCLUDE_INSTALL_DIR}/kmediaplayer COMPONENT Devel)
install(FILES
kmediaplayer_export.h
player.h
view.h
DESTINATION ${INCLUDE_INSTALL_DIR}/kmediaplayer
COMPONENT Devel
)
install( FILES kmediaplayerengine.desktop kmediaplayer.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} )
install( FILES org.kde.KMediaPlayer.xml DESTINATION ${DBUS_INTERFACES_INSTALL_DIR} )
install(FILES
kmediaplayerengine.desktop
kmediaplayer.desktop
DESTINATION
${SERVICETYPES_INSTALL_DIR}
)
install(FILES
org.kde.KMediaPlayer.xml
DESTINATION ${DBUS_INTERFACES_INSTALL_DIR}
)

93
interfaces/ktexteditor/CMakeLists.txt
View file

@ -1,49 +1,51 @@
include_directories( ${KDE4_KPARTS_INCLUDES} )
include_directories(${KDE4_KPARTS_INCLUDES})
########### next target ###############
set(ktexteditor_LIB_SRCS
ktexteditor.cpp
document.cpp
range.cpp
cursor.cpp
templateinterface.cpp
templateinterface2.cpp
editorchooser.cpp
attribute.cpp
cursorfeedback.cpp
rangefeedback.cpp
smartcursor.cpp
smartrange.cpp
codecompletioninterface.cpp
codecompletionmodel.cpp
codecompletionmodelcontrollerinterface.cpp
configinterface.cpp
smartinterface.cpp
highlightinterface.cpp
movinginterface.cpp
movingcursor.cpp
movingrange.cpp
movingrangefeedback.cpp
messageinterface.cpp
)
ktexteditor.cpp
document.cpp
range.cpp
cursor.cpp
templateinterface.cpp
templateinterface2.cpp
editorchooser.cpp
attribute.cpp
cursorfeedback.cpp
rangefeedback.cpp
smartcursor.cpp
smartrange.cpp
codecompletioninterface.cpp
codecompletionmodel.cpp
codecompletionmodelcontrollerinterface.cpp
configinterface.cpp
smartinterface.cpp
highlightinterface.cpp
movinginterface.cpp
movingcursor.cpp
movingrange.cpp
movingrangefeedback.cpp
messageinterface.cpp
editorchooser_ui.ui
)
add_library(ktexteditor ${LIBRARY_TYPE} ${ktexteditor_LIB_SRCS})
kde4_add_ui_files(ktexteditor_LIB_SRCS editorchooser_ui.ui )
target_link_libraries(ktexteditor PRIVATE
${KDE4_KDECORE_LIBS}
${QT_QTDBUS_LIBRARY}
${KDE4_KPARTS_LIBS}
)
target_link_libraries(ktexteditor PUBLIC ${KDE4_KPARTS_LIBS})
kde4_add_library(ktexteditor ${LIBRARY_TYPE} ${ktexteditor_LIB_SRCS})
target_link_libraries(ktexteditor PRIVATE ${KDE4_KDECORE_LIBS} ${QT_QTDBUS_LIBRARY} ${KDE4_KPARTS_LIBS} )
target_link_libraries(ktexteditor PUBLIC ${KDE4_KPARTS_LIBS} )
set_target_properties(ktexteditor
PROPERTIES VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION}
set_target_properties(ktexteditor PROPERTIES
VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION}
)
install(TARGETS ktexteditor EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
########### install files ###############
install( FILES
install(FILES
ktexteditor_export.h
factory.h
editor.h
@ -88,9 +90,22 @@ install( FILES
movingrangefeedback.h
recoveryinterface.h
messageinterface.h
DESTINATION ${INCLUDE_INSTALL_DIR}/ktexteditor COMPONENT Devel)
DESTINATION ${INCLUDE_INSTALL_DIR}/ktexteditor
COMPONENT Devel
)
install( FILES ktexteditor.desktop ktexteditorplugin.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} )
install( FILES kcm_ktexteditor.desktop DESTINATION ${DATA_INSTALL_DIR}/kcm_componentchooser )
install(FILES
ktexteditor.desktop
ktexteditorplugin.desktop
DESTINATION ${SERVICETYPES_INSTALL_DIR}
)
install( FILES ktexteditor_loadsavefiltercheckplugin.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} )
install(FILES
kcm_ktexteditor.desktop
DESTINATION ${DATA_INSTALL_DIR}/kcm_componentchooser
)
install(FILES
ktexteditor_loadsavefiltercheckplugin.desktop
DESTINATION ${SERVICETYPES_INSTALL_DIR}
)

2
interfaces/terminal/example/CMakeLists.txt
View file

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

402
kdecore/CMakeLists.txt
View file

@ -93,219 +93,213 @@ if (HAVE_RESOLV_LIBRARY)
set(kdecore_OPTIONAL_LIBS ${kdecore_OPTIONAL_LIBS} resolv)
endif (HAVE_RESOLV_LIBRARY)
if (UNIX)
set(kdecore_OPTIONAL_SRCS ${kdecore_OPTIONAL_SRCS}
kernel/ktoolinvocation_x11.cpp
kernel/kstandarddirs_unix.cpp
localization/klocale_unix.cpp
network/klocalsocket_unix.cpp
network/netsupp.cpp
io/klockfile_unix.cpp
util/kshell_unix.cpp
util/kuser_unix.cpp
util/kmacroexpander_unix.cpp
fakes.c
)
endif (UNIX)
add_subdirectory( kconfig_compiler )
add_subdirectory( tests )
add_subdirectory( sonnet/tests )
if(ENABLE_TESTING)
add_subdirectory( tests )
add_subdirectory( sonnet/tests )
endif()
add_subdirectory( network/kssld )
########### next target ###############
if (UNIX)
kde4_add_library(kdefakes ${LIBRARY_TYPE} fakes.c)
set_target_properties(kdefakes PROPERTIES
VERSION ${KDE_NON_GENERIC_LIB_VERSION}
SOVERSION ${KDE_NON_GENERIC_LIB_SOVERSION})
if (NOT HAVE_TRUNC)
target_link_libraries(kdefakes m )
endif (NOT HAVE_TRUNC)
install(TARGETS kdefakes EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS} )
endif (UNIX)
add_library(kdefakes ${LIBRARY_TYPE} fakes.c)
set_target_properties(kdefakes PROPERTIES
VERSION ${KDE_NON_GENERIC_LIB_VERSION}
SOVERSION ${KDE_NON_GENERIC_LIB_SOVERSION})
if (NOT HAVE_TRUNC)
target_link_libraries(kdefakes m )
endif (NOT HAVE_TRUNC)
install(TARGETS kdefakes
EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS}
)
########### next target ###############
set(kdecore_LIB_SRCS
compression/kgzipfilter.cpp
compression/kfilterbase.cpp
compression/kfilterdev.cpp
config/kconfig.cpp
config/kconfigbase.cpp
config/kconfigdata.cpp
config/kconfiggroup.cpp
config/kconfigbackend.cpp
config/kconfigini.cpp
config/kdesktopfile.cpp
config/ksharedconfig.cpp
config/kcoreconfigskeleton.cpp
date/kcalendarera.cpp
date/kcalendarsystem.cpp
date/kcalendarsystemcoptic.cpp
date/kcalendarsystemethiopian.cpp
date/kcalendarsystemqdate.cpp
date/kcalendarsystemgregorian.cpp
date/kcalendarsystemislamiccivil.cpp
date/kcalendarsystemhebrew.cpp
date/kcalendarsystemindiannational.cpp
date/kcalendarsystemjalali.cpp
date/kcalendarsystemjapanese.cpp
date/kcalendarsystemjulian.cpp
date/kcalendarsystemminguo.cpp
date/kcalendarsystemthai.cpp
date/kdatetime.cpp
date/kdatetimeformatter.cpp
date/kdatetimeparser.cpp
date/kdayperiod.cpp
date/klocalizeddate.cpp
date/ktimezone.cpp
date/ksystemtimezone.cpp
date/ktzfiletimezone.cpp
io/kar.cpp
io/karchive.cpp
io/kautosavefile.cpp
io/kdebug.cpp
io/kdebugdbusiface.cpp
io/kdirwatch.cpp
io/kfilesystemtype_p.cpp
io/klimitediodevice.cpp
io/kmessage.cpp
io/kmountpoint.cpp
io/kprocess.cpp
io/ksavefile.cpp
io/ktar.cpp
io/ktempdir.cpp
io/ktemporaryfile.cpp
io/kurl.cpp
io/kzip.cpp
jobs/kcompositejob.cpp
jobs/kjob.cpp
jobs/kjobuidelegate.cpp
jobs/kjobtrackerinterface.cpp
kernel/kauthorized.cpp
kernel/kaboutdata.cpp
kernel/kcmdlineargs.cpp
kernel/kdbusconnectionpool.cpp
kernel/kglobal.cpp
kernel/kcomponentdata.cpp
kernel/kstandarddirs.cpp
kernel/ktoolinvocation.cpp
auth/kauthaction.cpp
auth/kauthactionreply.cpp
auth/kauthactionwatcher.cpp
auth/AuthBackend.cpp
auth/BackendsManager.cpp
auth/HelperProxy.cpp
auth/kauthhelpersupport.cpp
services/kfoldermimetype.cpp
services/kmimetypefactory.cpp
services/kmimemagicrule.cpp
services/kmimetypetrader.cpp
services/kmimetype.cpp
services/kmimeglobsfileparser.cpp
services/kmimetyperepository.cpp
services/kservice.cpp
services/kserviceaction.cpp
services/kservicefactory.cpp
services/kservicegroup.cpp
services/kservicegroupfactory.cpp
services/kserviceoffer.cpp
services/kservicetype.cpp
services/kservicetypefactory.cpp
services/kservicetypeprofile.cpp
services/kservicetypetrader.cpp
services/ktraderparse.cpp
services/ktraderparsetree.cpp
services/yacc.c
services/lex.c
services/kplugininfo.cpp
sonnet/loader.cpp
sonnet/client.cpp
sonnet/spellerplugin.cpp
sonnet/speller.cpp
sonnet/filter.cpp
sonnet/settings.cpp
sonnet/backgroundchecker.cpp
sonnet/backgroundengine.cpp
sonnet/globals.cpp
)
compression/kgzipfilter.cpp
compression/kfilterbase.cpp
compression/kfilterdev.cpp
config/kconfig.cpp
config/kconfigbase.cpp
config/kconfigdata.cpp
config/kconfiggroup.cpp
config/kconfigbackend.cpp
config/kconfigini.cpp
config/kdesktopfile.cpp
config/ksharedconfig.cpp
config/kcoreconfigskeleton.cpp
date/kcalendarera.cpp
date/kcalendarsystem.cpp
date/kcalendarsystemcoptic.cpp
date/kcalendarsystemethiopian.cpp
date/kcalendarsystemqdate.cpp
date/kcalendarsystemgregorian.cpp
date/kcalendarsystemislamiccivil.cpp
date/kcalendarsystemhebrew.cpp
date/kcalendarsystemindiannational.cpp
date/kcalendarsystemjalali.cpp
date/kcalendarsystemjapanese.cpp
date/kcalendarsystemjulian.cpp
date/kcalendarsystemminguo.cpp
date/kcalendarsystemthai.cpp
date/kdatetime.cpp
date/kdatetimeformatter.cpp
date/kdatetimeparser.cpp
date/kdayperiod.cpp
date/klocalizeddate.cpp
date/ktimezone.cpp
date/ksystemtimezone.cpp
date/ktzfiletimezone.cpp
io/kar.cpp
io/karchive.cpp
io/kautosavefile.cpp
io/kdebug.cpp
io/kdebugdbusiface.cpp
io/kdirwatch.cpp
io/kfilesystemtype_p.cpp
io/klimitediodevice.cpp
io/kmessage.cpp
io/kmountpoint.cpp
io/kprocess.cpp
io/ksavefile.cpp
io/ktar.cpp
io/ktempdir.cpp
io/ktemporaryfile.cpp
io/kurl.cpp
io/kzip.cpp
jobs/kcompositejob.cpp
jobs/kjob.cpp
jobs/kjobuidelegate.cpp
jobs/kjobtrackerinterface.cpp
kernel/kauthorized.cpp
kernel/kaboutdata.cpp
kernel/kcmdlineargs.cpp
kernel/kdbusconnectionpool.cpp
kernel/kglobal.cpp
kernel/kcomponentdata.cpp
kernel/kstandarddirs.cpp
kernel/ktoolinvocation.cpp
auth/kauthaction.cpp
auth/kauthactionreply.cpp
auth/kauthactionwatcher.cpp
auth/AuthBackend.cpp
auth/BackendsManager.cpp
auth/HelperProxy.cpp
auth/kauthhelpersupport.cpp
services/kfoldermimetype.cpp
services/kmimetypefactory.cpp
services/kmimemagicrule.cpp
services/kmimetypetrader.cpp
services/kmimetype.cpp
services/kmimeglobsfileparser.cpp
services/kmimetyperepository.cpp
services/kservice.cpp
services/kserviceaction.cpp
services/kservicefactory.cpp
services/kservicegroup.cpp
services/kservicegroupfactory.cpp
services/kserviceoffer.cpp
services/kservicetype.cpp
services/kservicetypefactory.cpp
services/kservicetypeprofile.cpp
services/kservicetypetrader.cpp
services/ktraderparse.cpp
services/ktraderparsetree.cpp
services/yacc.c
services/lex.c
services/kplugininfo.cpp
sonnet/loader.cpp
sonnet/client.cpp
sonnet/spellerplugin.cpp
sonnet/speller.cpp
sonnet/filter.cpp
sonnet/settings.cpp
sonnet/backgroundchecker.cpp
sonnet/backgroundengine.cpp
sonnet/globals.cpp
set(kdecore_LIB_SRCS ${kdecore_LIB_SRCS}
network/klocalsocket.cpp
network/ksocketfactory.cpp
network/ksslcertificatemanager.cpp
network/ktcpsocket.cpp
localization/kcatalog.cpp
localization/kcurrencycode.cpp
localization/kcharsets.cpp
localization/kencodingdetector.cpp
localization/guess_ja.cpp
localization/kencodingprober.cpp
localization/probers/CharDistribution.cpp
localization/probers/ChineseGroupProber.cpp
localization/probers/JapaneseGroupProber.cpp
localization/probers/JpCntx.cpp
localization/probers/LangBulgarianModel.cpp
localization/probers/LangCyrillicModel.cpp
localization/probers/LangGreekModel.cpp
localization/probers/LangHebrewModel.cpp
localization/probers/LangHungarianModel.cpp
localization/probers/LangThaiModel.cpp
localization/probers/UnicodeGroupProber.cpp
localization/probers/nsBig5Prober.cpp
localization/probers/nsCharSetProber.cpp
localization/probers/nsEUCJPProber.cpp
localization/probers/nsEUCKRProber.cpp
localization/probers/nsEUCTWProber.cpp
localization/probers/nsEscCharsetProber.cpp
localization/probers/nsEscSM.cpp
localization/probers/nsGB2312Prober.cpp
localization/probers/nsHebrewProber.cpp
localization/probers/nsLatin1Prober.cpp
localization/probers/nsMBCSGroupProber.cpp
localization/probers/nsMBCSSM.cpp
localization/probers/nsSBCSGroupProber.cpp
localization/probers/nsSBCharSetProber.cpp
localization/probers/nsSJISProber.cpp
localization/probers/nsUniversalDetector.cpp
localization/klocale.cpp
localization/klocale_kde.cpp
localization/klocalizedstring.cpp
localization/kuitsemantics.cpp
localization/kuitformats.cpp
localization/common_helpers.cpp
sycoca/ksycoca.cpp
sycoca/ksycocadict.cpp
sycoca/ksycocaentry.cpp
sycoca/ksycocafactory.cpp
sycoca/kprotocolinfo.cpp
sycoca/kprotocolinfofactory.cpp
sycoca/kmemfile.cpp
text/kascii.cpp
text/kcodecs.cpp
text/kstringhandler.cpp
util/kallocator.cpp
util/kautostart.cpp
util/kdedmodule.cpp
util/kdeversion.cpp
util/klauncher_iface.cpp
util/klibrary.cpp
util/kmacroexpander.cpp
util/kpluginfactory.cpp
util/kpluginloader.cpp
util/kshell.cpp
util/krandom.cpp
util/krandomsequence.cpp
util/qtest_kde.cpp
${kdecore_OPTIONAL_SRCS}
${KAUTH_BACKEND_SRCS}
${KAUTH_HELPER_BACKEND_SRCS}
network/klocalsocket.cpp
network/ksocketfactory.cpp
network/ksslcertificatemanager.cpp
network/ktcpsocket.cpp
localization/kcatalog.cpp
localization/kcurrencycode.cpp
localization/kcharsets.cpp
localization/kencodingdetector.cpp
localization/guess_ja.cpp
localization/kencodingprober.cpp
localization/probers/CharDistribution.cpp
localization/probers/ChineseGroupProber.cpp
localization/probers/JapaneseGroupProber.cpp
localization/probers/JpCntx.cpp
localization/probers/LangBulgarianModel.cpp
localization/probers/LangCyrillicModel.cpp
localization/probers/LangGreekModel.cpp
localization/probers/LangHebrewModel.cpp
localization/probers/LangHungarianModel.cpp
localization/probers/LangThaiModel.cpp
localization/probers/UnicodeGroupProber.cpp
localization/probers/nsBig5Prober.cpp
localization/probers/nsCharSetProber.cpp
localization/probers/nsEUCJPProber.cpp
localization/probers/nsEUCKRProber.cpp
localization/probers/nsEUCTWProber.cpp
localization/probers/nsEscCharsetProber.cpp
localization/probers/nsEscSM.cpp
localization/probers/nsGB2312Prober.cpp
localization/probers/nsHebrewProber.cpp
localization/probers/nsLatin1Prober.cpp
localization/probers/nsMBCSGroupProber.cpp
localization/probers/nsMBCSSM.cpp
localization/probers/nsSBCSGroupProber.cpp
localization/probers/nsSBCharSetProber.cpp
localization/probers/nsSJISProber.cpp
localization/probers/nsUniversalDetector.cpp
localization/klocale.cpp
localization/klocale_kde.cpp
localization/klocalizedstring.cpp
localization/kuitsemantics.cpp
localization/kuitformats.cpp
localization/common_helpers.cpp
sycoca/ksycoca.cpp
sycoca/ksycocadict.cpp
sycoca/ksycocaentry.cpp
sycoca/ksycocafactory.cpp
sycoca/kprotocolinfo.cpp
sycoca/kprotocolinfofactory.cpp
sycoca/kmemfile.cpp
text/kascii.cpp
text/kcodecs.cpp
text/kstringhandler.cpp
util/kallocator.cpp
util/kautostart.cpp
util/kdedmodule.cpp
util/kdeversion.cpp
util/klauncher_iface.cpp
util/klibrary.cpp
util/kmacroexpander.cpp
util/kpluginfactory.cpp
util/kpluginloader.cpp
util/kshell.cpp
util/krandom.cpp
util/krandomsequence.cpp
util/qtest_kde.cpp
kernel/ktoolinvocation_x11.cpp
kernel/kstandarddirs_unix.cpp
localization/klocale_unix.cpp
network/klocalsocket_unix.cpp
network/netsupp.cpp
io/klockfile_unix.cpp
util/kshell_unix.cpp
util/kuser_unix.cpp
util/kmacroexpander_unix.cpp
fakes.c
${kdecore_OPTIONAL_SRCS}
${KAUTH_BACKEND_SRCS}
${KAUTH_HELPER_BACKEND_SRCS}
)
set(kdecore_LIB_SRCS ${kdecore_LIB_SRCS} util/kshareddatacache.cpp)
@ -320,7 +314,7 @@ if (NOT Q_WS_X11 AND NOT Q_WS_QWS)
add_definitions(-DNO_DISPLAY)
endif (NOT Q_WS_X11 AND NOT Q_WS_QWS)
kde4_add_library(kdecore ${LIBRARY_TYPE} ${kdecore_LIB_SRCS})
add_library(kdecore ${LIBRARY_TYPE} ${kdecore_LIB_SRCS})
target_link_libraries(kdecore PRIVATE ${QT_QTCORE_LIBRARY} ${QT_QTNETWORK_LIBRARY} ${QT_QTDBUS_LIBRARY} ${QT_QTXML_LIBRARY} ${ZLIB_LIBRARY} ${kdecore_OPTIONAL_LIBS})
@ -383,7 +377,7 @@ install(TARGETS kauth_helper_plugin
configure_file(localization/all_languages.desktop ${CMAKE_CURRENT_BINARY_DIR}/all_languages @ONLY)
kde4_add_executable(kde4-config NOGUI kde-config.cpp )
add_executable(kde4-config kde-config.cpp )
target_link_libraries(kde4-config ${KDE4_KDECORE_LIBS})

5
kdecore/auth/ConfigureChecks.cmake
View file

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

5
kdecore/kconfig_compiler/CMakeLists.txt
View file

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

39
kded/CMakeLists.txt
View file

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

35
kdesu/CMakeLists.txt
View file

@ -18,23 +18,22 @@ add_feature_info(Sudo SUDO_FOUND "Needed for password caching in kdesu" "http://
########### next target ###############
set(kdesu_LIB_SRCS
client.cpp
process.cpp
kcookie.cpp
su.cpp
ssh.cpp
stub.cpp
)
client.cpp
process.cpp
kcookie.cpp
su.cpp
ssh.cpp
stub.cpp
)
kde4_add_library(kdesu ${LIBRARY_TYPE} ${kdesu_LIB_SRCS})
add_library(kdesu ${LIBRARY_TYPE} ${kdesu_LIB_SRCS})
target_link_libraries(kdesu PRIVATE ${KDE4_KPTY_LIBS} )
target_link_libraries(kdesu PUBLIC ${QT_QTCORE_LIBRARY} )
if(SUDO_FOUND)
set_source_files_properties(su.cpp PROPERTIES
COMPILE_FLAGS -DKDESU_USE_SUDO_DEFAULT)
add_definitions(-DKDESU_USE_SUDO_DEFAULT)
endif(SUDO_FOUND)
set_target_properties(kdesu PROPERTIES
@ -49,12 +48,20 @@ install(TARGETS kdesu EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARG
set(kdesu_stub_SRCS kdesu_stub.c )
kde4_add_executable(kdesu_stub NOGUI ${kdesu_stub_SRCS})
add_executable(kdesu_stub ${kdesu_stub_SRCS})
install(TARGETS kdesu_stub DESTINATION ${LIBEXEC_INSTALL_DIR} )
########### install files ###############
install( FILES kdesu_export.h client.h process.h su.h ssh.h stub.h defaults.h
DESTINATION ${INCLUDE_INSTALL_DIR}/kdesu COMPONENT Devel)
install(FILES
kdesu_export.h
client.h
process.h
su.h
ssh.h
stub.h
defaults.h
DESTINATION ${INCLUDE_INSTALL_DIR}/kdesu
COMPONENT Devel
)

36
kdeui/CMakeLists.txt
View file

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

1
kdeui/dialogs/kshortcutschemeseditor.cpp
View file

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

1
kdeui/dialogs/kshortcutseditor.cpp
View file

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

1
kdeui/dialogs/kshortcutseditoritem.cpp
View file

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

2
kdewebkit/CMakeLists.txt
View file

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

2
kdewebkit/kwebkitpart/kdelauncher/CMakeLists.txt
View file

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

5
kdewebkit/kwebkitpart/src/CMakeLists.txt
View file

@ -24,10 +24,7 @@ set(kwebkit_LIB_SRCS
settings/webkit_filter.cpp
ui/searchbar.cpp
ui/passwordbar.cpp
)
kde4_add_ui_files(kwebkit_LIB_SRCS
ui/searchbar.ui
ui/searchbar.ui
)
########################### kwebkitpart #############################

84
kdewidgets/CMakeLists.txt
View file

@ -1,22 +1,21 @@
project(kdewidgets)
add_subdirectory( pics )
add_subdirectory( tests )
if(ENABLE_TESTING)
add_subdirectory(tests)
endif()
include_directories(
${KDE4_KIO_INCLUDES}
)
add_subdirectory(pics)
include_directories(${KDE4_KIO_INCLUDES})
########### next target ###############
set(makekdewidgets_SRCS makekdewidgets.cpp )
add_executable(makekdewidgets ${makekdewidgets_SRCS})
kde4_add_executable(makekdewidgets NOGUI ${makekdewidgets_SRCS})
target_link_libraries(makekdewidgets ${KDE4_KDECORE_LIBS} )
target_link_libraries(makekdewidgets ${KDE4_KDECORE_LIBS})
# "export" this target too so we can use the LOCATION property of the imported target in
# FindKDE4Internal.cmake to get the full path to the installed executable instead of using FIND_PROGRAM(), Alex
@ -26,65 +25,38 @@ install(TARGETS makekdewidgets EXPORT kdelibsToolsTargets ${INSTALL_TARGETS_DEF
########### next target ###############
if(QT_QTDESIGNER_FOUND)
# get the name of the generated wrapper script (which sets up LD_LIBRARY_PATH)
get_target_property(MAKEKDEWIDGETS_EXECUTABLE makekdewidgets WRAPPER_SCRIPT)
KDE4_ADD_WIDGET_FILES(kde.widgets)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp
COMMAND "${MAKEKDEWIDGETS_EXECUTABLE}" -o ${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp ${CMAKE_CURRENT_SOURCE_DIR}/kde.widgets
MAIN_DEPENDENCY kde.widgets DEPENDS makekdewidgets)
set(kdewidgets_PART_SRCS
classpreviews.cpp
$<TARGET_OBJECTS:kde_autowidgets>
)
set(kdewidgets_PART_SRCS
classpreviews.cpp
${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp
)
qt4_add_resources(kdewidgets_PART_SRCS kdewidgets.qrc)
qt4_generate_moc(${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.cpp ${CMAKE_CURRENT_BINARY_DIR}/kdewidgets.moc)
kde4_add_plugin(kdewidgets ${kdewidgets_PART_SRCS})
target_link_libraries(kdewidgets ${KDE4_KIO_LIBS})
qt4_add_resources(kdewidgets_PART_SRCS kdewidgets.qrc)
install(TARGETS kdewidgets DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer )
kde4_add_plugin(kdewidgets ${kdewidgets_PART_SRCS})
# kdewebkit widgets
include_directories(${CMAKE_SOURCE_DIR}/kdewebkit)
target_link_libraries(kdewidgets ${KDE4_KIO_LIBS})
set_target_properties(kdewidgets PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_RPATH ${LIB_INSTALL_DIR}
)
KDE4_ADD_WIDGET_FILES(kdewebkit.widgets)
install(TARGETS kdewidgets DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer )
set(kdewebkitwidgets_PART_SRCS
classpreviews.cpp
$<TARGET_OBJECTS:kdewebkit_autowidgets>
)
# kdewebkit widgets
include_directories(
${CMAKE_SOURCE_DIR}/kdewebkit
)
qt4_add_resources(kdewebkitwidgets_PART_SRCS kdewebkitwidgets.qrc)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp
COMMAND "${MAKEKDEWIDGETS_EXECUTABLE}" -o ${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp ${CMAKE_CURRENT_SOURCE_DIR}/kdewebkit.widgets
MAIN_DEPENDENCY kdewebkit.widgets DEPENDS makekdewidgets)
kde4_add_plugin(kdewebkitwidgets ${kdewebkitwidgets_PART_SRCS})
set(kdewebkitwidgets_PART_SRCS
classpreviews.cpp
${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp
)
target_link_libraries(kdewebkitwidgets ${KDE4_KDEUI_LIBS} ${KDE4_KDEWEBKIT_LIBS} ${QT_QTWEBKIT_LIBRARY})
qt4_generate_moc(${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.cpp ${CMAKE_CURRENT_BINARY_DIR}/kdewebkitwidgets.moc)
qt4_add_resources(kdewebkitwidgets_PART_SRCS kdewebkitwidgets.qrc)
kde4_add_plugin(kdewebkitwidgets ${kdewebkitwidgets_PART_SRCS})
target_link_libraries(kdewebkitwidgets ${KDE4_KDEUI_LIBS} ${KDE4_KDEWEBKIT_LIBS} ${QT_QTWEBKIT_LIBRARY})
set_target_properties(kdewebkitwidgets PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_RPATH ${LIB_INSTALL_DIR}
)
install(TARGETS kdewebkitwidgets DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer )
install(TARGETS kdewebkitwidgets DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer)
endif (QT_QTDESIGNER_FOUND)
########### install files ###############

18
kdewidgets/makekdewidgets.cpp
View file

@ -15,15 +15,15 @@
#include <QtCore/QTextStream>
static const char classHeader[] = "/**\n"
"* This file was autogenerated by makekdewidgets. Any changes will be lost!\n"
"* The generated code in this file is licensed under the same license that the\n"
"* input file.\n"
"*/\n"
"#include <QtGui/qicon.h>\n"
"#include <QtDesigner/container.h>\n"
"#include <QtDesigner/customwidget.h>\n"
"#include <QtCore/qplugin.h>\n"
"#include <QtCore/qdebug.h>\n";
"* This file was autogenerated by makekdewidgets. Any changes will be lost!\n"
"* The generated code in this file is licensed under the same license that the\n"
"* input file.\n"
"*/\n"
"#include <QtGui/qicon.h>\n"
"#include <QtDesigner/container.h>\n"
"#include <QtDesigner/customwidget.h>\n"
"#include <QtCore/qplugin.h>\n"
"#include <QtCore/qdebug.h>\n";
static const char collClassDef[] = "class %CollName : public QObject, public QDesignerCustomWidgetCollectionInterface\n"
"{\n"

95
kfile/CMakeLists.txt
View file

@ -1,41 +1,43 @@
project(kfile)
include_directories(
${KDE4_KIO_INCLUDES}
${CMAKE_SOURCE_DIR}/solid
${CMAKE_BINARY_DIR}/solid
${KDE4_KIO_INCLUDES}
${CMAKE_SOURCE_DIR}/solid
${CMAKE_BINARY_DIR}/solid
)
add_subdirectory(tests)
if(ENABLE_TESTING)
add_subdirectory(tests)
endif()
set(kfile_LIB_SRCS
kdiroperator.cpp
kdiroperatordetailview.cpp
kdirselectdialog.cpp
kdirsortfilterproxymodel.cpp #used in combination with kio/kio/kdirmodel.cpp
kfilebookmarkhandler.cpp
kfilefiltercombo.cpp
kfiletreeview.cpp
kfilewidget.cpp
kfileplacesitem.cpp
kfileplacesmodel.cpp
kfileplacessharedbookmarks.cpp
kfileplacesview.cpp
kfileplaceeditdialog.cpp
kfilepreviewgenerator.cpp
knameandurlinputdialog.cpp
knewfilemenu.cpp
kurlnavigatordropdownbutton.cpp
kurlnavigatorbuttonbase.cpp
kurlnavigatorbutton.cpp
kurlnavigatorplacesselector.cpp
kurlnavigatorprotocolcombo.cpp
kurlnavigatortogglebutton.cpp
kurlnavigator.cpp
kurlnavigatormenu.cpp
kdiroperator.cpp
kdiroperatordetailview.cpp
kdirselectdialog.cpp
kdirsortfilterproxymodel.cpp # used in combination with kio/kio/kdirmodel.cpp
kfilebookmarkhandler.cpp
kfilefiltercombo.cpp
kfiletreeview.cpp
kfilewidget.cpp
kfileplacesitem.cpp
kfileplacesmodel.cpp
kfileplacessharedbookmarks.cpp
kfileplacesview.cpp
kfileplaceeditdialog.cpp
kfilepreviewgenerator.cpp
knameandurlinputdialog.cpp
knewfilemenu.cpp
kurlnavigatordropdownbutton.cpp
kurlnavigatorbuttonbase.cpp
kurlnavigatorbutton.cpp
kurlnavigatorplacesselector.cpp
kurlnavigatorprotocolcombo.cpp
kurlnavigatortogglebutton.cpp
kurlnavigator.cpp
kurlnavigatormenu.cpp
)
kde4_add_library(kfile ${LIBRARY_TYPE} ${kfile_LIB_SRCS})
add_library(kfile ${LIBRARY_TYPE} ${kfile_LIB_SRCS})
target_link_libraries(kfile PRIVATE
${KDE4_KIO_LIBS}
${ZLIB_LIBRARY}
@ -56,26 +58,31 @@ set_target_properties(kfile PROPERTIES VERSION ${GENERIC_LIB_VERSION}
install(TARGETS kfile EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
install( FILES
kdiroperator.h
kdirselectdialog.h
kdirsortfilterproxymodel.h
kfilefiltercombo.h
kfileplacesmodel.h
kfileplacesview.h
kfilepreviewgenerator.h
kfiletreeview.h
kfilewidget.h
kurlnavigator.h
knewfilemenu.h
knameandurlinputdialog.h
kfile_export.h
DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel )
kdiroperator.h
kdirselectdialog.h
kdirsortfilterproxymodel.h
kfilefiltercombo.h
kfileplacesmodel.h
kfileplacesview.h
kfilepreviewgenerator.h
kfiletreeview.h
kfilewidget.h
kurlnavigator.h
knewfilemenu.h
knameandurlinputdialog.h
kfile_export.h
DESTINATION ${INCLUDE_INSTALL_DIR}
COMPONENT Devel
)
############ module used by KFileDialog ##########
set(kfilemodule_SRCS
kfilemodule.cpp
kfilemodule.cpp
)
kde4_add_plugin(kfilemodule ${kfilemodule_SRCS})
target_link_libraries(kfilemodule ${KDE4_KFILE_LIBS} ${KDE4_KIO_LIBS})
install(TARGETS kfilemodule DESTINATION ${PLUGIN_INSTALL_DIR})
install(FILES kfilemodule.desktop DESTINATION ${SERVICES_INSTALL_DIR})

33
kinit/CMakeLists.txt
View file

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

23
kio/CMakeLists.txt
View file

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

2
kio/kio/dummyanalyzers/CMakeLists.txt
View file

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

10
kio/kssl/kcm/CMakeLists.txt
View file

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

1
kio/kssl/kcm/cacertificatespage.cpp
View file

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

2
kio/kssl/kcm/displaycertdialog.cpp
View file

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

1
kio/kssl/kcm/displaycertdialog_p.h
View file

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

27
kio/misc/CMakeLists.txt
View file

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

2
kio/misc/kntlm/CMakeLists.txt
View file

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

2
kio/misc/kpac/CMakeLists.txt
View file

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

37
kioslave/http/CMakeLists.txt
View file

@ -1,7 +1,5 @@
project(kioslave-http)
macro_optional_find_package(GSSAPI)
set_package_properties(GSSAPI PROPERTIES DESCRIPTION "Allows KIO to make use of certain HTTP authentication services"
URL "http://web.mit.edu/kerberos/www"
@ -31,52 +29,51 @@ include_directories( ${KDE4_KIO_INCLUDES} ${ZLIB_INCLUDE_DIR} ${CMAKE_SOURCE_DIR
${CMAKE_BINARY_DIR}/solid )
include_directories( ${CMAKE_SOURCE_DIR}/interfaces ${CMAKE_SOURCE_DIR}/kio/httpfilter )
add_subdirectory( kcookiejar )
add_subdirectory( tests )
add_subdirectory(kcookiejar)
if(ENABLE_TESTING)
add_subdirectory(tests)
endif()
########### next target ###############
set(kio_http_cache_cleaner_SRCS
http_cache_cleaner.cpp
)
http_cache_cleaner.cpp
)
kde4_add_executable( kio_http_cache_cleaner NOGUI ${kio_http_cache_cleaner_SRCS})
add_executable(kio_http_cache_cleaner ${kio_http_cache_cleaner_SRCS})
target_link_libraries(kio_http_cache_cleaner ${KDE4_KIO_LIBS} ${ZLIB_LIBRARY})
install(TARGETS kio_http_cache_cleaner DESTINATION ${LIBEXEC_INSTALL_DIR} )
install(TARGETS kio_http_cache_cleaner DESTINATION ${LIBEXEC_INSTALL_DIR})
########### next target ###############
# kio/httpfilter/Makefile.am: httpfilter
set(kio_http_PART_SRCS
http.cpp
httpauthentication.cpp
${httpfilter_STAT_SRCS}
${CMAKE_SOURCE_DIR}/kio/httpfilter/httpfilter.cc
)
http.cpp
httpauthentication.cpp
${httpfilter_STAT_SRCS}
${CMAKE_SOURCE_DIR}/kio/httpfilter/httpfilter.cc
)
kde4_add_plugin(kio_http ${kio_http_PART_SRCS})
target_link_libraries(kio_http ${KDE4_KIO_LIBS} ${KDE4_SOLID_LIBS} kntlm ${ZLIB_LIBRARY} )
if(GSSAPI_FOUND)
target_link_libraries(kio_http ${GSSAPI_LIBS} )
target_link_libraries(kio_http ${GSSAPI_LIBS} )
endif(GSSAPI_FOUND)
install(TARGETS kio_http DESTINATION ${PLUGIN_INSTALL_DIR} )
########### install files ###############
install( FILES
install(FILES
http_cache_cleaner.desktop
http.protocol
https.protocol
webdav.protocol
webdavs.protocol
DESTINATION ${SERVICES_INSTALL_DIR} )
DESTINATION ${SERVICES_INSTALL_DIR}
)

14
kioslave/http/kcookiejar/CMakeLists.txt
View file

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

38
knotify/CMakeLists.txt
View file

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

37
knotify/config/CMakeLists.txt
View file

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

Some files were not shown because too many files have changed in this diff Show more