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

cmake: import various modules

Browse source 
Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
This commit is contained in:
Ivailo Monev 2015-10-29 10:09:43 +02:00
parent b12750be4a
commit d411471be1
27 changed files with 2428 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
cmake/modules/CMakeLists.txt
View file

@ -27,9 +27,15 @@ set(cmakeFiles
FindAvahi.cmake
FindBerkeleyDB.cmake
FindBlueZ.cmake
FindCanberra.cmake
FindCHM.cmake
FindCUPS.cmake
FindDBusMenuQt.cmake
FindKDevelop.cmake
FindDjVuLibre.cmake
FindDNSSD.cmake
FindENCHANT.cmake
FindEPub.cmake
FindEigen.cmake
FindEigen2.cmake
FindExiv2.cmake
@ -38,12 +44,16 @@ set(cmakeFiles
FindFlac.cmake
FindFlex.cmake
FindFontconfig.cmake
FindLibGcrypt.cmake
FindGLIB2.cmake
FindGMP.cmake
FindGObject.cmake
FindGSSAPI.cmake
FindGStreamer.cmake
FindGettext.cmake
FindGettextPO.cmake
FindSpeechd.cmake
FindGpgme.cmake
FindGphoto2.cmake
FindHUNSPELL.cmake
FindKDE4Internal.cmake
@ -54,17 +64,29 @@ set(cmakeFiles
FindKipi.cmake
FindKopete.cmake
FindKorundum.cmake
FindKSane.cmake
FindKTp.cmake
FindLCMS.cmake
FindLCMS2.cmake
FindLibArt.cmake
FindLibAttica.cmake
FindLibKasten.cmake
FindLibKonq.cmake
FindLibLZMA.cmake
FindLibOkteta.cmake
FindLibOktetaKasten.cmake
FindLibXslt.cmake
FindLibintl.cmake
FindLibNXCL.cmake
FindLibSpectre.cmake
FindLibVNCServer.cmake
FindLIBPARTED.cmake
FindLinuxWirelesstools.cmake
FindLibMms.cmake
FindMusicBrainz.cmake
FindMusicBrainz5.cmake
FindMySQL.cmake
FindMPFR.cmake
FindNetworkManager.cmake
FindOggVorbis.cmake
FindOpenEXR.cmake
@ -77,6 +99,7 @@ set(cmakeFiles
FindPyQt4.cmake
Qt4Macros.cmake
Qt4ConfigDependentSettings.cmake
FindPoppler.cmake
FindPythonLibrary.cmake
FindQCA2.cmake
FindQImageBlitz.cmake
@ -89,10 +112,13 @@ set(cmakeFiles
FindSharedMimeInfo.cmake
FindSqlite.cmake
FindStrigi.cmake
FindSubversionLibrary.cmake
FindTaglib.cmake
FindUDisks2.cmake
FindUSB.cmake
FindXCB.cmake
FindX11.cmake
FindX11_XCB.cmake
FindXKB.cmake
FindXine.cmake
FindXmms.cmake

33
cmake/modules/FindCHM.cmake Normal file
View file

@ -0,0 +1,33 @@
# - Try to find the chm library
# Once done this will define
#
# CHM_FOUND - system has the chm library
# CHM_INCLUDE_DIR - the chm include directory
# CHM_LIBRARY - Link this to use the chm library
#
# Copyright (c) 2006, Pino Toscano, <toscano.pino@tiscali.it>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if (CHM_LIBRARY AND CHM_INCLUDE_DIR)
# in cache already
set(CHM_FOUND TRUE)
else (CHM_LIBRARY AND CHM_INCLUDE_DIR)
find_path(CHM_INCLUDE_DIR chm_lib.h
${GNUWIN32_DIR}/include
)
find_library(CHM_LIBRARY NAMES chm
PATHS
${GNUWIN32_DIR}/lib
)
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(CHM DEFAULT_MSG CHM_INCLUDE_DIR CHM_LIBRARY )
# ensure that they are cached
set(CHM_INCLUDE_DIR ${CHM_INCLUDE_DIR} CACHE INTERNAL "The chmlib include path")
set(CHM_LIBRARY ${CHM_LIBRARY} CACHE INTERNAL "The libraries needed to use chmlib")
endif (CHM_LIBRARY AND CHM_INCLUDE_DIR)

59
cmake/modules/FindCUPS.cmake Normal file
View file

@ -0,0 +1,59 @@
#/***************************************************************************
# * Copyright (C) 2010-2012 by Daniel Nicoletti *
# * dantti12@gmail.com *
# * *
# * This program is free software; you can redistribute it and/or modify *
# * it under the terms of the GNU General Public License as published by *
# * the Free Software Foundation; either version 2 of the License, or *
# * (at your option) any later version. *
# * *
# * This program is distributed in the hope that it will be useful, *
# * but WITHOUT ANY WARRANTY; without even the implied warranty of *
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
# * GNU General Public License for more details. *
# * *
# * You should have received a copy of the GNU General Public License *
# * along with this program; see the file COPYING. If not, write to *
# * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, *
# * Boston, MA 02110-1301, USA. *
# ***************************************************************************/
# - Try to find CUPS
# Once done this will define
#
# CUPS_FOUND - system has CUPS
# CUPS_INCLUDE_DIR - the CUPS include directory
# CUPS_LIB - Link these to use CUPS
# CUPS_DEFINITIONS - Compiler switches required for using CUPS
# Copyright (c) 2010, Daniel Nicolett, <dantti12@gmail.com>
#
# Redistribution and use is allowed according to the terms of the GPLv2+ license.
IF (CUPS_INCLUDE_DIR AND CUPS_LIB)
SET(CUPS_FIND_QUIETLY TRUE)
ENDIF (CUPS_INCLUDE_DIR AND CUPS_LIB)
FIND_PATH( CUPS_INCLUDE_DIR cups)
FIND_LIBRARY(CUPS_LIB NAMES cups)
IF (CUPS_INCLUDE_DIR AND CUPS_LIB)
SET(CUPS_FOUND TRUE)
ELSE (CUPS_INCLUDE_DIR AND CUPS_LIB)
SET(CUPS_FOUND FALSE)
ENDIF (CUPS_INCLUDE_DIR AND CUPS_LIB)
SET(CUPS_INCLUDE_DIR ${CUPS_INCLUDE_DIR})
IF (CUPS_FOUND)
IF (NOT CUPS_FIND_QUIETLY)
MESSAGE(STATUS "Found CUPS: ${CUPS_LIB}")
ENDIF (NOT CUPS_FIND_QUIETLY)
ELSE (CUPS_FOUND)
IF (CUPS_FIND_REQUIRED)
MESSAGE(FATAL_ERROR "Could NOT find CUPS libraries")
ENDIF (CUPS_FIND_REQUIRED)
ENDIF (CUPS_FOUND)
MARK_AS_ADVANCED(CUPS_INCLUDE_DIR CUPS_LIB)

29
cmake/modules/FindCanberra.cmake Normal file
View file

@ -0,0 +1,29 @@
# - Find libcanberra's libraries and headers.
# This module defines the following variables:
#
# CANBERRA_FOUND - true if libcanberra was found
# CANBERRA_LIBRARIES - libcanberra libraries to link against
# CANBERRA_INCLUDE_DIRS - include path for libcanberra
#
# Copyright (c) 2012 Raphael Kubo da Costa <rakuco@FreeBSD.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
find_package(PkgConfig)
pkg_check_modules(PC_CANBERRA libcanberra)
find_library(CANBERRA_LIBRARIES
NAMES canberra
HINTS ${PC_CANBERRA_LIBRARY_DIRS} ${PC_CANBERRA_LIBDIR}
)
find_path(CANBERRA_INCLUDE_DIRS
NAMES canberra.h
HINTS ${PC_CANBERRA_INCLUDE_DIRS} ${PC_CANBERRA_INCLUDEDIR}
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Canberra REQUIRED_VARS CANBERRA_LIBRARIES CANBERRA_INCLUDE_DIRS)
mark_as_advanced(CANBERRA_LIBRARIES CANBERRA_INCLUDE_DIRS)

39
cmake/modules/FindDjVuLibre.cmake Normal file
View file

@ -0,0 +1,39 @@
# - Try to find the DjVuLibre library
# Once done this will define
#
# DJVULIBRE_FOUND - system has the DjVuLibre library
# DJVULIBRE_INCLUDE_DIR - the DjVuLibre include directory
# DJVULIBRE_LIBRARY - Link this to use the DjVuLibre library
if (DJVULIBRE_INCLUDE_DIR AND DJVULIBRE_LIBRARY)
# in cache already
set(DJVULIBRE_FOUND TRUE)
else (DJVULIBRE_INCLUDE_DIR AND DJVULIBRE_LIBRARY)
IF (NOT WIN32)
find_package(PkgConfig)
pkg_check_modules(PC_DJVULIBRE ddjvuapi)
endif(NOT WIN32)
find_path(DJVULIBRE_INCLUDE_DIR libdjvu/ddjvuapi.h
PATHS
${PC_DJVULIBRE_INCLUDEDIR}
${PC_DJVULIBRE_INCLUDE_DIRS}
${GNUWIN32_DIR}/include
)
find_library(DJVULIBRE_LIBRARY NAMES djvulibre
PATHS
${PC_DJVULIBRE_LIBDIR}
${PC_DJVULIBRE_LIBRARY_DIRS}
${GNUWIN32_DIR}/lib
)
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(DjVuLibre DEFAULT_MSG DJVULIBRE_INCLUDE_DIR DJVULIBRE_LIBRARY )
mark_as_advanced(DJVULIBRE_INCLUDE_DIR DJVULIBRE_LIBRARY)
endif (DJVULIBRE_INCLUDE_DIR AND DJVULIBRE_LIBRARY)

35
cmake/modules/FindEPub.cmake Normal file
View file

@ -0,0 +1,35 @@
# - Find EPub
# Find the EPub library.
#
# This module defines
# EPUB_FOUND - whether the EPub library was found
# EPUB_LIBRARIES - the EPub library
# EPUB_INCLUDE_DIR - the include path of the EPub library
# Copyright (c) 2008, Pino Toscano, <pino@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 (EPUB_INCLUDE_DIR AND EPUB_LIBRARIES)
# Already in cache
set (EPUB_FOUND TRUE)
else (EPUB_INCLUDE_DIR AND EPUB_LIBRARIES)
find_library (EPUB_LIBRARIES
NAMES epub libepub
)
find_path (EPUB_INCLUDE_DIR
NAMES epub.h
)
include (FindPackageHandleStandardArgs)
find_package_handle_standard_args (EPub DEFAULT_MSG EPUB_LIBRARIES EPUB_INCLUDE_DIR)
endif (EPUB_INCLUDE_DIR AND EPUB_LIBRARIES)
mark_as_advanced(EPUB_INCLUDE_DIR EPUB_LIBRARIES)

31
cmake/modules/FindGettextPO.cmake Normal file
View file

@ -0,0 +1,31 @@
# - Try to find GettextPO
#
# Once done this will define
#
# GETTEXTPO_FOUND - System has GETTEXTPO
# GETTEXTPO_INCLUDE_DIR - The GETTEXTPO include directory
# GETTEXTPO_LIBRARY - The library needed to use GETTEXTPO
# Copyright (c) 2012, Ni Hui <shuizhuyuanluo@126.com>
# Based off FindLibXml2.cmake from CMake 2.6.4 by 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(GETTEXTPO_INCLUDE_DIR AND GETTEXTPO_LIBRARY)
# in cache already
set(GETTEXTPO_FIND_QUIETLY TRUE)
endif(GETTEXTPO_INCLUDE_DIR AND GETTEXTPO_LIBRARY)
find_path(GETTEXTPO_INCLUDE_DIR gettext-po.h)
find_library(GETTEXTPO_LIBRARY NAMES gettextpo)
include(FindPackageHandleStandardArgs)
# handle the QUIETLY and REQUIRED arguments and set GETTEXTPO_FOUND to TRUE if
# all listed variables are TRUE
find_package_handle_standard_args(GettextPO DEFAULT_MSG GETTEXTPO_LIBRARY GETTEXTPO_INCLUDE_DIR)
mark_as_advanced(GETTEXTPO_INCLUDE_DIR GETTEXTPO_LIBRARY)

385
cmake/modules/FindGpgme.cmake Normal file
View file

@ -0,0 +1,385 @@
# Copied from KDE
# http://websvn.kde.org/trunk/KDE/kdepimlibs/cmake/modules/FindGpgme.cmake
# Added: include (MacroBoolTo01)
# Removed: macro_log_feature() call
# - Try to find the gpgme library
#
# Algorithm:
# - Windows:
# On Windows, there's three gpgme variants: gpgme{,-glib,-qt}.
# - The variant used determines the event loop integration possible:
# - gpgme: no event loop integration possible, only synchronous operations supported
# - gpgme-glib: glib event loop integration possible, only asynchronous operations supported
# - gpgme-qt: qt event loop integration possible, only asynchronous operations supported
# - GPGME_{VANILLA,GLIB,QT}_{FOUND,LIBRARIES} will be set for each of the above
# - GPGME_INCLUDES is the same for all of the above
# - GPGME_FOUND is set if any of the above was found
# - *nix:
# There's also three variants: gpgme{,-pthread,-pth}.
# - The variant used determines the multithreaded use possible:
# - gpgme: no multithreading support available
# - gpgme-pthread: multithreading available using POSIX threads
# - gpgme-pth: multithreading available using GNU PTH (cooperative multithreading)
# - GPGME_{VANILLA,PTH,PTHREAD}_{FOUND,LIBRARIES} will be set for each of the above
# - GPGME_INCLUDES is the same for all of the above
# - GPGME_FOUND is set if any of the above was found
#
# GPGME_LIBRARY_DIR - the directory where the libraries are located
#
# THIS IS ALMOST A 1:1 COPY OF FindAssuan.cmake in kdepim.
# Any changes here likely apply there, too.
#
# do away with crappy condition repetition on else/endfoo
set( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS_gpgme_saved ${CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS} )
set( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true )
#if this is built-in, please replace, if it isn't, export into a MacroToBool.cmake of it's own
macro( macro_bool_to_bool FOUND_VAR )
foreach( _current_VAR ${ARGN} )
if ( ${FOUND_VAR} )
set( ${_current_VAR} TRUE )
else()
set( ${_current_VAR} FALSE )
endif()
endforeach()
endmacro()
include (MacroEnsureVersion)
include (MacroBoolTo01)
if ( WIN32 )
# On Windows, we don't have a gpgme-config script, so we need to
# look for the stuff ourselves:
# in cmake, AND and OR have the same precedence, there's no
# subexpressions, and expressions are evaluated short-circuit'ed
# IOW: CMake if() suxx.
# Starting with CMake 2.6.3 you can group if expressions with (), but we
# don't require 2.6.3 but 2.6.2, we can't use it. Alex
set( _seem_to_have_cached_gpgme false )
if ( GPGME_INCLUDES )
if ( GPGME_VANILLA_LIBRARIES OR GPGME_QT_LIBRARIES OR GPGME_GLIB_LIBRARIES )
set( _seem_to_have_cached_gpgme true )
endif()
endif()
if ( _seem_to_have_cached_gpgme )
macro_bool_to_bool( GPGME_VANILLA_LIBRARIES GPGME_VANILLA_FOUND )
macro_bool_to_bool( GPGME_GLIB_LIBRARIES GPGME_GLIB_FOUND )
macro_bool_to_bool( GPGME_QT_LIBRARIES GPGME_QT_FOUND )
# this would have been preferred:
#set( GPGME_*_FOUND macro_bool_to_bool(GPGME_*_LIBRARIES) )
if ( GPGME_VANILLA_FOUND OR GPGME_GLIB_FOUND OR GPGME_QT_FOUND )
set( GPGME_FOUND true )
else()
set( GPGME_FOUND false )
endif()
else()
# is this needed, of just unreflected cut'n'paste?
# this isn't a KDE library, after all!
if( NOT KDEWIN_FOUND )
find_package( KDEWIN REQUIRED )
endif()
set( GPGME_FOUND false )
set( GPGME_VANILLA_FOUND false )
set( GPGME_GLIB_FOUND false )
set( GPGME_QT_FOUND false )
find_path( GPGME_INCLUDES gpgme.h
${CMAKE_INCLUDE_PATH}
${CMAKE_INSTALL_PREFIX}/include
)
find_library( _gpgme_vanilla_library NAMES gpgme libgpgme gpgme-11 libgpgme-11
PATHS
${CMAKE_LIBRARY_PATH}
${CMAKE_INSTALL_PREFIX}/lib
)
find_library( _gpgme_glib_library NAMES gpgme-glib libgpgme-glib gpgme-glib-11 libgpgme-glib-11
PATHS
${CMAKE_LIBRARY_PATH}
${CMAKE_INSTALL_PREFIX}/lib
)
find_library( _gpgme_qt_library NAMES gpgme-qt libgpgme-qt gpgme-qt-11 libgpgme-qt-11
PATHS
${CMAKE_LIBRARY_PATH}
${CMAKE_INSTALL_PREFIX}/lib
)
find_library( _gpg_error_library NAMES gpg-error libgpg-error gpg-error-0 libgpg-error-0
PATHS
${CMAKE_LIBRARY_PATH}
${CMAKE_INSTALL_PREFIX}/lib
)
set( GPGME_INCLUDES ${GPGME_INCLUDES} )
if ( _gpgme_vanilla_library AND _gpg_error_library )
set( GPGME_VANILLA_LIBRARIES ${_gpgme_vanilla_library} ${_gpg_error_library} )
set( GPGME_VANILLA_FOUND true )
set( GPGME_FOUND true )
endif()
if ( _gpgme_glib_library AND _gpg_error_library )
set( GPGME_GLIB_LIBRARIES ${_gpgme_glib_library} ${_gpg_error_library} )
set( GPGME_GLIB_FOUND true )
set( GPGME_FOUND true )
endif()
if ( _gpgme_qt_library AND _gpg_error_library )
set( GPGME_QT_LIBRARIES ${_gpgme_qt_library} ${_gpg_error_library} )
set( GPGME_QT_FOUND true )
set( GPGME_FOUND true )
endif()
endif()
# these are Unix-only:
set( GPGME_PTHREAD_FOUND false )
set( GPGME_PTH_FOUND false )
set( HAVE_GPGME_PTHREAD 0 )
set( HAVE_GPGME_PTH 0 )
macro_bool_to_01( GPGME_FOUND HAVE_GPGME )
macro_bool_to_01( GPGME_VANILLA_FOUND HAVE_GPGME_VANILLA )
macro_bool_to_01( GPGME_GLIB_FOUND HAVE_GPGME_GLIB )
macro_bool_to_01( GPGME_QT_FOUND HAVE_GPGME_QT )
else() # not WIN32
# On *nix, we have the gpgme-config script which can tell us all we
# need to know:
# see WIN32 case for an explanation of what this does:
set( _seem_to_have_cached_gpgme false )
if ( GPGME_INCLUDES )
if ( GPGME_VANILLA_LIBRARIES OR GPGME_PTHREAD_LIBRARIES OR GPGME_PTH_LIBRARIES )
set( _seem_to_have_cached_gpgme true )
endif()
endif()
if ( _seem_to_have_cached_gpgme )
macro_bool_to_bool( GPGME_VANILLA_LIBRARIES GPGME_VANILLA_FOUND )
macro_bool_to_bool( GPGME_PTHREAD_LIBRARIES GPGME_PTHREAD_FOUND )
macro_bool_to_bool( GPGME_PTH_LIBRARIES GPGME_PTH_FOUND )
if ( GPGME_VANILLA_FOUND OR GPGME_PTHREAD_FOUND OR GPGME_PTH_FOUND )
set( GPGME_FOUND true )
else()
set( GPGME_FOUND false )
endif()
else()
set( GPGME_FOUND false )
set( GPGME_VANILLA_FOUND false )
set( GPGME_PTHREAD_FOUND false )
set( GPGME_PTH_FOUND false )
find_program( _GPGMECONFIG_EXECUTABLE NAMES gpgme-config )
# if gpgme-config has been found
if ( _GPGMECONFIG_EXECUTABLE )
message( STATUS "Found gpgme-config at ${_GPGMECONFIG_EXECUTABLE}" )
exec_program( ${_GPGMECONFIG_EXECUTABLE} ARGS --version OUTPUT_VARIABLE GPGME_VERSION )
if("${GPGME_VERSION}" VERSION_LESS "1.0.0")
message( STATUS "The installed version of gpgme is too old: ${GPGME_VERSION} (required: >= ${_GPGME_MIN_VERSION})" )
else()
message( STATUS "Found gpgme v${GPGME_VERSION}, checking for flavours..." )
exec_program( ${_GPGMECONFIG_EXECUTABLE} ARGS --libs OUTPUT_VARIABLE _gpgme_config_vanilla_libs RETURN_VALUE _ret )
if ( _ret )
set( _gpgme_config_vanilla_libs )
endif()
exec_program( ${_GPGMECONFIG_EXECUTABLE} ARGS --thread=pthread --libs OUTPUT_VARIABLE _gpgme_config_pthread_libs RETURN_VALUE _ret )
if ( _ret )
set( _gpgme_config_pthread_libs )
endif()
exec_program( ${_GPGMECONFIG_EXECUTABLE} ARGS --thread=pth --libs OUTPUT_VARIABLE _gpgme_config_pth_libs RETURN_VALUE _ret )
if ( _ret )
set( _gpgme_config_pth_libs )
endif()
# append -lgpg-error to the list of libraries, if necessary
foreach ( _flavour vanilla pthread pth )
if ( _gpgme_config_${_flavour}_libs AND NOT _gpgme_config_${_flavour}_libs MATCHES "lgpg-error" )
set( _gpgme_config_${_flavour}_libs "${_gpgme_config_${_flavour}_libs} -lgpg-error" )
endif()
endforeach()
if ( _gpgme_config_vanilla_libs OR _gpgme_config_pthread_libs OR _gpgme_config_pth_libs )
exec_program( ${_GPGMECONFIG_EXECUTABLE} ARGS --cflags OUTPUT_VARIABLE _GPGME_CFLAGS )
if ( _GPGME_CFLAGS )
string( REGEX REPLACE "(\r?\n)+$" " " _GPGME_CFLAGS "${_GPGME_CFLAGS}" )
string( REGEX REPLACE " *-I" ";" GPGME_INCLUDES "${_GPGME_CFLAGS}" )
endif()
foreach ( _flavour vanilla pthread pth )
if ( _gpgme_config_${_flavour}_libs )
set( _gpgme_library_dirs )
set( _gpgme_library_names )
string( TOUPPER "${_flavour}" _FLAVOUR )
string( REGEX REPLACE " +" ";" _gpgme_config_${_flavour}_libs "${_gpgme_config_${_flavour}_libs}" )
foreach( _flag ${_gpgme_config_${_flavour}_libs} )
if ( "${_flag}" MATCHES "^-L" )
string( REGEX REPLACE "^-L" "" _dir "${_flag}" )
file( TO_CMAKE_PATH "${_dir}" _dir )
set( _gpgme_library_dirs ${_gpgme_library_dirs} "${_dir}" )
elseif( "${_flag}" MATCHES "^-l" )
string( REGEX REPLACE "^-l" "" _name "${_flag}" )
set( _gpgme_library_names ${_gpgme_library_names} "${_name}" )
endif()
endforeach()
set( GPGME_${_FLAVOUR}_FOUND true )
foreach( _name ${_gpgme_library_names} )
set( _gpgme_${_name}_lib )
# if -L options were given, look only there
if ( _gpgme_library_dirs )
find_library( _gpgme_${_name}_lib NAMES ${_name} PATHS ${_gpgme_library_dirs} NO_DEFAULT_PATH )
endif()
# if not found there, look in system directories
if ( NOT _gpgme_${_name}_lib )
find_library( _gpgme_${_name}_lib NAMES ${_name} )
endif()
# if still not found, then the whole flavour isn't found
if ( NOT _gpgme_${_name}_lib )
if ( GPGME_${_FLAVOUR}_FOUND )
set( GPGME_${_FLAVOUR}_FOUND false )
set( _not_found_reason "dependant library ${_name} wasn't found" )
endif()
endif()
set( GPGME_${_FLAVOUR}_LIBRARIES ${GPGME_${_FLAVOUR}_LIBRARIES} "${_gpgme_${_name}_lib}" )
endforeach()
#check_c_library_exists_explicit( gpgme gpgme_check_version "${_GPGME_CFLAGS}" "${GPGME_LIBRARIES}" GPGME_FOUND )
if ( GPGME_${_FLAVOUR}_FOUND )
message( STATUS " Found flavour '${_flavour}', checking whether it's usable...yes" )
else()
message( STATUS " Found flavour '${_flavour}', checking whether it's usable...no" )
message( STATUS " (${_not_found_reason})" )
endif()
endif()
endforeach( _flavour )
# ensure that they are cached
# This comment above doesn't make sense, the four following lines seem to do nothing. Alex
set( GPGME_INCLUDES ${GPGME_INCLUDES} )
set( GPGME_VANILLA_LIBRARIES ${GPGME_VANILLA_LIBRARIES} )
set( GPGME_PTHREAD_LIBRARIES ${GPGME_PTHREAD_LIBRARIES} )
set( GPGME_PTH_LIBRARIES ${GPGME_PTH_LIBRARIES} )
if ( GPGME_VANILLA_FOUND OR GPGME_PTHREAD_FOUND OR GPGME_PTH_FOUND )
set( GPGME_FOUND true )
else()
set( GPGME_FOUND false )
endif()
endif()
endif()
endif()
endif()
# these are Windows-only:
set( GPGME_GLIB_FOUND false )
set( GPGME_QT_FOUND false )
set( HAVE_GPGME_GLIB 0 )
set( HAVE_GPGME_QT 0 )
macro_bool_to_01( GPGME_FOUND HAVE_GPGME )
macro_bool_to_01( GPGME_VANILLA_FOUND HAVE_GPGME_VANILLA )
macro_bool_to_01( GPGME_PTHREAD_FOUND HAVE_GPGME_PTHREAD )
macro_bool_to_01( GPGME_PTH_FOUND HAVE_GPGME_PTH )
endif() # WIN32 | Unix
set( _gpgme_flavours "" )
if ( GPGME_VANILLA_FOUND )
set( _gpgme_flavours "${_gpgme_flavours} vanilla" )
endif()
if ( GPGME_GLIB_FOUND )
set( _gpgme_flavours "${_gpgme_flavours} Glib" )
endif()
if ( GPGME_QT_FOUND )
set( _gpgme_flavours "${_gpgme_flavours} Qt" )
endif()
if ( GPGME_PTHREAD_FOUND )
set( _gpgme_flavours "${_gpgme_flavours} pthread" )
endif()
if ( GPGME_PTH_FOUND )
set( _gpgme_flavours "${_gpgme_flavours} pth" )
endif()
# determine the library in one of the found flavours, can be reused e.g. by FindQgpgme.cmake, Alex
foreach(_currentFlavour vanilla glib qt pth pthread)
if(NOT GPGME_LIBRARY_DIR)
get_filename_component(GPGME_LIBRARY_DIR "${_gpgme_${_currentFlavour}_lib}" PATH)
endif()
endforeach()
if ( NOT Gpgme_FIND_QUIETLY )
if ( GPGME_FOUND )
message( STATUS "Usable gpgme flavours found: ${_gpgme_flavours}" )
else()
message( STATUS "No usable gpgme flavours found." )
endif()
macro_bool_to_bool( Gpgme_FIND_REQUIRED _req )
if ( WIN32 )
set( _gpgme_homepage "http://www.gpg4win.org" )
else()
set( _gpgme_homepage "http://www.gnupg.org/related_software/gpgme" )
endif()
else()
if ( Gpgme_FIND_REQUIRED AND NOT GPGME_FOUND )
message( FATAL_ERROR "Did not find GPGME" )
endif()
endif()
set( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS_gpgme_saved )

54
cmake/modules/FindKDE4Internal.cmake
View file

@ -310,16 +310,13 @@ if(NOT QT4_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 ? kdelibs_SOURCE_DIR comes from "project(kdelibs)" in kdelibs/CMakeLists.txt
# then enter bootstrap mode
# 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)
@ -345,7 +342,7 @@ if (_kdeBootStrapping)
set(KDE4_LIB_DIR ${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR})
set(KDE4_INSTALLED_VERSION_OK TRUE)
else (_kdeBootStrapping)
else(_kdeBootStrapping)
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib )
# These files contain information about the installed kdelibs
@ -416,7 +413,7 @@ else (_kdeBootStrapping)
# 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)
endif(_kdeBootStrapping)
# Set the various KDE4_FOO_LIBRARY/LIBS variables.
# In bootstrapping mode KDE4_TARGET_PREFIX is empty, so e.g. KDE4_KDECORE_LIBRARY
@ -601,13 +598,17 @@ endif()
# and all link directories which are not inside the current build dir.
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
# 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")
if("${_isSystemPlatformLibDir}" STREQUAL "-1"
AND "${_isSystemCLibDir}" STREQUAL "-1"
AND "${_isSystemCxxLibDir}" STREQUAL "-1")
set(CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}")
endif()
@ -615,7 +616,6 @@ 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)
@ -623,7 +623,6 @@ if(Q_WS_X11)
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)
@ -648,7 +647,6 @@ if(CMAKE_SYSTEM_NAME MATCHES Linux OR CMAKE_SYSTEM_NAME STREQUAL GNU)
endif()
endif()
set(_KDE4_PLATFORM_DEFINITIONS "${_KDE4_PLATFORM_DEFINITIONS} -D_LARGEFILE64_SOURCE")
check_cxx_source_compiles("
@ -691,7 +689,7 @@ if (CMAKE_COMPILER_IS_GNUCXX)
# 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)
add_definitions(-D_DEFAULT_SOURCE -D_BSD_SOURCE)
endif()
if(CMAKE_SYSTEM_NAME STREQUAL GNU)
@ -798,8 +796,8 @@ if (CMAKE_COMPILER_IS_GNUCXX)
)
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).")
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}")
@ -892,10 +890,8 @@ if(CMAKE_C_COMPILER MATCHES "icc")
# 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)
@ -923,13 +919,13 @@ macro(KDE4_PRINT_RESULTS)
else()
message(STATUS "ERROR: unable to find the KDE 4 core library")
endif()
endif(NOT _kdeBootStrapping)
endif()
if(KDE4_KCFGC_EXECUTABLE)
message(STATUS "Found the KDE4 kconfig_compiler preprocessor: ${KDE4_KCFGC_EXECUTABLE}")
else(KDE4_KCFGC_EXECUTABLE)
else()
message(STATUS "Didn't find the KDE4 kconfig_compiler preprocessor")
endif(KDE4_KCFGC_EXECUTABLE)
endif()
endmacro()
@ -976,12 +972,14 @@ set(KDE4_DEFINITIONS
)
if(NOT _kde4_uninstall_rule_created)
set(_kde4_uninstall_rule_created TRUE)
configure_file("${kde_cmake_module_dir}/kde4_cmake_uninstall.cmake.in" "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" @ONLY)
add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake")
endif(NOT _kde4_uninstall_rule_created)
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)

34
cmake/modules/FindKDevelop.cmake Normal file
View file

@ -0,0 +1,34 @@
#
# Find the KDevelop include dir
#
# KDEVELOP_INCLUDE_DIR
# adjust the directories where the kdevelop headers
#
# KDEVELOP_FOUND - set to TRUE if kdevelop was found
# FALSE otherwise
#
# KDEVELOP_INCLUDE_DIR - include dir of kdevelop, for example /usr/include/kdevelop
# can be set by the user to select different include dirs
#
# Copyright (c) 2007 Andreas Pakulat <apaku@gmx.de>
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if(WIN32)
file(TO_CMAKE_PATH "$ENV{PROGRAMFILES}" _progFiles)
set(_KDEVELOP_INCLUDE_DIR ${KDE4_INCLUDE_DIR} ${_progFiles}/kdevelop/include)
endif(WIN32)
find_path(KDEVELOP_INCLUDE_DIR make/imakebuilder.h
PATHS
${CMAKE_INSTALL_PREFIX}/include
${_KDEVELOP_INCLUDE_DIR}
${KDE4_INCLUDE_DIR}
PATH_SUFFIXES
kdevelop
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(KDevelop DEFAULT_MSG KDEVELOP_INCLUDE_DIR)
mark_as_advanced(KDEVELOP_INCLUDE_DIR)

44
cmake/modules/FindKSane.cmake Normal file
View file

@ -0,0 +1,44 @@
# cmake macro to test if libksane is installed
#
# KSANE_FOUND - system has KSANE libs
# KSANE_INCLUDE_DIR - the KSANE include directory
# KSANE_LIBRARY - The library needed to use KSANE
if (KSANE_INCLUDE_DIR)
# Already in cache, be silent
set(KSANE_FIND_QUIETLY TRUE)
endif (KSANE_INCLUDE_DIR)
FIND_FILE(KSANE_LOCAL_FOUND libksane/version.h.cmake ${CMAKE_SOURCE_DIR}/libs/libksane NO_DEFAULT_PATH)
if (KSANE_LOCAL_FOUND)
set(KSANE_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/libs/libksane)
set(KSANE_DEFINITIONS -I${KSANE_INCLUDE_DIR})
set(KSANE_LIBRARY ksane)
message(STATUS "Found KSane library in local sub-folder: ${KSANE_LIBRARY}")
set(KSANE_FOUND TRUE)
MARK_AS_ADVANCED(KSANE_INCLUDE_DIR KSANE_LIBRARY)
else (KSANE_LOCAL_FOUND)
FIND_PATH(KSANE_INCLUDE_DIR libksane/ksane.h ${KDE4_INCLUDES})
FIND_LIBRARY(KSANE_LIBRARY ksane PATH ${KDE4_LIB_DIR})
if (KSANE_INCLUDE_DIR AND KSANE_LIBRARY)
set(KSANE_FOUND TRUE)
else (KSANE_INCLUDE_DIR AND KSANE_LIBRARY)
set(KSANE_FOUND FALSE)
endif (KSANE_INCLUDE_DIR AND KSANE_LIBRARY)
if (KSANE_FOUND)
if (NOT KSane_FIND_QUIETLY)
message(STATUS "Found libksane: ${KSANE_LIBRARY}")
endif (NOT KSane_FIND_QUIETLY)
else (KSANE_FOUND)
if (KSane_FIND_REQUIRED)
message(FATAL_ERROR "Could not find libksane")
endif (KSane_FIND_REQUIRED)
endif (KSANE_FOUND)
endif (KSANE_LOCAL_FOUND)
MARK_AS_ADVANCED(KSANE_INCLUDE_DIR KSANE_LIBRARY)

38
cmake/modules/FindKTp.cmake Normal file
View file

@ -0,0 +1,38 @@
# Try to find the KTp library
# KTP_FOUND
# KTP_INCLUDE_DIR
# KTP_LIBRARIES
# KTP_MODELS_LIBRARIES
# KTP_WIDGETS_LIBRARIES
# Copyright (c) 2011, Dario Freddi <drf@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 (NOT IS_KTP_INTERNAL_MODULE)
message (FATAL_ERROR "KTp can be used just from internal components at this time")
endif (NOT IS_KTP_INTERNAL_MODULE)
SET (KTP_FIND_REQUIRED ${KTp_FIND_REQUIRED})
if (KTP_INCLUDE_DIRS AND KTP_LIBRARIES)
# Already in cache, be silent
set(KTP_FIND_QUIETLY TRUE)
endif (KTP_INCLUDE_DIRS AND KTP_LIBRARIES)
find_path(KTP_INCLUDE_DIR
NAMES KTp/presence.h
PATHS ${KDE4_INCLUDE_DIR}
)
find_library(KTP_LIBRARIES NAMES ktpcommoninternalsprivate )
find_library(KTP_MODELS_LIBRARIES NAMES ktpmodelsprivate )
find_library(KTP_WIDGETS_LIBRARIES NAMES ktpwidgetsprivate )
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(KTp DEFAULT_MSG
KTP_LIBRARIES
KTP_MODELS_LIBRARIES
KTP_INCLUDE_DIR)
mark_as_advanced(KTP_INCLUDE_DIRS KTP_LIBRARIES)

72
cmake/modules/FindLCMS2.cmake Normal file
View file

@ -0,0 +1,72 @@
# - Find LCMS2
# Find the LCMS2 includes and library
# This module defines
# LCMS2_INCLUDE_DIR, where to find lcms.h
# LCMS2_LIBRARIES, the libraries needed to use LCMS2.
# LCMS2_VERSION, The value of LCMS_VERSION defined in lcms.h
# LCMS2_FOUND, If false, do not try to use LCMS2.
# Copyright (c) 2008, Adrian Page, <adrian@pagenet.plus.com>
# Copyright (c) 2009, Cyrille Berger, <cberger@cberger.net>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
# use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
if(NOT WIN32)
find_package(PkgConfig)
pkg_check_modules(PC_LCMS2 lcms2)
set(LCMS2_DEFINITIONS ${PC_LCMS2_CFLAGS_OTHER})
endif()
find_path(LCMS2_INCLUDE_DIR lcms2.h
PATHS
${PC_LCMS2_INCLUDEDIR}
${PC_LCMS2_INCLUDE_DIRS}
PATH_SUFFIXES lcms2 liblcms2
)
find_library(LCMS2_LIBRARIES NAMES lcms2 liblcms2 lcms-2 liblcms-2
PATHS
${PC_LCMS2_LIBDIR}
${PC_LCMS2_LIBRARY_DIRS}
PATH_SUFFIXES lcms2
)
if(LCMS2_INCLUDE_DIR AND LCMS2_LIBRARIES)
set(LCMS2_FOUND TRUE)
else()
set(LCMS2_FOUND FALSE)
endif()
if(LCMS2_FOUND)
file(READ ${LCMS2_INCLUDE_DIR}/lcms2.h LCMS2_VERSION_CONTENT)
string(REGEX MATCH "#define LCMS_VERSION[ ]*[0-9]*\n" LCMS2_VERSION_MATCH ${LCMS2_VERSION_CONTENT})
if(LCMS2_VERSION_MATCH)
string(REGEX REPLACE "#define LCMS_VERSION[ ]*([0-9]*)\n" "\\1" LCMS2_VERSION ${LCMS2_VERSION_MATCH})
if(NOT LCMS2_FIND_QUIETLY)
string(SUBSTRING ${LCMS2_VERSION} 0 1 LCMS2_MAJOR_VERSION)
string(SUBSTRING ${LCMS2_VERSION} 1 2 LCMS2_MINOR_VERSION)
message(STATUS "Found lcms version ${LCMS2_MAJOR_VERSION}.${LCMS2_MINOR_VERSION}, ${LCMS2_LIBRARIES}")
endif()
else()
if(NOT LCMS2_FIND_QUIETLY)
message(STATUS "Found lcms2 but failed to find version ${LCMS2_LIBRARIES}")
endif()
set(LCMS2_VERSION NOTFOUND)
endif()
else()
if(NOT LCMS2_FIND_QUIETLY)
if(LCMS2_FIND_REQUIRED)
message(FATAL_ERROR "Required package lcms2 NOT found")
else()
message(STATUS "lcms2 NOT found")
endif()
endif()
endif()
mark_as_advanced(LCMS2_INCLUDE_DIR LCMS2_LIBRARIES LCMS2_VERSION)

58
cmake/modules/FindLIBPARTED.cmake Normal file
View file

@ -0,0 +1,58 @@
# Copyright (C) 2008,2010,2011 by Volker Lanz <vl@fidra.de>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
INCLUDE(CheckCSourceCompiles)
include(CheckFunctionExists)
if (LIBPARTED_INCLUDE_DIR AND LIBPARTED_LIBRARY)
# Already in cache, be silent
set(LIBPARTED_FIND_QUIETLY TRUE)
endif (LIBPARTED_INCLUDE_DIR AND LIBPARTED_LIBRARY)
FIND_PATH(LIBPARTED_INCLUDE_DIR parted.h PATH_SUFFIXES parted )
FIND_LIBRARY(LIBPARTED_LIBRARY NAMES parted)
FIND_LIBRARY(LIBPARTED_FS_RESIZE_LIBRARY NAMES parted-fs-resize)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBPARTED DEFAULT_MSG LIBPARTED_LIBRARY LIBPARTED_INCLUDE_DIR)
if (LIBPARTED_FS_RESIZE_LIBRARY)
set(LIBPARTED_LIBS ${LIBPARTED_FS_RESIZE_LIBRARY} ${LIBPARTED_LIBRARY})
else (LIBPARTED_FS_RESIZE_LIBRARY)
set(LIBPARTED_LIBS ${LIBPARTED_LIBRARY})
endif (LIBPARTED_FS_RESIZE_LIBRARY)
# KDE adds -ansi to the C make flags, parted headers use GNU extensions, so
# undo that
unset(CMAKE_C_FLAGS)
set(CMAKE_REQUIRED_INCLUDES ${LIBPARTED_INCLUDE_DIR})
set(CMAKE_REQUIRED_LIBRARIES ${LIBPARTED_LIBS})
CHECK_FUNCTION_EXISTS("ped_file_system_clobber" LIBPARTED_FILESYSTEM_SUPPORT) # parted < 3.0
CHECK_FUNCTION_EXISTS("ped_file_system_resize" LIBPARTED_FS_RESIZE_LIBRARY_SUPPORT) # parted != 3.0
MARK_AS_ADVANCED(LIBPARTED_LIBRARY LIBPARTED_INCLUDE_DIR LIBPARTED_FILESYSTEM_SUPPORT LIBPARTED_FS_RESIZE_LIBRARY LIBPARTED_FS_RESIZE_LIBRARY_SUPPORT)

91
cmake/modules/FindLibGcrypt.cmake Normal file
View file

@ -0,0 +1,91 @@
# - Try to find the libgcrypt library
# Once done this will define
#
# LIBGCRYPT_FOUND - system has libgcrypt
# LIBGCRYPT_INCLUDE_DIR - the libgcrypt include directory
# LIBGCRYPT_LIBRARIES - Link these to use libgcrypt
# Copyright (c) 2010 Joris Guisson <joris.guisson@gmail.com>
# Copyright (c) 2007 Charles Connell <charles@connells.org> (This was based upon FindKopete.cmake)
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if(LIBGCRYPT_INCLUDE_DIR AND LIBGCRYPT_LIBRARIES)
# read from cache
set(LIBGCRYPT_FOUND TRUE)
else(LIBGCRYPT_INCLUDE_DIR AND LIBGCRYPT_LIBRARIES)
FIND_PATH(LIBGCRYPT_INCLUDE_DIR
NAMES
gcrypt.h
PATHS
${KDE4_INCLUDE_DIR}
${INCLUDE_INSTALL_DIR}
PATH_SUFFIXES
libgcrypt
)
FIND_LIBRARY(LIBGCRYPT_LIBRARIES
NAMES
gcrypt
PATHS
${KDE4_LIB_DIR}
${LIB_INSTALL_DIR}
)
if(LIBGCRYPT_INCLUDE_DIR AND LIBGCRYPT_LIBRARIES)
set(LIBGCRYPT_FOUND TRUE)
endif(LIBGCRYPT_INCLUDE_DIR AND LIBGCRYPT_LIBRARIES)
if(MSVC)
FIND_LIBRARY(LIBGCRYPT_LIBRARIES_DEBUG
NAMES
gcryptd
PATHS
${KDE4_LIB_DIR}
${LIB_INSTALL_DIR}
)
if(NOT LIBGCRYPT_LIBRARIES_DEBUG)
set(LIBGCRYPT_FOUND FALSE)
endif(NOT LIBGCRYPT_LIBRARIES_DEBUG)
if(MSVC_IDE)
if( NOT LIBGCRYPT_LIBRARIES_DEBUG OR NOT LIBGCRYPT_LIBRARIES)
message(FATAL_ERROR "\nCould NOT find the debug AND release version of the libgcrypt library.\nYou need to have both to use MSVC projects.\nPlease build and install both libgcrypt libraries first.\n")
endif( NOT LIBGCRYPT_LIBRARIES_DEBUG OR NOT LIBGCRYPT_LIBRARIES)
else(MSVC_IDE)
string(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_TOLOWER)
if(CMAKE_BUILD_TYPE_TOLOWER MATCHES debug)
set(LIBGCRYPT_LIBRARIES ${LIBGCRYPT_LIBRARIES_DEBUG})
else(CMAKE_BUILD_TYPE_TOLOWER MATCHES debug)
set(LIBGCRYPT_LIBRARIES ${LIBGCRYPT_LIBRARIES})
endif(CMAKE_BUILD_TYPE_TOLOWER MATCHES debug)
endif(MSVC_IDE)
endif(MSVC)
if(LIBGCRYPT_FOUND)
if(NOT LIBGCRYPT_FIND_QUIETLY)
message(STATUS "Found libgcrypt: ${LIBGCRYPT_LIBRARIES} ")
endif(NOT LIBGCRYPT_FIND_QUIETLY)
else(LIBGCRYPT_FOUND)
if(LIBGCRYPT_FIND_REQUIRED)
if(NOT LIBGCRYPT_INCLUDE_DIR)
message(FATAL_ERROR "Could not find libgcrypt includes.")
endif(NOT LIBGCRYPT_INCLUDE_DIR)
if(NOT LIBGCRYPT_LIBRARIES)
message(FATAL_ERROR "Could not find libgcrypt library.")
endif(NOT LIBGCRYPT_LIBRARIES)
else(LIBGCRYPT_FIND_REQUIRED)
if(NOT LIBGCRYPT_INCLUDE_DIR)
message(STATUS "Could not find libgcrypt includes.")
endif(NOT LIBGCRYPT_INCLUDE_DIR)
if(NOT LIBGCRYPT_LIBRARIES)
message(STATUS "Could not find libgcrypt library.")
endif(NOT LIBGCRYPT_LIBRARIES)
endif(LIBGCRYPT_FIND_REQUIRED)
endif(LIBGCRYPT_FOUND)
endif(LIBGCRYPT_INCLUDE_DIR AND LIBGCRYPT_LIBRARIES)

163
cmake/modules/FindLibKasten.cmake Normal file
View file

@ -0,0 +1,163 @@
# - Find Kasten libraries, v0, v1 or v2
#
# This module defines
# LIBKASTEN_FOUND - whether the libkasten libraries were found
# LIBKASTEN_VERSION - version of the libkasten libraries found
# LIBKASTEN_LIBRARIES - the libkasten libraries
# LIBKASTEN_INCLUDE_DIRS - the include paths of the libkasten libraries
if( LIBKASTEN_INCLUDE_DIR AND LIBKASTEN_LIBRARIES AND LIBKASTEN_VERSION )
# Already in cache, be silent
set( Kasten_FIND_QUIETLY TRUE )
endif( LIBKASTEN_INCLUDE_DIR AND LIBKASTEN_LIBRARIES AND LIBKASTEN_VERSION )
if( LIBKASTEN_FIND_VERSION EQUAL 1 OR LIBKASTEN_FIND_VERSION EQUAL 2)
set( KV ${LIBKASTEN_FIND_VERSION} )
find_library( KASTEN1OR2_CORE_LIB
NAMES
kasten${KV}core
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( KASTEN1OR2_GUI_LIB
NAMES
kasten${KV}gui
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( KASTEN1OR2_CONTROLLERS_LIB
NAMES
kasten${KV}controllers
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_path( KASTEN1OR2_NORMAL_INCLUDE_DIR
NAMES
abstractmodel.h
PATH_SUFFIXES
kasten${KV}
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
find_path( KASTEN1OR2_CAMELCASE_INCLUDE_DIR
NAMES
Kasten${KV}/AbstractModel
PATH_SUFFIXES
KDE
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
if( KASTEN1OR2_NORMAL_INCLUDE_DIR AND KASTEN1OR2_CAMELCASE_INCLUDE_DIR AND
KASTEN1OR2_CORE_LIB AND KASTEN1OR2_GUI_LIB AND KASTEN1OR2_CONTROLLERS_LIB )
set( LIBKASTEN_FOUND TRUE )
endif( KASTEN1OR2_NORMAL_INCLUDE_DIR AND KASTEN1OR2_CAMELCASE_INCLUDE_DIR AND
KASTEN1OR2_CORE_LIB AND KASTEN1OR2_GUI_LIB AND KASTEN1OR2_CONTROLLERS_LIB )
if( LIBKASTEN_FOUND )
set( LIBKASTEN_VERSION ${KV} )
set( LIBKASTEN_INCLUDE_DIRS
${KASTEN1OR2_NORMAL_INCLUDE_DIR}
${KASTEN1OR2_CAMELCASE_INCLUDE_DIR}
)
set( LIBKASTEN_LIBRARIES
${KASTEN1OR2_CORE_LIB}
${KASTEN1OR2_GUI_LIB}
${KASTEN1OR2_CONTROLLERS_LIB}
)
endif( LIBKASTEN_FOUND )
endif( LIBKASTEN_FIND_VERSION EQUAL 1 OR LIBKASTEN_FIND_VERSION EQUAL 2 )
if( LIBKASTEN_FIND_VERSION EQUAL 0 )
find_library( LIBKASTENCORE0_LIBRARY
NAMES
kastencore
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBKASTENGUI0_LIBRARY
NAMES
kastengui
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBKASTENCONTROLLERS0_LIBRARY
NAMES
kastencontrollers
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_path( LIBKASTEN0_NORMAL_INCLUDE_DIR
NAMES
abstractmodel.h
PATH_SUFFIXES
kasten
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
find_path( LIBKASTEN0_CAMELCASE_INCLUDE_DIR
NAMES
Kasten/AbstractModel
PATH_SUFFIXES
KDE
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
if( LIBKASTEN0_NORMAL_INCLUDE_DIR AND LIBKASTEN0_CAMELCASE_INCLUDE_DIR AND
LIBKASTENCORE0_LIBRARY AND LIBKASTENGUI0_LIBRARY AND LIBKASTENCONTROLLERS0_LIBRARY )
set( LIBKASTEN_FOUND TRUE )
endif( LIBKASTEN0_NORMAL_INCLUDE_DIR AND LIBKASTEN0_CAMELCASE_INCLUDE_DIR AND
LIBKASTENCORE0_LIBRARY AND LIBKASTENGUI0_LIBRARY AND LIBKASTENCONTROLLERS0_LIBRARY )
if( LIBKASTEN_FOUND )
set( LIBKASTEN_VERSION 0 )
set( LIBKASTEN_INCLUDE_DIRS
${LIBKASTEN0_NORMAL_INCLUDE_DIR}
${LIBKASTEN0_CAMELCASE_INCLUDE_DIR}
)
set( LIBKASTEN_LIBRARIES
${LIBKASTENCORE0_LIBRARY}
${LIBKASTENGUI0_LIBRARY}
${LIBKASTENCONTROLLERS0_LIBRARY}
)
endif( LIBKASTEN_FOUND )
endif( LIBKASTEN_FIND_VERSION EQUAL 0 )
if( LIBKASTEN_FOUND )
if( NOT Kasten_FIND_QUIETLY )
message( STATUS "Found Kasten libraries v${LIBKASTEN_VERSION}: ${LIBKASTEN_LIBRARIES}" )
endif( NOT Kasten_FIND_QUIETLY )
else( LIBKASTEN_FOUND )
if( LibKasten_FIND_REQUIRED )
message( FATAL_ERROR "Could not find Kasten libraries." )
endif( LibKasten_FIND_REQUIRED )
endif( LIBKASTEN_FOUND )
mark_as_advanced(
LIBKASTEN_INCLUDE_DIRS
LIBKASTEN_LIBRARIES
LIBKASTEN_VERSION
)

62
cmake/modules/FindLibMms.cmake Normal file
View file

@ -0,0 +1,62 @@
# - Try to find the libmms library
# Once done this will define
#
# LIBMMS_FOUND - system has libmms
# LIBMMS_INCLUDE_DIR - the libmms include directory
# LIBMMS_LIBRARIES - Link these to use libmms
# Copyright (c) 2007 Joris Guisson <joris.guisson@gmail.com>
# Copyright (c) 2007 Charles Connell <charles@connells.org> (This was based upon FindKopete.cmake)
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if(LIBMMS_INCLUDE_DIR AND LIBMMS_LIBRARIES)
# read from cache
set(LIBMMS_FOUND TRUE)
else(LIBMMS_INCLUDE_DIR AND LIBMMS_LIBRARIES)
FIND_PATH(LIBMMS_INCLUDE_DIR
NAMES
mmsx.h
PATHS
${INCLUDE_INSTALL_DIR}
PATH_SUFFIXES
libmms
)
FIND_LIBRARY(LIBMMS_LIBRARIES
NAMES
mms
PATHS
${LIB_INSTALL_DIR}
)
if(LIBMMS_INCLUDE_DIR AND LIBMMS_LIBRARIES)
set(LIBMMS_FOUND TRUE)
endif(LIBMMS_INCLUDE_DIR AND LIBMMS_LIBRARIES)
if(LIBMMS_FOUND)
if(NOT LIBKTORRENT_FIND_QUIETLY)
message(STATUS "Found libmms: ${LIBMMS_LIBRARIES} ")
endif(NOT LIBKTORRENT_FIND_QUIETLY)
else(LIBMMS_FOUND)
if(LIBKTORRENT_FIND_REQUIRED)
if(NOT LIBMMS_INCLUDE_DIR)
message(FATAL_ERROR "Could not find libmms includes.")
endif(NOT LIBMMS_INCLUDE_DIR)
if(NOT LIBMMS_LIBRARIES)
message(FATAL_ERROR "Could not find libmms library.")
endif(NOT LIBMMS_LIBRARIES)
else(LIBKTORRENT_FIND_REQUIRED)
if(NOT LIBMMS_INCLUDE_DIR)
message(STATUS "Could not find libmms includes.")
endif(NOT LIBMMS_INCLUDE_DIR)
if(NOT LIBMMS_LIBRARIES)
message(STATUS "Could not find libmms library.")
endif(NOT LIBMMS_LIBRARIES)
endif(LIBKTORRENT_FIND_REQUIRED)
endif(LIBMMS_FOUND)
endif(LIBMMS_INCLUDE_DIR AND LIBMMS_LIBRARIES)

38
cmake/modules/FindLibNXCL.cmake Normal file
View file

@ -0,0 +1,38 @@
# cmake macro to test LIB NXCL
# Copyright (c) 2008, David Gross <gdavid.devel@gmail.com>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
include(CheckStructMember)
IF (LIBNXCL_INCLUDE_DIR AND LIBNXCL_LIBRARIES)
# Already in cache, be silent
SET(LIBNBXCL_FIND_QUIETLY TRUE)
ENDIF (LIBNXCL_INCLUDE_DIR AND LIBNXCL_LIBRARIES)
FIND_PATH(LIBNXCL_INCLUDE_DIR nxcl/nxclientlib.h)
FIND_LIBRARY(LIBNXCL_LIBRARIES NAMES nxcl libnxcl)
IF (LIBNXCL_INCLUDE_DIR AND LIBNXCL_LIBRARIES)
SET(CMAKE_REQUIRED_LIBRARIES "${LIBNXCL_LIBRARIES}" "${CMAKE_REQUIRED_LIBRARIES}")
SET(CMAKE_REQUIRED_INCLUDES "${LIBNXCL_INCLUDE_DIR}" "${CMAKE_REQUIRED_INCLUDES}")
CHECK_STRUCT_MEMBER(nxcl::NXClientLib "getNXSSHProcess()" nxcl/nxclientlib.h LIBNXCL_NXSSHPROCESS_FOUND)
CHECK_STRUCT_MEMBER(nxcl::NXClientLib "getXID()" nxcl/nxclientlib.h LIBNXCL_XID_FOUND)
ENDIF (LIBNXCL_INCLUDE_DIR AND LIBNXCL_LIBRARIES)
IF (LIBNXCL_NXSSHPROCESS_FOUND AND LIBNXCL_XID_FOUND)
SET(LIBNXCL_FOUND TRUE)
IF (NOT LIBNXCL_FIND_QUIETLY)
MESSAGE(STATUS "Found LibNXCL: ${LIBNXCL_LIBRARIES}")
ENDIF (NOT LIBNXCL_FIND_QUIETLY)
ELSE (LIBNXCL_NXSSHPROCESS_FOUND AND LIBNXCL_XID_FOUND)
SET(LIBNXCL_FOUND FALSE)
IF (LIBNXCL_FIND_REQUIRED)
MESSAGE(FATAL_ERROR "Could NOT find acceptable version of LibNXCL (version 1.0).")
ENDIF (LIBNXCL_FIND_REQUIRED)
ENDIF (LIBNXCL_NXSSHPROCESS_FOUND AND LIBNXCL_XID_FOUND)
MARK_AS_ADVANCED(LIBNXCL_INCLUDE_DIR LIBNXCL_LIBRARIES)

146
cmake/modules/FindLibOkteta.cmake Normal file
View file

@ -0,0 +1,146 @@
# - Find Okteta libraries, v0 or v1
#
# This module defines
# LIBOKTETA_FOUND - whether the libokteta libraries were found
# LIBOKTETA_VERSION - version of the libokteta libraries found
# LIBOKTETA_LIBRARIES - the libokteta libraries
# LIBOKTETA_INCLUDE_DIRS - the include paths of the libokteta libraries
if( LIBOKTETA_INCLUDE_DIRS AND LIBOKTETA_LIBRARIES AND LIBOKTETA_VERSION )
# Already in cache, be silent
set( Okteta_FIND_QUIETLY TRUE )
endif( LIBOKTETA_INCLUDE_DIRS AND LIBOKTETA_LIBRARIES AND LIBOKTETA_VERSION )
if( LIBOKTETA_FIND_VERSION EQUAL 1 )
find_library( LIBOKTETACORE1_LIBRARY
NAMES
okteta1core
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETAGUI1_LIBRARY
NAMES
okteta1gui
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_path( LIBOKTETA1_NORMAL_INCLUDE_DIR
NAMES
abstractbytearraymodel.h
PATH_SUFFIXES
okteta1
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
find_path( LIBOKTETA1_CAMELCASE_INCLUDE_DIR
NAMES
Okteta1/AbstractByteArrayModel
PATH_SUFFIXES
KDE
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
if( LIBOKTETA1_NORMAL_INCLUDE_DIR AND LIBOKTETA1_CAMELCASE_INCLUDE_DIR AND
LIBOKTETACORE1_LIBRARY AND LIBOKTETAGUI1_LIBRARY )
set( LIBOKTETA_FOUND TRUE )
endif( LIBOKTETA1_NORMAL_INCLUDE_DIR AND LIBOKTETA1_CAMELCASE_INCLUDE_DIR AND
LIBOKTETACORE1_LIBRARY AND LIBOKTETAGUI1_LIBRARY )
if( LIBOKTETA_FOUND )
set( LIBOKTETA_VERSION 1 )
set( LIBOKTETA_INCLUDE_DIRS
${LIBOKTETA1_NORMAL_INCLUDE_DIR}
${LIBOKTETA1_CAMELCASE_INCLUDE_DIR}
)
set( LIBOKTETA_LIBRARIES
${LIBOKTETACORE1_LIBRARY}
${LIBOKTETAGUI1_LIBRARY}
)
endif( LIBOKTETA_FOUND )
endif( LIBOKTETA_FIND_VERSION EQUAL 1 )
if( LIBOKTETA_FIND_VERSION EQUAL 0 )
find_library( LIBOKTETACORE0_LIBRARY
NAMES
oktetacore
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETAGUI0_LIBRARY
NAMES
oktetagui
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_path( LIBOKTETA0_NORMAL_INCLUDE_DIR
NAMES
abstractbytearraymodel.h
PATH_SUFFIXES
okteta
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
find_path( LIBOKTETA0_CAMELCASE_INCLUDE_DIR
NAMES
Okteta/AbstractByteArrayModel
PATH_SUFFIXES
KDE
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
if( LIBOKTETA0_NORMAL_INCLUDE_DIR AND LIBOKTETA0_CAMELCASE_INCLUDE_DIR AND
LIBOKTETACORE0_LIBRARY AND LIBOKTETAGUI0_LIBRARY )
set( LIBOKTETA_FOUND TRUE )
endif( LIBOKTETA0_NORMAL_INCLUDE_DIR AND LIBOKTETA0_CAMELCASE_INCLUDE_DIR AND
LIBOKTETACORE0_LIBRARY AND LIBOKTETAGUI0_LIBRARY )
if( LIBOKTETA_FOUND )
set( LIBOKTETA_VERSION 0 )
set( LIBOKTETA_INCLUDE_DIRS
${LIBOKTETA0_NORMAL_INCLUDE_DIR}
${LIBOKTETA0_CAMELCASE_INCLUDE_DIR}
)
set( LIBOKTETA_LIBRARIES
${LIBOKTETACORE0_LIBRARY}
${LIBOKTETAGUI0_LIBRARY}
)
endif( LIBOKTETA_FOUND )
endif( LIBOKTETA_FIND_VERSION EQUAL 0 )
if( LIBOKTETA_FOUND )
if( NOT Okteta_FIND_QUIETLY )
message( STATUS "Found Okteta libraries v${LIBOKTETA_VERSION}: ${LIBOKTETA_LIBRARIES}" )
endif( NOT Okteta_FIND_QUIETLY )
else( LIBOKTETA_FOUND )
if( LibOkteta_FIND_REQUIRED )
message( FATAL_ERROR "Could not find Okteta libraries" )
endif( LibOkteta_FIND_REQUIRED )
endif( LIBOKTETA_FOUND )
mark_as_advanced(
LIBOKTETA_INCLUDE_DIRS
LIBOKTETA_LIBRARIES
LIBOKTETA_VERSION
)

207
cmake/modules/FindLibOktetaKasten.cmake Normal file
View file

@ -0,0 +1,207 @@
# - Find Okteta Kasten libraries, v0, v1 or v2
#
# This module defines
# LIBOKTETAKASTEN_FOUND - whether the Okteta Kasten libraries were found
# LIBOKTETAKASTEN_VERSION - version of the Okteta Kasten libraries found
# LIBOKTETAKASTEN_LIBRARIES - the Okteta Kasten libraries
# LIBOKTETAKASTEN_INCLUDE_DIRS - the include paths of the Okteta Kasten libraries
if( LIBOKTETAKASTEN_INCLUDE_DIRS AND LIBOKTETAKASTEN_LIBRARIES AND LIBOKTETAKASTEN_VERSION AND
LIBOKTETAKASTEN_NEEDS_KASTEN_VERSION AND LIBOKTETAKASTEN_NEEDS_OKTETA_VERSION )
# Already in cache, be silent
set( OktetaKasten_FIND_QUIETLY TRUE )
endif( LIBOKTETAKASTEN_INCLUDE_DIRS AND LIBOKTETAKASTEN_LIBRARIES AND LIBOKTETAKASTEN_VERSION AND
LIBOKTETAKASTEN_NEEDS_KASTEN_VERSION AND LIBOKTETAKASTEN_NEEDS_OKTETA_VERSION )
# First search version 2
find_library( LIBOKTETA1KASTEN2CORE_LIBRARY
NAMES
kasten2okteta1core
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETA1KASTEN2GUI_LIBRARY
NAMES
kasten2okteta1gui
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETA1KASTEN2CONTROLLERS_LIBRARY
NAMES
kasten2okteta1controllers
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_path( LIBOKTETA1KASTEN2_INCLUDE_DIR
NAMES
bytearraydocument.h
PATH_SUFFIXES
kasten2/okteta1
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
if( LIBOKTETA1KASTEN2_INCLUDE_DIR AND
LIBOKTETA1KASTEN2CORE_LIBRARY AND LIBOKTETA1KASTEN2GUI_LIBRARY AND LIBOKTETA1KASTEN2CONTROLLERS_LIBRARY )
set( LIBOKTETAKASTEN_FOUND TRUE )
endif( LIBOKTETA1KASTEN2_INCLUDE_DIR AND
LIBOKTETA1KASTEN2CORE_LIBRARY AND LIBOKTETA1KASTEN2GUI_LIBRARY AND LIBOKTETA1KASTEN2CONTROLLERS_LIBRARY )
if( LIBOKTETAKASTEN_FOUND )
set( LIBOKTETAKASTEN_VERSION 2 )
set( LIBOKTETAKASTEN_NEEDS_KASTEN_VERSION 2 )
set( LIBOKTETAKASTEN_NEEDS_OKTETA_VERSION 1 )
set( LIBOKTETAKASTEN_LIBRARIES
${LIBOKTETA1KASTEN2CORE_LIBRARY}
${LIBOKTETA1KASTEN2GUI_LIBRARY}
${LIBOKTETA1KASTEN2CONTROLLERS_LIBRARY}
)
set( LIBOKTETAKASTEN_INCLUDE_DIRS
${LIBOKTETA1KASTEN2_INCLUDE_DIR}
)
endif( LIBOKTETAKASTEN_FOUND )
# Then search version 1
if( NOT LIBOKTETAKASTEN_FOUND )
find_library( LIBOKTETA1KASTEN1CORE_LIBRARY
NAMES
kasten1okteta1core
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETA1KASTEN1GUI_LIBRARY
NAMES
kasten1okteta1gui
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETA1KASTEN1CONTROLLERS_LIBRARY
NAMES
kasten1okteta1controllers
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_path( LIBOKTETA1KASTEN1_INCLUDE_DIR
NAMES
bytearraydocument.h
PATH_SUFFIXES
kasten1/okteta1
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
if( LIBOKTETA1KASTEN1_INCLUDE_DIR AND
LIBOKTETA1KASTEN1CORE_LIBRARY AND LIBOKTETA1KASTEN1GUI_LIBRARY AND LIBOKTETA1KASTEN1CONTROLLERS_LIBRARY )
set( LIBOKTETAKASTEN_FOUND TRUE )
endif( LIBOKTETA1KASTEN1_INCLUDE_DIR AND
LIBOKTETA1KASTEN1CORE_LIBRARY AND LIBOKTETA1KASTEN1GUI_LIBRARY AND LIBOKTETA1KASTEN1CONTROLLERS_LIBRARY )
if( LIBOKTETAKASTEN_FOUND )
set( LIBOKTETAKASTEN_VERSION 1 )
set( LIBOKTETAKASTEN_NEEDS_KASTEN_VERSION 1 )
set( LIBOKTETAKASTEN_NEEDS_OKTETA_VERSION 1 )
set( LIBOKTETAKASTEN_LIBRARIES
${LIBOKTETA1KASTEN1CORE_LIBRARY}
${LIBOKTETA1KASTEN1GUI_LIBRARY}
${LIBOKTETA1KASTEN1CONTROLLERS_LIBRARY}
)
set( LIBOKTETAKASTEN_INCLUDE_DIRS
${LIBOKTETA1KASTEN1_INCLUDE_DIR}
)
endif( LIBOKTETAKASTEN_FOUND )
endif( NOT LIBOKTETAKASTEN_FOUND )
# Then search version 0
if( NOT LIBOKTETAKASTEN_FOUND )
find_library( LIBOKTETAKASTENCORE0_LIBRARY
NAMES
oktetakastencore
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETAKASTENGUI0_LIBRARY
NAMES
oktetakastengui
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_library( LIBOKTETAKASTENCONTROLLERS0_LIBRARY
NAMES
oktetakastencontrollers
HINTS
${LIB_INSTALL_DIR}
${KDE4_LIB_DIR}
)
find_path( LIBOKTETAKASTEN0_INCLUDE_DIR
NAMES
bytearraydocument.h
PATH_SUFFIXES
kasten
HINTS
${INCLUDE_INSTALL_DIR}
${KDE4_INCLUDE_DIR}
)
if( LIBOKTETAKASTEN0_INCLUDE_DIR AND
LIBOKTETAKASTENCORE0_LIBRARY AND LIBOKTETAKASTENGUI0_LIBRARY AND LIBOKTETAKASTENCONTROLLERS0_LIBRARY )
set( LIBOKTETAKASTEN_FOUND TRUE )
endif( LIBOKTETAKASTEN0_INCLUDE_DIR AND
LIBOKTETAKASTENCORE0_LIBRARY AND LIBOKTETAKASTENGUI0_LIBRARY AND LIBOKTETAKASTENCONTROLLERS0_LIBRARY )
if( LIBOKTETAKASTEN_FOUND )
set( LIBOKTETAKASTEN_VERSION 0 )
set( LIBOKTETAKASTEN_NEEDS_KASTEN_VERSION 0 )
set( LIBOKTETAKASTEN_NEEDS_OKTETA_VERSION 0 )
set( LIBOKTETAKASTEN_INCLUDE_DIRS
${LIBOKTETAKASTEN0_INCLUDE_DIR}
)
set( LIBOKTETAKASTEN_LIBRARIES
${LIBOKTETAKASTENCORE0_LIBRARY}
${LIBOKTETAKASTENGUI0_LIBRARY}
${LIBOKTETAKASTENCONTROLLERS0_LIBRARY}
)
endif( LIBOKTETAKASTEN_FOUND )
endif( NOT LIBOKTETAKASTEN_FOUND )
if( LIBOKTETAKASTEN_FOUND )
if( NOT OktetaKasten_FIND_QUIETLY )
message( STATUS "Found Okteta Kasten libraries v${LIBOKTETAKASTEN_VERSION}: ${LIBOKTETAKASTEN_LIBRARIES}" )
endif( NOT OktetaKasten_FIND_QUIETLY )
else( LIBOKTETAKASTEN_FOUND )
if( LibKasten_FIND_REQUIRED )
message( FATAL_ERROR "Could not find Okteta Kasten libraries" )
endif( LibKasten_FIND_REQUIRED )
endif( LIBOKTETAKASTEN_FOUND )
mark_as_advanced(
LIBOKTETAKASTEN_INCLUDE_DIRS
LIBOKTETAKASTEN_LIBRARIES
LIBOKTETAKASTEN_VERSION
LIBOKTETAKASTEN_NEEDS_KASTEN_VERSION
LIBOKTETAKASTEN_NEEDS_OKTETA_VERSION
)

67
cmake/modules/FindLibSpectre.cmake Normal file
View file

@ -0,0 +1,67 @@
# - Try to find the libspectre PS library
# Once done this will define
#
# LIBSPECTRE_FOUND - system has libspectre
# LIBSPECTRE_INCLUDE_DIR - the libspectre include directory
# LIBSPECTRE_LIBRARY - Link this to use libspectre
#
# Copyright (c) 2006-2007, Pino Toscano, <pino@kde.org>
# Copyright (c) 2008, Albert Astals Cid, <aacid@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(LIBSPECTRE_INCLUDE_DIR AND LIBSPECTRE_LIBRARY)
# in cache already
set(LIBSPECTRE_INTERNAL_FOUND TRUE)
else(LIBSPECTRE_INCLUDE_DIR AND LIBSPECTRE_LIBRARY)
if(NOT WIN32)
# use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
INCLUDE(UsePkgConfig)
PKGCONFIG(libspectre _SpectreIncDir _SpectreLinkDir _SpectreLinkFlags _SpectreCflags)
if(_SpectreLinkFlags)
# find again pkg-config, to query it about libspectre version
FIND_PROGRAM(PKGCONFIG_EXECUTABLE NAMES pkg-config PATHS /usr/bin/ /usr/local/bin )
# query pkg-config asking for a libspectre >= LIBSPECTRE_MINIMUM_VERSION
EXEC_PROGRAM(${PKGCONFIG_EXECUTABLE} ARGS --atleast-version=${LIBSPECTRE_MINIMUM_VERSION} libspectre RETURN_VALUE _return_VALUE OUTPUT_VARIABLE _pkgconfigDevNull )
if(_return_VALUE STREQUAL "0")
set(LIBSPECTRE_INTERNAL_FOUND TRUE)
endif(_return_VALUE STREQUAL "0")
endif(_SpectreLinkFlags)
else(NOT WIN32)
# do not use pkg-config on windows
find_library(_SpectreLinkFlags NAMES libspectre spectre PATHS ${CMAKE_LIBRARY_PATH})
find_path(LIBSPECTRE_INCLUDE_DIR spectre.h PATH_SUFFIXES libspectre )
set(LIBSPECTRE_INTERNAL_FOUND TRUE)
endif(NOT WIN32)
if (LIBSPECTRE_INTERNAL_FOUND)
set(LIBSPECTRE_LIBRARY ${_SpectreLinkFlags})
# the cflags for libspectre can contain more than one include path
separate_arguments(_SpectreCflags)
foreach(_includedir ${_SpectreCflags})
string(REGEX REPLACE "-I(.+)" "\\1" _includedir "${_includedir}")
set(LIBSPECTRE_INCLUDE_DIR ${LIBSPECTRE_INCLUDE_DIR} ${_includedir})
endforeach(_includedir)
endif (LIBSPECTRE_INTERNAL_FOUND)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(LibSpectre DEFAULT_MSG LIBSPECTRE_LIBRARY LIBSPECTRE_INTERNAL_FOUND)
# ensure that they are cached
set(LIBSPECTRE_INCLUDE_DIR ${LIBSPECTRE_INCLUDE_DIR} CACHE INTERNAL "The libspectre include path")
set(LIBSPECTRE_LIBRARY ${LIBSPECTRE_LIBRARY} CACHE INTERNAL "The libspectre library")
endif(LIBSPECTRE_INCLUDE_DIR AND LIBSPECTRE_LIBRARY)

41
cmake/modules/FindLibVNCServer.cmake Normal file
View file

@ -0,0 +1,41 @@
# cmake macro to test LIBVNCSERVER LIB
# Copyright (c) 2006, Alessandro Praduroux <pradu@pradu.it>
# Copyright (c) 2007, Urs Wolfer <uwolfer @ kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
INCLUDE(CheckPointerMember)
IF (LIBVNCSERVER_INCLUDE_DIR AND LIBVNCSERVER_LIBRARIES)
# Already in cache, be silent
SET(LIBVNCSERVER_FIND_QUIETLY TRUE)
ENDIF (LIBVNCSERVER_INCLUDE_DIR AND LIBVNCSERVER_LIBRARIES)
FIND_PATH(LIBVNCSERVER_INCLUDE_DIR rfb/rfb.h)
FIND_LIBRARY(LIBVNCSERVER_LIBRARIES NAMES vncserver libvncserver)
# libvncserver and libvncclient are in the same package, so it does
# not make sense to add a new cmake script for finding libvncclient.
# instead just find the libvncclient also in this file.
FIND_PATH(LIBVNCCLIENT_INCLUDE_DIR rfb/rfbclient.h)
FIND_LIBRARY(LIBVNCCLIENT_LIBRARIES NAMES vncclient libvncclient)
IF (LIBVNCSERVER_INCLUDE_DIR AND LIBVNCSERVER_LIBRARIES)
SET(CMAKE_REQUIRED_INCLUDES "${LIBVNCSERVER_INCLUDE_DIR}" "${CMAKE_REQUIRED_INCLUDES}")
CHECK_POINTER_MEMBER(rfbClient* GotXCutText rfb/rfbclient.h LIBVNCSERVER_FOUND)
ENDIF (LIBVNCSERVER_INCLUDE_DIR AND LIBVNCSERVER_LIBRARIES)
IF (LIBVNCSERVER_FOUND)
IF (NOT LIBVNCSERVER_FIND_QUIETLY)
MESSAGE(STATUS "Found LibVNCServer: ${LIBVNCSERVER_LIBRARIES}")
ENDIF (NOT LIBVNCSERVER_FIND_QUIETLY)
ELSE (LIBVNCSERVER_FOUND)
IF (LIBVNCSERVER_FIND_REQUIRED)
MESSAGE(FATAL_ERROR "Could NOT find acceptable version of LibVNCServer (version 0.9 or later required).")
ENDIF (LIBVNCSERVER_FIND_REQUIRED)
ENDIF (LIBVNCSERVER_FOUND)
MARK_AS_ADVANCED(LIBVNCSERVER_INCLUDE_DIR LIBVNCSERVER_LIBRARIES)

23
cmake/modules/FindMPFR.cmake Normal file
View file

@ -0,0 +1,23 @@
# Try to find the MPFR librairies
# MPFR_FOUND - system has MPFR lib
# MPFR_INCLUDE_DIR - the MPFR include directory
# MPFR_LIBRARIES - Libraries needed to use MPFR
# Copyright (c) 2012, Evan Teran <evan.teran@gmail.com>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if (MPFR_INCLUDE_DIR AND MPFR_LIBRARIES)
# Already in cache, be silent
set(MPFR_FIND_QUIETLY TRUE)
endif (MPFR_INCLUDE_DIR AND MPFR_LIBRARIES)
find_path(MPFR_INCLUDE_DIR NAMES mpfr.h )
find_library(MPFR_LIBRARIES NAMES mpfr libmpfr)
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(MPFR DEFAULT_MSG MPFR_INCLUDE_DIR MPFR_LIBRARIES)
mark_as_advanced(MPFR_INCLUDE_DIR MPFR_LIBRARIES)

170
cmake/modules/FindPoppler.cmake Normal file
View file

@ -0,0 +1,170 @@
# - Try to find the poppler PDF library
# Once done this will define
#
# POPPLER_FOUND - system has poppler
# POPPLER_INCLUDE_DIR - the poppler include directory
# POPPLER_LIBRARY - Link this to use poppler
#
# Copyright (c) 2006-2010, Pino Toscano, <pino@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(POPPLER_INCLUDE_DIR AND POPPLER_LIBRARY)
# in cache already
set(POPPLER_FOUND TRUE)
else(POPPLER_INCLUDE_DIR AND POPPLER_LIBRARY)
set(_poppler_version_bad FALSE)
if(NOT WIN32)
# use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
include(FindPkgConfig)
pkg_check_modules(_pc_poppler poppler-qt4)
if(_pc_poppler_FOUND)
if(NOT "${_pc_poppler_VERSION}" VERSION_GREATER 0.5.3)
set(_poppler_version_bad TRUE)
endif(NOT "${_pc_poppler_VERSION}" VERSION_GREATER 0.5.3)
endif(_pc_poppler_FOUND)
endif(NOT WIN32)
if(NOT _poppler_version_bad)
set(POPPLER_FOUND FALSE)
find_library(POPPLER_LIBRARY poppler-qt4
HINTS ${_pc_poppler_LIBRARY_DIRS}
)
find_path(POPPLER_INCLUDE_DIR poppler-qt4.h
HINTS ${_pc_poppler_INCLUDE_DIRS}
PATH_SUFFIXES poppler/qt4
)
find_path(POPPLER_INCLUDE_DIR_core qt4/poppler-qt4.h
HINTS ${_pc_poppler_INCLUDE_DIRS}
PATH_SUFFIXES poppler
)
if(POPPLER_LIBRARY AND POPPLER_INCLUDE_DIR AND POPPLER_INCLUDE_DIR_core)
list(APPEND POPPLER_INCLUDE_DIR "${POPPLER_INCLUDE_DIR_core}")
set(POPPLER_FOUND TRUE)
endif(POPPLER_LIBRARY AND POPPLER_INCLUDE_DIR AND POPPLER_INCLUDE_DIR_core)
endif(NOT _poppler_version_bad)
if (POPPLER_FOUND)
include(CheckCXXSourceCompiles)
# check whether we're using poppler 0.6
set(CMAKE_REQUIRED_INCLUDES ${POPPLER_INCLUDE_DIR} ${QT_INCLUDE_DIR})
set(CMAKE_REQUIRED_LIBRARIES ${POPPLER_LIBRARY} ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTXML_LIBRARY})
check_cxx_source_compiles("
#include <poppler-qt4.h>
int main()
{
Poppler::Document::RenderHint hint = Poppler::Document::TextHinting;
return 0;
}
" HAVE_POPPLER_0_12_1)
check_cxx_source_compiles("
#include <poppler-qt4.h>
void debugFunction(const QString &message, const QVariant &closure)
{
}
int main()
{
Poppler::setDebugErrorFunction(debugFunction, QVariant());
return 0;
}
" HAVE_POPPLER_0_16)
check_cxx_source_compiles("
#include <poppler-qt4.h>
#include <poppler-media.h>
int main()
{
Poppler::ScreenAnnotation *annot = 0;
Poppler::LinkRendition *link = 0;
const Poppler::LinkMovie::Operation operation = Poppler::LinkMovie::Play;
return 0;
}
" HAVE_POPPLER_0_20)
check_cxx_source_compiles("
#include <poppler-qt4.h>
#include <poppler-annotation.h>
#include <poppler-link.h>
int main()
{
Poppler::MovieObject *movie = 0;
Poppler::Document *doc = 0;
movie->showPosterImage();
const Poppler::Annotation::AdditionalActionType type = Poppler::Annotation::PageOpeningAction;
const Poppler::LinkRendition::RenditionAction action = Poppler::LinkRendition::NoRendition;
const Poppler::Document::FormType formType = doc->formType();
return 0;
}
" HAVE_POPPLER_0_22)
check_cxx_source_compiles("
#include <poppler-qt4.h>
int main()
{
Poppler::Document::RenderHint hint = Poppler::Document::ThinLineSolid;
return 0;
}
" HAVE_POPPLER_0_24)
check_cxx_source_compiles("
#include <poppler-qt4.h>
int main()
{
Poppler::Page *p = 0;
p->annotations( QSet<Poppler::Annotation::SubType>() << Poppler::Annotation::ASound );
return 0;
}
" HAVE_POPPLER_0_28)
set(CMAKE_REQUIRED_INCLUDES)
set(CMAKE_REQUIRED_LIBRARIES)
if (HAVE_POPPLER_0_28)
set(popplerVersionMessage "0.28")
elseif (HAVE_POPPLER_0_24)
set(popplerVersionMessage "0.24")
elseif (HAVE_POPPLER_0_22)
set(popplerVersionMessage "0.22")
elseif (HAVE_POPPLER_0_20)
set(popplerVersionMessage "0.20")
elseif (HAVE_POPPLER_0_16)
set(popplerVersionMessage "0.16")
elseif (HAVE_POPPLER_0_12_1)
set(popplerVersionMessage "0.12.1")
else (HAVE_POPPLER_0_28)
set(popplerVersionMessage "0.5.4")
endif (HAVE_POPPLER_0_28)
if (NOT Poppler_FIND_QUIETLY)
message(STATUS "Found Poppler-Qt4: ${POPPLER_LIBRARY}, (>= ${popplerVersionMessage})")
endif (NOT Poppler_FIND_QUIETLY)
else (POPPLER_FOUND)
if (Poppler_FIND_REQUIRED)
message(FATAL_ERROR "Could NOT find Poppler-Qt4")
endif (Poppler_FIND_REQUIRED)
message(STATUS "Could not find OPTIONAL package Poppler-Qt4")
endif (POPPLER_FOUND)
# ensure that they are cached
set(POPPLER_INCLUDE_DIR ${POPPLER_INCLUDE_DIR} CACHE INTERNAL "The Poppler-Qt4 include path")
set(POPPLER_LIBRARY ${POPPLER_LIBRARY} CACHE INTERNAL "The Poppler-Qt4 library")
set(HAVE_POPPLER_0_12_1 ${HAVE_POPPLER_0_12_1} CACHE INTERNAL "Whether the version of Poppler-Qt4 is >= 0.12.1")
endif(POPPLER_INCLUDE_DIR AND POPPLER_LIBRARY)

17
cmake/modules/FindSpeechd.cmake Normal file
View file

@ -0,0 +1,17 @@
# find speech-dispatcher library and header if available
# Copyright (c) 2009, Jeremy Whiting <jpwhiting@kde.org>
# Copyright (c) 2011, Raphael Kubo da Costa <kubito@gmail.com>
# This module defines
# SPEECHD_INCLUDE_DIR, where to find libspeechd.h
# SPEECHD_LIBRARIES, the libraries needed to link against speechd
# SPEECHD_FOUND, If false, speechd was not found
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
find_path(SPEECHD_INCLUDE_DIR libspeechd.h PATH_SUFFIXES speech-dispatcher)
find_library(SPEECHD_LIBRARIES NAMES speechd)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Speechd REQUIRED_VARS SPEECHD_INCLUDE_DIR SPEECHD_LIBRARIES)

463
cmake/modules/FindSubversionLibrary.cmake Normal file
View file

@ -0,0 +1,463 @@
# - Try to find subversion libraries
#
# This macro uses the following variables as preference for seraching the
# headers and includes:
# SUBVERSION_INSTALL_PATH - root directory where subversion is installed (ususally /usr)
# APR_CONFIG_PATH - path where apr-config or apr-1-config are located
# APU_CONFIG_PATH - path where apu-config or apu-1-config are located
#
# The variables set by this macro are:
# SUBVERSION_FOUND - system has subversion libraries
# SUBVERSION_INCLUDE_DIRS - the include directories to link to subversion
# SUBVERSION_LIBRARIES - The libraries needed to link to subversion
# Copyright (c) 2009 Lambert CLARA <lambert.clara@yahoo.fr>
# Copyright (c) 2009 Bernhard Rosenkraenzer <ber@arklinux.org>
# Copyright (c) 2007-2009 Andreas Pakulat <apaku@gmx.de>
#
# Redistribution AND use is allowed according to the terms of the New
# BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
IF(SUBVERSION_INCLUDE_DIRS AND SUBVERSION_LIBRARIES)
# Already in cache, be silent
SET(Subversion_FIND_QUIETLY TRUE)
ENDIF(SUBVERSION_INCLUDE_DIRS AND SUBVERSION_LIBRARIES)
IF (NOT WIN32)
MACRO(FIND_SUB_LIB targetvar libname)
FIND_LIBRARY(${targetvar} ${libname}
HINTS
${SUBVERSION_INSTALL_PATH}/lib
)
ENDMACRO(FIND_SUB_LIB)
FIND_PATH(SUBVERSION_INCLUDE_DIR svn_version.h
HINTS
${SUBVERSION_INSTALL_PATH}/include
PATH_SUFFIXES subversion-1
)
FIND_SUB_LIB(SUBVERSION_CLIENTLIB svn_client-1)
FIND_SUB_LIB(SUBVERSION_REPOSITORYLIB svn_repos-1)
FIND_SUB_LIB(SUBVERSION_WCLIB svn_wc-1)
FIND_SUB_LIB(SUBVERSION_FSLIB svn_fs-1)
FIND_SUB_LIB(SUBVERSION_SUBRLIB svn_subr-1)
FIND_SUB_LIB(SUBVERSION_RALIB svn_ra-1)
IF(APR_CONFIG_PATH)
FIND_PROGRAM(APR_CONFIG NAMES apr-config apr-1-config
PATHS
${APR_CONFIG_PATH}
/usr/local/apr/bin
)
ELSE(APR_CONFIG_PATH)
FIND_PROGRAM(APR_CONFIG NAMES apr-config apr-1-config
PATHS
/usr/local/apr/bin
)
ENDIF(APR_CONFIG_PATH)
IF(APU_CONFIG_PATH)
FIND_PROGRAM(APU_CONFIG NAMES apu-config apu-1-config
PATHS
${APU_CONFIG_PATH}
/usr/local/apr/bin
)
ELSE(APU_CONFIG_PATH)
FIND_PROGRAM(APU_CONFIG NAMES apu-config apu-1-config
PATHS
/usr/local/apr/bin
)
ENDIF(APU_CONFIG_PATH)
IF(NOT APR_CONFIG)
MESSAGE(STATUS "no apr-config found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE(NOT APR_CONFIG)
EXEC_PROGRAM(${APR_CONFIG} ARGS "--includedir" OUTPUT_VARIABLE APR_INCLUDE_DIR)
STRING(REPLACE "-I" "" APR_INCLUDE_DIR ${APR_INCLUDE_DIR})
EXEC_PROGRAM(${APR_CONFIG} ARGS "--link-ld" OUTPUT_VARIABLE _LINK_LD_ARGS)
STRING( REPLACE " " ";" _LINK_LD_ARGS ${_LINK_LD_ARGS} )
FOREACH( _ARG ${_LINK_LD_ARGS} )
IF(${_ARG} MATCHES "^-L")
STRING(REGEX REPLACE "^-L" "" _ARG ${_ARG})
SET(_APR_LIB_PATHS ${_APR_LIB_PATHS} ${_ARG})
ENDIF(${_ARG} MATCHES "^-L")
IF(${_ARG} MATCHES "^-l")
STRING(REGEX REPLACE "^-l" "" _ARG ${_ARG})
FIND_LIBRARY(_APR_LIB_FROM_ARG NAMES ${_ARG}
PATHS
${_APR_LIB_PATHS}
)
IF(_APR_LIB_FROM_ARG)
SET(APR_LIBRARY ${APR_LIBRARY} ${_APR_LIB_FROM_ARG})
ENDIF(_APR_LIB_FROM_ARG)
ENDIF(${_ARG} MATCHES "^-l")
ENDFOREACH(_ARG)
ENDIF(NOT APR_CONFIG)
IF(NOT APU_CONFIG)
MESSAGE(STATUS "no apu-config found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE(NOT APU_CONFIG)
EXEC_PROGRAM(${APU_CONFIG} ARGS "--includedir" OUTPUT_VARIABLE APU_INCLUDE_DIR)
STRING(REPLACE "-I" "" APU_INCLUDE_DIR ${APU_INCLUDE_DIR})
EXEC_PROGRAM(${APU_CONFIG} ARGS "--link-ld" OUTPUT_VARIABLE _LINK_LD_ARGS)
STRING( REPLACE " " ";" _LINK_LD_ARGS ${_LINK_LD_ARGS} )
SET(_APU_LIB_PATHS "")
FOREACH( _ARG ${_LINK_LD_ARGS} )
IF(${_ARG} MATCHES "^-L")
STRING(REGEX REPLACE "^-L" "" _ARG ${_ARG})
SET(_APU_LIB_PATHS ${_APU_LIB_PATHS} ${_ARG})
ENDIF(${_ARG} MATCHES "^-L")
IF(${_ARG} MATCHES "^-l")
STRING(REGEX REPLACE "^-l" "" _ARG ${_ARG})
FIND_LIBRARY(_APU_LIB_FROM_ARG NAMES ${_ARG}
PATHS
${_APU_LIB_PATHS}
)
IF(_APU_LIB_FROM_ARG)
SET(APU_LIBRARY ${APU_LIBRARY} ${_APU_LIB_FROM_ARG})
ENDIF(_APU_LIB_FROM_ARG)
ENDIF(${_ARG} MATCHES "^-l")
ENDFOREACH(_ARG)
ENDIF(NOT APU_CONFIG)
ELSE (NOT WIN32)
#search libaries for Windows
#this needs more work
# search for pathes
MACRO(FIND_SUB_INC targetvar libname pathadd)
IF (SUBVERSION_INSTALL_PATH)
FIND_PATH(${targetvar} ${libname}
PATHS
${SUBVERSION_INSTALL_PATH}/include${pathadd}
"$ENV{ProgramFiles}/Subversion/include${pathadd}"
)
ELSE(SUBVERSION_INSTALL_PATH)
FIND_LIBRARY(${targetvar} ${libname}
PATHS
"$ENV{ProgramFiles}/Subversion/include${pathadd}"
)
ENDIF(SUBVERSION_INSTALL_PATH)
ENDMACRO(FIND_SUB_INC)
MACRO(FIND_SUB_LIB targetvar libname)
IF (SUBVERSION_INSTALL_PATH)
FIND_LIBRARY(${targetvar} ${libname}
PATHS
${SUBVERSION_INSTALL_PATH}/lib
"$ENV{ProgramFiles}/Subversion/lib"
)
ELSE(SUBVERSION_INSTALL_PATH)
FIND_LIBRARY(${targetvar} ${libname}
PATHS
"$ENV{ProgramFiles}/Subversion/lib"
)
ENDIF(SUBVERSION_INSTALL_PATH)
ENDMACRO(FIND_SUB_LIB)
FIND_SUB_INC(SUBVERSION_INCLUDE_DIR svn_version.h "")
FIND_SUB_INC(APR_INCLUDE_DIR apr.h /apr)
FIND_SUB_INC(APU_INCLUDE_DIR apu.h /apr-util)
# search for libraries
FIND_SUB_LIB(APR_LIBRARY apr)
FIND_SUB_LIB(APRICONV_LIB apriconv)
FIND_SUB_LIB(APU_LIBRARY aprutil)
#FIND_SUB_LIB(APU_XMLLIB xml)
#FIND_SUB_LIB(NEON_LIB libneon)
#FIND_SUB_LIB(NEON_ZLIBSTATLIB zlibstat )
FIND_SUB_LIB(SUBVERSION_CLIENTLIB libsvn_client-1)
FIND_SUB_LIB(SUBVERSION_DELTALIB libsvn_delta-1)
FIND_SUB_LIB(SUBVERSION_DIFFLIB libsvn_diff-1)
#FIND_SUB_LIB(SUBVERSION_FSBASELIB libsvn_fs_base-1)
#FIND_SUB_LIB(SUBVERSION_FSFSLIB libsvn_fs_fs-1)
FIND_SUB_LIB(SUBVERSION_FSLIB libsvn_fs-1)
#FIND_SUB_LIB(SUBVERSION_RADAVLIB libsvn_ra_dav-1)
#FIND_SUB_LIB(SUBVERSION_RALOCALLIB libsvn_ra_local-1)
#FIND_SUB_LIB(SUBVERSION_RASVNLIB libsvn_ra_svn-1)
FIND_SUB_LIB(SUBVERSION_RALIB libsvn_ra-1)
FIND_SUB_LIB(SUBVERSION_REPOSITORYLIB libsvn_repos-1)
FIND_SUB_LIB(SUBVERSION_SUBRLIB libsvn_subr-1)
FIND_SUB_LIB(SUBVERSION_WCLIB libsvn_wc-1)
# these are the win32-only libs, the others handled at the bottom.
MARK_AS_ADVANCED(
APRICONV_LIB
#APU_XMLLIB
#NEON_LIB
#NEON_ZLIBSTATLIB
SUBVERSION_DELTALIB
SUBVERSION_DIFFLIB
SUBVERSION_FSBASELIB
SUBVERSION_FSFSLIB
SUBVERSION_RADAVLIB
SUBVERSION_RALOCALLIB
SUBVERSION_RASVNLIB
)
# check found libraries
IF (NOT APRICONV_LIB)
MESSAGE(STATUS "No apriconv lib found!")
ELSE (NOT APRICONV_LIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found apriconv lib: ${APRICONV_LIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${APRICONV_LIB})
ENDIF(NOT APRICONV_LIB)
#IF (NOT APU_XMLLIB)
# MESSAGE(STATUS "No xml lib found!")
#ELSE (NOT APU_XMLLIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found xml lib: ${APU_XMLLIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${APU_XMLLIB})
#ENDIF(NOT APU_XMLLIB)
#IF (NOT NEON_LIB)
# MESSAGE(STATUS "No neon lib found!")
#ELSE (NOT NEON_LIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found neon lib: ${NEON_LIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${NEON_LIB})
#ENDIF(NOT NEON_LIB)
#IF (NOT NEON_ZLIBSTATLIB)
# MESSAGE(STATUS "No zlibstat lib found!")
#ELSE (NOT APRICONV_LIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found zlibstat lib: ${NEON_ZLIBSTATLIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${NEON_ZLIBSTATLIB})
#ENDIF(NOT NEON_ZLIBSTATLIB)
IF (NOT SUBVERSION_DELTALIB)
MESSAGE(STATUS "No subversion delta lib found!")
ELSE (NOT SUBVERSION_DELTALIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion delta lib: ${SUBVERSION_DELTALIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_DELTALIB})
ENDIF(NOT SUBVERSION_DELTALIB)
IF (NOT SUBVERSION_DIFFLIB)
MESSAGE(STATUS "No subversion diff lib found!")
ELSE (NOT SUBVERSION_DIFFLIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion diff lib: ${SUBVERSION_DIFFLIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_DIFFLIB})
ENDIF(NOT SUBVERSION_DIFFLIB)
#IF (NOT SUBVERSION_FSBASELIB)
# MESSAGE(STATUS "No subversion fs base lib found!")
#ELSE (NOT SUBVERSION_FSBASELIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found subversion fs base lib: ${SUBVERSION_FSBASELIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_FSBASELIB})
#ENDIF(NOT SUBVERSION_FSBASELIB)
#IF (NOT SUBVERSION_FSFSLIB)
# MESSAGE(STATUS "No subversion fs fs lib found!")
#ELSE (NOT SUBVERSION_FSFSLIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found subversion fs fs lib: ${SUBVERSION_FSFSLIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_FSFSLIB})
#ENDIF(NOT SUBVERSION_FSFSLIB)
#IF (NOT SUBVERSION_RADAVLIB)
# MESSAGE(STATUS "No subversion ra dav lib found!")
#ELSE (NOT SUBVERSION_RADAVLIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found subversion lib: ${SUBVERSION_RADAVLIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_RADAVLIB})
#ENDIF(NOT SUBVERSION_RADAVLIB)
#IF (NOT SUBVERSION_RALOCALLIB)
# MESSAGE(STATUS "No subversion ra local lib found!")
#ELSE (NOT SUBVERSION_RALOCALLIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found subversion ra local lib: ${SUBVERSION_RALOCALLIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_RALOCALLIB})
#ENDIF(NOT SUBVERSION_RALOCALLIB)
#IF (NOT SUBVERSION_RASVNLIB)
# MESSAGE(STATUS "No subversion ra svn lib found!")
#ELSE (NOT SUBVERSION_RASVNLIB)
# IF(NOT Subversion_FIND_QUIETLY)
# MESSAGE(STATUS "Found subversion ra svn lib: ${SUBVERSION_RASVNLIB}")
# ENDIF(NOT Subversion_FIND_QUIETLY)
# SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_RASVNLIB})
#ENDIF(NOT SUBVERSION_RASVNLIB)
ENDIF (NOT WIN32)
##############################
# Setup the result variables #
##############################
IF(NOT SUBVERSION_INCLUDE_DIR)
MESSAGE(STATUS "No subversion includes found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE(NOT SUBVERSION_INCLUDE_DIR)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion include: ${SUBVERSION_INCLUDE_DIR}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_FOUND true)
SET(SUBVERSION_INCLUDE_DIRS ${SUBVERSION_INCLUDE_DIR})
ENDIF(NOT SUBVERSION_INCLUDE_DIR)
IF(NOT APR_INCLUDE_DIR)
MESSAGE(STATUS "No apr includes found, subversion support will be disabled")
SET(APR_FOUND false)
ELSE(NOT APR_INCLUDE_DIR)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found apr include: ${APR_INCLUDE_DIR}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_INCLUDE_DIRS ${SUBVERSION_INCLUDE_DIRS} ${APR_INCLUDE_DIR})
ENDIF(NOT APR_INCLUDE_DIR)
IF(NOT APU_INCLUDE_DIR)
MESSAGE(STATUS "No apu includes found, subversion support will be disabled")
SET(APU_FOUND false)
ELSE(NOT APU_INCLUDE_DIR)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found apu include: ${APU_INCLUDE_DIR}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_INCLUDE_DIRS ${SUBVERSION_INCLUDE_DIRS} ${APU_INCLUDE_DIR})
ENDIF(NOT APU_INCLUDE_DIR)
IF (NOT SUBVERSION_CLIENTLIB)
MESSAGE(STATUS "No subversion client libs found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT SUBVERSION_CLIENTLIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion client lib: ${SUBVERSION_CLIENTLIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_CLIENTLIB})
ENDIF(NOT SUBVERSION_CLIENTLIB)
IF (NOT SUBVERSION_REPOSITORYLIB)
MESSAGE(STATUS "No subversion repository lib found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT SUBVERSION_REPOSITORYLIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion repository lib: ${SUBVERSION_REPOSITORYLIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_REPOSITORYLIB})
ENDIF(NOT SUBVERSION_REPOSITORYLIB)
IF (NOT SUBVERSION_FSLIB)
MESSAGE(STATUS "No subversion fs lib found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT SUBVERSION_FSLIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion fs lib: ${SUBVERSION_FSLIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_FSLIB})
ENDIF(NOT SUBVERSION_FSLIB)
IF (NOT SUBVERSION_SUBRLIB)
MESSAGE(STATUS "No subversion subr lib found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT SUBVERSION_SUBRLIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion subr lib: ${SUBVERSION_SUBRLIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_SUBRLIB})
ENDIF(NOT SUBVERSION_SUBRLIB)
IF (NOT SUBVERSION_WCLIB)
MESSAGE(STATUS "No subversion wc lib found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT SUBVERSION_WCLIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion wc lib: ${SUBVERSION_WCLIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_WCLIB})
ENDIF(NOT SUBVERSION_WCLIB)
IF (NOT SUBVERSION_RALIB)
MESSAGE(STATUS "No subversion ra lib found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT SUBVERSION_RALIB)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found subversion ra lib: ${SUBVERSION_RALIB}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${SUBVERSION_RALIB})
ENDIF(NOT SUBVERSION_RALIB)
IF (NOT APR_LIBRARY)
MESSAGE(STATUS "No apr lib found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT APR_LIBRARY)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found apr lib: ${APR_LIBRARY}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${APR_LIBRARY})
ENDIF(NOT APR_LIBRARY)
IF (NOT APU_LIBRARY)
MESSAGE(STATUS "No apu lib found, subversion support will be disabled")
SET(SUBVERSION_FOUND false)
ELSE (NOT APU_LIBRARY)
IF(NOT Subversion_FIND_QUIETLY)
MESSAGE(STATUS "Found apu lib: ${APU_LIBRARY}")
ENDIF(NOT Subversion_FIND_QUIETLY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} ${APU_LIBRARY})
ENDIF(NOT APU_LIBRARY)
SET(SUBVERSION_LIBRARIES ${SUBVERSION_LIBRARIES} CACHE STRING "List of all subversion and related libraries")
SET(SUBVERSION_INCLUDE_DIRS ${SUBVERSION_INCLUDE_DIRS} CACHE STRING "List of all subversion and related libraries include directories")
#SET(SUBVERSION_INCLUDE_DIR ${SUBVERSION_INCLUDE_DIR} CACHE PATH "Path of subversion include directory")
MARK_AS_ADVANCED(
SUBVERSION_RALIB
SUBVERSION_WCLIB
SUBVERSION_SUBRLIB
SUBVERSION_FSLIB
SUBVERSION_CLIENTLIB
SUBVERSION_REPOSITORYLIB
SUBVERSION_INCLUDE_DIR
SUBVERSION_INCLUDE_DIRS
SUBVERSION_LIBRARIES
APR_INCLUDE_DIR
APR_LIBRARY
APU_INCLUDE_DIR
APU_LIBRARY
)
#kate: space-indent on; indent-width 2; tab-width: 2; replace-tabs on; auto-insert-doxygen on

31
cmake/modules/FindX11_XCB.cmake Normal file
View file

@ -0,0 +1,31 @@
# - Try to find libX11-xcb
# Once done this will define
#
# X11_XCB_FOUND - system has libX11-xcb
# X11_XCB_LIBRARIES - Link these to use libX11-xcb
# X11_XCB_INCLUDE_DIR - the libX11-xcb include dir
# X11_XCB_DEFINITIONS - compiler switches required for using libX11-xcb
# Copyright (c) 2012 Fredrik Höglund <fredrik@kde.org>
# Copyright (c) 2008 Helio Chissini de Castro, <helio@kde.org>
# Copyright (c) 2007 Matthias Kretz, <kretz@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
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(PKG_X11_XCB QUIET x11-xcb)
SET(X11_XCB_DEFINITIONS ${PKG_X11_XCB_CFLAGS})
FIND_PATH(X11_XCB_INCLUDE_DIR NAMES X11/Xlib-xcb.h HINTS ${PKG_X11_XCB_INCLUDE_DIRS})
FIND_LIBRARY(X11_XCB_LIBRARIES NAMES X11-xcb HINTS ${PKG_X11_XCB_LIBRARY_DIRS})
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(X11_XCB DEFAULT_MSG X11_XCB_LIBRARIES X11_XCB_INCLUDE_DIR)
MARK_AS_ADVANCED(X11_XCB_INCLUDE_DIR X11_XCB_LIBRARIES)
ENDIF (NOT WIN32)