Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-23 18:32:49 +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 ################# ################# 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}) 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 ################# ################# setup the include directories #################
# for including config.h and for includes like <kparts/foo.h> # 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. # Those variables for are only valid inside of kdelibs, of course.
# Use the one variable for the lib you depend upon. # 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}. # E.g. kdeui uses ${KDE4_KDECORE_INCLUDES}. Something that depends on kparts uses ${KDE4_KPARTS_INCLUDES}.
# kdecore depends on Qt # kdecore depends on Qt
set(KDE4_KDECORE_INCLUDES ${KDE4_KDECORE_INCLUDES} set(KDE4_KDECORE_INCLUDES
${CMAKE_SOURCE_DIR}/kdecore ${KDE4_KDECORE_INCLUDES}
${CMAKE_BINARY_DIR}/kdecore ${CMAKE_SOURCE_DIR}/kdecore
${CMAKE_SOURCE_DIR}/kdecore/compression ${CMAKE_BINARY_DIR}/kdecore
${CMAKE_SOURCE_DIR}/kdecore/config ${CMAKE_SOURCE_DIR}/kdecore/compression
${CMAKE_SOURCE_DIR}/kdecore/date ${CMAKE_SOURCE_DIR}/kdecore/config
${CMAKE_SOURCE_DIR}/kdecore/io ${CMAKE_SOURCE_DIR}/kdecore/date
${CMAKE_SOURCE_DIR}/kdecore/jobs ${CMAKE_SOURCE_DIR}/kdecore/io
${CMAKE_SOURCE_DIR}/kdecore/kernel ${CMAKE_SOURCE_DIR}/kdecore/jobs
${CMAKE_SOURCE_DIR}/kdecore/auth ${CMAKE_SOURCE_DIR}/kdecore/kernel
${CMAKE_SOURCE_DIR}/kdecore/network ${CMAKE_SOURCE_DIR}/kdecore/auth
${CMAKE_SOURCE_DIR}/kdecore/services ${CMAKE_SOURCE_DIR}/kdecore/network
${CMAKE_SOURCE_DIR}/kdecore/localization ${CMAKE_SOURCE_DIR}/kdecore/services
${CMAKE_SOURCE_DIR}/kdecore/sycoca ${CMAKE_SOURCE_DIR}/kdecore/localization
${CMAKE_SOURCE_DIR}/kdecore/text ${CMAKE_SOURCE_DIR}/kdecore/sycoca
${CMAKE_SOURCE_DIR}/kdecore/util ${CMAKE_SOURCE_DIR}/kdecore/text
${CMAKE_SOURCE_DIR}/kdecore/sonnet ${CMAKE_SOURCE_DIR}/kdecore/util
${QT_INCLUDES} ${CMAKE_SOURCE_DIR}/kdecore/sonnet
${_KDE4_PLATFORM_INCLUDE_DIRS}) ${QT_INCLUDES}
${_KDE4_PLATFORM_INCLUDE_DIRS}
)
# kdeui depends on kdecore # kdeui depends on kdecore
set(KDE4_KDEUI_INCLUDES ${CMAKE_SOURCE_DIR}/kdeui set(KDE4_KDEUI_INCLUDES
${CMAKE_SOURCE_DIR}/kdeui/actions ${CMAKE_SOURCE_DIR}/kdeui
${CMAKE_SOURCE_DIR}/kdeui/colors ${CMAKE_SOURCE_DIR}/kdeui/actions
${CMAKE_SOURCE_DIR}/kdeui/config ${CMAKE_SOURCE_DIR}/kdeui/colors
${CMAKE_SOURCE_DIR}/kdeui/dialogs ${CMAKE_SOURCE_DIR}/kdeui/config
${CMAKE_SOURCE_DIR}/kdeui/findreplace ${CMAKE_SOURCE_DIR}/kdeui/dialogs
${CMAKE_SOURCE_DIR}/kdeui/fonts ${CMAKE_SOURCE_DIR}/kdeui/findreplace
${CMAKE_SOURCE_DIR}/kdeui/icons ${CMAKE_SOURCE_DIR}/kdeui/fonts
${CMAKE_SOURCE_DIR}/kdeui/itemviews ${CMAKE_SOURCE_DIR}/kdeui/icons
${CMAKE_SOURCE_DIR}/kdeui/jobs ${CMAKE_SOURCE_DIR}/kdeui/itemviews
${CMAKE_SOURCE_DIR}/kdeui/kernel ${CMAKE_SOURCE_DIR}/kdeui/jobs
${CMAKE_SOURCE_DIR}/kdeui/notifications ${CMAKE_SOURCE_DIR}/kdeui/kernel
${CMAKE_SOURCE_DIR}/kdeui/paged ${CMAKE_SOURCE_DIR}/kdeui/notifications
${CMAKE_SOURCE_DIR}/kdeui/plotting ${CMAKE_SOURCE_DIR}/kdeui/paged
${CMAKE_SOURCE_DIR}/kdeui/shortcuts ${CMAKE_SOURCE_DIR}/kdeui/plotting
${CMAKE_SOURCE_DIR}/kdeui/sonnet ${CMAKE_SOURCE_DIR}/kdeui/shortcuts
${CMAKE_SOURCE_DIR}/kdeui/util ${CMAKE_SOURCE_DIR}/kdeui/sonnet
${CMAKE_SOURCE_DIR}/kdeui/widgets ${CMAKE_SOURCE_DIR}/kdeui/util
${CMAKE_SOURCE_DIR}/kdeui/windowmanagement ${CMAKE_SOURCE_DIR}/kdeui/widgets
${CMAKE_SOURCE_DIR}/kdeui/xmlgui ${CMAKE_SOURCE_DIR}/kdeui/windowmanagement
${KDE4_KDECORE_INCLUDES}) ${CMAKE_SOURCE_DIR}/kdeui/xmlgui
${KDE4_KDECORE_INCLUDES}
)
# kio depends on kdeui # kio depends on kdeui
set(KDE4_KIO_INCLUDES ${CMAKE_SOURCE_DIR}/kio set(KDE4_KIO_INCLUDES
${CMAKE_SOURCE_DIR}/kio/bookmarks ${CMAKE_SOURCE_DIR}/kio
${CMAKE_SOURCE_DIR}/kio/kio ${CMAKE_SOURCE_DIR}/kio/bookmarks
${CMAKE_SOURCE_DIR}/kio/kfile ${CMAKE_SOURCE_DIR}/kio/kio
${KDE4_KDEUI_INCLUDES}) ${CMAKE_SOURCE_DIR}/kio/kfile
${KDE4_KDEUI_INCLUDES}
)
# kpty # 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 # kparts depends on kio
set(KDE4_KPARTS_INCLUDES ${CMAKE_SOURCE_DIR}/kparts set(KDE4_KPARTS_INCLUDES
${KDE4_KIO_INCLUDES}) ${CMAKE_SOURCE_DIR}/kparts
${KDE4_KIO_INCLUDES}
)
################# configure checks and create the configured files ################# ################# 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)" install(CODE "set(EXPORT_FILES KDELibs4LibraryTargets.cmake KDELibs4ToolsTargets.cmake)"
CODE "set(EXPORT_INSTALL_DIR \"${DATA_INSTALL_DIR}/cmake/modules\")" CODE "set(EXPORT_INSTALL_DIR \"${DATA_INSTALL_DIR}/cmake/modules\")"
SCRIPT "${CMAKE_SOURCE_DIR}/cmake/modules/check_installed_exports_file.cmake" ) SCRIPT "${CMAKE_SOURCE_DIR}/cmake/modules/check_installed_exports_file.cmake" )
install( EXPORT kdelibsLibraryTargets DESTINATION ${DATA_INSTALL_DIR}/cmake/modules NAMESPACE ${KDE4_TARGET_PREFIX} FILE KDELibs4LibraryTargets.cmake ) install(EXPORT kdelibsLibraryTargets
install( EXPORT kdelibsToolsTargets DESTINATION ${DATA_INSTALL_DIR}/cmake/modules NAMESPACE ${KDE4_TARGET_PREFIX} FILE KDELibs4ToolsTargets.cmake ) DESTINATION ${DATA_INSTALL_DIR}/cmake/modules
NAMESPACE ${KDE4_TARGET_PREFIX}
FILE KDELibs4LibraryTargets.cmake
)
install(EXPORT kdelibsToolsTargets
DESTINATION ${DATA_INSTALL_DIR}/cmake/modules
NAMESPACE ${KDE4_TARGET_PREFIX}
FILE KDELibs4ToolsTargets.cmake
)
# the following will be the correct locations once cmake has the improved FIND_PACKAGE() # 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 feature_summary(WHAT ALL
INCLUDE_QUIET_PACKAGES INCLUDE_QUIET_PACKAGES
FATAL_ON_MISSING_REQUIRED_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 # to have it around, so there is a place where the modules which are not installed
# are listed explicitly: # are listed explicitly:
set(cmakeFilesDontInstall set(cmakeFilesDontInstall
FindHUpnp.cmake FindHUpnp.cmake
FindUDev.cmake FindUDev.cmake
) )
# Explicitly list all files which will be installed. # Explicitly list all files which will be installed.
# We don't use a GLOB anymore so we can have also cmake files here # 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 # so become part of the public interface of kdelibs which has to be kept
# compatible). # compatible).
set(cmakeFiles set(cmakeFiles
CheckPointerMember.cmake CheckPointerMember.cmake
CheckPrototypeExists.cmake CheckPrototypeExists.cmake
CheckStructMember.cmake CheckStructMember.cmake
FindACL.cmake FindACL.cmake
FindAGG.cmake FindAGG.cmake
FindAkode.cmake FindAkode.cmake
FindAlsa.cmake FindAlsa.cmake
FindAutomoc4.cmake FindAvahi.cmake
FindAvahi.cmake FindBerkeleyDB.cmake
FindBerkeleyDB.cmake FindBlueZ.cmake
FindBlueZ.cmake FindCarbon.cmake
FindCarbon.cmake FindDBusMenuQt.cmake
FindDBusMenuQt.cmake FindDNSSD.cmake
FindDNSSD.cmake FindENCHANT.cmake
FindENCHANT.cmake FindEigen.cmake
FindEigen.cmake FindEigen2.cmake
FindEigen2.cmake FindExiv2.cmake
FindExiv2.cmake FindFAM.cmake
FindFAM.cmake FindFFmpeg.cmake
FindFFmpeg.cmake FindFlac.cmake
FindFlac.cmake FindFlex.cmake
FindFlex.cmake FindFontconfig.cmake
FindFontconfig.cmake FindGLIB2.cmake
FindGLIB2.cmake FindGMP.cmake
FindGMP.cmake FindGObject.cmake
FindGObject.cmake FindGSSAPI.cmake
FindGSSAPI.cmake FindGStreamer.cmake
FindGStreamer.cmake FindGettext.cmake
FindGettext.cmake FindGphoto2.cmake
FindGphoto2.cmake FindHUNSPELL.cmake
FindHUNSPELL.cmake FindKDE4Internal.cmake
FindKDE4Internal.cmake FindKDE4Workspace.cmake
FindKDE4Workspace.cmake FindKDevPlatform.cmake
FindKDevPlatform.cmake FindKdcraw.cmake
FindKdcraw.cmake FindKdeMultimedia.cmake
FindKdeMultimedia.cmake FindKdepim.cmake
FindKdepim.cmake FindKdepimLibs.cmake
FindKdepimLibs.cmake FindKexiv2.cmake
FindKexiv2.cmake FindKipi.cmake
FindKipi.cmake FindKopete.cmake
FindKopete.cmake FindKorundum.cmake
FindKorundum.cmake FindLCMS.cmake
FindLCMS.cmake FindLibArt.cmake
FindLibArt.cmake FindLibAttica.cmake
FindLibAttica.cmake FindLibKonq.cmake
FindLibKonq.cmake FindLibLZMA.cmake
FindLibLZMA.cmake FindLibXslt.cmake
FindLibXslt.cmake FindLibintl.cmake
FindLibintl.cmake FindLinuxWirelesstools.cmake
FindLibraryWithDebug.cmake FindMsgfmt.cmake
FindLinuxWirelesstools.cmake FindMusicBrainz.cmake
FindMsgfmt.cmake FindMySQL.cmake
FindMusicBrainz.cmake FindNetworkManager.cmake
FindMySQL.cmake FindOggVorbis.cmake
FindNetworkManager.cmake FindOpenEXR.cmake
FindOggVorbis.cmake FindPCRE.cmake
FindOpenEXR.cmake FindPhonon.cmake
FindPCRE.cmake FindPopplerQt4.cmake
FindPhonon.cmake FindPostgreSQL.cmake
FindPopplerQt4.cmake FindPulseAudio.cmake
FindPostgreSQL.cmake FindPyKDE4.cmake
FindPulseAudio.cmake FindPyQt4.cmake
FindPyKDE4.cmake Qt4Macros.cmake
FindPyQt4.cmake Qt4ConfigDependentSettings.cmake
Qt4Macros.cmake FindPythonLibrary.cmake
Qt4ConfigDependentSettings.cmake FindQCA2.cmake
KatieMacros.cmake FindQImageBlitz.cmake
FindPythonLibrary.cmake FindQt4.cmake
FindQCA2.cmake FindRUBY.cmake
FindQImageBlitz.cmake FindSIP.cmake
FindQt4.cmake FindSamba.cmake
FindKatie.cmake FindSane.cmake
FindRUBY.cmake FindSasl2.cmake
FindSIP.cmake FindSharedMimeInfo.cmake
FindSamba.cmake FindSqlite.cmake
FindSane.cmake FindStrigi.cmake
FindSasl2.cmake FindTaglib.cmake
FindSharedMimeInfo.cmake FindUDisks2.cmake
FindSqlite.cmake FindUSB.cmake
FindStrigi.cmake FindWcecompat.cmake
FindTaglib.cmake FindX11.cmake
FindUDisks2.cmake FindXKB.cmake
FindUSB.cmake FindXine.cmake
FindWcecompat.cmake FindXmms.cmake
FindX11.cmake HandleImportedTargetsInCMakeRequiredLibraries.cmake
FindXKB.cmake KDE4Defaults.cmake
FindXine.cmake KDE4Macros.cmake
FindXmms.cmake MacroAddCompileFlags.cmake
HandleImportedTargetsInCMakeRequiredLibraries.cmake MacroAddLinkFlags.cmake
KDE4Defaults.cmake MacroAdditionalCleanFiles.cmake
KDE4Macros.cmake MacroAppendIf.cmake
MacroAddCompileFlags.cmake MacroBoolTo01.cmake
MacroAddLinkFlags.cmake MacroEnsureVersion.cmake
MacroAdditionalCleanFiles.cmake MacroLibrary.cmake
MacroAppendIf.cmake MacroLogFeature.cmake
MacroBoolTo01.cmake MacroOptionalAddSubdirectory.cmake
MacroEnsureOutOfSourceBuild.cmake MacroOptionalDependPackage.cmake
MacroEnsureVersion.cmake MacroOptionalFindPackage.cmake
MacroLibrary.cmake MacroPushRequiredVars.cmake
MacroLogFeature.cmake MacroWriteBasicCMakeVersionFile.cmake
MacroOptionalAddSubdirectory.cmake PythonMacros.cmake
MacroOptionalDependPackage.cmake SIPMacros.cmake
MacroOptionalFindPackage.cmake check_installed_exports_file.cmake
MacroPushRequiredVars.cmake config-alsa.h.cmake
MacroWriteBasicCMakeVersionFile.cmake create_exe_symlink.cmake
PythonMacros.cmake kde4uic.cmake
SIPMacros.cmake cmake-modules-styleguide.txt
check_installed_exports_file.cmake kde4_cmake_uninstall.cmake.in
config-alsa.h.cmake BasicFindPackageVersion.cmake.in
create_exe_symlink.cmake FindLibPython.py
kde4_exec_via_sh.cmake FindPyKDE4.py
kde4uic.cmake FindPyQt.py
cmake-modules-styleguide.txt FindSIP.py
kde4init_dummy.cpp.in PythonCompile.py
kde4_cmake_uninstall.cmake.in )
BasicFindPackageVersion.cmake.in
FindLibPython.py
FindPyKDE4.py
FindPyQt.py
FindSIP.py
PythonCompile.py
)
install(FILES ${cmakeFiles} install(FILES ${cmakeFiles} DESTINATION ${module_install_dir})
DESTINATION ${module_install_dir} )
# the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex
#set(FILES_TO_REMOVE
#)
#install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake )
#file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, don't edit\n\n")
#foreach ( _current_FILE ${FILES_TO_REMOVE})
# file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${_current_FILE}\" )\n" )
# file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${_current_FILE} OUTPUT_VARIABLE _dummy)\n" )
#endforeach ( _current_FILE)
if(NOT CMAKE_VERSION VERSION_GREATER 2.8.12)
# create and install a man page for the kdelibs cmake modules
add_custom_target(KDECMakeModulesManPage ALL COMMAND ${CMAKE_COMMAND} -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR} --help-custom-modules ${CMAKE_CURRENT_BINARY_DIR}/kdecmake.1)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/kdecmake.1 DESTINATION "${MAN_INSTALL_DIR}/man1")
endif()

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_BUILD_TESTS - enable this to build the testcases
# KDE4_ENABLE_FPIE - enable it to use gcc Position Independent Executables feature # 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 # KDE4_SERIALIZE_TOOL - wrapper to serialize potentially resource-intensive commands during
# parallel builds (set to 'icecc' when using icecream) # parallel builds (set to 'icecc' when using icecream)
# #
@ -219,18 +216,6 @@
# KGlobal::dirs()->addResourceDir( "data", KDESRCDIR ) # 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() # KDE4_UPDATE_ICONCACHE()
# Notifies the icon cache that new icons have been installed by updating # Notifies the icon cache that new icons have been installed by updating
# mtime of ${ICON_INSTALL_DIR}/hicolor directory. # mtime of ${ICON_INSTALL_DIR}/hicolor directory.
@ -438,23 +423,14 @@ if (_kdeBootStrapping)
set(EXECUTABLE_OUTPUT_PATH ${kdelibs_BINARY_DIR}/bin ) set(EXECUTABLE_OUTPUT_PATH ${kdelibs_BINARY_DIR}/bin )
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib ) set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib )
set(KDE4_KCFGC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler${CMAKE_EXECUTABLE_SUFFIX}.shell ) set(KDE4_KCFGC_EXECUTABLE kconfig_compiler${CMAKE_EXECUTABLE_SUFFIX} )
set(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets${CMAKE_EXECUTABLE_SUFFIX}.shell ) set(KDE4_MAKEKDEWIDGETS_EXECUTABLE makekdewidgets${CMAKE_EXECUTABLE_SUFFIX} )
set(KDE4_LIB_DIR ${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}) 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) set(KDE4_INSTALLED_VERSION_OK TRUE)
else (_kdeBootStrapping) else (_kdeBootStrapping)
# ... but NOT otherwise
set( _KDE4_KCONFIG_COMPILER_DEP)
set( _KDE4_MAKEKDEWIDGETS_DEP)
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib ) set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib )
# These files contain information about the installed kdelibs, Alex # 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. # 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 # 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: # 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) if (KDE4_FIND_VERSION_MAJOR)
set(KDE_MIN_VERSION "${KDE4_FIND_VERSION_MAJOR}.${KDE4_FIND_VERSION_MINOR}.${KDE4_FIND_VERSION_PATCH}") 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") set(KDE_MIN_VERSION "4.14.3")
endif (KDE4_FIND_VERSION_MAJOR) endif()
endif (NOT KDE_MIN_VERSION) endif()
#message(FATAL_ERROR "KDE_MIN_VERSION=${KDE_MIN_VERSION} found ${KDE_VERSION} exact: -${KDE4_FIND_VERSION_EXACT}- version: -${KDE4_FIND_VERSION}-") #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, # 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 # 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_LIB_DIR ${KDE4_LIB_INSTALL_DIR})
set(KDE4_INCLUDE_DIR ${KDE4_INCLUDE_INSTALL_DIR} ) set(KDE4_INCLUDE_DIR ${KDE4_INCLUDE_INSTALL_DIR})
# This setting is currently not recorded in KDELibsDependencies.cmake: # 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) 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(PLASMA plasma "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(SOLID solid "${KDE4_TARGET_PREFIX}") _kde4_set_lib_variables(SOLID solid "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(THREADWEAVER threadweaver "${KDE4_TARGET_PREFIX}") _kde4_set_lib_variables(THREADWEAVER threadweaver "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(KDEFAKES kdefakes "${KDE4_TARGET_PREFIX}")
if (UNIX) _kde4_set_lib_variables(KDESU kdesu "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(KDEFAKES kdefakes "${KDE4_TARGET_PREFIX}") _kde4_set_lib_variables(KPTY kpty "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(KDESU kdesu "${KDE4_TARGET_PREFIX}")
_kde4_set_lib_variables(KPTY kpty "${KDE4_TARGET_PREFIX}")
endif (UNIX)
################### try to find Phonon ############################################ ################### try to find Phonon ############################################
@ -583,24 +555,25 @@ set(KDE4_PHONON_LIBS ${PHONON_LIBS})
set(KDE4_PHONON_INCLUDES ${PHONON_INCLUDES}) set(KDE4_PHONON_INCLUDES ${PHONON_INCLUDES})
if(NOT PHONON_FOUND) if(NOT PHONON_FOUND)
message(STATUS "KDE4 not found, because Phonon was not found") message(STATUS "KDE4 not found, because Phonon was not found")
return() return()
endif(NOT PHONON_FOUND) endif(NOT PHONON_FOUND)
##################### provide some options ########################################## ##################### 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") set(KDE4_SERIALIZE_TOOL "" CACHE STRING "Tool to serialize resource-intensive commands in parallel builds")
# if CMake 2.6.3 or above is used, provide an option which should be used by other KDE packages # for CMake 2.6.3 or above, provide an option which should be used by other KDE
# whether to install a CMake FooConfig.cmake into lib/foo/cmake/ or /lib/cmake/foo/ # packages whether to install a CMake FooConfig.cmake into lib/foo/cmake/ or
# (with 2.6.3 and above also lib/cmake/foo/ is supported): # /lib/cmake/foo/ (with 2.6.3 and above also lib/cmake/foo/ is supported):
if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} VERSION_GREATER 2.6.2) option(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR
option(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR "Prefer to install the <package>Config.cmake files to lib/cmake/<package> instead to lib/<package>/cmake" TRUE) "Prefer to install the <package>Config.cmake files to lib/cmake/<package> instead to lib/<package>/cmake"
else(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} VERSION_GREATER 2.6.2) TRUE
set(KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR FALSE) )
endif(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} VERSION_GREATER 2.6.2)
# Position-Independent-Executable is a feature of Binutils, Libc, and GCC that creates an executable # 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. # 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(LIB_SUFFIX "${_Init_LIB_SUFFIX}" CACHE STRING "Define suffix of directory name (32/64)" )
set(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
set(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share")
set(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin")
set(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin")
set(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
set(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec")
set(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include")
########## the following are directories where stuff will be installed to ########### set(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4")
# set(IMPORTS_INSTALL_DIR "${PLUGIN_INSTALL_DIR}/imports")
# this has to be after find_xxx() block above, since there KDELibsDependencies.cmake is included set(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config")
# which contains the install dirs from kdelibs, which are reused below set(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps")
set(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons")
set(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg")
set(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale")
set(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk")
set(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/services")
set(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes")
set(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds")
set(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates")
set(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers")
set(DEMO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/demos")
set(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update")
set(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart")
# This macro implements some very special logic how to deal with the cache. set(XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/kde4")
# By default the various install locations inherit their value from their "parent" variable set(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories")
# so if you set CMAKE_INSTALL_PREFIX, then EXEC_INSTALL_PREFIX, PLUGIN_INSTALL_DIR will set(XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages")
# calculate their value by appending subdirs to CMAKE_INSTALL_PREFIX .
# This would work completely without using the cache.
# But if somebody wants e.g. a different EXEC_INSTALL_PREFIX this value has to go into
# the cache, otherwise it will be forgotten on the next cmake run.
# Once a variable is in the cache, it doesn't depend on its "parent" variables
# anymore and you can only change it by editing it directly.
# this macro helps in this regard, because as long as you don't set one of the
# variables explicitly to some location, it will always calculate its value from its
# parents. So modifying CMAKE_INSTALL_PREFIX later on will have the desired effect.
# But once you decide to set e.g. EXEC_INSTALL_PREFIX to some special location
# this will go into the cache and it will no longer depend on CMAKE_INSTALL_PREFIX.
#
# additionally if installing to the same location as kdelibs, the other install
# directories are reused from the installed kdelibs
macro(_SET_FANCY _var _value _comment)
set(predefinedvalue "${_value}")
if ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var})
set(predefinedvalue "${KDE4_${_var}}")
endif ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var})
if (NOT DEFINED ${_var}) set(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc")
set(${_var} ${predefinedvalue}) set(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man")
else (NOT DEFINED ${_var}) set(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info")
set(${_var} "${${_var}}" CACHE PATH "${_comment}") set(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces")
endif (NOT DEFINED ${_var}) set(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services")
endmacro(_SET_FANCY) set(DBUS_SYSTEM_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/system-services")
_set_fancy(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" "Base directory for executables and libraries")
_set_fancy(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share" "Base directory for files which go to share/")
_set_fancy(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" "The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)")
_set_fancy(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" "The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)")
_set_fancy(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" "The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})")
_set_fancy(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec" "The subdirectory relative to the install prefix where libraries will be installed (default is ${LIB_INSTALL_DIR}/kde4/libexec)")
_set_fancy(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" "The subdirectory to the header prefix")
_set_fancy(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4" "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4)")
_set_fancy(IMPORTS_INSTALL_DIR "${PLUGIN_INSTALL_DIR}/imports" "The subdirectory relative to the install prefix where imports will be installed")
_set_fancy(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config" "The config file install dir")
_set_fancy(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps" "The parent directory where applications can install their data")
_set_fancy(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons" "The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)")
_set_fancy(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg" "The install dir for kconfig files")
_set_fancy(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" "The install dir for translations")
_set_fancy(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk" "The install dir for the mimetype desktop files")
_set_fancy(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/services" "The install dir for service (desktop, protocol, ...) files")
_set_fancy(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes" "The install dir for servicestypes desktop files")
_set_fancy(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds" "The install dir for sound files")
_set_fancy(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates" "The install dir for templates (Create new file...)")
_set_fancy(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers" "The install dir for wallpapers")
_set_fancy(DEMO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/demos" "The install dir for demos")
_set_fancy(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update" "The kconf_update install dir")
_set_fancy(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart" "The install dir for autostart files")
_set_fancy(XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/kde4" "The XDG apps dir")
_set_fancy(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" "The XDG directory")
_set_fancy(XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages" "The install dir for the xdg mimetypes")
_set_fancy(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc" "The sysconfig install dir (default ${CMAKE_INSTALL_PREFIX}/etc)")
_set_fancy(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man" "The man install dir (default ${SHARE_INSTALL_PREFIX}/man/)")
_set_fancy(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info" "The info install dir (default ${SHARE_INSTALL_PREFIX}/info)")
_set_fancy(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces" "The dbus interfaces install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)")
_set_fancy(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services" "The dbus services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/services)")
_set_fancy(DBUS_SYSTEM_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/system-services" "The dbus system services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/system-services)")
set(KAUTH_HELPER_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/helper")
set(KAUTH_BACKEND_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/backend")
# For more documentation see above. # For more documentation see above.
# Later on it will be possible to extend this for installing OSX frameworks # 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 # 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) 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) endif(WIN32 OR CYGWIN OR APPLE)
# setup default RPATH/install_name handling, may be overridden by KDE4_HANDLE_RPATH_FOR_EXECUTABLE # setup default RPATH/install_name handling, it sets up to build with full
# It sets up to build with full RPATH. When installing, RPATH will be changed to the LIB_INSTALL_DIR # RPATH. When installing, RPATH will be changed to the LIB_INSTALL_DIR
# and all link directories which are not inside the current build dir. # 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 # add our LIB_INSTALL_DIR to the RPATH (but only when it is not one of the standard system link
# here the defaults are set # directories listed in CMAKE_{PLATFORM,C,CXX}_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured out by cmake when compiling
# 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
list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemPlatformLibDir) 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_C_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCLibDir)
list(FIND CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCxxLibDir) list(FIND CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCxxLibDir)
if("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1") if("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1")
set(CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}") set(CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}")
endif("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1") endif("${_isSystemPlatformLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1")
set(CMAKE_SKIP_BUILD_RPATH FALSE) set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
endif (UNIX)
if (Q_WS_X11) if(Q_WS_X11)
# Done by FindQt4.cmake already # Done by FindQt4.cmake already
#find_package(X11 REQUIRED) #find_package(X11 REQUIRED)
# UNIX has already set _KDE4_PLATFORM_INCLUDE_DIRS, so append # UNIX has already set _KDE4_PLATFORM_INCLUDE_DIRS, so append
set(_KDE4_PLATFORM_INCLUDE_DIRS ${_KDE4_PLATFORM_INCLUDE_DIRS} ${X11_INCLUDE_DIR} ) 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}") if(CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
set ( CMAKE_MODULE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_MODULE_LINKER_FLAGS}") if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
set ( CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_EXE_LINKER_FLAGS}") 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... set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_SHARED_LINKER_FLAGS}")
if(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile) set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_MODULE_LINKER_FLAGS}")
set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") set(CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_EXE_LINKER_FLAGS}")
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)
if (UNIX) # we profile...
set ( _KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_LARGEFILE64_SOURCE") 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> #include <sys/types.h>
/* Check that off_t can represent 2**63 - 1 correctly. /* Check that off_t can represent 2**63 - 1 correctly.
We can't simply define LARGE_OFF_T to be 9223372036854775807, We can't simply define LARGE_OFF_T to be 9223372036854775807,
@ -811,10 +740,10 @@ if (UNIX)
int main() { return 0; } int main() { return 0; }
" _OFFT_IS_64BIT) " _OFFT_IS_64BIT)
if (NOT _OFFT_IS_64BIT) if(NOT _OFFT_IS_64BIT)
set ( _KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_FILE_OFFSET_BITS=64") set(_KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_FILE_OFFSET_BITS=64")
endif (NOT _OFFT_IS_64BIT) endif()
endif (UNIX) endif()
############################################################ ############################################################
@ -832,20 +761,20 @@ endmacro(KDE_CHECK_FLAG_EXISTS FLAG VAR)
# This macro is for internal use only # This macro is for internal use only
# Return the directories present in gcc's include path. # Return the directories present in gcc's include path.
macro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _result) macro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _result)
set(${_result}) set(${_result})
set(_gccOutput) set(_gccOutput)
file(WRITE "${CMAKE_BINARY_DIR}/CMakeFiles/dummy" "\n" ) file(WRITE "${CMAKE_BINARY_DIR}/CMakeFiles/dummy" "\n" )
execute_process(COMMAND ${CMAKE_C_COMPILER} -v -E -x ${_lang} -dD dummy execute_process(COMMAND ${CMAKE_C_COMPILER} -v -E -x ${_lang} -dD dummy
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles
ERROR_VARIABLE _gccOutput ERROR_VARIABLE _gccOutput
OUTPUT_VARIABLE _gccStdout ) 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" ) if("${_gccOutput}" MATCHES "> search starts here[^\n]+\n *(.+) *\n *End of (search) list")
SET(${_result} ${CMAKE_MATCH_1}) SET(${_result} ${CMAKE_MATCH_1})
STRING(REPLACE "\n" " " ${_result} "${${_result}}") STRING(REPLACE "\n" " " ${_result} "${${_result}}")
SEPARATE_ARGUMENTS(${_result}) SEPARATE_ARGUMENTS(${_result})
ENDIF( "${_gccOutput}" MATCHES "> search starts here[^\n]+\n *(.+) *\n *End of (search) list" ) endif()
ENDMACRO(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang) ENDMACRO(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang)
if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES Clang) 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 # 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") 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. # 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}) # 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. # and also because it is/was needed by glibc for snprintf to be available when building C files.
# See commit 4a44862b2d178c1d2e1eb4da90010d19a1e4a42c. # See commit 4a44862b2d178c1d2e1eb4da90010d19a1e4a42c.
add_definitions (-D_DEFAULT_SOURCE -D_BSD_SOURCE) 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) if(CMAKE_SYSTEM_NAME STREQUAL GNU)
set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -pthread") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -pthread")
endif (CMAKE_SYSTEM_NAME STREQUAL GNU) endif(CMAKE_SYSTEM_NAME STREQUAL GNU)
# gcc under Windows # gcc under Windows
if (MINGW) if (MINGW)
@ -1145,15 +1074,22 @@ set(KDE4_INCLUDES
get_filename_component(_KDE4_CMAKE_TOPLEVEL_DIR "${CMAKE_SOURCE_DIR}/.." ABSOLUTE) get_filename_component(_KDE4_CMAKE_TOPLEVEL_DIR "${CMAKE_SOURCE_DIR}/.." ABSOLUTE)
string(LENGTH "${_KDE4_CMAKE_TOPLEVEL_DIR}" _KDE4_CMAKE_TOPLEVEL_DIR_LENGTH) 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) set(_kde4_uninstall_rule_created TRUE)
configure_file("${kde_cmake_module_dir}/kde4_cmake_uninstall.cmake.in" "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" @ONLY) 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") 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) 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) # 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 # install bin directory to the Python file. The Python file is also make
# executable. # 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. # Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file. # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
include(FindLibraryWithDebug)
if (QCA2_INCLUDE_DIR AND QCA2_LIBRARIES) if (QCA2_INCLUDE_DIR AND QCA2_LIBRARIES)
# in cache already # in cache already
@ -30,11 +28,10 @@ else (QCA2_INCLUDE_DIR AND QCA2_LIBRARIES)
set(QCA2_DEFINITIONS ${PC_QCA2_CFLAGS_OTHER}) set(QCA2_DEFINITIONS ${PC_QCA2_CFLAGS_OTHER})
endif (NOT WIN32) endif (NOT WIN32)
find_library_with_debug(QCA2_LIBRARIES find_library(QCA2_LIBRARIES
WIN32_DEBUG_POSTFIX d NAMES qca
NAMES qca HINTS ${PC_QCA2_LIBDIR} ${PC_QCA2_LIBRARY_DIRS}
HINTS ${PC_QCA2_LIBDIR} ${PC_QCA2_LIBRARY_DIRS} )
)
find_path(QCA2_INCLUDE_DIR QtCrypto find_path(QCA2_INCLUDE_DIR QtCrypto
HINTS ${PC_QCA2_INCLUDEDIR} ${PC_QCA2_INCLUDE_DIRS} 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. # Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file. # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
include(FindLibraryWithDebug)
if (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES) if (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES)
set(QImageBlitz_FIND_QUIETLY TRUE) set(QImageBlitz_FIND_QUIETLY TRUE)
endif (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES) endif (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES)
@ -34,8 +32,7 @@ find_path(QIMAGEBLITZ_INCLUDES
${INCLUDE_INSTALL_DIR} ${INCLUDE_INSTALL_DIR}
) )
find_library_with_debug(QIMAGEBLITZ_LIBRARIES find_library(QIMAGEBLITZ_LIBRARIES
WIN32_DEBUG_POSTFIX d
qimageblitz qimageblitz
HINTS HINTS
$ENV{QIMAGEBLITZDIR}/lib $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) else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
# this else() branch is for finding strigi versions before November 16th, 2008. Alex # this else() branch is for finding strigi versions before November 16th, 2008. Alex
include(FindLibraryWithDebug)
include(MacroPushRequiredVars) include(MacroPushRequiredVars)
if (WIN32) if (WIN32)
@ -86,8 +85,7 @@ else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
endif (NOT STRIGI_INCLUDEDIR) endif (NOT STRIGI_INCLUDEDIR)
find_library_with_debug(STRIGI_STREAMANALYZER_LIBRARY find_library(STRIGI_STREAMANALYZER_LIBRARY
WIN32_DEBUG_POSTFIX d
NAMES streamanalyzer NAMES streamanalyzer
PATHS PATHS
${strigi_home}/lib ${strigi_home}/lib
@ -95,8 +93,7 @@ else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
${_program_FILES_DIR}/strigi/lib ${_program_FILES_DIR}/strigi/lib
) )
find_library_with_debug(STRIGI_STREAMS_LIBRARY find_library(STRIGI_STREAMS_LIBRARY
WIN32_DEBUG_POSTFIX d
NAMES streams NAMES streams
PATHS PATHS
${strigi_home}/lib ${strigi_home}/lib
@ -104,8 +101,7 @@ else(STRIGI_CONFIG_FOUND_AND_HAS_COMPLETE_INFORMATION)
${_program_FILES_DIR}/strigi/lib ${_program_FILES_DIR}/strigi/lib
) )
find_library_with_debug(STRIGI_STRIGIQTDBUSCLIENT_LIBRARY find_library(STRIGI_STRIGIQTDBUSCLIENT_LIBRARY
WIN32_DEBUG_POSTFIX d
NAMES strigiqtdbusclient NAMES strigiqtdbusclient
PATHS PATHS
${strigi_home}/lib ${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") set(TAGLIB_MIN_VERSION "1.4")
endif(NOT TAGLIB_MIN_VERSION) endif(NOT TAGLIB_MIN_VERSION)
if(NOT WIN32) find_program(TAGLIBCONFIG_EXECUTABLE NAMES taglib-config PATHS
find_program(TAGLIBCONFIG_EXECUTABLE NAMES taglib-config PATHS ${BIN_INSTALL_DIR}
${BIN_INSTALL_DIR} )
)
endif(NOT WIN32)
#reset vars #reset vars
set(TAGLIB_LIBRARIES) set(TAGLIB_LIBRARIES)
@ -48,7 +46,6 @@ if(TAGLIBCONFIG_EXECUTABLE)
else(TAGLIBCONFIG_EXECUTABLE) else(TAGLIBCONFIG_EXECUTABLE)
include(FindLibraryWithDebug)
include(FindPackageHandleStandardArgs) include(FindPackageHandleStandardArgs)
find_path(TAGLIB_INCLUDES find_path(TAGLIB_INCLUDES
@ -60,14 +57,13 @@ else(TAGLIBCONFIG_EXECUTABLE)
${INCLUDE_INSTALL_DIR} ${INCLUDE_INSTALL_DIR}
) )
find_library_with_debug(TAGLIB_LIBRARIES find_library(TAGLIB_LIBRARIES
WIN32_DEBUG_POSTFIX d
NAMES tag NAMES tag
PATHS PATHS
${KDE4_LIB_DIR} ${KDE4_LIB_DIR}
${LIB_INSTALL_DIR} ${LIB_INSTALL_DIR}
) )
find_package_handle_standard_args(Taglib DEFAULT_MSG find_package_handle_standard_args(Taglib DEFAULT_MSG
TAGLIB_INCLUDES TAGLIB_LIBRARIES) TAGLIB_INCLUDES TAGLIB_LIBRARIES)
endif(TAGLIBCONFIG_EXECUTABLE) 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 # let cmake handle mocking
# since cmake 2.8.6 # since cmake 2.8.6
set(CMAKE_AUTOMOC ON) set(CMAKE_AUTOMOC ON)
# set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
# Always include srcdir and builddir in include path # Always include srcdir and builddir in include path
# This saves typing ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} in about every subdir # 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 # for documentation look at FindKDE4Internal.cmake
# this file contains the following macros (or functions): # this file contains the following macros (or functions):
# KDE4_ADD_UI_FILES
# KDE4_ADD_KCFG_FILES # KDE4_ADD_KCFG_FILES
# _KDE4_SET_CUSTOM_TARGET_PROPERTY
# _KDE4_GET_CUSTOM_TARGET_PROPERTY
# KDE4_ADD_PLUGIN # KDE4_ADD_PLUGIN
# KDE4_ADD_KDEINIT_EXECUTABLE # KDE4_ADD_TEST
# KDE4_ADD_UNIT_TEST
# KDE4_ADD_EXECUTABLE
# KDE4_ADD_WIDGET_FILES # KDE4_ADD_WIDGET_FILES
# KDE4_UPDATE_ICONCACHE
# KDE4_INSTALL_ICONS # KDE4_INSTALL_ICONS
# KDE4_REMOVE_OBSOLETE_CMAKE_FILES
# KDE4_ADD_APP_ICON
# KDE4_CREATE_MANPAGE # KDE4_CREATE_MANPAGE
# KDE4_CREATE_BASIC_CMAKE_VERSION_FILE (function)
# KDE4_INSTALL_AUTH_HELPER_FILES # KDE4_INSTALL_AUTH_HELPER_FILES
# KDE4_AUTH_INSTALL_ACTIONS # 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") 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(_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 if (_kcfg_relativepath) # Process relative path only if the option was set
# Get relative path # Get relative path
get_filename_component(_rel_PATH ${_current_FILE} PATH) get_filename_component(_rel_PATH ${_current_FILE} DIRECTORY)
if (IS_ABSOLUTE ${_rel_PATH}) if (IS_ABSOLUTE ${_rel_PATH})
# We got an absolute path # We got an absolute path
@ -90,7 +81,8 @@ macro (KDE4_ADD_KCFG_FILES _sources )
COMMAND ${KDE4_KCFGC_EXECUTABLE} COMMAND ${KDE4_KCFGC_EXECUTABLE}
ARGS ${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH} ARGS ${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR}/${_rel_PATH}
MAIN_DEPENDENCY ${_tmp_FILE} MAIN_DEPENDENCY ${_tmp_FILE}
DEPENDS ${_kcfg_FILE} ${_KDE4_KCONFIG_COMPILER_DEP} ) DEPENDS ${_kcfg_FILE}
)
if(_kcfg_generatemoc) if(_kcfg_generatemoc)
qt4_generate_moc(${_header_FILE} ${_moc_FILE} ) qt4_generate_moc(${_header_FILE} ${_moc_FILE} )
@ -105,80 +97,7 @@ macro (KDE4_ADD_KCFG_FILES _sources )
endmacro (KDE4_ADD_KCFG_FILES) endmacro (KDE4_ADD_KCFG_FILES)
get_filename_component(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH) get_filename_component(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
#create the implementation files from the ui files and add them to the list of sources
#usage: KDE4_ADD_UI_FILES(foo_SRCS ${ui_files})
macro (KDE4_ADD_UI_FILES _sources )
foreach (_current_FILE ${ARGN})
get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE)
get_filename_component(_basename ${_tmp_FILE} NAME_WE)
set(_header ${CMAKE_CURRENT_BINARY_DIR}/ui_${_basename}.h)
# we need to run uic and replace some things in the generated file
# this is done by executing the cmake script kde4uic.cmake
add_custom_command(OUTPUT ${_header}
COMMAND ${CMAKE_COMMAND}
ARGS
-DKDE4_HEADER:BOOL=ON
-DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE}
-DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
-DKDE_UIC_H_FILE:FILEPATH=${_header}
-DKDE_UIC_BASENAME:STRING=${_basename}
-P ${KDE4_MODULE_DIR}/kde4uic.cmake
MAIN_DEPENDENCY ${_tmp_FILE}
)
list(APPEND ${_sources} ${_header})
endforeach (_current_FILE)
endmacro (KDE4_ADD_UI_FILES)
# this is basically a copy of the qt4_get_moc_flags() macros from FindQt4.cmake
# which is for internal use only, so we should not use it here:
macro (_KDE4_GET_MOC_FLAGS _moc_flags)
set(${_moc_flags})
get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES)
foreach(_current ${_inc_DIRS})
set(${_moc_flags} ${${_moc_flags}} "-I${_current}")
endforeach(_current ${_inc_DIRS})
get_directory_property(_defines COMPILE_DEFINITIONS)
foreach(_current ${_defines})
set(${_moc_flags} ${${_moc_flags}} "-D${_current}")
endforeach(_current ${_defines})
# if Qt is installed only as framework, add -F /library/Frameworks to the moc arguments
# otherwise moc can't find the headers in the framework include dirs
if(APPLE AND "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
set(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-F/Library/Frameworks")
endif(APPLE AND "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
endmacro(_KDE4_GET_MOC_FLAGS)
macro (_KDE4_SET_CUSTOM_TARGET_PROPERTY _target_name _property_name _property)
string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}")
set(_kde4_${_dir}_${_target_name}_${_property_name} "${_property}")
endmacro (_KDE4_SET_CUSTOM_TARGET_PROPERTY)
macro (_KDE4_GET_CUSTOM_TARGET_PROPERTY _var _target_name _property_name)
string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}")
set(${_var} "${_kde4_${_dir}_${_target_name}_${_property_name}}")
endmacro (_KDE4_GET_CUSTOM_TARGET_PROPERTY)
macro(KDE4_INSTALL_TS_FILES _lang _sdir)
file(GLOB_RECURSE _ts_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${_sdir}/*)
foreach(_current_TS_FILES ${_ts_files})
string(REGEX MATCH "\\.svn/" _in_svn ${_current_TS_FILES})
if(NOT _in_svn)
get_filename_component(_subpath ${_current_TS_FILES} PATH)
install(FILES ${_current_TS_FILES} DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_SCRIPTS/${_subpath})
endif(NOT _in_svn)
endforeach(_current_TS_FILES)
endmacro(KDE4_INSTALL_TS_FILES)
macro (KDE4_CREATE_MANPAGE _docbook _section) macro (KDE4_CREATE_MANPAGE _docbook _section)
get_filename_component(_input ${_docbook} ABSOLUTE) get_filename_component(_input ${_docbook} ABSOLUTE)
@ -224,19 +143,6 @@ macro (KDE4_CREATE_MANPAGE _docbook _section)
endmacro (KDE4_CREATE_MANPAGE) 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 # a "map" of short type names to the directories
# unknown names should give empty results # unknown names should give empty results
# KDE 3 compatibility # KDE 3 compatibility
@ -260,498 +166,158 @@ set(_KDE4_ICON_GROUP_intl "intl")
# a "map" of short theme names to the theme directory # a "map" of short theme names to the theme directory
set(_KDE4_ICON_THEME_ox "ariya") set(_KDE4_ICON_THEME_ox "ariya")
set(_KDE4_ICON_THEME_cr "crystalsvg")
set(_KDE4_ICON_THEME_lo "locolor") set(_KDE4_ICON_THEME_lo "locolor")
set(_KDE4_ICON_THEME_hi "hicolor") set(_KDE4_ICON_THEME_hi "hicolor")
# only used internally by KDE4_INSTALL_ICONS # only used internally by KDE4_INSTALL_ICONS
macro (_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME _l10n_SUBDIR) 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 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})
if (NOT ${_group} STREQUAL ${_install_NAME} ) set(_icon_GROUP ${_KDE4_ICON_GROUP_${_group}})
set(_icon_GROUP ${_KDE4_ICON_GROUP_${_group}}) if(NOT _icon_GROUP)
if(NOT _icon_GROUP) set(_icon_GROUP "actions")
set(_icon_GROUP "actions") endif()
endif(NOT _icon_GROUP) # message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name} l10n: ${_l10n_SUBDIR}")
# 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} )
install(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/${_l10n_SUBDIR}/ RENAME ${_install_NAME} ) endif()
endif (NOT ${_group} STREQUAL ${_install_NAME} ) endmacro(_KDE4_ADD_ICON_INSTALL_RULE)
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) # first the png icons
set(_lang ${ARGV1}) file(GLOB _icons *.png)
if(_lang) foreach(_current_ICON ${_icons} )
set(_l10n_SUBDIR l10n/${_lang}) # since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty
else(_lang) string(REGEX MATCH "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" _dummy "${_current_ICON}")
set(_l10n_SUBDIR ".") set(_type "${CMAKE_MATCH_1}")
endif(_lang) set(_size "${CMAKE_MATCH_2}")
set(_group "${CMAKE_MATCH_3}")
set(_name "${CMAKE_MATCH_4}")
# first the png icons set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
file(GLOB _icons *.png) if( _theme_GROUP)
foreach (_current_ICON ${_icons} ) _KDE4_ADD_ICON_INSTALL_RULE(
# since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty ${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
string(REGEX MATCH "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" _dummy "${_current_ICON}")
set(_type "${CMAKE_MATCH_1}")
set(_size "${CMAKE_MATCH_2}")
set(_group "${CMAKE_MATCH_3}")
set(_name "${CMAKE_MATCH_4}")
set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
if( _theme_GROUP)
_KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
${_defaultpath}/${_theme_GROUP}/${_size}x${_size}
${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR})
endif( _theme_GROUP)
endforeach (_current_ICON)
# mng icons
file(GLOB _icons *.mng)
foreach (_current_ICON ${_icons} )
# since CMake 2.6 regex matches are stored in special variables CMAKE_MATCH_x, if it didn't match, they are empty
string(REGEX MATCH "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" _dummy "${_current_ICON}")
set(_type "${CMAKE_MATCH_1}")
set(_size "${CMAKE_MATCH_2}")
set(_group "${CMAKE_MATCH_3}")
set(_name "${CMAKE_MATCH_4}")
set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
if( _theme_GROUP)
_KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
${_defaultpath}/${_theme_GROUP}/${_size}x${_size} ${_defaultpath}/${_theme_GROUP}/${_size}x${_size}
${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}) ${_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
) )
else () endif( _theme_GROUP)
add_custom_command(TARGET ${_target_NAME} POST_BUILD endforeach(_current_ICON)
COMMAND ${CMAKE_COMMAND}
-D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable} # mng icons
-D_ld_library_path="${_ld_library_path}" -D_executable=${_executable} file(GLOB _icons *.mng)
-P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake 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 set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}})
# so it can be queried and used later on easily if(_theme_GROUP)
set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}.shell) _KDE4_ADD_ICON_INSTALL_RULE(
${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake
else (UNIX) ${_defaultpath}/${_theme_GROUP}/scalable
# under windows, set the property WRAPPER_SCRIPT just to the name of the executable ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}
# 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 ) endif()
set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}) endforeach()
endmacro(KDE4_INSTALL_ICONS)
set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}\;${LIB_INSTALL_DIR}\;${KDE4_LIB_DIR}\;${QT_LIBRARY_DIR}")
get_target_property(_executable ${_target_NAME} LOCATION )
# use add_custom_target() to have the batch-file-wrapper generated during build time instead of cmake time
add_custom_command(TARGET ${_target_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND}
-D_filename="${_executable}.bat"
-D_ld_library_path="${_ld_library_path}" -D_executable="${_executable}"
-P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake
)
endif (UNIX)
endmacro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE)
macro (KDE4_ADD_PLUGIN _target_NAME ) # If "WITH_PREFIX" is in the arugments then the standard "lib" prefix will be
#if the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, # preserved
#otherwise set the prefix empty macro(KDE4_ADD_PLUGIN _target_NAME)
set(_args ${ARGN})
set(_plugin_type MODULE)
set(_plugin_prefix)
set(_plugin_srcs)
set(_args ${ARGN}) foreach(arg ${_args})
# default to module if(arg STREQUAL "STATIC")
set(_add_lib_param "MODULE") set(_plugin_type STATIC)
set(_with_pre FALSE) elseif(arg STREQUAL "SHARED")
set(_plugin_type SHARED)
foreach(arg ${_args}) elseif(arg STREQUAL "WITH_PREFIX")
if (arg STREQUAL "WITH_PREFIX") set(_plugin_prefix TRUE)
set(_with_pre TRUE) else()
endif (arg STREQUAL "WITH_PREFIX") list(APPEND _plugin_srcs ${arg})
if (arg STREQUAL "STATIC") endif()
set(_add_lib_param STATIC) endforeach(arg)
endif (arg STREQUAL "STATIC")
if (arg STREQUAL "SHARED")
set(_add_lib_param SHARED)
endif (arg STREQUAL "SHARED")
if (arg STREQUAL "MODULE")
set(_add_lib_param MODULE)
endif (arg STREQUAL "MODULE")
endforeach(arg)
if(_with_pre) add_library(${_target_NAME} ${_plugin_type} ${_plugin_srcs})
list(REMOVE_ITEM _args "WITH_PREFIX")
endif(_with_pre)
if(_add_lib_param STREQUAL "STATIC")
list(REMOVE_ITEM _args "STATIC")
endif(_add_lib_param STREQUAL "STATIC")
if (_add_lib_param STREQUAL "SHARED")
list(REMOVE_ITEM _args "SHARED")
endif (_add_lib_param STREQUAL "SHARED")
if (_add_lib_param STREQUAL "MODULE")
list(REMOVE_ITEM _args "MODULE")
endif (_add_lib_param STREQUAL "MODULE")
set(_SRCS ${_args}) if("${_plugin_type}" STREQUAL STATIC)
target_compile_definitions(${_target_NAME} PRIVATE -DQT_STATICPLUGIN)
endif()
if("${_add_lib_param}" STREQUAL "STATIC") if(NOT "${_plugin_prefix}")
add_definitions(-DQT_STATICPLUGIN) set_target_properties(${_target_NAME} PROPERTIES PREFIX "")
endif("${_add_lib_param}" STREQUAL "STATIC") endif()
endmacro(KDE4_ADD_PLUGIN)
add_library(${_target_NAME} ${_add_lib_param} ${_SRCS}) # 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.
if (NOT _with_pre) macro(KDE4_ADD_TEST _targetName)
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)
set(_srcList ${ARGN}) set(_srcList ${ARGN})
set(_targetName ${_test_NAME}) add_executable(${_targetName} ${_srcList})
if( ${ARGV1} STREQUAL "TESTNAME" )
set(_targetName ${ARGV2})
list(REMOVE_AT _srcList 0 1)
endif( ${ARGV1} STREQUAL "TESTNAME" )
set(_nogui) string(REPLACE "test" "" _testName ${_targetName})
list(GET _srcList 0 first_PARAM) add_test(NAME ${_testName} COMMAND ${_targetName})
if( ${first_PARAM} STREQUAL "NOGUI" )
set(_nogui "NOGUI")
endif( ${first_PARAM} STREQUAL "NOGUI" )
kde4_add_executable( ${_test_NAME} TEST ${_srcList} ) target_compile_definitions(${_targetName} PRIVATE -DKDESRCDIR="${CMAKE_CURRENT_SOURCE_DIR}/")
endmacro(KDE4_ADD_TEST)
if(NOT KDE4_TEST_OUTPUT) macro(KDE4_ADD_WIDGET_FILES _sources)
set(KDE4_TEST_OUTPUT plaintext) foreach(_current_FILE ${_sources})
endif(NOT KDE4_TEST_OUTPUT) get_filename_component(_input ${_current_FILE} ABSOLUTE)
set(KDE4_TEST_OUTPUT ${KDE4_TEST_OUTPUT} CACHE STRING "The output to generate when running the QTest unit tests") get_filename_component(_basename ${_input} NAME_WE)
get_filename_component(_extension ${_input} EXT)
set(using_qtest "") set(_source ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.cpp)
foreach(_filename ${_srcList}) set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.moc)
if(NOT using_qtest)
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}")
file(READ ${_filename} file_CONTENT)
string(REGEX MATCH "QTEST_(KDE)?MAIN" using_qtest "${file_CONTENT}")
endif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}")
endif(NOT using_qtest)
endforeach(_filename)
get_target_property( loc ${_test_NAME} LOCATION ) # 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") qt4_generate_moc(${_source} ${_moc})
#MESSAGE(STATUS "${_targetName} : Using QTestLib, can produce XML report.")
add_test( ${_targetName} ${_executable} -xml -o ${_targetName}.tml)
else (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
#MESSAGE(STATUS "${_targetName} : NOT using QTestLib, can't produce XML report, please use QTestLib to write your unit tests.")
add_test( ${_targetName} ${_executable} )
endif (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
# add_test( ${_targetName} ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME} -xml -o ${_test_NAME}.tml ) 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. # 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. # 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. # *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) function(KDE4_INSTALL_AUTH_HELPER_FILES HELPER_TARGET HELPER_ID HELPER_USER)
if (_kdeBootStrapping) if (_kdeBootStrapping)
set(_stubFilesDir ${CMAKE_SOURCE_DIR}/kdecore/auth/backends/dbus/ ) set(_stubFilesDir ${CMAKE_SOURCE_DIR}/kdecore/auth/backends/dbus/)
else (_kdeBootStrapping) else (_kdeBootStrapping)
set(_stubFilesDir ${KDE4_DATA_INSTALL_DIR}/kauth/ ) set(_stubFilesDir ${KDE4_DATA_INSTALL_DIR}/kauth/)
endif (_kdeBootStrapping) endif (_kdeBootStrapping)
configure_file(${_stubFilesDir}/dbus_policy.stub 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 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${HELPER_ID}.service
DESTINATION ${DBUS_SYSTEM_SERVICES_INSTALL_DIR}) DESTINATION ${DBUS_SYSTEM_SERVICES_INSTALL_DIR})
endfunction(KDE4_INSTALL_AUTH_HELPER_FILES) 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(MacroAddCompileFlags)
INCLUDE(MacroAddLinkFlags) INCLUDE(MacroAddLinkFlags)
INCLUDE(MacroAppendIf) INCLUDE(MacroAppendIf)
INCLUDE(MacroEnsureOutOfSourceBuild)
INCLUDE(MacroBoolTo01) INCLUDE(MacroBoolTo01)
INCLUDE(MacroPushRequiredVars) INCLUDE(MacroPushRequiredVars)
INCLUDE(MacroLogFeature) 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) set(kdnssd_LIB_SRCS servicebase.cpp servicemodel.cpp domainmodel.cpp)
kde4_add_kcfg_files(kdnssd_LIB_SRCS ${CMAKE_CURRENT_BINARY_DIR}/settings.kcfgc ) kde4_add_kcfg_files(kdnssd_LIB_SRCS ${CMAKE_CURRENT_BINARY_DIR}/settings.kcfgc )
if (HAVE_AVAHI) if(HAVE_AVAHI)
include_directories( ${AVAHI_INCLUDE_DIR} ) include_directories( ${AVAHI_INCLUDE_DIR} )
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS} set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS}
avahi-domainbrowser.cpp avahi-domainbrowser.cpp
avahi-servicebrowser.cpp avahi-servicebrowser.cpp
avahi-remoteservice.cpp avahi-remoteservice.cpp
avahi-publicservice.cpp avahi-publicservice.cpp
avahi-servicetypebrowser.cpp avahi-servicetypebrowser.cpp
avahi_server_interface.cpp avahi_server_interface.cpp
avahi_serviceresolver_interface.cpp avahi_serviceresolver_interface.cpp
avahi_entrygroup_interface.cpp avahi_entrygroup_interface.cpp
) )
qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.DomainBrowser.xml avahi_domainbrowser_interface ) qt4_add_dbus_interface(
qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.ServiceBrowser.xml avahi_servicebrowser_interface ) kdnssd_LIB_SRCS
qt4_add_dbus_interface (kdnssd_LIB_SRCS org.freedesktop.Avahi.ServiceTypeBrowser.xml avahi_servicetypebrowser_interface ) org.freedesktop.Avahi.DomainBrowser.xml
else (HAVE_AVAHI) avahi_domainbrowser_interface
)
macro_optional_find_package(DNSSD) qt4_add_dbus_interface(
macro_bool_to_01(DNSSD_FOUND HAVE_DNSSD) kdnssd_LIB_SRCS
set_package_properties(DNSSD PROPERTIES DESCRIPTION "Facilities for service discovery on a local network" org.freedesktop.Avahi.ServiceBrowser.xml
URL "http://avahi.org" avahi_servicebrowser_interface
TYPE OPTIONAL )
PURPOSE "Either Avahi or DNSSD is required for KDE applications to make use of multicast DNS/DNS-SD service discovery" qt4_add_dbus_interface(
) kdnssd_LIB_SRCS
org.freedesktop.Avahi.ServiceTypeBrowser.xml
if (HAVE_DNSSD) avahi_servicetypebrowser_interface
include_directories( ${DNSSD_INCLUDE_DIR} ) )
set(kdnssd_LIB_SRCS ${kdnssd_LIB_SRCS} else(HAVE_AVAHI)
mdnsd-domainbrowser.cpp macro_optional_find_package(DNSSD)
mdnsd-remoteservice.cpp macro_bool_to_01(DNSSD_FOUND HAVE_DNSSD)
mdnsd-publicservice.cpp set_package_properties(DNSSD PROPERTIES
mdnsd-responder.cpp DESCRIPTION "Facilities for service discovery on a local network"
mdnsd-servicebrowser.cpp URL "http://avahi.org"
mdnsd-servicetypebrowser.cpp TYPE OPTIONAL
) PURPOSE "Either Avahi or DNSSD is required for KDE applications to make use of multicast DNS/DNS-SD service discovery"
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_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 ############### ########### next target ###############
add_library(kdnssd ${LIBRARY_TYPE} ${kdnssd_LIB_SRCS})
kde4_add_library(kdnssd ${LIBRARY_TYPE} ${kdnssd_LIB_SRCS})
# KDE 5: don't link against KDEUI_LIBS (when settings.kfgc is changed) # KDE 5: don't link against KDEUI_LIBS (when settings.kfgc is changed)
if (HAVE_DNSSD) if (HAVE_DNSSD)
@ -80,18 +89,30 @@ else (HAVE_DNSSD)
target_link_libraries(kdnssd PRIVATE ${KDNSSD_BASE_LIBS} ${QT_QTNETWORK_LIBRARY}) target_link_libraries(kdnssd PRIVATE ${KDNSSD_BASE_LIBS} ${QT_QTNETWORK_LIBRARY})
endif (HAVE_DNSSD) 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 set_target_properties(kdnssd PROPERTIES
VERSION ${GENERIC_LIB_VERSION} VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION} SOVERSION ${GENERIC_LIB_SOVERSION}
) )
install(TARGETS kdnssd EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS}) install(TARGETS kdnssd EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
########### install files ############### ########### install files ###############
install( FILES dnssd_export.h domainbrowser.h remoteservice.h servicetypebrowser.h publicservice.h install(FILES
servicebase.h servicebrowser.h servicemodel.h domainmodel.h ${CMAKE_CURRENT_BINARY_DIR}/settings.h dnssd_export.h
DESTINATION ${INCLUDE_INSTALL_DIR}/dnssd COMPONENT Devel) domainbrowser.h
remoteservice.h
servicetypebrowser.h
publicservice.h
servicebase.h
servicebrowser.h
servicemodel.h
domainmodel.h
${CMAKE_CURRENT_BINARY_DIR}/settings.h
DESTINATION ${INCLUDE_INSTALL_DIR}/dnssd
COMPONENT Devel
)

4
experimental/libkdeclarative/CMakeLists.txt
View file

@ -26,7 +26,7 @@ set(kdeclarative_LIB_SRCS
bindings/icon.cpp bindings/icon.cpp
bindings/url.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}) 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 set(kdeclarative_TEST_SRCS
test/test.cpp) 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}) 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 ) include_directories(${KDE4_KIO_INCLUDES})
add_subdirectory( library )
########### next target ###############
set(kimproxy_LIB_SRCS
kimproxy.cpp
)
qt4_add_dbus_adaptor( kimproxy_LIB_SRCS org.kde.KIMIface.xml kimproxy.h KIMProxy)
qt4_add_dbus_interface(kimproxy_LIB_SRCS org.kde.KIMIface.xml kimiface )
add_library(kimproxy ${LIBRARY_TYPE} ${kimproxy_LIB_SRCS})
target_link_libraries(kimproxy PRIVATE ${KDE4_KIO_LIBS})
target_link_libraries(kimproxy PUBLIC ${QT_QTCORE_LIBRARY})
set_target_properties(kimproxy PROPERTIES
VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION}
)
########### install files ###############
install(TARGETS kimproxy EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
install(FILES
kimproxy_export.h
kimproxy.h
DESTINATION ${INCLUDE_INSTALL_DIR}
COMPONENT Devel
)
install(FILES
dbusinstantmessenger.desktop
DESTINATION ${SERVICETYPES_INSTALL_DIR}
)
install(FILES
kcm_instantmessenger.desktop
DESTINATION ${DATA_INSTALL_DIR}/kcm_componentchooser
)
install(FILES
org.kde.KIMIface.xml
DESTINATION ${DBUS_INTERFACES_INSTALL_DIR}
)

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 ############### ########### next target ###############
set(kmediaplayer_LIB_SRCS set(kmediaplayer_LIB_SRCS
player.cpp player.cpp
view.cpp view.cpp
kmediaplayeradaptor.cpp kmediaplayeradaptor.cpp
) )
add_library(kmediaplayer ${LIBRARY_TYPE} ${kmediaplayer_LIB_SRCS})
kde4_add_library(kmediaplayer ${LIBRARY_TYPE} ${kmediaplayer_LIB_SRCS})
target_link_libraries(kmediaplayer PRIVATE ${KDE4_KPARTS_LIBS} ) target_link_libraries(kmediaplayer PRIVATE ${KDE4_KPARTS_LIBS} )
target_link_libraries(kmediaplayer PUBLIC ${KDE4_KPARTS_LIBS} ${QT_QTGUI_LIBRARY} ) target_link_libraries(kmediaplayer PUBLIC ${KDE4_KPARTS_LIBS} ${QT_QTGUI_LIBRARY} )
set_target_properties(kmediaplayer PROPERTIES set_target_properties(kmediaplayer PROPERTIES
VERSION ${GENERIC_LIB_VERSION} VERSION ${GENERIC_LIB_VERSION}
SOVERSION ${GENERIC_LIB_SOVERSION} SOVERSION ${GENERIC_LIB_SOVERSION}
) )
install(TARGETS kmediaplayer EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS}) install(TARGETS kmediaplayer EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
########### install files ############### ########### install files ###############
install( FILES kmediaplayer_export.h player.h view.h DESTINATION ${INCLUDE_INSTALL_DIR}/kmediaplayer COMPONENT Devel) install(FILES
kmediaplayer_export.h
player.h
view.h
DESTINATION ${INCLUDE_INSTALL_DIR}/kmediaplayer
COMPONENT Devel
)
install( FILES kmediaplayerengine.desktop kmediaplayer.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} ) install(FILES
install( FILES org.kde.KMediaPlayer.xml DESTINATION ${DBUS_INTERFACES_INSTALL_DIR} ) kmediaplayerengine.desktop
kmediaplayer.desktop
DESTINATION
${SERVICETYPES_INSTALL_DIR}
)
install(FILES
org.kde.KMediaPlayer.xml
DESTINATION ${DBUS_INTERFACES_INSTALL_DIR}
)

93
interfaces/ktexteditor/CMakeLists.txt
View file

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

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

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

5
kdecore/kconfig_compiler/CMakeLists.txt
View file

@ -1,7 +1,7 @@
set(kconfig_compiler_SRCS kconfig_compiler.cpp) 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}) 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 # target in # FindKDE4Internal.cmake to get the full path to the installed
# executable instead of using FIND_PROGRAM(), Alex # executable instead of using FIND_PROGRAM(), Alex
install(TARGETS kconfig_compiler 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) project(kded)
add_subdirectory( tests ) if(ENABLE_TESTING)
add_subdirectory(tests)
endif()
include_directories( ${KDE4_KIO_INCLUDES} ) include_directories( ${KDE4_KIO_INCLUDES} )
@ -13,18 +15,19 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kded.h.cmake ${CMAKE_CURRENT_B
########### next target ############### ########### 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 ${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}) target_link_libraries(kded4 ${KDE4_KIO_LIBS} ${X11_LIBRARIES})
install(TARGETS kded4 ${INSTALL_TARGETS_DEFAULT_ARGS} ) install(TARGETS kded4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
qt4_generate_dbus_interface( kdedadaptor.h org.kde.kded.xml ) 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}) 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 ############### ########### next target ###############
set(kbuildsycoca_SRCS set(kbuildsycoca_SRCS
kbuildsycoca.cpp kbuildsycoca.cpp
kbuildmimetypefactory.cpp kbuildmimetypefactory.cpp
kmimeassociations.cpp kmimeassociations.cpp
kbuildservicetypefactory.cpp kbuildservicetypefactory.cpp
kbuildservicefactory.cpp kbuildservicefactory.cpp
kbuildservicegroupfactory.cpp kbuildservicegroupfactory.cpp
kbuildprotocolinfofactory.cpp kbuildprotocolinfofactory.cpp
kctimefactory.cpp kctimefactory.cpp
vfolder_menu.cpp vfolder_menu.cpp
) )
if(KBUILDSYCOCA_NO_KCRASH) if(KBUILDSYCOCA_NO_KCRASH)
set(KBUILDSYCOCA_MAIN_LIBS ${KDE4_KDECORE_LIBS}) set(KBUILDSYCOCA_MAIN_LIBS ${KDE4_KDECORE_LIBS})
else(KBUILDSYCOCA_NO_KCRASH) else()
set(KBUILDSYCOCA_MAIN_LIBS ${KDE4_KDEUI_LIBS}) set(KBUILDSYCOCA_MAIN_LIBS ${KDE4_KDEUI_LIBS})
endif(KBUILDSYCOCA_NO_KCRASH) endif()
add_executable(kbuildsycoca4 ${kbuildsycoca_SRCS})
# We need to add a '4' so that kde3 apps running kbuildsycoca don't run the kde4 one.
kde4_add_executable( kbuildsycoca4 NOGUI ${kbuildsycoca_SRCS})
target_link_libraries(kbuildsycoca4 ${KBUILDSYCOCA_MAIN_LIBS} ${QT_QTXML_LIBRARY}) 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 ############### ########### next target ###############
set(kdesu_LIB_SRCS set(kdesu_LIB_SRCS
client.cpp client.cpp
process.cpp process.cpp
kcookie.cpp kcookie.cpp
su.cpp su.cpp
ssh.cpp ssh.cpp
stub.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 PRIVATE ${KDE4_KPTY_LIBS} )
target_link_libraries(kdesu PUBLIC ${QT_QTCORE_LIBRARY} ) target_link_libraries(kdesu PUBLIC ${QT_QTCORE_LIBRARY} )
if(SUDO_FOUND) if(SUDO_FOUND)
set_source_files_properties(su.cpp PROPERTIES add_definitions(-DKDESU_USE_SUDO_DEFAULT)
COMPILE_FLAGS -DKDESU_USE_SUDO_DEFAULT)
endif(SUDO_FOUND) endif(SUDO_FOUND)
set_target_properties(kdesu PROPERTIES 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 ) 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(TARGETS kdesu_stub DESTINATION ${LIBEXEC_INSTALL_DIR} )
########### install files ############### ########### 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( about )
add_subdirectory( tests ) if(ENABLE_TESTING)
add_subdirectory( sonnet/tests ) add_subdirectory( tests )
add_subdirectory( sonnet/tests )
endif()
########### next target ############### ########### next target ###############
set(kdeui_LIB_SRCS 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) set (kdeui_LIB_SRCS ${kdeui_LIB_SRCS} util/kmodifierkeyinfoprovider_dummy.cpp)
endif (Q_WS_X11 AND X11_Xkb_FOUND) endif (Q_WS_X11 AND X11_Xkb_FOUND)
set( kdeui_UI set(kdeui_LIB_SRCS
dialogs/kpassworddialog.ui ${kdeui_LIB_SRCS}
dialogs/knewpassworddialog.ui dialogs/kpassworddialog.ui
dialogs/kshortcutsdialog.ui dialogs/knewpassworddialog.ui
widgets/kdatetimeedit.ui dialogs/kshortcutsdialog.ui
widgets/kshortcutwidget.ui widgets/kdatetimeedit.ui
sonnet/sonnetui.ui widgets/kshortcutwidget.ui
sonnet/configui.ui sonnet/sonnetui.ui
) sonnet/configui.ui
)
if (Q_WS_X11) if (Q_WS_X11)
set( kdeui_UI ${kdeui_UI} dialogs/kcupsoptionspageswidget.ui set(kdeui_LIB_SRCS
dialogs/kcupsoptionsjobwidget.ui ${kdeui_LIB_SRCS}
dialogs/kcupsoptionspageswidget.ui
dialogs/kcupsoptionsjobwidget.ui
) )
endif (Q_WS_X11) endif (Q_WS_X11)
kde4_add_ui_files(kdeui_LIB_SRCS ${kdeui_UI} )
set(kwallet_xml util/org.kde.KWallet.xml) set(kwallet_xml util/org.kde.KWallet.xml)
install(FILES ${kwallet_xml} DESTINATION ${DBUS_INTERFACES_INSTALL_DIR}) 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) set(knotify_xml ${CMAKE_CURRENT_SOURCE_DIR}/notifications/org.kde.KNotify.xml)
qt4_add_dbus_interface(kdeui_LIB_SRCS ${knotify_xml} knotify_interface) 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} target_link_libraries(kdeui PRIVATE ${KDE4_KDECORE_LIBS} ${X11_LIBRARIES} ${QT_QTGUI_LIBRARY}
${QT_QTXML_LIBRARY} ${KDEUI_EXTRA_LIBS} ${QT_QTNETWORK_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 <kmessagebox.h>
#include <kxmlguiclient.h> #include <kxmlguiclient.h>
#include <kinputdialog.h> #include <kinputdialog.h>
#include <klocale.h>
#include "kshortcutsdialog.h" #include "kshortcutsdialog.h"
#include "kshortcutschemeshelper_p.h" #include "kshortcutschemeshelper_p.h"

1
kdeui/dialogs/kshortcutseditor.cpp
View file

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

1
kdeui/dialogs/kshortcutseditoritem.cpp
View file

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

2
kdewebkit/CMakeLists.txt
View file

@ -22,7 +22,7 @@ set(kdewebkit_LIB_SRCS
kwebpluginfactory.cpp kwebpluginfactory.cpp
) )
kde4_add_library(kdewebkit ${LIBRARY_TYPE} add_library(kdewebkit ${LIBRARY_TYPE}
${kdewebkit_LIB_SRCS} ${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}) include_directories(${KDE4_INCLUDES} ${CMAKE_CURRENT_SOURCE_DIR})
add_definitions(${QT_DEFINITIONS} ${KDE4_DEFINITIONS}) add_definitions(${QT_DEFINITIONS} ${KDE4_DEFINITIONS})
kde4_add_executable(kdelauncher main.cpp ) add_executable(kdelauncher main.cpp )
target_link_libraries(kdelauncher target_link_libraries(kdelauncher
${QT_QTWEBKIT_LIBRARY} ${QT_QTWEBKIT_LIBRARY}
${QT_QTCORE_LIBRARY} ${QT_QTCORE_LIBRARY}

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

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

84
kdewidgets/CMakeLists.txt
View file

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

18
kdewidgets/makekdewidgets.cpp
View file

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

95
kfile/CMakeLists.txt
View file

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

33
kinit/CMakeLists.txt
View file

@ -1,6 +1,8 @@
project(kdeinit) project(kdeinit)
add_subdirectory( tests ) if(ENABLE_TESTING)
add_subdirectory(tests)
endif()
include_directories( ${KDE4_KPARTS_INCLUDES} ) 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_SRCS kinit.cpp proctitle.cpp klauncher_cmds.cpp )
set(kdeinit_LIBS "") set(kdeinit_LIBS "")
# on win32 kdeinit4 has to be a console application add_executable(kdeinit4 ${kdeinit_SRCS})
# to be able to catch stderr based --verbose output
kde4_add_executable(kdeinit4 NOGUI ${kdeinit_SRCS})
target_link_libraries(kdeinit4 ${KDE4_KDEUI_LIBS} ${kdeinit_LIBS} ${KINIT_SOCKET_LIBRARY} ) target_link_libraries(kdeinit4 ${KDE4_KDEUI_LIBS} ${kdeinit_LIBS} ${KINIT_SOCKET_LIBRARY} )
if (Q_WS_X11) if (Q_WS_X11)
@ -46,7 +46,7 @@ install(TARGETS kdeinit4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
set(kwrapper_SRCS kwrapper.c ) set(kwrapper_SRCS kwrapper.c )
kde4_add_executable(kwrapper4 NOGUI ${kwrapper_SRCS}) add_executable(kwrapper4 ${kwrapper_SRCS})
target_link_libraries(kwrapper4 ${KINIT_SOCKET_LIBRARY}) target_link_libraries(kwrapper4 ${KINIT_SOCKET_LIBRARY})
@ -54,7 +54,7 @@ install(TARGETS kwrapper4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
########### kdeinit4_wrapper ############### ########### kdeinit4_wrapper ###############
kde4_add_executable(kdeinit4_wrapper NOGUI wrapper.c) add_executable(kdeinit4_wrapper wrapper.c)
target_link_libraries(kdeinit4_wrapper ${KINIT_SOCKET_LIBRARY}) 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) 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} )
install(TARGETS kdeinit4_wrapper ${INSTALL_TARGETS_DEFAULT_ARGS} RENAME kdeinit4_shutdown)
########### kshell4 ############### ########### kshell4 ###############
kde4_add_executable(kshell4 NOGUI shell.c) add_executable(kshell4 shell.c)
target_link_libraries(kshell4 ${KINIT_SOCKET_LIBRARY}) target_link_libraries(kshell4 ${KINIT_SOCKET_LIBRARY})
install(TARGETS kshell4 ${INSTALL_TARGETS_DEFAULT_ARGS} ) 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 ############### ########### lnusertemp ###############
set(lnusertemp_SRCS lnusertemp.c ) set(lnusertemp_SRCS lnusertemp.c )
kde4_add_executable(lnusertemp NOGUI ${lnusertemp_SRCS}) add_executable(lnusertemp ${lnusertemp_SRCS})
target_link_libraries(lnusertemp kdefakes) target_link_libraries(lnusertemp kdefakes)
@ -95,10 +88,9 @@ install(TARGETS lnusertemp DESTINATION ${LIBEXEC_INSTALL_DIR} )
set(kioslave_SRCS kioslave.cpp) 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} ) install(TARGETS kioslave DESTINATION ${LIBEXEC_INSTALL_DIR} )
@ -116,8 +108,7 @@ set(klauncher_SRCS
# The adaptor is manually edited, generate the xml from it. # The adaptor is manually edited, generate the xml from it.
qt4_generate_dbus_interface(klauncher_adaptor.h org.kde.KLauncher.xml) qt4_generate_dbus_interface(klauncher_adaptor.h org.kde.KLauncher.xml)
add_executable( klauncher ${klauncher_SRCS})
kde4_add_executable( klauncher NOGUI ${klauncher_SRCS})
set_target_properties(klauncher PROPERTIES DEFINE_SYMBOL MAKE_KLAUNCHER) set_target_properties(klauncher PROPERTIES DEFINE_SYMBOL MAKE_KLAUNCHER)
target_link_libraries(klauncher ${KDE4_KIO_LIBS} ${X11_LIBRARIES}) 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( kssl/kcm )
add_subdirectory( misc ) add_subdirectory( misc )
add_subdirectory( tests ) if(ENABLE_TESTING)
add_subdirectory( tests )
endif()
if(STRIGI_FOUND) if(STRIGI_FOUND)
add_subdirectory( kio/dummyanalyzers ) add_subdirectory( kio/dummyanalyzers )
endif(STRIGI_FOUND) endif(STRIGI_FOUND)
@ -239,6 +241,12 @@ set(kio_LIB_SRCS
${kbookmarks_STAT_SRCS} ${kbookmarks_STAT_SRCS}
${kfile_STAT_SRCS} ${kfile_STAT_SRCS}
${kssl_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 set(kio_LIB_PRIVATE_SRCS
@ -252,18 +260,9 @@ set(kfilemetadatareaderprocess_SRCS
kfile/kfilemetadatareaderprocess.cpp kfile/kfilemetadatareaderprocess.cpp
) )
kde4_add_ui_files(kio_LIB_SRCS add_library(kio ${LIBRARY_TYPE} ${kio_LIB_SRCS})
kfile/kpropertiesdesktopadvbase.ui
kfile/kpropertiesdesktopbase.ui
kssl/keygenwizard.ui
kssl/keygenwizard2.ui
kssl/sslinfo.ui
kssl/certificateparty.ui
)
kde4_add_library(kio ${LIBRARY_TYPE} ${kio_LIB_SRCS}) add_executable(kfilemetadatareader ${kfilemetadatareaderprocess_SRCS})
kde4_add_executable(kfilemetadatareader ${kfilemetadatareaderprocess_SRCS})
target_link_libraries(kfilemetadatareader ${KDE4_KIO_LIBS}) target_link_libraries(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 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} ) 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 # build the analyzer as a module
kde4_add_library(dummy MODULE dummyanalyzers.cpp) add_library(dummy MODULE dummyanalyzers.cpp)
# link with the required libraries # link with the required libraries
target_link_libraries(dummy ${STRIGI_STREAMANALYZER_LIBRARY}) target_link_libraries(dummy ${STRIGI_STREAMANALYZER_LIBRARY})

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

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

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

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

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

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

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

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

27
kio/misc/CMakeLists.txt
View file

@ -11,7 +11,7 @@ add_subdirectory( kntlm )
set(kmailservice_SRCS kmailservice.cpp ) set(kmailservice_SRCS kmailservice.cpp )
kde4_add_executable(kmailservice NOGUI ${kmailservice_SRCS}) add_executable(kmailservice ${kmailservice_SRCS})
target_link_libraries(kmailservice ${KDE4_KDEUI_LIBS}) 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 ) set(ktelnetservice_SRCS ktelnetservice.cpp )
add_executable(ktelnetservice ${ktelnetservice_SRCS})
kde4_add_executable(ktelnetservice NOGUI ${ktelnetservice_SRCS})
target_link_libraries(ktelnetservice ${KDE4_KDEUI_LIBS} ) 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( 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 install(PROGRAMS fileshareset DESTINATION ${LIBEXEC_INSTALL_DIR} )
if (UNIX)
install(PROGRAMS fileshareset DESTINATION ${LIBEXEC_INSTALL_DIR} )
install(CODE " install(CODE "
set(FILESHARESET_PATH \"\$ENV{DESTDIR}${LIBEXEC_INSTALL_DIR}/fileshareset\") set(FILESHARESET_PATH \"\$ENV{DESTDIR}${LIBEXEC_INSTALL_DIR}/fileshareset\")
EXECUTE_PROCESS(COMMAND sh -c \"chown 0 '\${FILESHARESET_PATH}' && chmod u+s '\${FILESHARESET_PATH}'\") 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)
# 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 ) 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} ) 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) 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) if (HAVE_NSL_LIBRARY)
# Assume Solaris # Assume Solaris

37
kioslave/http/CMakeLists.txt
View file

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

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

@ -1,13 +1,11 @@
if(ENABLE_TESTING)
add_subdirectory( tests ) add_subdirectory(tests)
endif()
# all done by parent dir
# include_directories( ${KDE4_KIO_INCLUDES} )
####### kcookiejar4: command line tool for talking to the kded kcookiejar module ####### ####### kcookiejar4: command line tool for talking to the kded kcookiejar module #######
set(kcookiejar_SRCS 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") set_source_files_properties(${kcookieserver_xml} PROPERTIES INCLUDE "kcookiejar_include.h")
qt4_add_dbus_interfaces(kcookiejar_SRCS ${kcookieserver_xml}) 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} ) install(TARGETS kcookiejar4 ${INSTALL_TARGETS_DEFAULT_ARGS} )

38
knotify/CMakeLists.txt
View file

@ -1,9 +1,39 @@
project(knotify) 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