Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-25 03:12:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
kdelibs/cmake/modules/FindKDE4Internal.cmake
Ivailo Monev 43240c2b1a cmake: setup phonon as found if origin is Katie 
Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
2015-11-13 02:32:24 +02:00

999 lines
46 KiB
CMake
Raw Blame History

# - Find the KDE4 include and library dirs, KDE preprocessors and define a some macros
#
# This module defines the following variables:
#
# KDE4_FOUND - set to TRUE if everything required for building KDE software has been found
#
# KDE4_DEFINITIONS - compiler definitions required for compiling KDE software
# KDE4_INCLUDE_DIR - the KDE 4 include directory
# KDE4_INCLUDES - all include directories required for KDE, i.e.
# KDE4_INCLUDE_DIR, but also the Qt4 include directories
# and other platform specific include directories
# KDE4_LIB_DIR - the directory where the KDE libraries are installed,
# intended to be used with LINK_DIRECTORIES(). In general, this is not necessary.
# KDE4_LIBEXEC_INSTALL_DIR - the directory where libexec executables from kdelibs are installed
# KDE4_BIN_INSTALL_DIR - the directory where executables from kdelibs are installed
# KDE4_SBIN_INSTALL_DIR - the directory where system executables from kdelibs are installed
# KDE4_DATA_INSTALL_DIR - the parent directory where kdelibs applications install their data
# KDE4_CONFIG_INSTALL_DIR - the directory where config files from kdelibs are installed
# KDE4_ICON_INSTALL_DIR - the directory where icons from kdelibs are
# KDE4_IMPORTS_INSTALL_DIR - the directory where imports from kdelibs are
# KDE4_KCFG_INSTALL_DIR - the directory where kconfig files from kdelibs are installed
# KDE4_LOCALE_INSTALL_DIR - the directory where translations from kdelibs are installed
# KDE4_MIME_INSTALL_DIR - the directory where mimetype desktop files from kdelibs are installed
# KDE4_SOUND_INSTALL_DIR - the directory where sound files from kdelibs are installed
# KDE4_TEMPLATES_INSTALL_DIR - the directory where templates (Create new file...) from kdelibs are installed
# KDE4_WALLPAPER_INSTALL_DIR - the directory where wallpapers from kdelibs are installed
# KDE4_AUTOSTART_INSTALL_DIR - the directory where autostart from kdelibs are installed
# KDE4_XDG_APPS_INSTALL_DIR - the XDG apps dir from kdelibs
# KDE4_XDG_DIRECTORY_INSTALL_DIR - the XDG directory from kdelibs
# KDE4_SYSCONF_INSTALL_DIR - the directory where sysconfig files from kdelibs are installed
# KDE4_MAN_INSTALL_DIR - the directory where man pages from kdelibs are installed
# KDE4_INFO_INSTALL_DIR - the directory where info files from kdelibs are installed
# KDE4_DBUS_INTERFACES_DIR - the directory where dbus interfaces from kdelibs are installed
# KDE4_DBUS_SERVICES_DIR - the directory where dbus service files from kdelibs are installed
#
# The following variables are defined for the various tools required to
# compile KDE software:
#
# KDE4_KCFGC_EXECUTABLE - the kconfig_compiler executable
# KDE4_MAKEKDEWIDGETS_EXECUTABLE - the makekdewidgets executable
#
# The following variables point to the location of the KDE libraries,
# but shouldn't be used directly:
#
# KDE4_KDECORE_LIBRARY - the kdecore library
# KDE4_KDEUI_LIBRARY - the kdeui library
# KDE4_KIO_LIBRARY - the kio library
# KDE4_KPARTS_LIBRARY - the kparts library
# KDE4_KEMOTICONS_LIBRARY - the kemoticons library
# KDE4_KIDLETIME_LIBRARY - the kidletime library
# KDE4_KCMUTILS_LIBRARY - the kcmutils library
# KDE4_KPRINTUTILS_LIBRARY - the kprintutils library
# KDE4_KFILE_LIBRARY - the kfile library
# KDE4_KDNSSD_LIBRARY - the kdnssd library
# KDE4_PHONON_LIBRARY - the phonon library
# KDE4_THREADWEAVER_LIBRARY- the threadweaver library
# KDE4_SOLID_LIBRARY - the solid library
# KDE4_KNOTIFYCONFIG_LIBRARY- the knotifyconfig library
# KDE4_KROSSCORE_LIBRARY - the krosscore library
# KDE4_KTEXTEDITOR_LIBRARY - the ktexteditor library
# KDE4_PLASMA_LIBRARY - the plasma library
# KDE4_KUNITCONVERSION_LIBRARY - the kunitconversion library
# KDE4_KDEWEBKIT_LIBRARY - the kdewebkit library
# KDE4_KCDDB_LIBRARY - the kcddb library
# KDE4_KCOMPACTDISC_LIBRARY - the kcompactdisc library
# KDE4_KDCRAW_LIBRARY - the kdcraw library
# KDE4_KEXIV2_LIBRARY - the kexiv2 library
#
# Compared to the variables above, the following variables
# also contain all of the depending libraries, so the variables below
# should be used instead of the ones above:
#
# KDE4_KDECORE_LIBS - the kdecore library and all depending libraries
# KDE4_KDEUI_LIBS - the kdeui library and all depending libraries
# KDE4_KIO_LIBS - the kio library and all depending libraries
# KDE4_KPARTS_LIBS - the kparts library and all depending libraries
# KDE4_KEMOTICONS_LIBS - the kemoticons library and all depending libraries
# KDE4_KIDLETIME_LIBS - the kidletime library and all depending libraries
# KDE4_KCMUTILS_LIBS - the kcmutils library and all depending libraries
# KDE4_KPRINTUTILS_LIBS - the kprintutils library and all depending libraries
# KDE4_KFILE_LIBS - the kfile library and all depending libraries
# KDE4_KDNSSD_LIBS - the kdnssd library and all depending libraries
# KDE4_KDESU_LIBS - the kdesu library and all depending libraries
# KDE4_KPTY_LIBS - the kpty library and all depending libraries
# KDE4_PHONON_LIBS - the phonon library and all depending librairies
# KDE4_THREADWEAVER_LIBS - the threadweaver library and all depending libraries
# KDE4_SOLID_LIBS - the solid library and all depending libraries
# KDE4_KNOTIFYCONFIG_LIBS - the knotify config library and all depending libraries
# KDE4_KROSSCORE_LIBS - the kross core library and all depending libraries
# KDE4_KROSSUI_LIBS - the kross ui library which includes core and all depending libraries
# KDE4_KTEXTEDITOR_LIBS - the ktexteditor library and all depending libraries
# KDE4_PLASMA_LIBS - the plasma library and all depending librairies
# KDE4_KUNITCONVERSION_LIBS - the kunitconversion library and all depending libraries
# KDE4_KDEWEBKIT_LIBS - the kdewebkit library and all depending libraries
# KDE4_KCDDB_LIBS - the kcddb library and all depending libraries
# KDE4_KCOMPACTDISC_LIBS - the kcompactdisc library and all depending libraries
# KDE4_KDCRAW_LIBS - the kdcraw library and all depending libraries
# KDE4_KEXIV2_LIBS - the kexiv2 library and all depending libraries
#
# This module defines also a bunch of variables used as locations for install directories
# for files of the package which is using this module. These variables don't say
# anything about the location of the installed KDE.
# They can be relative (to CMAKE_INSTALL_PREFIX) or absolute.
#
# BIN_INSTALL_DIR - the directory where executables will be installed (default is prefix/bin)
# SBIN_INSTALL_DIR - the directory where system executables will be installed (default is prefix/sbin)
# LIB_INSTALL_DIR - the directory where libraries will be installed (default is prefix/lib)
# CONFIG_INSTALL_DIR - the directory where config files will be installed
# DATA_INSTALL_DIR - the parent directory where applications can install their data
# ICON_INSTALL_DIR - the directory where the icons will be installed (default prefix/share/icons/)
# INFO_INSTALL_DIR - the directory where info files will be installed (default prefix/info)
# KCFG_INSTALL_DIR - the directory where kconfig files will be installed
# LOCALE_INSTALL_DIR - the directory where translations will be installed
# MAN_INSTALL_DIR - the directory where man pages will be installed (default prefix/man/)
# MIME_INSTALL_DIR - the directory where mimetype desktop files will be installed
# PLUGIN_INSTALL_DIR - the subdirectory relative to the install prefix where plugins will be installed (default is ${KDE4_LIB_INSTALL_DIR}/kde4)
# IMPORTS_INSTALL_DIR - the subdirectory relative to the install prefix where imports will be installed
# SERVICES_INSTALL_DIR - the directory where service (desktop, protocol, ...) files will be installed
# SERVICETYPES_INSTALL_DIR - the directory where servicestypes desktop files will be installed
# SOUND_INSTALL_DIR - the directory where sound files will be installed
# TEMPLATES_INSTALL_DIR - the directory where templates (Create new file...) will be installed
# WALLPAPER_INSTALL_DIR - the directory where wallpapers will be installed
# AUTOSTART_INSTALL_DIR - the directory where autostart files will be installed
# SYSCONF_INSTALL_DIR - the directory where sysconfig files will be installed (default /usr/etc)
# XDG_APPS_INSTALL_DIR - the XDG apps dir
# XDG_DIRECTORY_INSTALL_DIR- the XDG directory
# XDG_MIME_INSTALL_DIR - the XDG mimetypes install dir
# DBUS_INTERFACES_INSTALL_DIR - the directory where dbus interfaces will be installed (default is prefix/share/dbus-1/interfaces)
# DBUS_SERVICES_INSTALL_DIR - the directory where dbus services will be installed (default is prefix/share/dbus-1/services )
# DBUS_SYSTEM_SERVICES_INSTALL_DIR - the directory where dbus system services will be installed (default is prefix/share/dbus-1/system-services )
#
# The variable INSTALL_TARGETS_DEFAULT_ARGS can be used when installing libraries
# or executables into the default locations.
# The INSTALL_TARGETS_DEFAULT_ARGS variable should be used when libraries are installed.
# It should also be used when installing applications.
# The variable MUST NOT be used for installing plugins.
# It also MUST NOT be used for executables which are intended to go into sbin/ or libexec/.
#
# Usage is like this:
# install(TARGETS kdecore kdeui ${INSTALL_TARGETS_DEFAULT_ARGS} )
#
# This will install libraries correctly under UNIX, OSX and Windows (i.e. dll's go
# into bin/.
#
#
# The following user adjustable options are provided:
#
# KDE4_ENABLE_FPIE - enable it to use gcc Position Independent Executables feature
#
# KDE4_ADD_KCFG_FILES (SRCS_VAR [GENERATE_MOC] [USE_RELATIVE_PATH] file1.kcfgc ... fileN.kcfgc)
# Use this to add KDE config compiler files to your application/library.
# Use optional GENERATE_MOC to generate moc if you use signals in your kcfg files.
# Use optional USE_RELATIVE_PATH to generate the classes in the build following the given
# relative path to the file.
#
# KDE4_ADD_WIDGET (SRCS_VAR file1.widgets ... fileN.widgets)
# Use this to add widget description files for the makekdewidgets code generator
# for Qt Designer plugins.
#
# KDE4_ADD_PLUGIN ( name [WITH_PREFIX] file1 ... fileN )
# Create a KDE plugin (KPart, kioslave, etc.) from the given source files.
# If WITH_PREFIX is given, the resulting plugin will have the prefix "lib", otherwise it won't.
#
# KDE4_ADD_TEST (testname file1 ... fileN)
# add a unit test, which is executed when running make test. The targets
# are build and executed only if the ENABLE_TESTING option is enabled.
# KDESRCDIR is set to the source directory of the test, this can be used
# with KGlobal::dirs()->addResourceDir( "data", KDESRCDIR )
#
# KDE4_ADD_MANUAL_TEST (testname file1 ... fileN)
# same as KDE_ADD_TEST() except that the test is not run on `make test`
#
# KDE4_INSTALL_ICONS ( path theme)
# Installs all png and svgz files in the current directory to the icon
# directory given in path, in the subdirectory for the given icon theme.
#
# KDE4_CREATE_MANPAGE ( docbookfile section )
# Create the manpage for the specified section from the docbookfile
# The resulting manpage will be installed to <installdest> when using
# INSTALL_DESTINATION <installdest>, or to <installdest>/<subdir> if
# SUBDIR <subdir> is specified.
#
# KDE4_INSTALL_AUTH_HELPER_FILES ( HELPER_TARGET HELPER_ID HELPER_USER )
# This macro adds the needed files for an helper executable meant to be used by applications using KAuth.
# It accepts the helper target, the helper ID (the DBUS name) and the user under which the helper will run on.
# This macro takes care of generate the needed files, and install them in the right location. This boils down
# to a DBus policy to let the helper register on the system bus, and a service file for letting the helper
# being automatically activated by the system bus.
# *WARNING* You have to install the helper in ${LIBEXEC_INSTALL_DIR} to make sure everything will work.
#
#
#
# A note on the possible values for CMAKE_BUILD_TYPE and how KDE handles
# the flags for those buildtypes. FindKDE4Internal supports the values
# Release, RelWithDebInfo and Debug:
#
# Release
# optimised for speed, qDebug/kDebug turned off, no debug symbols, no asserts
# RelWithDebInfo (Release with debug info)
# similar to Release, optimised for speed, but with debugging symbols on (-g)
# Debug
# optimised but debuggable, debugging on (-g)
# (-fno-reorder-blocks -fno-schedule-insns -fno-inline)
# MinSizeRel:
# optimization for smallest size, no debugging information
#
#
# The default buildtype is RelWithDebInfo.
# It is expected that the "Debug" build type be still debuggable with gdb
# without going all over the place, but still produce better performance.
# It's also important to note that gcc cannot detect all warning conditions
# unless the optimiser is active.
#
#
# This module allows to depend on a particular minimum version of kdelibs.
# To acomplish that one should use the appropriate cmake syntax for
# find_package. For example to depend on kdelibs >= 4.1.0 one should use
#
# find_package(KDE4 4.18.0 REQUIRED)
#
# In earlier versions of KDE you could use the variable KDE_MIN_VERSION to
# have such a dependency. This variable is deprecated with KDE 4.2.0, but
# will still work to make the module backwards-compatible.
# _KDE4_PLATFORM_INCLUDE_DIRS is used only internally
# _KDE4_PLATFORM_DEFINITIONS is used only internally
# Copyright (c) 2006-2009, Alexander Neundorf <neundorf@kde.org>
# Copyright (c) 2006, Laurent Montel, <montel@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
# this is required by cmake >=2.6
cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR)
# CMake 2.6, set compatibility behaviour to cmake 2.4
# this must be executed always, because the CMAKE_MINIMUM_REQUIRED() command above
# resets the policy settings, so we get a lot of warnings
# CMP0000: don't require cmake_minimum_version() directly in the top level
# CMakeLists.txt, FindKDE4Internal.cmake is good enough
cmake_policy(SET CMP0000 OLD)
# CMP0003: add the link paths to the link command as with cmake 2.4
cmake_policy(SET CMP0003 OLD)
# CMP0005: keep escaping behaviour for definitions added via add_definitions()
cmake_policy(SET CMP0005 OLD)
# Only do something if it hasn't been found yet
if(NOT KDE4_FOUND)
# get the directory of the current file, used later on in the file
get_filename_component(kde_cmake_module_dir ${CMAKE_CURRENT_LIST_FILE} PATH)
# We may only search for other packages with "REQUIRED" if we are required ourselves.
# This file can be processed either (usually) included in FindKDE4.cmake or
# (when building kdelibs) directly via FIND_PACKAGE(KDE4Internal), that's why
# we have to check for both KDE4_FIND_REQUIRED and KDE4Internal_FIND_REQUIRED.
if(KDE4_FIND_REQUIRED OR KDE4Internal_FIND_REQUIRED)
set(_REQ_STRING_KDE4 REQUIRED)
set(_REQ_STRING_KDE4_MESSAGE FATAL_ERROR)
else()
set(_REQ_STRING_KDE4 )
set(_REQ_STRING_KDE4_MESSAGE STATUS)
endif()
# Store CMAKE_MODULE_PATH and then append the current dir to it, so we are sure
# we get the FindQt4.cmake located next to us and not a different one.
# The original CMAKE_MODULE_PATH is restored later on.
set(_kde_cmake_module_path_back ${CMAKE_MODULE_PATH})
set(CMAKE_MODULE_PATH ${kde_cmake_module_dir} ${CMAKE_MODULE_PATH} )
# if the minimum Qt requirement is changed, change all occurrence in the
# following lines
if(NOT QT_MIN_VERSION )
set(QT_MIN_VERSION "4.8.2")
endif()
if(${QT_MIN_VERSION} VERSION_LESS "4.8.2")
set(QT_MIN_VERSION "4.8.2")
endif()
# Tell FindQt4.cmake to point the QT_QTFOO_LIBRARY targets at the imported targets
# for the Qt libraries, so we get full handling of release and debug versions of the
# Qt libs and are flexible regarding the install location of Qt under Windows:
set(QT_USE_IMPORTED_TARGETS TRUE)
#this line includes FindQt4.cmake, which searches the Qt library and headers
# TODO: we should check here that all necessary modules of Qt have been found, e.g. QtDBus
set(KATIE_COMPAT TRUE)
find_package(Katie)
if(NOT KATIE_FOUND)
find_package(Qt4 ${_REQ_STRING_KDE4})
endif()
# Perl is not required for building KDE software but is during runtime from
# kdelibs and kde-workspace, also it is here since 4.0
find_package(Perl)
if(NOT PERL_FOUND)
message(STATUS "Perl not found")
endif()
# restore the original CMAKE_MODULE_PATH
set(CMAKE_MODULE_PATH ${_kde_cmake_module_path_back})
# Check that we really found everything.
# If KDE4 was searched with REQUIRED, we error out with FATAL_ERROR if something
# wasn't found already above in the other FIND_PACKAGE() calls. If KDE4 was
# searched without REQUIRED and something in the FIND_PACKAGE() calls above
# wasn't found,then we get here and must check that everything has actually
# been found. If something is missing, we must not fail with FATAL_ERROR, but only not set KDE4_FOUND.
if(NOT QT4_FOUND)
message(STATUS "KDE4 not found, because Qt4 was not found")
return()
endif(NOT QT4_FOUND)
# now we are sure we have everything we need
include(MacroLibrary)
include(CheckCXXCompilerFlag)
include(CheckCXXSourceCompiles)
# are we trying to compile kdelibs? then enter bootstrap mode
# kdelibs_SOURCE_DIR comes from "project(kdelibs)" in kdelibs/CMakeLists.txt
if(kdelibs_SOURCE_DIR)
set(_kdeBootStrapping TRUE)
message(STATUS "Building kdelibs...")
else(kdelibs_SOURCE_DIR)
set(_kdeBootStrapping FALSE)
endif(kdelibs_SOURCE_DIR)
# Used in configure_file() and install(EXPORT)
set(KDE4_TARGET_PREFIX KDE4::)
####################### #now try to find some kde stuff ################################
if (_kdeBootStrapping)
set(KDE4_INCLUDE_DIR ${kdelibs_SOURCE_DIR})
set(EXECUTABLE_OUTPUT_PATH ${kdelibs_BINARY_DIR}/bin )
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib )
set(KDE4_KCFGC_EXECUTABLE kconfig_compiler${CMAKE_EXECUTABLE_SUFFIX} )
set(KDE4_MAKEKDEWIDGETS_EXECUTABLE makekdewidgets${CMAKE_EXECUTABLE_SUFFIX} )
set(KDE4_LIB_DIR ${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR})
set(KDE4_INSTALLED_VERSION_OK TRUE)
else(_kdeBootStrapping)
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib )
# These files contain information about the installed kdelibs
include(${kde_cmake_module_dir}/KDE4Config.cmake)
include(${kde_cmake_module_dir}/KDE4Version.cmake)
# Check the version of KDE. It must be at least KDE_MIN_VERSION as set by the user.
# KDE_VERSION is set in KDE4Config.cmake since KDE 4.17.x.
if(NOT KDE_MIN_VERSION)
set(KDE_MIN_VERSION "4.18.0")
endif()
set(KDE4_INSTALLED_VERSION_OK FALSE)
if(NOT "${KDE_VERSION}" VERSION_LESS "${KDE_MIN_VERSION}")
set(KDE4_INSTALLED_VERSION_OK TRUE)
endif()
# KDE4_LIB_INSTALL_DIR and KDE4_INCLUDE_INSTALL_DIR are set in KDE4Config.cmake,
# use them to set the KDE4_LIB_DIR and KDE4_INCLUDE_DIR "public interface" variables
set(KDE4_LIB_DIR ${KDE4_LIB_INSTALL_DIR})
set(KDE4_INCLUDE_DIR ${KDE4_INCLUDE_INSTALL_DIR})
# Now include the file with the imported tools (executable targets).
# This export-file is generated and installed by the toplevel CMakeLists.txt of kdelibs.
# Having the libs and tools in two separate files should help with cross compiling.
include(${kde_cmake_module_dir}/KDELibs4ToolsTargets.cmake)
set(KDE4_KCFGC_EXECUTABLE ${KDE4_TARGET_PREFIX}kconfig_compiler)
set(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${KDE4_TARGET_PREFIX}makekdewidgets)
# allow searching cmake modules in all given kde install locations (KDEDIRS based)
execute_process(
COMMAND "${KDE4_KDECONFIG_EXECUTABLE}" --path data
OUTPUT_VARIABLE _data_DIR
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
file(TO_CMAKE_PATH "${_data_DIR}" _data_DIR)
foreach(dir ${_data_DIR})
set (apath "${dir}/cmake/modules")
if (EXISTS "${apath}")
set (included 0)
string(TOLOWER "${apath}" _apath)
# ignore already added pathes, case insensitive
foreach(adir ${CMAKE_MODULE_PATH})
string(TOLOWER "${adir}" _adir)
if ("${_adir}" STREQUAL "${_apath}")
set (included 1)
endif ("${_adir}" STREQUAL "${_apath}")
endforeach(adir)
if (NOT included)
message(STATUS "Adding ${apath} to CMAKE_MODULE_PATH")
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${apath}")
endif (NOT included)
endif (EXISTS "${apath}")
endforeach(dir)
# This file contains the exported library target from kdelibs (new with cmake 2.6.x), e.g.
# the library target "kdeui" is exported as "KDE4__kdeui". The "KDE4__" is used as
# "namespace" to separate the imported targets from "normal" targets, it is stored in
# KDE4_TARGET_PREFIX, which is set in KDELibsDependencies.cmake .
# This export-file is generated and installed by the toplevel CMakeLists.txt of kdelibs.
# Include it to "import" the libraries from kdelibs into the current projects as targets.
# This makes setting the _LIBRARY and _LIBS variables actually a bit superfluos, since e.g.
# the kdeui library could now also be used just as "KDE4__kdeui" and still have all their
# dependent libraries handled correctly. But to keep compatibility and not to change
# behaviour we set all these variables anyway as seen below. Alex
include(${kde_cmake_module_dir}/KDELibs4LibraryTargets.cmake)
endif(_kdeBootStrapping)
# Set the various KDE4_FOO_LIBRARY/LIBS variables.
# In bootstrapping mode KDE4_TARGET_PREFIX is empty, so e.g. KDE4_KDECORE_LIBRARY
# will be simply set to "kdecore".
set(_kde_libraries
kcddb
kcmutils
kcompactdisc
kdcraw
kdeclarative
kdecore
kdefakes
kdesu
kdeui
kdeui
kdewebkit
kdewebkit
kdnssd
kemoticons
kexiv2
kfile
khtml
kidletime
kio
kjs
kjsapi
knotifyconfig
kparts
kprintutils
kpty
krosscore
krossui
ktexteditor
kunitconversion
plasma
solid
threadweaver
)
foreach(_lib ${_kde_libraries})
string(TOUPPER ${_lib} _upperlib)
if(_kdeBootStrapping)
set(KDE4_${_upperlib}_LIBRARY ${_lib})
set(KDE4_${_upperlib}_LIBS ${_lib})
else()
set(KDE4_${_upperlib}_LIBRARY ${KDE4_TARGET_PREFIX}${_lib})
set(KDE4_${_upperlib}_LIBS ${KDE4_TARGET_PREFIX}${_lib})
endif()
endforeach()
################### try to find Phonon ############################################
# we do this here instead of above together with the checks for Perl etc.
# since FindPhonon.cmake also uses ${KDE4_LIB_INSTALL_DIR} to check for Phonon,
# which helps with finding the phonon installed as part of kdesupport:
# only make Phonon REQUIRED if KDE4 itself is REQUIRED
if(NOT KATIE_FOUND AND NOT KATIE_PHONON_FOUND)
find_package(Phonon 4.7.0 ${_REQ_STRING_KDE4})
set(KDE4_PHONON_LIBRARY ${PHONON_LIBRARY})
set(KDE4_PHONON_LIBS ${PHONON_LIBS})
set(KDE4_PHONON_INCLUDES ${PHONON_INCLUDES})
else()
set(PHONON_FOUND TRUE)
set(KDE4_PHONON_LIBRARY ${KATIE_PHONON_LIBRARIES})
set(KDE4_PHONON_LIBS ${KATIE_PHONON_LIBRARIES})
set(KDE4_PHONON_INCLUDES ${KATIE_PHONON_INCLUDES})
endif()
if(NOT PHONON_FOUND)
message(STATUS "KDE4 not found, because Phonon was not found")
return()
endif()
##################### provide some options ##########################################
if(ENABLE_TESTING)
enable_testing()
endif()
# Position-Independent-Executable is a feature of Binutils, Libc, and GCC that creates an executable
# which is something between a shared library and a normal executable.
# Programs compiled with these features appear as ?shared object? with the file command.
option(KDE4_ENABLE_FPIE "Enable platform supports PIE linking")
##################### some more settings ##########################################
# If we are building ! kdelibs, check where kdelibs are installed.
# If they are installed in a directory which contains "lib64", we default to "64" for LIB_SUFFIX,
# so the current project will by default also go into lib64.
# The same for lib32. Alex
set(_Init_LIB_SUFFIX "")
if ("${KDE4_LIB_DIR}" MATCHES lib64)
set(_Init_LIB_SUFFIX 64)
endif ("${KDE4_LIB_DIR}" MATCHES lib64)
if ("${KDE4_LIB_DIR}" MATCHES lib32)
set(_Init_LIB_SUFFIX 32)
endif ("${KDE4_LIB_DIR}" MATCHES lib32)
# FIXME: this should not be needed
macro(_set_fancy variable value)
set(${variable} "${value}")
set(${variable} "${value}" CACHE PATH "KDE standard path variable")
endmacro()
set(LIB_SUFFIX "${_Init_LIB_SUFFIX}" CACHE STRING "Define suffix of directory name (32/64)")
_set_fancy(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
_set_fancy(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share")
_set_fancy(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin")
_set_fancy(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin")
_set_fancy(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
_set_fancy(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec")
_set_fancy(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include")
_set_fancy(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4")
_set_fancy(IMPORTS_INSTALL_DIR "${PLUGIN_INSTALL_DIR}/imports")
_set_fancy(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config")
_set_fancy(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps")
_set_fancy(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons")
_set_fancy(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg")
_set_fancy(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale")
_set_fancy(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk")
_set_fancy(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/services")
_set_fancy(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes")
_set_fancy(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds")
_set_fancy(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates")
_set_fancy(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers")
_set_fancy(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart")
_set_fancy(XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/kde4")
_set_fancy(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories")
_set_fancy(XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages")
_set_fancy(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc")
_set_fancy(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man")
_set_fancy(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info")
_set_fancy(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces")
_set_fancy(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services")
_set_fancy(DBUS_SYSTEM_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/system-services")
_set_fancy(KAUTH_HELPER_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/helper")
_set_fancy(KAUTH_BACKEND_PLUGIN_DIR "${PLUGIN_INSTALL_DIR}/plugins/kauth/backend")
# For more documentation see above.
# Later on it will be possible to extend this for installing OSX frameworks
# The COMPONENT Devel argument has the effect that static libraries belong to the
# "Devel" install component. If we use this also for all install() commands
# for header files, it will be possible to install
# -everything: make install OR cmake -P cmake_install.cmake
# -only the development files: cmake -DCOMPONENT=Devel -P cmake_install.cmake
# -everything except the development files: cmake -DCOMPONENT=Unspecified -P cmake_install.cmake
# This can then also be used for packaging with cpack.
set(INSTALL_TARGETS_DEFAULT_ARGS
RUNTIME DESTINATION "${BIN_INSTALL_DIR}"
LIBRARY DESTINATION "${LIB_INSTALL_DIR}"
ARCHIVE DESTINATION "${LIB_INSTALL_DIR}"
COMPONENT Devel
)
############## add some more default search paths ###############
#
# the KDE4_xxx_INSTALL_DIR variables are empty when building kdelibs itself
# and otherwise point to the kde4 install dirs
set(CMAKE_SYSTEM_INCLUDE_PATH
${CMAKE_SYSTEM_INCLUDE_PATH}
"${KDE4_INCLUDE_INSTALL_DIR}"
)
set(CMAKE_SYSTEM_PROGRAM_PATH
${CMAKE_SYSTEM_PROGRAM_PATH}
"${KDE4_BIN_INSTALL_DIR}"
)
set(CMAKE_SYSTEM_LIBRARY_PATH
${CMAKE_SYSTEM_LIBRARY_PATH}
"${KDE4_LIB_INSTALL_DIR}"
)
######################################################
# and now the platform specific stuff
######################################################
if(WIN32 OR CYGWIN OR APPLE)
message(FATAL_ERROR "Windows/Cygwin/Apple is NOT supported.")
endif()
set(_KDE4_PLATFORM_INCLUDE_DIRS)
# add our LIB_INSTALL_DIR to the RPATH (but only when it is not one of the
# standard system link directories listed in
# CMAKE_{PLATFORM,C,CXX}_IMPLICIT_LINK_DIRECTORIES) and use the RPATH figured
# out by cmake when compiling
list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemPlatformLibDir)
list(FIND CMAKE_C_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCLibDir)
list(FIND CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" _isSystemCxxLibDir)
if("${_isSystemPlatformLibDir}" STREQUAL "-1"
AND "${_isSystemCLibDir}" STREQUAL "-1"
AND "${_isSystemCxxLibDir}" STREQUAL "-1")
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH};${LIB_INSTALL_DIR}")
endif()
# add our LIB_INSTALL_DIR to the RPATH, also skip re-linking during install
set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
if(Q_WS_X11)
# Done by FindQt4.cmake already
#find_package(X11 REQUIRED)
# UNIX has already set _KDE4_PLATFORM_INCLUDE_DIRS, so append
set(_KDE4_PLATFORM_INCLUDE_DIRS ${_KDE4_PLATFORM_INCLUDE_DIRS} ${X11_INCLUDE_DIR} )
endif()
if(CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
set(_KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE)
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_SHARED_LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_MODULE_LINKER_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_EXE_LINKER_FLAGS}")
# we profile...
if(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
endif()
endif()
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()
set(_KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_LARGEFILE64_SOURCE")
check_cxx_source_compiles("
#include <sys/types.h>
/* Check that off_t can represent 2**63 - 1 correctly.
We can't simply define LARGE_OFF_T to be 9223372036854775807,
since some C++ compilers masquerading as C compilers
incorrectly reject 9223372036854775807. */
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1];
int main() { return 0; }
" _OFFT_IS_64BIT)
if(NOT _OFFT_IS_64BIT)
set(_KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_FILE_OFFSET_BITS=64")
endif()
############################################################
# compiler specific settings
############################################################
if(CMAKE_COMPILER_IS_GNUCXX)
set(KDE4_ENABLE_EXCEPTIONS "-fexceptions -UQT_NO_EXCEPTIONS")
# Select flags.
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O2 -fno-reorder-blocks -fno-schedule-insns -fno-inline")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_C_FLAGS_RELEASE "-O2 -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_C_FLAGS_DEBUG "-g -O2 -fno-reorder-blocks -fno-schedule-insns -fno-inline")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-long-long -std=iso9899:1990 -Wundef -Wcast-align -Werror-implicit-function-declaration -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-common")
# As of Qt 4.6.x we need to override the new exception macros if we want compile with -fno-exceptions
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wno-long-long -Wundef -Wcast-align -Wchar-subscripts -Wall -W -Wpointer-arith -Wformat-security -fno-exceptions -DQT_NO_EXCEPTIONS -fno-check-new -fno-common")
if(CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
# This should not be needed, as it is also part of _KDE4_PLATFORM_DEFINITIONS below.
# It is kept here nonetheless both for backwards compatibility in case
# one does not use add_definitions(${KDE4_DEFINITIONS}) and also
# because it is/was needed by glibc for snprintf to be available when
# building C files.See commit 4a44862b2d178c1d2e1eb4da90010d19a1e4a42c.
add_definitions(-D_DEFAULT_SOURCE -D_BSD_SOURCE)
endif()
if(CMAKE_SYSTEM_NAME STREQUAL GNU)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -pthread")
endif()
check_cxx_compiler_flag(-fPIE HAVE_FPIE_SUPPORT)
if(KDE4_ENABLE_FPIE)
if(HAVE_FPIE_SUPPORT)
set (KDE4_CXX_FPIE_FLAGS "-fPIE")
set (KDE4_PIE_LDFLAGS "-pie")
else(HAVE_FPIE_SUPPORT)
message(STATUS "Your compiler doesn't support the PIE flag")
endif(HAVE_FPIE_SUPPORT)
endif()
check_cxx_compiler_flag(-Woverloaded-virtual __KDE_HAVE_W_OVERLOADED_VIRTUAL)
if(__KDE_HAVE_W_OVERLOADED_VIRTUAL)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Woverloaded-virtual")
endif()
# visibility support
check_cxx_compiler_flag(-fvisibility=hidden __KDE_HAVE_GCC_VISIBILITY)
set(__KDE_HAVE_GCC_VISIBILITY ${__KDE_HAVE_GCC_VISIBILITY} CACHE BOOL "GCC support for hidden visibility")
# get the gcc version
execute_process(
COMMAND ${CMAKE_C_COMPILER} --version
ERROR_QUIET
OUTPUT_VARIABLE _gcc_version_info
)
string (REGEX MATCH "[345]\\.[0-9]\\.[0-9]" _gcc_version "${_gcc_version_info}")
# gcc on mac just reports: "gcc (GCC) 3.3 20030304 ..." without the patch level, handle this here:
if (NOT _gcc_version)
string (REGEX MATCH ".*\\(GCC\\).* ([34]\\.[0-9]) .*" "\\1.0" _gcc_version "${gcc_on_macos}")
if (gcc_on_macos)
string (REGEX REPLACE ".*\\(GCC\\).* ([34]\\.[0-9]) .*" "\\1.0" _gcc_version "${_gcc_version_info}")
endif (gcc_on_macos)
endif (NOT _gcc_version)
if(_gcc_version)
if(NOT "${_gcc_version}" VERSION_LESS "4.1.0")
set(GCC_IS_NEWER_THAN_4_1 TRUE)
if(NOT "${_gcc_version}" VERSION_LESS "4.2.0")
set(GCC_IS_NEWER_THAN_4_2 TRUE)
if(NOT "${_gcc_version}" VERSION_LESS "4.3.0")
set(GCC_IS_NEWER_THAN_4_3 TRUE)
endif()
endif()
endif()
endif()
# save a little by making local statics not threadsafe
# ### do not enable it for older compilers, see
# ### http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31806
if (GCC_IS_NEWER_THAN_4_3)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-threadsafe-statics")
endif (GCC_IS_NEWER_THAN_4_3)
set(_GCC_COMPILED_WITH_BAD_ALLOCATOR FALSE)
if (GCC_IS_NEWER_THAN_4_1)
execute_process(
COMMAND ${CMAKE_C_COMPILER} -v
ERROR_QUIET
OUTPUT_VARIABLE _gcc_alloc_info
)
string(REGEX MATCH "(--enable-libstdcxx-allocator=mt)" _GCC_COMPILED_WITH_BAD_ALLOCATOR "${_gcc_alloc_info}")
endif()
if (__KDE_HAVE_GCC_VISIBILITY
AND GCC_IS_NEWER_THAN_4_1
AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR
AND NOT WIN32)
set(_include_dirs "-DINCLUDE_DIRECTORIES:STRING=${QT_INCLUDES}")
# first check if we can compile a Qt application
set(_source "#include <QtCore/qglobal.h>\n int main() \n {\n return 0; \n } \n")
set(_source_file ${CMAKE_BINARY_DIR}/CMakeTmp/check_qt_application.cpp)
file(WRITE "${_source_file}" "${_source}")
try_compile(_basic_compile_result
${CMAKE_BINARY_DIR} ${_source_file}
CMAKE_FLAGS "${_include_dirs}"
OUTPUT_VARIABLE _compile_output_var
)
if(_basic_compile_result)
# now ready to check for visibility=hidden
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
set (KDE4_C_FLAGS "-fvisibility=hidden")
# check that Qt defines Q_DECL_EXPORT as __attribute__ ((visibility("default")))
# if it doesn't and KDE compiles with hidden default visibiltiy plugins will break
set(_source "#include <QtCore/qglobal.h>\n int main()\n {\n #ifndef QT_VISIBILITY_AVAILABLE \n #error QT_VISIBILITY_AVAILABLE is not available\n #endif \n }\n")
set(_source_file ${CMAKE_BINARY_DIR}/CMakeTmp/check_qt_visibility.cpp)
file(WRITE "${_source_file}" "${_source}")
try_compile(_compile_result
${CMAKE_BINARY_DIR}
${_source_file}
CMAKE_FLAGS "${_include_dirs}"
OUTPUT_VARIABLE _compile_output_var
)
if(NOT _compile_result)
message("${_compile_output_var}")
message(FATAL_ERROR "Qt compiled without support for -fvisibility=hidden. This will break plugins and linking of some applications. Please fix your Qt installation (try passing --reduce-exports to configure).")
endif(NOT _compile_result)
else()
message("${_compile_output_var}")
message(FATAL_ERROR "Unable to compile a basic Qt application. Qt has not been found correctly.")
endif()
if(GCC_IS_NEWER_THAN_4_2)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=return-type -fvisibility-inlines-hidden")
endif()
else(__KDE_HAVE_GCC_VISIBILITY
AND GCC_IS_NEWER_THAN_4_1
AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR
AND NOT WIN32)
set(__KDE_HAVE_GCC_VISIBILITY 0)
endif()
endif(CMAKE_COMPILER_IS_GNUCXX)
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
# Note that exceptions are enabled by default when building with clang. That
# is, -fno-exceptions is not set in CMAKE_CXX_FLAGS below. This is because a
# lot of code in different KDE modules ends up including code that throws
# exceptions. Most (or all) of the occurrences are in template code that
# never gets instantiated. Contrary to GCC, ICC and MSVC, clang (most likely
# rightfully) complains about that. Trying to work around the issue by
# passing -fdelayed-template-parsing brings other problems, as noted in
# http://lists.kde.org/?l=kde-core-devel&m=138157459706783&w=2.
# The generated code will be slightly bigger, but there is no way to avoid
# it.
set(KDE4_ENABLE_EXCEPTIONS "-fexceptions -UQT_NO_EXCEPTIONS")
# Select flags.
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O2 -fno-inline")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_C_FLAGS_RELEASE "-O2 -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_C_FLAGS_DEBUG "-g -O2 -fno-inline")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-long-long -std=iso9899:1990 -Wundef -Wcast-align -Werror-implicit-function-declaration -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-common")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wno-long-long -Wundef -Wcast-align -Wchar-subscripts -Wall -W -Wpointer-arith -Wformat-security -Woverloaded-virtual -fno-common -fvisibility=hidden -Werror=return-type -fvisibility-inlines-hidden")
set(KDE4_C_FLAGS "-fvisibility=hidden")
# At least kdepim exports one function with C linkage that returns a
# QString in a plugin, but clang does not like that.
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage")
set(KDE4_CXX_FPIE_FLAGS "-fPIE")
set(KDE4_PIE_LDFLAGS "-pie")
if(CMAKE_SYSTEM_NAME STREQUAL GNU)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -pthread")
endif (CMAKE_SYSTEM_NAME STREQUAL GNU)
set(__KDE_HAVE_GCC_VISIBILITY TRUE)
# check that Qt defines Q_DECL_EXPORT as __attribute__ ((visibility("default")))
# if it doesn't and KDE compiles with hidden default visibiltiy plugins will break
set(_source "#include <QtCore/QtGlobal>\n int main()\n {\n #ifndef QT_VISIBILITY_AVAILABLE \n #error QT_VISIBILITY_AVAILABLE is not available\n #endif \n }\n")
set(_source_file ${CMAKE_BINARY_DIR}/CMakeTmp/check_qt_visibility.cpp)
file(WRITE "${_source_file}" "${_source}")
set(_include_dirs "-DINCLUDE_DIRECTORIES:STRING=${QT_INCLUDES}")
try_compile(_compile_result ${CMAKE_BINARY_DIR} ${_source_file} CMAKE_FLAGS "${_include_dirs}" OUTPUT_VARIABLE _compile_output_var)
if(NOT _compile_result)
message("${_compile_output_var}")
message(FATAL_ERROR "Qt compiled without support for -fvisibility=hidden. This will break plugins and linking of some applications. Please fix your Qt installation (try passing --reduce-exports to configure).")
endif(NOT _compile_result)
endif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if(CMAKE_C_COMPILER MATCHES "icc")
set(KDE4_ENABLE_EXCEPTIONS "-fexceptions")
# Select flags.
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_CXX_FLAGS_DEBUG "-O2 -g -fno-inline -noalign")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g")
set(CMAKE_C_FLAGS_RELEASE "-O2 -DNDEBUG -DQT_NO_DEBUG")
set(CMAKE_C_FLAGS_DEBUG "-O2 -g -fno-inline -noalign")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ansi -Wall -w1 -Wpointer-arith -fno-common")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ansi -Wall -w1 -Wpointer-arith -fno-exceptions -fno-common")
# visibility support
set(__KDE_HAVE_ICC_VISIBILITY)
# check_cxx_compiler_flag(-fvisibility=hidden __KDE_HAVE_ICC_VISIBILITY)
# if (__KDE_HAVE_ICC_VISIBILITY)
# set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
# endif (__KDE_HAVE_ICC_VISIBILITY)
endif()
########### end of platform specific stuff ##########################
# KDE4Macros.cmake contains all the KDE specific macros
include(${kde_cmake_module_dir}/KDE4Macros.cmake)
# decide whether KDE4 has been found
set(KDE4_FOUND FALSE)
if (KDE4_INCLUDE_DIR
AND KDE4_LIB_DIR
AND KDE4_KCFGC_EXECUTABLE
AND KDE4_INSTALLED_VERSION_OK)
set(KDE4_FOUND TRUE)
set(KDE4Internal_FOUND TRUE) # for feature_summary
endif()
macro(KDE4_PRINT_RESULTS)
# inside kdelibs the include dir and lib dir are internal, not "found"
if(NOT _kdeBootStrapping)
if(KDE4_INCLUDE_DIR)
message(STATUS "Found KDE 4.18 include dir: ${KDE4_INCLUDE_DIR}")
else()
message(STATUS "ERROR: unable to find the KDE 4 headers")
endif()
if(KDE4_LIB_DIR)
message(STATUS "Found KDE 4.18 library dir: ${KDE4_LIB_DIR}")
else()
message(STATUS "ERROR: unable to find the KDE 4 core library")
endif()
endif()
if(KDE4_KCFGC_EXECUTABLE)
message(STATUS "Found the KDE4 kconfig_compiler preprocessor: ${KDE4_KCFGC_EXECUTABLE}")
else()
message(STATUS "Didn't find the KDE4 kconfig_compiler preprocessor")
endif()
endmacro()
if(KDE4Internal_FIND_REQUIRED AND NOT KDE4_FOUND)
#bail out if something wasn't found
kde4_print_results()
if (NOT KDE4_INSTALLED_VERSION_OK)
message(FATAL_ERROR "ERROR: the installed kdelibs version ${KDE_VERSION} is too old, at least version ${KDE_MIN_VERSION} is required")
endif()
if(NOT KDE4_KCFGC_EXECUTABLE)
message(FATAL_ERROR "ERROR: could not detect a usable kconfig_compiler")
endif()
message(FATAL_ERROR "ERROR: could NOT find everything required for compiling KDE 4 programs")
endif()
if(NOT KDE4Internal_FIND_QUIETLY)
kde4_print_results()
endif()
# add the found Qt and KDE include directories to the current include path
# the ${KDE4_INCLUDE_DIR}/KDE directory is for forwarding includes, eg. #include <KMainWindow>
set(KDE4_INCLUDES
${KDE4_INCLUDE_DIR}
${KDE4_INCLUDE_DIR}/KDE
${KDE4_PHONON_INCLUDES}
${QT_INCLUDES}
${_KDE4_PLATFORM_INCLUDE_DIRS}
)
# Used by kdebug.h: the "toplevel dir" is one level above CMAKE_SOURCE_DIR
get_filename_component(_KDE4_CMAKE_TOPLEVEL_DIR "${CMAKE_SOURCE_DIR}/.." ABSOLUTE)
string(LENGTH "${_KDE4_CMAKE_TOPLEVEL_DIR}" _KDE4_CMAKE_TOPLEVEL_DIR_LENGTH)
set(KDE4_DEFINITIONS
${_KDE4_PLATFORM_DEFINITIONS}
-DQT_NO_STL
-DQT_NO_CAST_TO_ASCII
-DQT_DEPRECATED_WARNINGS
-D_REENTRANT
-DKDE_DEPRECATED_WARNINGS
-DKDE4_CMAKE_TOPLEVEL_DIR_LENGTH=${_KDE4_CMAKE_TOPLEVEL_DIR_LENGTH}
)
if(NOT _kde4_uninstall_rule_created)
set(_kde4_uninstall_rule_created TRUE)
configure_file(
"${kde_cmake_module_dir}/kde4_cmake_uninstall.cmake.in"
"${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" @ONLY
)
add_custom_target(uninstall
COMMAND "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake"
)
endif()
endif(NOT KDE4_FOUND)
Reference in a new issue View git blame Copy permalink