CentOS 7.0 - man page for kdecmake (centos section 1)

Linux & Unix Commands - Search Man Pages

Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


kdecmake(1)									      kdecmake(1)

NAME
       kdecmake - Reference of available CMake custom modules.

DESCRIPTION
       The  "cmake"  executable is the CMake command-line interface.  It may be used to configure
       projects in scripts.  Project configuration settings may be specified on the command  line
       with  the -D option.  The -i option will cause cmake to interactively prompt for such set-
       tings.

       CMake is a cross-platform build system generator.  Projects specify  their  build  process
       with platform-independent CMake listfiles included in each directory of a source tree with
       the name CMakeLists.txt. Users build a project by using CMake to generate a  build  system
       for a native tool on their platform.

CUSTOM MODULES
       The  following modules are also available for CMake. They can be used with INCLUDE(Module-
       Name).

	 Custom CMake Modules - Additional Modules for CMake.

       This is the documentation for additional modules and scripts for CMake. Using  these  mod-
       ules  you  can  check the computer system for installed software packages, features of the
       compiler and the existance of headers to name just a few.

       CheckPointerMember
	      Check if the given struct or class has the specified member variable

	      CHECK_POINTER_MEMBER (POINTER MEMBER HEADER VARIABLE)

		POINTER - the name of the struct or class you are interested in
		MEMBER - the member which existence you want to check
		HEADER - the header(s) where the prototype should be declared
		VARIABLE - variable to store the result

	      The following variables may be set before calling this macro to modify the way  the
	      check is run:

		CMAKE_REQUIRED_FLAGS = string of compile command line flags
		CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
		CMAKE_REQUIRED_INCLUDES = list of include directories

       CheckPrototypeExists
	      Check if the prototype for a function exists.

	      CHECK_PROTOTYPE_EXISTS (FUNCTION HEADER VARIABLE)

		FUNCTION - the name of the function you are looking for
		HEADER - the header(s) where the prototype should be declared
		VARIABLE - variable to store the result

	      The  following variables may be set before calling this macro to modify the way the
	      check is run:

		CMAKE_REQUIRED_FLAGS = string of compile command line flags
		CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
		CMAKE_REQUIRED_INCLUDES = list of include directories

       CheckStructMember
	      Check if the given struct or class has the specified member variable

	      CHECK_STRUCT_MEMBER (STRUCT MEMBER HEADER VARIABLE)

		STRUCT - the name of the struct or class you are interested in
		MEMBER - the member which existence you want to check
		HEADER - the header(s) where the prototype should be declared
		VARIABLE - variable to store the result

	      The following variables may be set before calling this macro to modify the way  the
	      check is run:

		CMAKE_REQUIRED_FLAGS = string of compile command line flags
		CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
		CMAKE_REQUIRED_INCLUDES = list of include directories

       FindACL
	      Try to find the ACL library

	      Once done this will define

		ACL_FOUND - system has the ACL library
		ACL_LIBS - The libraries needed to use ACL

       FindAGG
	      Try to find the AGG graphics library

	      Once done this will define

		AGG_FOUND - system has AGG
		AGG_INCLUDE_DIR - the AGG include directory
		AGG_LIBRARIES - Link these to use AGG
		AGG_DEFINITIONS - Compiler switches required for using AGG

       FindAkode
	      Try to find the aKode library

	      Once done this will define

		AKODE_FOUND - system has the aKode library
		AKODE_INCLUDE_DIR - the aKode include directory
		AKODE_LIBRARIES - The libraries needed to use aKode

       FindAlsa

	      Alsa  check,  based  on libkmid/configure.in.in. Only the support for Alsa >= 0.9.x
	      was included; 0.5.x was dropped (but feel free to re-add it  if  you  need  it)  It
	      defines ... It offers the following macros:

		ALSA_CONFIGURE_FILE(config_header) - generate a config.h, typical usage:
						     ALSA_CONFIGURE_FILE(${CMAKE_BINARY_DIR}/config-alsa.h)
		ALSA_VERSION_STRING(version_string)  looks for alsa/version.h and reads the version string into
						     the first argument passed to the macro

       FindAutomoc4
	      Try to find automoc4

	      Once done this will define

		AUTOMOC4_FOUND - automoc4 has been found
		AUTOMOC4_EXECUTABLE - the automoc4 tool
		AUTOMOC4_VERSION - the full version of automoc4
		AUTOMOC4_VERSION_MAJOR, AUTOMOC4_VERSION_MINOR, AUTOMOC4_VERSION_PATCH - AUTOMOC4_VERSION
				   broken into its components

	      It also adds the following macros

		AUTOMOC4(<target> <SRCS_VAR>)
		  Use this to run automoc4 on all files contained in the list <SRCS_VAR>.

		AUTOMOC4_MOC_HEADERS(<target> header1.h header2.h ...)
		  Use this to add more header files to be processed with automoc4.

		AUTOMOC4_ADD_EXECUTABLE(<target_NAME> src1 src2 ...)
		  This macro does the same as ADD_EXECUTABLE, but additionally
		  adds automoc4 handling for all source files.

	      AUTOMOC4_ADD_LIBRARY(<target_NAME> src1 src2 ...)

		  This macro does the same as ADD_LIBRARY, but additionally
		  adds automoc4 handling for all source files.

       FindAvahi

	      Find Avahi. Only avahi-common/defs.h is really needed

       FindBerkeleyDB
	      Try to find Berkeley DB

	      Once done this will define

		BERKELEY_DB_FOUND - system has Berkeley DB
		BERKELEY_DB_INCLUDE_DIR - the Berkeley DB include directory
		BERKELEY_DB_LIBRARIES - Link these to use Berkeley DB
		BERKELEY_DB_DEFINITIONS - Compiler switches required for using Berkeley DB

       FindBlitz
	      Try to find blitz lib

	      Once done this will define

		BLITZ_FOUND - system has blitz lib
		BLITZ_INCLUDES - the blitz include directory
		BLITZ_LIBRARIES - The libraries needed to use blitz

       FindBlueZ
	      Try to find BlueZ

	      Once done this will define

		BLUEZ_FOUND - system has BlueZ
		BLUEZ_INCLUDE_DIR - the BlueZ include directory
		BLUEZ_LIBRARIES - Link these to use BlueZ
		BLUEZ_DEFINITIONS - Compiler switches required for using BlueZ

	      Redistribution  and  use	is allowed according to the terms of the BSD license. For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

       FindCarbon
	      Find Carbon on Mac

		CARBON_LIBRARY - the library to use Carbon
		CARBON_FOUND - true if Carbon has been found

       FindDBusMenuQt
	      Try to find dbusmenu-qt

	      This  module  helps  finding  an	installation  of  the  DBusMenuQt  library   (see
	      https://launchpad.net/libdbusmenu-qt/) Once done this will define

		DBUSMENUQT_FOUND - system has dbusmenu-qt
		DBUSMENUQT_INCLUDE_DIR - the dbusmenu-qt include directory
		DBUSMENUQT_LIBRARIES - the libraries needed to use dbusmenu-qt
		DBUSMENUQT_DEFINITIONS - Compiler switches required for using dbusmenu-qt

	      The minimum required version of DBusMenuQt can be specified using the standard syn-
	      tax, e.g. find_package(DBusMenuQt 0.6)

	      WARNING: versions below 0.4.0 cannot be checked for. So if you want to have a  ver-
	      sion check, require at least 0.4.0 of dbusmenuqt.

       FindDNSSD
	      Try to find DNSSD

	      Once done this will define

		DNSSD_FOUND - system has DNSSD
		DNSSD_INCLUDE_DIR - the DNSSD include directory
		DNSSD_LIBRARIES - Link these to use dnssd
		DNSSD_DEFINITIONS - Compiler switches required for using DNSSD

	      need more test: look at into dnssd/configure.in.in

       FindDocBookXML

	      Try to find DocBook XML DTDs Once done, it will define:

		DOCBOOKXML_FOUND - system has the required DocBook XML DTDs
		DOCBOOKXML_CURRENTDTD_VERSION - the version of currently used DocBook XML
		   DTD
		DOCBOOKXML_CURRENTDTD_DIR - the directory containing the definition of
		   the currently used DocBook XML version

       FindDocBookXSL

	      Try to find DocBook XSL stylesheet Once done, it will define:

		DOCBOOKXSL_FOUND - system has the required DocBook XML DTDs
		DOCBOOKXSL_DIR - the directory containing the stylesheets
		used to process DocBook XML

       FindENCHANT
	      Try to find the Enchant spell checker

	      Once done this will define

		ENCHANT_FOUND - system has ENCHANT
		ENCHANT_INCLUDE_DIR - the ENCHANT include directory
		ENCHANT_LIBRARIES - Link these to use ENCHANT
		ENCHANT_DEFINITIONS - Compiler switches required for using ENCHANT

       FindEigen
	      Try to find Eigen1 library

	      Note  that  Eigen1  is deprecated in favor of Eigen2. So this file is deprecated in
	      favor of FindEigen2.cmake. It is kept only for compatibility.

	      Once done this will define

		EIGEN_FOUND - system has eigen lib
		EIGEN_INCLUDE_DIR - the eigen include directory

       FindEigen2
	      Try to find Eigen2 lib

	      This module supports requiring a minimum version, e.g. you can do

		 find_package(Eigen2 2.0.3)

	      to require version 2.0.3 to newer of Eigen2.

	      Once done this will define

		EIGEN2_FOUND - system has eigen lib with correct version
		EIGEN2_INCLUDE_DIR - the eigen include directory
		EIGEN2_VERSION - eigen version

       FindExiv2
	      Try to find the Exiv2 library

		EXIV2_MIN_VERSION - You can set this variable to the minimum version you need
				    before doing FIND_PACKAGE(Exiv2). The default is 0.12.

	      Once done this will define

		EXIV2_FOUND - system has libexiv2
		EXIV2_INCLUDE_DIR - the libexiv2 include directory
		EXIV2_LIBRARIES - Link these to use libexiv2
		EXIV2_DEFINITIONS - Compiler switches required for using libexiv2

	      The minimum required version of Exiv2 can be specified using the	standard  syntax,
	      e.g. find_package(Exiv2 0.17)

	      For  compatibility,  also  the variable EXIV2_MIN_VERSION can be set to the minimum
	      version you need before doing FIND_PACKAGE(Exiv2). The default is 0.12.

       FindFAM
	      Try to find the FAM directory notification library

	      Once done this will define

		FAM_FOUND - system has FAM
		FAM_INCLUDE_DIR - the FAM include directory
		FAM_LIBRARIES - The libraries needed to use FAM

       FindFFmpeg
	      Try to find the required ffmpeg components(default: AVFORMAT, AVUTIL, AVCODEC)

	      vim: ts=2 sw=2

	      Once done this will define

		FFMPEG_FOUND	     - System has the all required components.
		FFMPEG_INCLUDE_DIRS  - Include directory necessary for using the required components headers.
		FFMPEG_LIBRARIES     - Link these to use the required ffmpeg components.
		FFMPEG_DEFINITIONS   - Compiler switches required for using the required ffmpeg components.

	      For each of the components it will additionally set.

		 - AVCODEC
		 - AVDEVICE
		 - AVFORMAT
		 - AVUTIL
		 - POSTPROCESS
		 - SWSCALE

	      the following variables will be defined

		<component>_FOUND	 - System has <component>
		<component>_INCLUDE_DIRS - Include directory necessary for using the <component> headers
		<component>_LIBRARIES	 - Link these to use <component>
		<component>_DEFINITIONS  - Compiler switches required for using <component>
		<component>_VERSION	 - The components version

	      Copyright (c) 2006, Matthias Kretz, <kretz@kde.org> Copyright (c)  2008,	Alexander
	      Neundorf,     <neundorf@kde.org>	  Copyright    (c)    2011,    Michael	  Jansen,
	      <kde@michael-jansen.biz>

	      Redistribution and use is allowed according to the terms of the  BSD  license.  For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

       FindFlac
	      Try to find Flac, the Free Lossless Audio Codec

	      Once done this will define

		FLAC_FOUND - system has Flac
		FLAC_INCLUDE_DIR - the Flac include directory
		FLAC_LIBRARIES - Link these to use Flac
		FLAC_OGGFLAC_LIBRARIES - Link these to use OggFlac

	      No version checking is done - use FLAC_API_VERSION_CURRENT to conditionally compile
	      version-dependent code

       FindFlex
	      Try to find Flex

	      Once done this will define

		FLEX_FOUND - system has Flex
		FLEX_EXECUTABLE - path of the flex executable
		FLEX_VERSION - the version string, like "2.5.31"

	      The minimum required version of Flex can be specified using  the	standard  syntax,
	      e.g. find_package(Flex 2.5)

       FindFontconfig
	      Try to find the  Fontconfig

	      Once done this will define

		FONTCONFIG_FOUND - system has Fontconfig
		FONTCONFIG_INCLUDE_DIR - The include directory to use for the fontconfig headers
		FONTCONFIG_LIBRARIES - Link these to use FONTCONFIG
		FONTCONFIG_DEFINITIONS - Compiler switches required for using FONTCONFIG

       FindGLIB2
	      Try to find the GLIB2 libraries

	      Once done this will define

		GLIB2_FOUND - system has glib2
		GLIB2_INCLUDE_DIR - the glib2 include directory
		GLIB2_LIBRARIES - glib2 library

       FindGMP

	      Try to find the GMP librairies

		GMP_FOUND - system has GMP lib
		GMP_INCLUDE_DIR - the GMP include directory
		GMP_LIBRARIES - Libraries needed to use GMP

       FindGObject
	      Try to find GObject

	      Once done this will define

		GOBJECT_FOUND - system has GObject
		GOBJECT_INCLUDE_DIR - the GObject include directory
		GOBJECT_LIBRARIES - the libraries needed to use GObject
		GOBJECT_DEFINITIONS - Compiler switches required for using GObject

       FindGSSAPI
	      Try to detect the GSSAPI support

	      Once done this will define

		GSSAPI_FOUND - system supports GSSAPI
		GSSAPI_INCS - the GSSAPI include directory
		GSSAPI_LIBS - the libraries needed to use GSSAPI
		GSSAPI_FLAVOR - the type of API - MIT or HEIMDAL

       FindGStreamer
	      Try to find GStreamer

	      Once done this will define

		GSTREAMER_FOUND - system has GStreamer
		GSTREAMER_INCLUDE_DIR - the GStreamer include directory
		GSTREAMER_LIBRARIES - the libraries needed to use GStreamer
		GSTREAMER_DEFINITIONS - Compiler switches required for using GStreamer

       FindGettext

	      Try to find Gettext functionality Once done this will define

		GETTEXT_FOUND - system has Gettext
		GETTEXT_INCLUDE_DIR - Gettext include directory
		GETTEXT_LIBRARIES - Libraries needed to use Gettext

       FindGphoto2

	      cmake macro to test if we use gphoto2

		GPHOTO2_FOUND - system has the GPHOTO2 library
		GPHOTO2_INCLUDE_DIR - the GPHOTO2 include directory
		GPHOTO2_LIBRARIES - The libraries needed to use GPHOTO2

       FindHUNSPELL
	      Try to find HUNSPELL

	      Once done this will define

		HUNSPELL_FOUND - system has HUNSPELL
		HUNSPELL_INCLUDE_DIR - the HUNSPELL include directory
		HUNSPELL_LIBRARIES - The libraries needed to use HUNSPELL
		HUNSPELL_DEFINITIONS - Compiler switches required for using HUNSPELL

       FindHUpnp
	      Try to find HUPnP library

		Once done this will define

		HUPNP_FOUND - system has HUPnP
		HUPNP_INCLUDE_DIR - the LIBHUpnp include directory
		HUPNP_LIBS - the LIBHUpnp libraries
		HUPNP_VERSION_STRING - The version of HUpnp
		HUPNP_VERSION_MAJOR - The major version of HUpnp
		HUPNP_VERSION_MINOR - The minor version of HUpnp
		HUPNP_VERSION_PATCH - The patch version of HUpnp

	      Copyright (c) 2010, Paulo Romulo Alves Barros <paulo.romulo@kdemail.net>

       FindIOKit
	      Find IOKit on Mac

		IOKIT_LIBRARY - the library to use IOKit
		IOKIT_FOUND - true if IOKit has been found

       FindKDE4Internal
	      Find the KDE4 include and library dirs, KDE preprocessors and define a some macros

	      This module defines the following variables:

		KDE4_FOUND		 - set to TRUE if everything required for building KDE software has been found

		KDE4_DEFINITIONS	 - compiler definitions required for compiling KDE software
		KDE4_INCLUDE_DIR	 - the KDE 4 include directory
		KDE4_INCLUDES		 - all include directories required for KDE, i.e.
					   KDE4_INCLUDE_DIR, but also the Qt4 include directories
					   and other platform specific include directories
		KDE4_LIB_DIR		 - the directory where the KDE libraries are installed,
					   intended to be used with LINK_DIRECTORIES(). In general, this is not necessary.
		KDE4_LIBEXEC_INSTALL_DIR - the directory where libexec executables from kdelibs are installed
		KDE4_BIN_INSTALL_DIR	 - the directory where executables from kdelibs are installed
		KDE4_SBIN_INSTALL_DIR	 - the directory where system executables from kdelibs are installed
		KDE4_DATA_INSTALL_DIR	 - the parent directory where kdelibs applications install their data
		KDE4_HTML_INSTALL_DIR	 - the directory where HTML documentation from kdelibs is installed
		KDE4_CONFIG_INSTALL_DIR  - the directory where config files from kdelibs are installed
		KDE4_ICON_INSTALL_DIR	 - the directory where icons from kdelibs are
		KDE4_IMPORTS_INSTALL_DIR - the directory where imports from kdelibs are
		KDE4_KCFG_INSTALL_DIR	 - the directory where kconfig files from kdelibs are installed
		KDE4_LOCALE_INSTALL_DIR  - the directory where translations from kdelibs are installed
		KDE4_MIME_INSTALL_DIR	 - the directory where mimetype desktop files from kdelibs are installed
		KDE4_SOUND_INSTALL_DIR	 - the directory where sound files from kdelibs are installed
		KDE4_TEMPLATES_INSTALL_DIR     - the directory where templates (Create new file...) from kdelibs are installed
		KDE4_WALLPAPER_INSTALL_DIR     - the directory where wallpapers from kdelibs are installed
		KDE4_KCONF_UPDATE_INSTALL_DIR  - the directory where kconf_update files from kdelibs are installed
		KDE4_AUTOSTART_INSTALL_DIR     - the directory where autostart from kdelibs are installed
		KDE4_XDG_APPS_INSTALL_DIR      - the XDG apps dir from kdelibs
		KDE4_XDG_DIRECTORY_INSTALL_DIR - the XDG directory from kdelibs
		KDE4_SYSCONF_INSTALL_DIR       - the directory where sysconfig files from kdelibs are installed
		KDE4_MAN_INSTALL_DIR	       - the directory where man pages from kdelibs are installed
		KDE4_INFO_INSTALL_DIR	       - the directory where info files from kdelibs are installed
		KDE4_DBUS_INTERFACES_DIR       - the directory where dbus interfaces from kdelibs are installed
		KDE4_DBUS_SERVICES_DIR	       - the directory where dbus service files from kdelibs are installed

	      The  following  variables are defined for the various tools required to compile KDE
	      software:

		KDE4_KCFGC_EXECUTABLE	 - the kconfig_compiler4 executable
		KDE4_AUTOMOC_EXECUTABLE  - the kde4automoc executable, deprecated, use AUTOMOC4_EXECUTABLE instead
		KDE4_MEINPROC_EXECUTABLE - the meinproc4 executable
		KDE4_MAKEKDEWIDGETS_EXECUTABLE - the makekdewidgets4 executable

	      The following variables point to the location of the KDE libraries,  but	shouldn't
	      be used directly:

		KDE4_KDECORE_LIBRARY	 - the kdecore library
		KDE4_KDEUI_LIBRARY	 - the kdeui library
		KDE4_KIO_LIBRARY	 - the kio library
		KDE4_KPARTS_LIBRARY	 - the kparts library
		KDE4_KUTILS_LIBRARY	 - the kutils library
		KDE4_KEMOTICONS_LIBRARY  - the kemoticons library
		KDE4_KIDLETIME_LIBRARY	 - the kidletime library
		KDE4_KCMUTILS_LIBRARY	 - the kcmutils library
		KDE4_KPRINTUTILS_LIBRARY - the kprintutils library
		KDE4_KDE3SUPPORT_LIBRARY - the kde3support library
		KDE4_KFILE_LIBRARY	 - the kfile library
		KDE4_KHTML_LIBRARY	 - the khtml library
		KDE4_KJS_LIBRARY	 - the kjs library
		KDE4_KJSAPI_LIBRARY	 - the kjs public api library
		KDE4_KNEWSTUFF2_LIBRARY  - the knewstuff2 library
		KDE4_KNEWSTUFF3_LIBRARY  - the knewstuff3 library
		KDE4_KDNSSD_LIBRARY	 - the kdnssd library
		KDE4_PHONON_LIBRARY	 - the phonon library
		KDE4_THREADWEAVER_LIBRARY- the threadweaver library
		KDE4_SOLID_LIBRARY	 - the solid library
		KDE4_KNOTIFYCONFIG_LIBRARY- the knotifyconfig library
		KDE4_KROSSCORE_LIBRARY	 - the krosscore library
		KDE4_KTEXTEDITOR_LIBRARY - the ktexteditor library
		KDE4_NEPOMUK_LIBRARY	 - the nepomuk library
		KDE4_PLASMA_LIBRARY	 - the plasma library
		KDE4_KUNITCONVERSION_LIBRARY - the kunitconversion library
		KDE4_KDEWEBKIT_LIBRARY	 - the kdewebkit library

		KDE4_PLASMA_OPENGL_FOUND  - TRUE if the OpenGL support of Plasma has been found, NOTFOUND otherwise

	      Compared	to  the  variables above, the following variables also contain all of the
	      depending libraries, so the variables below should be  used  instead  of	the  ones
	      above:

		KDE4_KDECORE_LIBS	   - the kdecore library and all depending libraries
		KDE4_KDEUI_LIBS 	   - the kdeui library and all depending libraries
		KDE4_KIO_LIBS		   - the kio library and all depending libraries
		KDE4_KPARTS_LIBS	   - the kparts library and all depending libraries
		KDE4_KUTILS_LIBS	   - the kutils library and all depending libraries
		KDE4_KEMOTICONS_LIBS	   - the kemoticons library and all depending libraries
		KDE4_KIDLETIME_LIBS	   - the kidletime library and all depending libraries
		KDE4_KCMUTILS_LIBS	   - the kcmutils library and all depending libraries
		KDE4_KPRINTUTILS_LIBS	   - the kprintutils library and all depending libraries
		KDE4_KDE3SUPPORT_LIBS	   - the kde3support library and all depending libraries
		KDE4_KFILE_LIBS 	   - the kfile library and all depending libraries
		KDE4_KHTML_LIBS 	   - the khtml library and all depending libraries
		KDE4_KJS_LIBS		   - the kjs library and all depending libraries
		KDE4_KJSAPI_LIBS	   - the kjs public api library and all depending libraries
		KDE4_KNEWSTUFF2_LIBS	   - the knewstuff2 library and all depending libraries
		KDE4_KNEWSTUFF3_LIBS	   - the knewstuff3 library and all depending libraries
		KDE4_KDNSSD_LIBS	   - the kdnssd library and all depending libraries
		KDE4_KDESU_LIBS 	   - the kdesu library and all depending libraries
		KDE4_KPTY_LIBS		   - the kpty library and all depending libraries
		KDE4_PHONON_LIBS	   - the phonon library and all depending librairies
		KDE4_THREADWEAVER_LIBRARIES- the threadweaver library and all depending libraries
		KDE4_SOLID_LIBS 	   - the solid library and all depending libraries
		KDE4_KNOTIFYCONFIG_LIBS    - the knotify config library and all depending libraries
		KDE4_KROSSCORE_LIBS	   - the kross core library and all depending libraries
		KDE4_KROSSUI_LIBS	   - the kross ui library which includes core and all depending libraries
		KDE4_KTEXTEDITOR_LIBS	   - the ktexteditor library and all depending libraries
		KDE4_NEPOMUK_LIBS	   - the nepomuk library and all depending libraries
		KDE4_PLASMA_LIBS	   - the plasma library and all depending librairies
		KDE4_KUNITCONVERSION_LIBS  - the kunitconversion library and all depending libraries
		KDE4_KDEWEBKIT_LIBS	   - the kdewebkit library and all depending libraries

	      This  module defines also a bunch of variables used as locations for install direc-
	      tories for files of the package which is using this module. These  variables  don't
	      say  anything  about  the  location  of the installed KDE. They can be relative (to
	      CMAKE_INSTALL_PREFIX) or absolute. Under Windows they are always relative.

		BIN_INSTALL_DIR 	 - the directory where executables will be installed (default is prefix/bin)
		BUNDLE_INSTALL_DIR	 - Mac only: the directory where application bundles will be installed (default is /Applications/KDE4 )
		SBIN_INSTALL_DIR	 - the directory where system executables will be installed (default is prefix/sbin)
		LIB_INSTALL_DIR 	 - the directory where libraries will be installed (default is prefix/lib)
		CONFIG_INSTALL_DIR	 - the directory where config files will be installed
		DATA_INSTALL_DIR	 - the parent directory where applications can install their data
		HTML_INSTALL_DIR	 - the directory where HTML documentation will be installed
		ICON_INSTALL_DIR	 - the directory where the icons will be installed (default prefix/share/icons/)
		INFO_INSTALL_DIR	 - the directory where info files will be installed (default prefix/info)
		KCFG_INSTALL_DIR	 - the directory where kconfig files will be installed
		LOCALE_INSTALL_DIR	 - the directory where translations will be installed
		MAN_INSTALL_DIR 	 - the directory where man pages will be installed (default prefix/man/)
		MIME_INSTALL_DIR	 - the directory where mimetype desktop files will be installed
		PLUGIN_INSTALL_DIR	 - the subdirectory relative to the install prefix where plugins will be installed (default is ${KDE4_LIB_INSTALL_DIR}/kde4)
		IMPORTS_INSTALL_DIR	 - the subdirectory relative to the install prefix where imports will be installed
		SERVICES_INSTALL_DIR	 - the directory where service (desktop, protocol, ...) files will be installed
		SERVICETYPES_INSTALL_DIR - the directory where servicestypes desktop files will be installed
		SOUND_INSTALL_DIR	 - the directory where sound files will be installed
		TEMPLATES_INSTALL_DIR	 - the directory where templates (Create new file...) will be installed
		WALLPAPER_INSTALL_DIR	 - the directory where wallpapers will be installed
		AUTOSTART_INSTALL_DIR	 - the directory where autostart files will be installed
		DEMO_INSTALL_DIR	 - the directory where demos will be installed
		KCONF_UPDATE_INSTALL_DIR - the directory where kconf_update files will be installed
		SYSCONF_INSTALL_DIR	 - the directory where sysconfig files will be installed (default /etc)
		XDG_APPS_INSTALL_DIR	 - the XDG apps dir
		XDG_DIRECTORY_INSTALL_DIR- the XDG directory
		XDG_MIME_INSTALL_DIR	 - the XDG mimetypes install dir
		DBUS_INTERFACES_INSTALL_DIR - the directory where dbus interfaces will be installed (default is prefix/share/dbus-1/interfaces)
		DBUS_SERVICES_INSTALL_DIR	 - the directory where dbus services will be installed (default is prefix/share/dbus-1/services )
		DBUS_SYSTEM_SERVICES_INSTALL_DIR	- the directory where dbus system services will be installed (default is prefix/share/dbus-1/system-services )

	      The variable INSTALL_TARGETS_DEFAULT_ARGS can be used when installing libraries  or
	      executables  into  the default locations. The INSTALL_TARGETS_DEFAULT_ARGS variable
	      should be used when libraries are installed. It should also be used when installing
	      applications,  since  then  on  OS  X application bundles will be installed to BUN-
	      DLE_INSTALL_DIR. The variable MUST NOT be used for installing plugins. It also MUST
	      NOT be used for executables which are intended to go into sbin/ or libexec/.

	      Usage is like this:

		  install(TARGETS kdecore kdeui ${INSTALL_TARGETS_DEFAULT_ARGS} )

	      This  will  install  libraries correctly under UNIX, OSX and Windows (i.e. dll's go
	      into bin/.

	      The following variable is provided, but seem to be unused:

		LIBS_HTML_INSTALL_DIR	 /share/doc/HTML	    CACHE STRING "Is this still used ?")

	      The following user adjustable options are provided:

		KDE4_ENABLE_FINAL - enable KDE-style enable-final all-in-one-compilation
		KDE4_BUILD_TESTS  - enable this to build the testcases
		KDE4_ENABLE_FPIE  - enable it to use gcc Position Independent Executables feature
		KDE4_USE_COMMON_CMAKE_PACKAGE_CONFIG_DIR - only present for CMake >= 2.6.3, defaults to TRUE
				    If enabled, the package should install its <package>Config.cmake file to
				    lib/cmake/<package>/ instead to lib/<package>/cmake
		KDE4_SERIALIZE_TOOL - wrapper to serialize potentially resource-intensive commands during
				    parallel builds (set to 'icecc' when using icecream)

	      It also adds the following macros and functions (from KDE4Macros.cmake)

		KDE4_ADD_UI_FILES (SRCS_VAR file1.ui ... fileN.ui)
		  Use this to add Qt designer ui files to your application/library.

		KDE4_ADD_UI3_FILES (SRCS_VAR file1.ui ... fileN.ui)
		  Use this to add Qt designer ui files from Qt version 3 to your application/library.

		KDE4_ADD_KCFG_FILES (SRCS_VAR [GENERATE_MOC] [USE_RELATIVE_PATH] file1.kcfgc ... fileN.kcfgc)
		  Use this to add KDE config compiler files to your application/library.
		  Use optional GENERATE_MOC to generate moc if you use signals in your kcfg files.
		  Use optional USE_RELATIVE_PATH to generate the classes in the build following the given
		  relative path to the file.

		KDE4_ADD_WIDGET_FILES (SRCS_VAR file1.widgets ... fileN.widgets)
		  Use this to add widget description files for the makekdewidgets4 code generator
		  for Qt Designer plugins.

		KDE4_CREATE_FINAL_FILES (filename_CXX filename_C file1 ... fileN)
		  This macro is intended mainly for internal uses.
		  It is used for enable-final. It will generate two source files,
		  one for the C files and one for the C++ files.
		  These files will have the names given in filename_CXX and filename_C.

		KDE4_ADD_PLUGIN ( name [WITH_PREFIX] file1 ... fileN )
		  Create a KDE plugin (KPart, kioslave, etc.) from the given source files.
		  It supports KDE4_ENABLE_FINAL.
		  If WITH_PREFIX is given, the resulting plugin will have the prefix "lib", otherwise it won't.

		KDE4_ADD_KDEINIT_EXECUTABLE (name [NOGUI] [RUN_UNINSTALLED] file1 ... fileN)
		  Create a KDE application in the form of a module loadable via kdeinit.
		  A library named kdeinit_<name> will be created and a small executable which links to it.
		  It supports KDE4_ENABLE_FINAL
		  If the executable doesn't have a GUI, use the option NOGUI. By default on OS X
		  application bundles are created, with the NOGUI option no bundles but simple executables
		  are created. Under Windows this flag is also necessary to separate between applications
		  with GUI and without. On other UNIX systems this flag has no effect.
		  RUN_UNINSTALLED is deprecated and is ignored, for details see the documentation for
		  KDE4_ADD_EXECUTABLE().

		KDE4_ADD_EXECUTABLE (name [NOGUI] [TEST] [RUN_UNINSTALLED] file1 ... fileN)
		  Equivalent to ADD_EXECUTABLE(), but additionally adds some more features:
		  -support for KDE4_ENABLE_FINAL
		  -support for automoc
		  -automatic RPATH handling
		  If the executable doesn't have a GUI, use the option NOGUI. By default on OS X
		  application bundles are created, with the NOGUI option no bundles but simple executables
		  are created. Under Windows this flag is also necessary to separate between applications
		  with GUI and without. On other UNIX systems this flag has no effect.
		  The option TEST is for internal use only.
		  The option RUN_UNINSTALLED is ignored. It was necessary with KDE 4.0 and 4.1
		  if the executable had to be run from the build tree. Since KDE 4.2 all
		  executables can be always run uninstalled (the RPATH of executables which are not
		  yet installed points since then into the buildtree and is changed
		  to the proper location when installing, so RUN_UNINSTALLED is not necessary anymore).

		KDE4_ADD_LIBRARY (name [STATIC | SHARED | MODULE ] file1 ... fileN)
		  Equivalent to ADD_LIBRARY(). Additionally it supports KDE4_ENABLE_FINAL,
		  includes automoc-handling and sets LINK_INTERFACE_LIBRARIES target property empty.
		  The RPATH is set according to the global RPATH settings as set up by FindKDE4Internal.cmake
		  (CMAKE_SKIP_BUILD_RPATH=FALSE, CMAKE_BUILD_WITH_INSTALL_RPATH=FALSE, CMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE)
		  Under Windows it adds a -DMAKE_<name>_LIB definition to the compilation.

		KDE4_ADD_UNIT_TEST (testname [TESTNAME targetname] file1 ... fileN)
		  add a unit test, which is executed when running make test
		  it will be built with RPATH poiting to the build dir
		  The targets are always created, but only built for the "all"
		  target if the option KDE4_BUILD_TESTS is enabled. Otherwise the rules for the target
		  are created but not built by default. You can build them by manually building the target.
		  The name of the target can be specified using TESTNAME <targetname>, if it is not given
		  the macro will default to the <testname>
		  KDESRCDIR is set to the source directory of the test, this can be used with
		  KGlobal::dirs()->addResourceDir( "data", KDESRCDIR )

		KDE4_ADD_APP_ICON (SRCS_VAR pattern)
		adds an application icon to target source list.
		Make sure you have a 128x128 icon, or the icon won't display on Mac OS X.
		Mac OSX notes : the application icon is added to a Mac OS X bundle so that Finder and friends show the right thing.
		Win32 notes: the application icon(s) are compiled into the application
		There is some workaround in kde4_add_kdeinit_executable to make it possible for those applications as well.

	      Parameters:

		SRCS_VAR  - specifies the list of source files
		pattern   - regular expression for searching application icons
		Example: KDE4_ADD_APP_ICON( myapp_SOURCES "pics/cr*-myapp.png")
		Example: KDE4_ADD_APP_ICON( myapp_KDEINIT_SRCS "icons/oxygen/*/apps/myapp.png")

		KDE4_UPDATE_ICONCACHE()
		  Notifies the icon cache that new icons have been installed by updating
		  mtime of ${ICON_INSTALL_DIR}/hicolor directory.

		KDE4_INSTALL_ICONS( path theme)
		  Installs all png and svgz files in the current directory to the icon
		  directory given in path, in the subdirectory for the given icon theme.

		KDE4_CREATE_HANDBOOK( docbookfile [INSTALL_DESTINATION installdest] [SUBDIR subdir])
		 Create the handbook from the docbookfile (using meinproc4)
		 The resulting handbook will be installed to <installdest> when using
		 INSTALL_DESTINATION <installdest>, or to <installdest>/<subdir> if
		 SUBDIR <subdir> is specified.

		KDE4_CREATE_MANPAGE( docbookfile section )
		 Create the manpage for the specified section from the docbookfile (using meinproc4)
		 The resulting manpage will be installed to <installdest> when using
		 INSTALL_DESTINATION <installdest>, or to <installdest>/<subdir> if
		 SUBDIR <subdir> is specified.

		KDE4_INSTALL_AUTH_ACTIONS( HELPER_ID ACTIONS_FILE )
		 This macro generates an action file, depending on the backend used, for applications using KAuth.
		 It accepts the helper id (the DBUS name) and a file containing the actions (check kdelibs/kdecore/auth/example
		 for file format). The macro will take care of generating the file according to the backend specified,
		 and to install it in the right location. This (at the moment) means that on Linux (PolicyKit) a .policy
		 file will be generated and installed into the policykit action directory (usually /usr/share/PolicyKit/policy/),
		 and on Mac (Authorization Services) will be added to the system action registry using the native MacOS API during
		 the install phase

		KDE4_INSTALL_AUTH_HELPER_FILES( HELPER_TARGET HELPER_ID HELPER_USER )
		 This macro adds the needed files for an helper executable meant to be used by applications using KAuth.
		 It accepts the helper target, the helper ID (the DBUS name) and the user under which the helper will run on.
		 This macro takes care of generate the needed files, and install them in the right location. This boils down
		 to a DBus policy to let the helper register on the system bus, and a service file for letting the helper
		 being automatically activated by the system bus.
		 *WARNING* You have to install the helper in ${LIBEXEC_INSTALL_DIR} to make sure everything will work.

		A note on the possible values for CMAKE_BUILD_TYPE and how KDE handles
		the flags for those buildtypes. FindKDE4Internal supports the values
		Debug, Release, RelWithDebInfo, Profile and Debugfull:

		Release
			optimised for speed, qDebug/kDebug turned off, no debug symbols, no asserts
		RelWithDebInfo (Release with debug info)
			similar to Release, optimised for speed, but with debugging symbols on (-g)
		Debug
			optimised but debuggable, debugging on (-g)
			(-fno-reorder-blocks -fno-schedule-insns -fno-inline)
		DebugFull
			no optimization, full debugging on (-g3)
		Profile
			DebugFull + -ftest-coverage -fprofile-arcs

		The default buildtype is RelWithDebInfo.
		It is expected that the "Debug" build type be still debuggable with gdb
		without going all over the place, but still produce better performance.
		It's also important to note that gcc cannot detect all warning conditions
		unless the optimiser is active.

		This module allows to depend on a particular minimum version of kdelibs.
		To acomplish that one should use the appropriate cmake syntax for
		find_package. For example to depend on kdelibs >= 4.1.0 one should use

		find_package(KDE4 4.1.0 REQUIRED)

		In earlier versions of KDE you could use the variable KDE_MIN_VERSION to
		have such a dependency. This variable is deprecated with KDE 4.2.0, but
		will still work to make the module backwards-compatible.

       FindKDE4Workspace

	      Find if we installed kdebase/workspaces. Once done this will define

		KDE4WORKSPACE_FOUND - system has KDE workspace installed
		KDE4WORKSPACE_INCLUDE_DIR - the KDE workspace include directory

	      It also sets variables for the following libraries:

		 KDE4WORKSPACE_TASKMANAGER_LIBRARY, KDE4WORKSPACE_TASKMANAGER_LIBS
		 KDE4WORKSPACE_KWORKSPACE_LIBRARY, KDE4WORKSPACE_KWORKSPACE_LIBS
		 KDE4WORKSPACE_SOLIDCONTROLIFACES_LIBRARY, KDE4WORKSPACE_SOLIDCONTROLIFACES_LIBS
		 KDE4WORKSPACE_SOLIDCONTROL_LIBRARY, KDE4WORKSPACE_SOLIDCONTROL_LIBS
		 KDE4WORKSPACE_PROCESSUI_LIBRARY, KDE4WORKSPACE_PROCESSUI_LIBS
		 KDE4WORKSPACE_LSOFUI_LIBRARY, KDE4WORKSPACE_LSOFUI_LIBS
		 KDE4WORKSPACE_PLASMACLOCK_LIBRARY, KDE4WORKSPACE_PLASMACLOCK_LIBS
		 KDE4WORKSPACE_NEPOMUKQUERYCLIENT_LIBRARY, KDE4WORKSPACE_NEPOMUKQUERYCLIENT_LIBS
		 KDE4WORKSPACE_NEPOMUKQUERY_LIBRARY, KDE4WORKSPACE_NEPOMUKQUERY_LIBS
		 KDE4WORKSPACE_KSCREENSAVER_LIBRARY, KDE4WORKSPACE_KSCREENSAVER_LIBS
		 KDE4WORKSPACE_WEATHERION_LIBRARY, KDE4WORKSPACE_WEATHERION_LIBS
		 KDE4WORKSPACE_KWINEFFECTS_LIBRARY, KDE4WORKSPACE_KWINEFFECTS_LIBS
		 KDE4WORKSPACE_KDECORATIONS_LIBRARY, KDE4WORKSPACE_KDECORATIONS_LIBS
		 KDE4WORKSPACE_KSGRD_LIBRARY, KDE4WORKSPACE_KSGRD_LIBS
		 KDE4WORKSPACE_KEPHAL_LIBRARY, KDE4WORKSPACE_KEPHAL_LIBS

	      And the following locations:

		 KDE4WORKSPACE_LIB_DIR
		 KDE4WORKSPACE_LIBEXEC_DIR
		 KDE4WORKSPACE_INCLUDE_DIR
		 KDE4WORKSPACE_BIN_DIR
		 KDE4WORKSPACE_SBIN_DIR
		 KDE4WORKSPACE_DATA_DIR
		 KDE4WORKSPACE_HTML_DIR
		 KDE4WORKSPACE_CONFIG_DIR
		 KDE4WORKSPACE_ICON_DIR
		 KDE4WORKSPACE_KCFG_DIR
		 KDE4WORKSPACE_LOCALE_DIR
		 KDE4WORKSPACE_MIME_DIR
		 KDE4WORKSPACE_SOUND_DIR
		 KDE4WORKSPACE_TEMPLATES_DIR
		 KDE4WORKSPACE_WALLPAPER_DIR
		 KDE4WORKSPACE_KCONF_UPDATE_DIR
		 KDE4WORKSPACE_AUTOSTART_DIR
		 KDE4WORKSPACE_XDG_APPS_DIR
		 KDE4WORKSPACE_XDG_DIRECTORY_DIR
		 KDE4WORKSPACE_SYSCONF_DIR
		 KDE4WORKSPACE_MAN_DIR
		 KDE4WORKSPACE_INFO_DIR
		 KDE4WORKSPACE_DBUS_INTERFACES_DIR
		 KDE4WORKSPACE_DBUS_SERVICES_DIR
		 KDE4WORKSPACE_SERVICES_DIR
		 KDE4WORKSPACE_SERVICETYPES_DIR

       FindKDevPlatform

	      Find the KDevelop Platform modules and sets various variables accordingly

	      Example usage of this module: find_package(KDevPlatform 1.0.0 REQUIRED)

	      The version number and REQUIRED flag are optional. You  can  set	CMAKE_PREFIX_PATH
	      variable to help it find the required files and directories

       FindKNepomuk

	      Once done this will define

		KNEPOMUK_FOUND - system has the Nepomuk-KDE backbone lib KNep
		KNEPOMUK_INCLUDES - the libKNep include directory
		KNEPOMUK_LIBRARIES - Link these to use libKNep

       FindKdcraw

	      Try to find the Kdcraw library

	      Parameters:

		KDCRAW_LOCAL_DIR - If you have put a local version of libkdcraw into
				   your source tree, set KDCRAW_LOCAL_DIR to the
				   relative path from the root of your source tree
				   to the libkdcraw local directory.

	      Once done this will define

		KDCRAW_FOUND - System has libkdcraw
		KDCRAW_INCLUDE_DIR - The libkdcraw include directory/directories (for #include <libkdcraw/...> style)
		KDCRAW_LIBRARIES - Link these to use libkdcraw
		KDCRAW_DEFINITIONS - Compiler switches required for using libkdcraw
		KDCRAW_VERSION - Version of libkdcraw which was found

	      Copyright  (c)  2008-2011, Gilles Caulier, <caulier.gilles@gmail.com> Copyright (c)
	      2011, Michael G. Hansen, <mike@mghansen.de>

	      Redistribution and use is allowed according to the terms of the  BSD  license.  For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

       FindKdeMultimedia

	      Module to see if we have KDE4 kdemultimedia installed

	      This module defines

		KDEMULTIMEDIA_INCLUDE_DIR - the include dir
		KCDDB_LIBRARY - the kcddb library
		KCOMPACTDISC_LIBRARY - the kcompactdisk library
		KDEMULTIMEDIA_LIBRARIES - all of the KDE multimedia libraries together
		KDEMULTIMEDIA_FOUND - true if the above have been found

       FindKdepim

	      Nothing should require kdepim. We'll show a fatal error and an explanation.

       FindKdepimLibs

	      Find if we installed kdepimlibs before to compile it Once done this will define

		KDEPIMLIBS_FOUND - system has KDE PIM Libraries
		KDEPIMLIBS_INCLUDE_DIR - the KDE PIM Libraries include directory
		KDEPIMLIBS_INCLUDE_DIRS - the KDE PIM Libraries include directory and CamelCase headers

	      It also sets variables for the following libraries:

		 KDEPIMLIBS_AKONADI_LIBS
		 KDEPIMLIBS_AKONADI_CONTACT_LIBS
		 KDEPIMLIBS_AKONADI_KABC_LIBS
		 KDEPIMLIBS_AKONADI_KMIME_LIBS
		 KDEPIMLIBS_GPGMEPP_LIBS
		 KDEPIMLIBS_KABC_LIBS
		 KDEPIMLIBS_KALARMCAL_LIBS
		 KDEPIMLIBS_KBLOG_LIBS
		 KDEPIMLIBS_KCAL_LIBS
		 KDEPIMLIBS_KCALCORE_LIBS
		 KDEPIMLIBS_KCALUTILS_LIBS
		 KDEPIMLIBS_KHOLIDAYS_LIBS
		 KDEPIMLIBS_KIMAP_LIBS
		 KDEPIMLIBS_KLDAP_LIBS
		 KDEPIMLIBS_KMIME_LIBS
		 KDEPIMLIBS_KONTACTINTERFACE_LIBS
		 KDEPIMLIBS_KPIMIDENTITIES_LIBS
		 KDEPIMLIBS_KPIMTEXTEDIT_LIBS
		 KDEPIMLIBS_KPIMUTILS_LIBS
		 KDEPIMLIBS_KRESOURCES_LIBS
		 KDEPIMLIBS_KTNEF_LIBS
		 KDEPIMLIBS_KXMLRPCCLIENT_LIBS
		 KDEPIMLIBS_MAILTRANSPORT_LIBS
		 KDEPIMLIBS_MICROBLOG_LIBS
		 KDEPIMLIBS_QGPGME_LIBS
		 KDEPIMLIBS_SYNDICATION_LIBS

	      And the following locations:

		 KDEPIMLIBS_DATA_DIR
		 KDEPIMLIBS_DBUS_INTERFACES_DIR
		 KDEPIMLIBS_DBUS_SERVICES_DIR
		 KDEPIMLIBS_INCLUDE_DIR
		 KDEPIMLIBS_INCLUDE_DIRS
		 KDEPIMLIBS_LIB_DIR
		 KDEPIMLIBS_BIN_DIR
		 KDEPIMLIBS_LIBEXEC_DIR
		 KDEPIMLIBS_SBIN_DIR
		 KDEPIMLIBS_HTML_DIR
		 KDEPIMLIBS_CONFIG_DIR
		 KDEPIMLIBS_ICON_DIR
		 KDEPIMLIBS_KCFG_DIR
		 KDEPIMLIBS_LOCALE_DIR
		 KDEPIMLIBS_MIME_DIR
		 KDEPIMLIBS_SOUND_DIR
		 KDEPIMLIBS_TEMPLATES_DIR
		 KDEPIMLIBS_KCONF_UPDATE_DIR
		 KDEPIMLIBS_AUTOSTART_DIR
		 KDEPIMLIBS_XDG_APPS_DIR
		 KDEPIMLIBS_XDG_DIRECTORY_DIR
		 KDEPIMLIBS_SYSCONF_DIR
		 KDEPIMLIBS_MAN_DIR
		 KDEPIMLIBS_INFO_DIR
		 KDEPIMLIBS_SERVICES_DIR
		 KDEPIMLIBS_SERVICETYPES_DIR

       FindKexiv2
	      Try to find the KExiv2 library

	      If  you  have  put  a  local  version  of  libkexiv2  into  your	source	tree, set
	      KEXIV2_LOCAL_DIR to the relative path to the local directory.

	      Once done this will define

		KEXIV2_FOUND - system has libkexiv2
		KEXIV2_INCLUDE_DIR - the libkexiv2 include directory
		KEXIV2_LIBRARIES - Link these to use libkexiv2
		KEXIV2_DEFINITIONS - Compiler switches required for using libkexiv2

       FindKipi

	      Module that tries to find the Kipi library

	      Input values :

	      KIPI_LOCAL_DIR	- If you have put a local version of  libkipi  into  your  source
	      tree,

				   set this variable to the relative path from the local directory.

	      Output values :

		KIPI_FOUND	 - System has libkipi
		KIPI_INCLUDE_DIR - The libkipi include directory
		KIPI_LIBRARIES	 - Link these to use libkipi
		KIPI_DEFINITIONS - Compiler switches required for using libkipi
		KIPI_VERSION	 - The release version of the Kipi library
		KIPI_SO_VERSION  - The binary SO version of the Kipi library

       FindKonto

	      Once done this will define

		KONTO_FOUND - system has the Nepomuk-KDE backbone lib Konto
		KONTO_INCLUDES - the libKonto include directory
		KONTO_LIBRARIES - Link these to use libKonto

       FindKopete
	      Try to find the Kopete library

	      Once done this will define

		Kopete_FOUND - system has kopete
		KOPETE_INCLUDE_DIR - the kopete include directory
		KOPETE_LIBRARIES - Link these to use kopete

       FindKorundum
	      Find Korundum - the KDE Ruby bindings

	      This module finds if Korundum is installed. It defines the following variables:

		KORUNDUM_PATH - the path to the korundum ruby file
		KORUNDUM_FOUND - true if it has been found

       FindLCMS
	      Find LCMS

	      Find the LCMS (Little Color Management System) library and includes and This module
	      defines

		LCMS_INCLUDE_DIR, where to find lcms.h
		LCMS_LIBRARIES, the libraries needed to use LCMS.
		LCMS_DOT_VERSION, The version number of the LCMS library, e.g. "1.19"
		LCMS_VERSION, Similar to LCMS_DOT_VERSION, but without the dots, e.g. "119"
		LCMS_FOUND, If false, do not try to use LCMS.

	      The minimum required version of LCMS can be specified using  the	standard  syntax,
	      e.g. find_package(LCMS 1.10)

       FindLibArt
	      Try to find the LibArt 2D graphics library

	      Once done this will define

		LIBART_FOUND - system has the LibArt
		LIBART_INCLUDE_DIR - the LibArt include directory
		LIBART_LIBRARIES - The libraries needed to use LibArt

       FindLibAttica

	      Try to find the Attica library Once done this will define

		 LIBATTICA_FOUND	  Indicates that Attica was found
		 LIBATTICA_LIBRARIES	  Libraries needed to use Attica
		 LIBATTICA_LIBRARY_DIRS   Paths needed for linking against Attica
		 LIBATTICA_INCLUDE_DIR	  Path needed for finding Attica include files

	      The  minimum required version of LibAttica can be specified using the standard syn-
	      tax, e.g. find_package(LibAttica 0.20)

       FindLibKonq
	      Try to find konqueror library

	      Once done this will define

		LIBKONQ_FOUND - system has libkonq library
		LIBKONQ_INCLUDE_DIR - the LIBKONQ include directory
		LIBKONQ_LIBRARY - the libkonq library

       FindLibLZMA
	      Find LibLZMA

	      Find LibLZMA headers and library

		LIBLZMA_FOUND		  - True if liblzma is found.
		LIBLZMA_INCLUDE_DIRS	  - Directory where liblzma headers are located.
		LIBLZMA_LIBRARIES	  - Lzma libraries to link against.
		LIBLZMA_HAS_AUTO_DECODER  - True if lzma_auto_decoder() is found (required).
		LIBLZMA_HAS_EASY_ENCODER  - True if lzma_easy_encoder() is found (required).
		LIBLZMA_HAS_LZMA_PRESET   - True if lzma_lzma_preset() is found (required).

       FindLibXslt
	      Try to find LibXslt

	      Once done this will define

		LIBXSLT_FOUND - system has LibXslt
		LIBXSLT_INCLUDE_DIR - the LibXslt include directory
		LIBXSLT_LIBRARIES - Link these to LibXslt
		LIBXSLT_DEFINITIONS - Compiler switches required for using LibXslt
		LIBXSLT_XSLTPROC_EXECUTABLE - path to the xsltproc tool

       FindLibintl

	      Try to find Libintl functionality Once done this will define

		LIBINTL_FOUND - system has Libintl
		LIBINTL_INCLUDE_DIR - Libintl include directory
		LIBINTL_LIBRARIES - Libraries needed to use Libintl

	      TODO: This will enable translations only if Gettext  functionality  is  present  in
	      libc.  Must  have  more  robust system for release, where Gettext functionality can
	      also reside in standalone Gettext library, or the one embedded within kdelibs  (cf.
	      gettext.m4 from Gettext source).

       FindLibraryWithDebug

		FIND_LIBRARY_WITH_DEBUG
		-> enhanced FIND_LIBRARY to allow the search for an
		   optional debug library with a WIN32_DEBUG_POSTFIX similar
		   to CMAKE_DEBUG_POSTFIX when creating a shared lib
		   it has to be the second and third argument

       FindLinuxWirelesstools
	      Try to find wireless extensions support libraries

	      Once done this will define

		IW_FOUND - system has IW
		IW_INCLUDE_DIR - the IW include directory
		IW_LIBRARIES - Link to these to use IW

       FindMsgfmt
	      Try to find msgfmt

	      Once done this will define

		MSGFMT_FOUND - system has msgfmt

       FindMusicBrainz

	      Module to find the musicbrainz library

	      It defines

		MUSICBRAINZ_INCLUDE_DIR - the include dir
		MUSICBRAINZ_LIBRARIES - the required libraries
		MUSICBRAINZ_FOUND - true if both of the above have been found

       FindMySQL
	      Try to find MySQL / MySQL Embedded library

	      Find the MySQL includes and client library This module defines

		MYSQL_INCLUDE_DIR, where to find mysql.h
		MYSQL_LIBRARIES, the libraries needed to use MySQL.
		MYSQL_LIB_DIR, path to the MYSQL_LIBRARIES
		MYSQL_EMBEDDED_LIBRARIES, the libraries needed to use MySQL Embedded.
		MYSQL_EMBEDDED_LIB_DIR, path to the MYSQL_EMBEDDED_LIBRARIES
		MYSQL_FOUND, If false, do not try to use MySQL.
		MYSQL_EMBEDDED_FOUND, If false, do not try to use MySQL Embedded.

       FindNepomuk

	      Once done this will define

		NEPOMUK_FOUND - system has Nepomuk
		NEPOMUK_INCLUDE_DIRS - all include directories needed to compile Nepomuk
		NEPOMUK_INCLUDE_DIR - the Nepomuk include directory (do not use. only for compatibility)
		NEPOMUK_LIBRARIES - Link these to use Nepomuk
		NEPOMUK_QUERY_LIBRARIES - Link these to use Nepomuk query
		NEPOMUK_UTILS_LIBRARIES - Link these to use Nepomuk utils
		NEPOMUK_DEFINITIONS - Compiler switches required for using Nepomuk

	      Nepomuk requires Soprano, so this module checks for Soprano too.

       FindNetworkManager
	      Try to find NetworkManager

	      Once done this will define

		NETWORKMANAGER_FOUND - system has NetworkManager
		NETWORKMANAGER_INCLUDE_DIRS - the NetworkManager include directories
		NETWORKMANAGER_LIBRARIES - the libraries needed to use NetworkManager
		NETWORKMANAGER_CFLAGS - Compiler switches required for using NetworkManager
		NETWORKMANAGER_VERSION - version number of NetworkManager

       FindOggVorbis
	      Try to find the OggVorbis libraries

	      Once done this will define

		OGGVORBIS_FOUND - system has OggVorbis
		OGGVORBIS_VERSION - set either to 1 or 2
		OGGVORBIS_INCLUDE_DIR - the OggVorbis include directory
		OGGVORBIS_LIBRARIES - The libraries needed to use OggVorbis
		OGG_LIBRARY	    - The Ogg library
		VORBIS_LIBRARY	    - The Vorbis library
		VORBISFILE_LIBRARY  - The VorbisFile library
		VORBISENC_LIBRARY   - The VorbisEnc library

       FindOpenEXR

	      Try to find the OpenEXR libraries This check defines:

		OPENEXR_FOUND - system has OpenEXR
		OPENEXR_INCLUDE_DIR - OpenEXR include directory
		OPENEXR_LIBRARIES - Libraries needed to use OpenEXR
		OPENEXR_DEFINITIONS - definitions required to use OpenEXR

       FindPCRE
	      Try to find the PCRE regular expression library

	      Once done this will define

		PCRE_FOUND - system has the PCRE library
		PCRE_INCLUDE_DIR - the PCRE include directory
		PCRE_LIBRARIES - The libraries needed to use PCRE

       FindPhonon

	      Find libphonon Once done this will define

		PHONON_FOUND	- system has Phonon Library
		PHONON_INCLUDES - the Phonon include directory
		PHONON_LIBS	- link these to use Phonon
		PHONON_VERSION	- the version of the Phonon Library

       FindPolkitQt-1
	      Try to find PolkitQt-1

	      Once done this will define

		POLKITQT-1_FOUND - system has Polkit-qt
		POLKITQT-1_INCLUDE_DIR - the Polkit-qt include directory
		POLKITQT-1_LIBRARIES - Link these to use all Polkit-qt libs
		POLKITQT-1_CORE_LIBRARY - Link this to use the polkit-qt-core library only
		POLKITQT-1_GUI_LIBRARY - Link this to use GUI elements in polkit-qt (polkit-qt-gui)
		POLKITQT-1_AGENT_LIBRARY - Link this to use the agent wrapper in polkit-qt
		POLKITQT-1_DEFINITIONS - Compiler switches required for using Polkit-qt

	      The minimum required version of PolkitQt-1 can be specified using the standard syn-
	      tax, e.g. find_package(PolkitQt-1 1.0)

       FindPolkitQt
	      Try to find Polkit-qt

	      Once done this will define

		POLKITQT_FOUND - system has Polkit-qt
		POLKITQT_INCLUDE_DIR - the Polkit-qt include directory
		POLKITQT_LIBRARIES - Link these to use all Polkit-qt libs
		POLKITQT_CORE_LIBRARY - Link this to use the polkit-qt-core library only
		POLKITQT_GUI_LIBRARY - Link this to use GUI elements in polkit-qt (polkit-qt-gui)
		POLKITQT_DEFINITIONS - Compiler switches required for using Polkit-qt
		POLKITQT_POLICY_FILES_INSTALL_DIR - The directory where policy files should be installed to.

	      The minimum required version of PolkitQt can be specified using the  standard  syn-
	      tax,  e.g.  find_package(PolkitQt  1.0) For compatibility, this can also be done by
	      setting the POLKITQT_MIN_VERSION variable.

       FindPopplerQt4
	      Try to find the Qt4 binding of the Poppler library

	      Once done this will define

		POPPLER_QT4_FOUND - system has poppler-qt4
		POPPLER_QT4_INCLUDE_DIR - the poppler-qt4 include directory
		POPPLER_QT4_LIBRARIES - Link these to use poppler-qt4
		POPPLER_QT4_DEFINITIONS - Compiler switches required for using poppler-qt4

       FindPostgreSQL
	      Find PostgreSQL

	      Find the PostgreSQL includes and client library This module defines

		POSTGRESQL_INCLUDE_DIR, where to find POSTGRESQL.h
		POSTGRESQL_LIBRARIES, the libraries needed to use POSTGRESQL.
		POSTGRESQL_FOUND, If false, do not try to use PostgreSQL.

       FindPulseAudio

	      Try to find the PulseAudio library

	      Once done this will define:

		PULSEAUDIO_FOUND - system has the PulseAudio library
		PULSEAUDIO_INCLUDE_DIR - the PulseAudio include directory
		PULSEAUDIO_LIBRARY - the libraries needed to use PulseAudio
		PULSEAUDIO_MAINLOOP_LIBRARY - the libraries needed to use PulsAudio Mainloop

	      The minimum required version of PulseAudio can be specified using the standard syn-
	      tax, e.g. find_package(PulseAudio 1.0)

       FindPyKDE4

	      FindPyKDE4

	      Checks that Python and PyKDE4 are installed and defines a couple macros:

		   * PYKDE4_INSTALL_PYTHON_FILES
		   * PYKDE4_ADD_UI_FILES
		   * PYKDE4_ADD_EXECUTABLE

       FindPyQt4

	      Find  PyQt4 ~~~~~~~~~~ Copyright (c) 2007-2008, Simon Edwards <simon@simonzone.com>
	      Redistribution and use is allowed according to the terms of the  BSD  license.  For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

	      PyQt4 website: http://www.riverbankcomputing.co.uk/pyqt/index.php

	      Find  the  installed version of PyQt4. FindPyQt4 should only be called after Python
	      has been found.

	      This file defines the following variables:

	      PYQT4_VERSION - The version of PyQt4 found expressed as a 6 digit hex number

		   suitable for comparison as a string

	      PYQT4_VERSION_STR - The version of PyQt4 as a human readable string.

	      PYQT4_VERSION_TAG - The PyQt version tag using by PyQt's sip files.

	      PYQT4_SIP_DIR - The directory holding the PyQt4 .sip files.

	      PYQT4_SIP_FLAGS - The SIP flags used to build PyQt.

       FindPythonLibrary

	      Find Python ~~~~~~~~~~~ Find the Python interpreter and related Python directories.

	      This file defines the following variables:

	      PYTHON_EXECUTABLE - The path and filename of the Python interpreter.

	      PYTHON_SHORT_VERSION - The version of the Python interpreter found,

		   excluding the patch version number. (e.g. 2.5 and not 2.5.1))

	      PYTHON_LONG_VERSION - The version of the Python interpreter found as a human

		   readable string.

	      PYTHON_SITE_PACKAGES_INSTALL_DIR - this cache variable can be used for installing

					    own python modules. You may want to adjust this to be the
					    same as ${PYTHON_SITE_PACKAGES_DIR}, but then admin
					    privileges may be required for installation.

	      PYTHON_SITE_PACKAGES_DIR - Location of the Python site-packages directory.

	      PYTHON_INCLUDE_PATH - Directory holding the python.h include file.

	      PYTHON_LIBRARY, PYTHON_LIBRARIES- Location of the Python library.

       FindQCA2
	      Try to find QCA2 (Qt Cryptography Architecture 2)

	      Once done this will define

		QCA2_FOUND - system has QCA2
		QCA2_INCLUDE_DIR - the QCA2 include directory
		QCA2_LIBRARIES - the libraries needed to use QCA2
		QCA2_DEFINITIONS - Compiler switches required for using QCA2

	      use pkg-config to get the directories and then use these values in the  FIND_PATH()
	      and FIND_LIBRARY() calls

       FindQImageBlitz
	      Try to find the qimageblitz lib

	      Once done this will define

		QIMAGEBLITZ_FOUND - system has qimageblitz lib
		QIMAGEBLITZ_INCLUDES - the qimageblitz include directory
		QIMAGEBLITZ_LIBRARIES - The libraries needed to use qimageblitz

       FindQt4
	      Find QT 4

	      This module can be used to find Qt4. The most important issue is that the Qt4 qmake
	      is available via the system path. This qmake  is	then  used  to	detect	basically
	      everything  else.  This  module  defines a number of key variables and macros.  The
	      variable QT_USE_FILE is set which is the path to a CMake file that can be  included
	      to compile Qt 4 applications and libraries.  It sets up the compilation environment
	      for include directories, preprocessor defines and populates  a  QT_LIBRARIES  vari-
	      able.

	      Typical usage could be something like:

		 find_package(Qt4 4.4.3 COMPONENTS QtCore QtGui QtXml REQUIRED )
		 include(${QT_USE_FILE})
		 add_executable(myexe main.cpp)
		 target_link_libraries(myexe ${QT_LIBRARIES})

	      The  minimum  required  version  can  be	specified  using  the standard find_pack-
	      age()-syntax (see  example  above).   For  compatibility	with  older  versions  of
	      FindQt4.cmake it is also possible to set the variable QT_MIN_VERSION to the minimum
	      required version of Qt4 before the  find_package(Qt4) command.  If both  are  used,
	      the  version  used in the find_package() command overrides the one from QT_MIN_VER-
	      SION.

	      When using the components argument, QT_USE_QT* variables are automatically set  for
	      the QT_USE_FILE to pick up.  If one wishes to manually set them, the available ones
	      to set include:

				  QT_DONT_USE_QTCORE
				  QT_DONT_USE_QTGUI
				  QT_USE_QT3SUPPORT
				  QT_USE_QTASSISTANT
				  QT_USE_QAXCONTAINER
				  QT_USE_QAXSERVER
				  QT_USE_QTDESIGNER
				  QT_USE_QTMOTIF
				  QT_USE_QTMAIN
				  QT_USE_QTMULTIMEDIA
				  QT_USE_QTNETWORK
				  QT_USE_QTNSPLUGIN
				  QT_USE_QTOPENGL
				  QT_USE_QTSQL
				  QT_USE_QTXML
				  QT_USE_QTSVG
				  QT_USE_QTTEST
				  QT_USE_QTUITOOLS
				  QT_USE_QTDBUS
				  QT_USE_QTSCRIPT
				  QT_USE_QTASSISTANTCLIENT
				  QT_USE_QTHELP
				  QT_USE_QTWEBKIT
				  QT_USE_QTXMLPATTERNS
				  QT_USE_PHONON
				  QT_USE_QTSCRIPTTOOLS
				  QT_USE_QTDECLARATIVE

		QT_USE_IMPORTED_TARGETS
		      If this variable is set to TRUE, FindQt4.cmake will create imported
		      library targets for the various Qt libraries and set the
		      library variables like QT_QTCORE_LIBRARY to point at these imported
		      targets instead of the library file on disk. This provides much better
		      handling of the release and debug versions of the Qt libraries and is
		     also always backwards compatible, except for the case that dependencies
		     of libraries are exported, these will then also list the names of the
		     imported targets as dependency and not the file location on disk. This
		     is much more flexible, but requires that FindQt4.cmake is executed before
		     such an exported dependency file is processed.

	      There are also some files that need processing by some Qt tools  such  as  moc  and
	      uic.  Listed below are macros that may be used to process those files.

		macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
		      create moc code from a list of files containing Qt class with
		      the Q_OBJECT declaration.  Per-direcotry preprocessor definitions
		      are also added.  Options may be given to moc, such as those found
		      when executing "moc -help".

		macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
		      create code from a list of Qt designer ui files.
		      Options may be given to uic, such as those found
		      when executing "uic -help"

		macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
		      create code from a list of Qt resource files.
		      Options may be given to rcc, such as those found
		      when executing "rcc -help"

		macro QT4_GENERATE_MOC(inputfile outputfile )
		      creates a rule to run moc on infile and create outfile.
		      Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
		      because you need a custom filename for the moc file or something similar.

		macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... )
		      This macro is still experimental.
		      It can be used to have moc automatically handled.
		      So if you have the files foo.h and foo.cpp, and in foo.h a
		      a class uses the Q_OBJECT macro, moc has to run on it. If you don't
		      want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
		      #include "foo.moc"
		      in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
		      scan all listed files at cmake-time for such included moc files and if it finds
		      them cause a rule to be generated to run moc at build time on the
		      accompanying header file foo.h.
		      If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.

		macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
		      create a the interface header and implementation files with the
		      given basename from the given interface xml file and add it to
		      the list of sources.
		      To disable generating a namespace header, set the source file property
		      NO_NAMESPACE to TRUE on the interface file.
		      To include a header in the interface header, set the source file property
		      INCLUDE to the name of the header.
		      To specify a class name to use, set the source file property CLASSNAME
		      to the name of the class.

		macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
		      create the interface header and implementation files
		      for all listed interface xml files
		      the name will be automatically determined from the name of the xml file
		      To disable generating namespace headers, set the source file property
		      NO_NAMESPACE to TRUE for these inputfiles.
		      To include a header in the interface header, set the source file property
		      INCLUDE to the name of the header.
		      To specify a class name to use, set the source file property CLASSNAME
		      to the name of the class.

		macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] [classname])
		      create a dbus adaptor (header and implementation file) from the xml file
		      describing the interface, and add it to the list of sources. The adaptor
		      forwards the calls to a parent class, defined in parentheader and named
		      parentclassname. The name of the generated files will be
		      <basename>adaptor.{cpp,h} where basename defaults to the basename of the xml file.
		      If <classname> is provided, then it will be used as the classname of the
		      adaptor itself.

		macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] OPTIONS ...)
		      generate the xml interface file from the given header.
		      If the optional argument interfacename is omitted, the name of the
		      interface file is constructed from the basename of the header with
		      the suffix .xml appended.
		      Options may be given to qdbuscpp2xml, such as those found when executing "qdbuscpp2xml --help"

		macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ...
					      ts_files ... OPTIONS ...)
		      out: qm_files
		      in:  directories sources ts_files
		      options: flags to pass to lupdate, such as -extensions to specify
		      extensions for a directory scan.
		      generates commands to create .ts (vie lupdate) and .qm
		      (via lrelease) - files from directories and/or sources. The ts files are
		      created and/or updated in the source tree (unless given with full paths).
		      The qm files are generated in the build tree.
		      Updating the translations can be done by adding the qm_files
		      to the source list of your library/executable, so they are
		      always updated, or by adding a custom target to control when
		      they get updated/generated.

		macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
		      out: qm_files
		      in:  ts_files
		      generates commands to create .qm from .ts - files. The generated
		      filenames can be found in qm_files. The ts_files
		      must exists and are not updated in any way.

		Below is a detailed list of variables that FindQt4.cmake sets.
		QT_FOUND	 If false, don't try to use Qt.
		QT4_FOUND	 If false, don't try to use Qt 4.

		QT_VERSION_MAJOR The major version of Qt found.
		QT_VERSION_MINOR The minor version of Qt found.
		QT_VERSION_PATCH The patch version of Qt found.

		QT_EDITION		 Set to the edition of Qt (i.e. DesktopLight)
		QT_EDITION_DESKTOPLIGHT  True if QT_EDITION == DesktopLight
		QT_QTCORE_FOUND 	 True if QtCore was found.
		QT_QTGUI_FOUND		 True if QtGui was found.
		QT_QT3SUPPORT_FOUND	 True if Qt3Support was found.
		QT_QTASSISTANT_FOUND	 True if QtAssistant was found.
		QT_QTASSISTANTCLIENT_FOUND  True if QtAssistantClient was found.
		QT_QAXCONTAINER_FOUND	 True if QAxContainer was found (Windows only).
		QT_QAXSERVER_FOUND	 True if QAxServer was found (Windows only).
		QT_QTDBUS_FOUND 	 True if QtDBus was found.
		QT_QTDESIGNER_FOUND	 True if QtDesigner was found.
		QT_QTDESIGNERCOMPONENTS  True if QtDesignerComponents was found.
		QT_QTHELP_FOUND 	 True if QtHelp was found.
		QT_QTMOTIF_FOUND	 True if QtMotif was found.
		QT_QTMULTIMEDIA_FOUND	 True if QtMultimedia was found (since Qt 4.6.0).
		QT_QTNETWORK_FOUND	 True if QtNetwork was found.
		QT_QTNSPLUGIN_FOUND	 True if QtNsPlugin was found.
		QT_QTOPENGL_FOUND	 True if QtOpenGL was found.
		QT_QTSQL_FOUND		 True if QtSql was found.
		QT_QTSVG_FOUND		 True if QtSvg was found.
		QT_QTSCRIPT_FOUND	 True if QtScript was found.
		QT_QTSCRIPTTOOLS_FOUND	 True if QtScriptTools was found.
		QT_QTTEST_FOUND 	 True if QtTest was found.
		QT_QTUITOOLS_FOUND	 True if QtUiTools was found.
		QT_QTWEBKIT_FOUND	 True if QtWebKit was found.
		QT_QTXML_FOUND		 True if QtXml was found.
		QT_QTXMLPATTERNS_FOUND	 True if QtXmlPatterns was found.
		QT_PHONON_FOUND 	 True if phonon was found.
		QT_QTDECLARATIVE_FOUND	 True if QtDeclarative was found.

		QT_MAC_USE_COCOA    For Mac OS X, its whether Cocoa or Carbon is used.
				    In general, this should not be used, but its useful
				    when having platform specific code.

		QT_DEFINITIONS	 Definitions to use when compiling code that uses Qt.
				 You do not need to use this if you include QT_USE_FILE.
				 The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
				 to fit your current build type.  Those are not contained
				 in QT_DEFINITIONS.

		QT_INCLUDES	 List of paths to all include directories of
				 Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
				 always in this variable even if NOTFOUND,
				 all other INCLUDE_DIRS are
				 only added if they are found.
				 You do not need to use this if you include QT_USE_FILE.

		Include directories for the Qt modules are listed here.
		You do not need to use these variables if you include QT_USE_FILE.

		QT_INCLUDE_DIR		    Path to "include" of Qt4
		QT_QT_INCLUDE_DIR	    Path to "include/Qt"
		QT_QT3SUPPORT_INCLUDE_DIR   Path to "include/Qt3Support"
		QT_QTASSISTANT_INCLUDE_DIR  Path to "include/QtAssistant"
		QT_QTASSISTANTCLIENT_INCLUDE_DIR       Path to "include/QtAssistant"
		QT_QAXCONTAINER_INCLUDE_DIR Path to "include/ActiveQt" (Windows only)
		QT_QAXSERVER_INCLUDE_DIR    Path to "include/ActiveQt" (Windows only)
		QT_QTCORE_INCLUDE_DIR	    Path to "include/QtCore"
		QT_QTDBUS_INCLUDE_DIR	    Path to "include/QtDBus"
		QT_QTDESIGNER_INCLUDE_DIR   Path to "include/QtDesigner"
		QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR   Path to "include/QtDesigner"
		QT_QTGUI_INCLUDE_DIR	    Path to "include/QtGui"
		QT_QTHELP_INCLUDE_DIR	    Path to "include/QtHelp"
		QT_QTMOTIF_INCLUDE_DIR	    Path to "include/QtMotif"
		QT_QTMULTIMEDIA_INCLUDE_DIR Path to "include/QtMultimedia"
		QT_QTNETWORK_INCLUDE_DIR    Path to "include/QtNetwork"
		QT_QTNSPLUGIN_INCLUDE_DIR   Path to "include/QtNsPlugin"
		QT_QTOPENGL_INCLUDE_DIR     Path to "include/QtOpenGL"
		QT_QTSCRIPT_INCLUDE_DIR     Path to "include/QtScript"
		QT_QTSQL_INCLUDE_DIR	    Path to "include/QtSql"
		QT_QTSVG_INCLUDE_DIR	    Path to "include/QtSvg"
		QT_QTTEST_INCLUDE_DIR	    Path to "include/QtTest"
		QT_QTWEBKIT_INCLUDE_DIR     Path to "include/QtWebKit"
		QT_QTXML_INCLUDE_DIR	    Path to "include/QtXml"
		QT_QTXMLPATTERNS_INCLUDE_DIR  Path to "include/QtXmlPatterns"
		QT_PHONON_INCLUDE_DIR	    Path to "include/phonon"
		QT_QTSCRIPTTOOLS_INCLUDE_DIR	   Path to "include/QtScriptTools"
		QT_QTDECLARATIVE_INCLUDE_DIR	   Path to "include/QtDeclarative"

		QT_BINARY_DIR		    Path to "bin" of Qt4
		QT_LIBRARY_DIR		    Path to "lib" of Qt4
		QT_PLUGINS_DIR		    Path to "plugins" for Qt4
		QT_TRANSLATIONS_DIR	    Path to "translations" of Qt4
		QT_IMPORTS_DIR		    Path to "imports" of Qt4
		QT_DOC_DIR		    Path to "doc" of Qt4
		QT_MKSPECS_DIR		    Path to "mkspecs" of Qt4

	      For every library of Qt, a QT_QTFOO_LIBRARY variable is defined, with the full path
	      to the library.

	      So there are  the  following  variables:	The  Qt3Support  library:      QT_QT3SUP-
	      PORT_LIBRARY

	      The QtAssistant library:	  QT_QTASSISTANT_LIBRARY

	      The QtAssistantClient library:  QT_QTASSISTANTCLIENT_LIBRARY

	      The QAxServer library:	  QT_QAXSERVER_LIBRARY

	      The QAxContainer library:   QT_QAXCONTAINER_LIBRARY

	      The QtCore library:	  QT_QTCORE_LIBRARY

	      The QtDBus library:	  QT_QTDBUS_LIBRARY

	      The QtDesigner library:	  QT_QTDESIGNER_LIBRARY

	      The QtDesignerComponents library:     QT_QTDESIGNERCOMPONENTS_LIBRARY

	      The QtGui library:	  QT_QTGUI_LIBRARY

	      The QtHelp library:	  QT_QTHELP_LIBRARY

	      The QtMotif library:	  QT_QTMOTIF_LIBRARY

	      The QtMultimedia library:   QT_QTMULTIMEDIA_LIBRARY

	      The QtNetwork library:	  QT_QTNETWORK_LIBRARY

	      The QtNsPLugin library:	  QT_QTNSPLUGIN_LIBRARY

	      The QtOpenGL library:	  QT_QTOPENGL_LIBRARY

	      The QtScript library:	  QT_QTSCRIPT_LIBRARY

	      The QtScriptTools library:      QT_QTSCRIPTTOOLS_LIBRARY

	      The QtSql library:	  QT_QTSQL_LIBRARY

	      The QtSvg library:	  QT_QTSVG_LIBRARY

	      The QtTest library:	  QT_QTTEST_LIBRARY

	      The QtUiTools library:	  QT_QTUITOOLS_LIBRARY

	      The QtWebKit library:	  QT_QTWEBKIT_LIBRARY

	      The QtXml library:	  QT_QTXML_LIBRARY

	      The QtXmlPatterns library:  QT_QTXMLPATTERNS_LIBRARY

	      The qtmain library for Windows QT_QTMAIN_LIBRARY

	      The Phonon library:	      QT_PHONON_LIBRARY

	      The QtDeclarative library:	     QT_QTDECLARATIVE_LIBRARY

	      also defined, but NOT for general use are

		QT_MOC_EXECUTABLE		    Where to find the moc tool.
		QT_UIC_EXECUTABLE		    Where to find the uic tool.
		QT_UIC3_EXECUTABLE		    Where to find the uic3 tool.
		QT_RCC_EXECUTABLE		    Where to find the rcc tool
		QT_DBUSCPP2XML_EXECUTABLE	    Where to find the qdbuscpp2xml tool.
		QT_DBUSXML2CPP_EXECUTABLE	    Where to find the qdbusxml2cpp tool.
		QT_LUPDATE_EXECUTABLE		    Where to find the lupdate tool.
		QT_LRELEASE_EXECUTABLE		    Where to find the lrelease tool.
		QT_QCOLLECTIONGENERATOR_EXECUTABLE  Where to find the qcollectiongenerator tool.
		QT_DESIGNER_EXECUTABLE		    Where to find the Qt designer tool.
		QT_LINGUIST_EXECUTABLE		    Where to find the Qt linguist tool.

	      These are around for backwards compatibility  they will be set

		QT_WRAP_CPP  Set true if QT_MOC_EXECUTABLE is found
		QT_WRAP_UI   Set true if QT_UIC_EXECUTABLE is found

	      These variables do _NOT_ have any effect anymore (compared to FindQt.cmake)

		QT_MT_REQUIRED	       Qt4 is now always multithreaded

	      These  variables are set to "" Because Qt structure changed  (They make no sense in
	      Qt4)

		QT_QT_LIBRARY	     Qt-Library is now split

       FindRUBY
	      Find Ruby

	      This module finds if Ruby is installed and determines where the include  files  and
	      libraries  are.  It also determines what the name of the library is. This code sets
	      the following variables:

		RUBY_LIBRARY	  = full path+file to the ruby library
		RUBY_INCLUDE_PATH = path to where ruby.h can be found
		RUBY_EXECUTABLE   = full path+file to the ruby binary
		RUBY_FOUND	  = Ruby was found under system.

       FindSIP

	      Find SIP ~~~~~~~~

	      SIP website: http://www.riverbankcomputing.co.uk/sip/index.php

	      Find the installed version of SIP. FindSIP should be called after Python	has  been
	      found.

	      This file defines the following variables:

	      SIP_VERSION - The version of SIP found expressed as a 6 digit hex number

		   suitable for comparison as a string.

	      SIP_VERSION_STR - The version of SIP found as a human readable string.

	      SIP_EXECUTABLE - Path and filename of the SIP command line executable.

	      SIP_INCLUDE_DIR - Directory holding the SIP C++ header file.

	      SIP_DEFAULT_SIP_DIR - Default directory where .sip files should be installed

		   into.

       FindSamba
	      Try to find the samba directory library

	      Once done this will define

		SAMBA_FOUND - system has SAMBA
		SAMBA_INCLUDE_DIR - the SAMBA include directory
		SAMBA_LIBRARIES - The libraries needed to use SAMBA
		Set SAMBA_REQUIRE_SMBC_SET_CONTEXT to TRUE if you need a version of Samba
		which comes with smbc_set_context()

       FindSane

	      cmake macro to test if we use sane

		SANE_FOUND - system has SANE libs
		SANE_INCLUDE_DIR - the SANE include directory
		SANE_LIBRARIES - The libraries needed to use SANE

       FindSasl2
	      Try to find the sasl2 directory library

	      Once done this will define

		SASL2_FOUND - system has SASL2
		SASL2_INCLUDE_DIR - the SASL2 include directory
		SASL2_LIBRARIES - The libraries needed to use SASL2

       FindSharedDesktopOntologies
	      Try to find shared-desktop-ontologies

	      The  shared-desktop-ontologies package is a direct dependancy of the Nepomuk seman-
	      tic desktop system and provides all necessary ontology files like RDF,  RDFS,  NRL,
	      or NIE.

	      The package is created by the OSCAF project (http://oscaf.sourceforge.net).

	      Once done this will define

		SHAREDDESKTOPONTOLOGIES_FOUND	      - system has shared-desktop-ontologies
		SHAREDDESKTOPONTOLOGIES_ROOT_DIR      - Folder where the ontologies are stored
		SHAREDDESKTOPONTOLOGIES_VERSION_MAJOR - The major version number, i.e. '1' in '1.2'
		SHAREDDESKTOPONTOLOGIES_VERSION_MINOR - The minor version number, i.e. '2' in '1.2'
		SHAREDDESKTOPONTOLOGIES_VERSION       - The complete version string, i.e. '1.2'

       FindSharedMimeInfo
	      Try to find the shared-mime-info package

	      Once done this will define

		SHAREDMIMEINFO_FOUND - system has the shared-mime-info package
		UPDATE_MIME_DATABASE_EXECUTABLE - the update-mime-database executable

	      The  minimum required version of SharedMimeInfo can be specified using the standard
	      syntax, e.g. find_package(SharedMimeInfo 0.20)

	      For backward compatibility, the following two variables are also supported:

		SHARED_MIME_INFO_FOUND - same as SHAREDMIMEINFO_FOUND
		SHARED_MIME_INFO_MINIMUM_VERSION - set to the minimum version you need, default is 0.18.
		  When both are used, i.e. the version is set in the find_package() call and
		 SHARED_MIME_INFO_MINIMUM_VERSION is set, the version specified in the find_package()
		 call takes precedence.

       FindSoprano

	      Find an installation of Soprano

	      Sets the following variables:

		Soprano_FOUND, SOPRANO_FOUND  - true is Soprano has been found
		SOPRANO_ONTO2VOCABULARYCLASS_EXECUTABLE - the onto2vocabularyclass program, required for adding ontologies
		SOPRANO_SOPRANOCMD_EXECUTABLE - the sopranocmd program
		SOPRANO_INCLUDE_DIR	 - The include directory
		SOPRANO_LIBRARIES	 - The Soprano core library to link to (libsoprano)
		SOPRANO_INDEX_LIBRARIES  - The Soprano index library (libsopranoindex)
		SOPRANO_CLIENT_LIBRARIES - The Soprano client library (libsopranoclient)
		SOPRANO_SERVER_LIBRARIES - The Soprano server library (libsopranoserver)
		SOPRANO_VERSION 	 - The Soprano version (string value)

	      SOPRANO_PLUGIN_NQUADPARSER_FOUND	    - true if the  nquadparser	plugin	is  found
	      SOPRANO_PLUGIN_NQUADSERIALIZER_FOUND  - true if the nquadserializer plugin is found
	      SOPRANO_PLUGIN_RAPTORPARSER_FOUND     - true if the raptorparser	plugin	is  found
	      SOPRANO_PLUGIN_RAPTORSERIALIZER_FOUND  -	true  if  the  raptorserializer plugin is
	      found SOPRANO_PLUGIN_REDLANDBACKEND_FOUND   - true if the redlandbackend plugin  is
	      found  SOPRANO_PLUGIN_SESAME2BACKEND_FOUND   - true if the sesame2backend plugin is
	      found SOPRANO_PLUGIN_VIRTUOSOBACKEND_FOUND  - true if the virtuosobackend plugin is
	      found

	      Options:

		Set SOPRANO_MIN_VERSION to set the minimum required Soprano version (default: 1.99)

	      FindSoprano.cmake  supports  the	COMPONENTS  keyword  of  find_package().  If  the
	      REQUIRED keyword is used and any of the specified components have not  been  found,
	      SOPRANO_FOUND will be set to FALSE.

	      The following components are supported:

		 PLUGIN_NQUADPARSER
		 PLUGIN_NQUADSERIALIZER
		 PLUGIN_RAPTORPARSER
		 PLUGIN_RAPTORSERIALIZER
		 PLUGIN_REDLANDBACKEND
		 PLUGIN_SESAME2BACKEND
		 PLUGIN_VIRTUOSOBACKEND

       FindSqlite
	      Try to find Sqlite

	      Once done this will define

		SQLITE_FOUND - system has Sqlite
		SQLITE_INCLUDE_DIR - the Sqlite include directory
		SQLITE_LIBRARIES - Link these to use Sqlite
		SQLITE_DEFINITIONS - Compiler switches required for using Sqlite

	      Redistribution  and  use	is allowed according to the terms of the BSD license. For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

       FindStrigi
	      Try to find Strigi, a fast and small desktop search program  (http://strigi.source-
	      forge.net )

	      Once done this will define

		STRIGI_FOUND - system has Strigi
		STRIGI_INCLUDE_DIRS - the Strigi include directories
		STRIGI_STREAMANALYZER_LIBRARY - Link these to use Strigi streamanalyzer
		STRIGI_STREAMS_LIBRARY - Link these to use Strigi streams
		STRIGI_LINE_ANALYZER_PREFIX - strigi plugin prefix
		STRIGI_THROUGH_ANALYZER_PREFIX - strigi plugin prefix

	      The following variable is set for source compatibility purpose.

		STRIGI_INCLUDE_DIR - the Strigi include directory

	      Copyright (c) 2008, Jos van den Oever, <jos@vandenoever.info>

	      Redistribution  and  use	is allowed according to the terms of the BSD license. For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

       FindTaglib
	      Try to find the Taglib library

	      Once done this will define

		TAGLIB_FOUND - system has the taglib library
		TAGLIB_CFLAGS - the taglib cflags
		TAGLIB_LIBRARIES - The libraries needed to use taglib

       FindUDev
	      Try to find UDev

	      Once done this will define

		UDEV_FOUND - system has UDev
		UDEV_INCLUDE_DIR - the libudev include directory
		UDEV_LIBS - The libudev libraries

       FindUSB
	      Try to find the freetype library

	      Once done this defines

		LIBUSB_FOUND - system has libusb
		LIBUSB_INCLUDE_DIR - the libusb include directory
		LIBUSB_LIBRARIES - Link these to use libusb

       FindWcecompat

	      Try to find Wcecompat functionality Once done this will define

		WCECOMPAT_FOUND - system has Wcecompat
		WCECOMPAT_INCLUDE_DIR - Wcecompat include directory
		WCECOMPAT_LIBRARIES - Libraries needed to use Wcecompat

	      Copyright (c) 2010, Andreas Holzammer, <andy@kdab.com>

	      Redistribution and use is allowed according to the terms of the BSD license.

       FindX11
	      Find X11 installation

	      Try to find X11 on UNIX systems. The following values are defined

		X11_FOUND	 - True if X11 is available
		X11_INCLUDE_DIR  - include directories to use X11
		X11_LIBRARIES	 - link against these to use X11

	      and also the following more fine grained variables:

			      X11_ICE_INCLUDE_PATH,	     X11_ICE_LIB,	 X11_ICE_FOUND
			      X11_SM_INCLUDE_PATH,	     X11_SM_LIB,	 X11_SM_FOUND
			      X11_X11_INCLUDE_PATH,	     X11_X11_LIB
			      X11_Xaccessrules_INCLUDE_PATH,			 X11_Xaccess_FOUND
			      X11_Xaccessstr_INCLUDE_PATH,			 X11_Xaccess_FOUND
			      X11_Xau_INCLUDE_PATH,	     X11_Xau_LIB,	 X11_Xau_FOUND
			      X11_Xcomposite_INCLUDE_PATH,   X11_Xcomposite_LIB, X11_Xcomposite_FOUND
			      X11_Xcursor_INCLUDE_PATH,      X11_Xcursor_LIB,	 X11_Xcursor_FOUND
			      X11_Xdamage_INCLUDE_PATH,      X11_Xdamage_LIB,	 X11_Xdamage_FOUND
			      X11_Xdmcp_INCLUDE_PATH,	     X11_Xdmcp_LIB,	 X11_Xdmcp_FOUND
							     X11_Xext_LIB,	 X11_Xext_FOUND
			      X11_dpms_INCLUDE_PATH,	     (in X11_Xext_LIB),  X11_dpms_FOUND
			      X11_XShm_INCLUDE_PATH,	     (in X11_Xext_LIB),  X11_XShm_FOUND
			      X11_Xshape_INCLUDE_PATH,	     (in X11_Xext_LIB),  X11_Xshape_FOUND
			      X11_xf86misc_INCLUDE_PATH,     X11_Xxf86misc_LIB,  X11_xf86misc_FOUND
			      X11_xf86vmode_INCLUDE_PATH,			 X11_xf86vmode_FOUND
			      X11_Xfixes_INCLUDE_PATH,	     X11_Xfixes_LIB,	 X11_Xfixes_FOUND
			      X11_Xft_INCLUDE_PATH,	     X11_Xft_LIB,	 X11_Xft_FOUND
			      X11_Xinerama_INCLUDE_PATH,     X11_Xinerama_LIB,	 X11_Xinerama_FOUND
			      X11_Xinput_INCLUDE_PATH,	     X11_Xinput_LIB,	 X11_Xinput_FOUND
			      X11_Xkb_INCLUDE_PATH,				 X11_Xkb_FOUND
			      X11_Xkblib_INCLUDE_PATH,				 X11_Xkb_FOUND
			      X11_Xkbfile_INCLUDE_PATH,      X11_Xkbfile_LIB,	 X11_Xkbfile_FOUND
			      X11_Xpm_INCLUDE_PATH,	     X11_Xpm_LIB,	 X11_Xpm_FOUND
			      X11_XTest_INCLUDE_PATH,	     X11_XTest_LIB,	 X11_XTest_FOUND
			      X11_Xrandr_INCLUDE_PATH,	     X11_Xrandr_LIB,	 X11_Xrandr_FOUND
			      X11_Xrender_INCLUDE_PATH,      X11_Xrender_LIB,	 X11_Xrender_FOUND
			      X11_Xscreensaver_INCLUDE_PATH, X11_Xscreensaver_LIB, X11_Xscreensaver_FOUND
			      X11_Xt_INCLUDE_PATH,	     X11_Xt_LIB,	 X11_Xt_FOUND
			      X11_Xutil_INCLUDE_PATH,				 X11_Xutil_FOUND
			      X11_Xv_INCLUDE_PATH,	     X11_Xv_LIB,	 X11_Xv_FOUND
			      X11_XSync_INCLUDE_PATH,	     (in X11_Xext_LIB),  X11_XSync_FOUND

       FindXine
	      Try to find the XINE  library

	      Once done this will define

		XINE_FOUND - system has the XINE library
		XINE_VERSION - XINE version
		XINE_BUGFIX_VERSION - the XINE bugfix version
		XINE_INCLUDE_DIR - the XINE include directory
		XINE_LIBRARY - The libraries needed to use XINE
		XINE_XCB_FOUND - libxine can use XCB for video output

       FindXmms

	      Search xmms Once done this will define

		XMMS_FOUND	  - system has xmms
		XMMS_INCLUDE_DIRS - the xmms include directory
		XMMS_LIBRARIES	  - Link these to use xmms
		XMMS_LDFLAGS	  - for compatibility only, same as XMMS_LIBRARIES

       KDE4Macros

	      for documentation look at FindKDE4Internal.cmake

       MacroAddCompileFlags
	      MACRO_ADD_COMPILE_FLAGS(<_target> "flags...")

       MacroAddLinkFlags
	      MACRO_ADD_LINK_FLAGS(<_target> "flags...")

       MacroAdditionalCleanFiles
	      MACRO_ADDITIONAL_CLEAN_FILES(files...)

	      MACRO_OPTIONAL_FIND_PACKAGE( <name> [QUIT] )

       MacroAppendIf

	      MACRO_APPEND_IF(CONDITION VAR VALUE1...VALUEN ) This convenience macro appends  the
	      values  VALUE1 up to VALUEN to the list given in VAR, but only if the variable CON-
	      DITION is TRUE:

	      usage example: IF(SOMELIB_FOUND)

		 SET(my_sources ${my_sources} somefile.c someotherfile.c)

	      ENDIF(SOMELIB_FOUND)

	      becomes: MACRO_APPEND_IF(SOMELIB_FOUND  my_sources  somefile.c someotherfile.c)

       MacroBoolTo01

	      MACRO_BOOL_TO_01( VAR RESULT0 ... RESULTN ) This macro evaluates its first argument
	      and  sets  all  the  given  vaiables either to 0 or 1 depending on the value of the
	      first one

       MacroEnsureOutOfSourceBuild
	      MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)

	      MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)

		  Call this macro in your project if you want to enforce out-of-source builds.
		  If an in-source build is detected, it will abort with the given error message.
		  This macro works in any of the CMakeLists.txt of your project, but the recommended
		  location to call this is close to the beginning of the top level CMakeLists.txt

       MacroEnsureVersion

	      This file defines the following macros for  developers  to  use  in  ensuring  that
	      installed software is of the right version:

	      MACRO_ENSURE_VERSION	  - test that a version number is greater than

					     or equal to some minimum

	      MACRO_ENSURE_VERSION_RANGE - test that a version number is greater than

					     or equal to some minimum and less than some
					     maximum

	      MACRO_ENSURE_VERSION2	  - deprecated, do not use in new code

       MacroLibrary
	      include  MacroLibrary offers a collection of macros which extend the built-in cmake
	      commands

       MacroLogFeature

	      This file defines the Feature Logging macros.

	      MACRO_LOG_FEATURE(VAR FEATURE DESCRIPTION URL [REQUIRED [MIN_VERSION [COMMENTS]]])

		 Logs the information so that it can be displayed at the end
		 of the configure run
		 VAR : TRUE or FALSE, indicating whether the feature is supported
		 FEATURE: name of the feature, e.g. "libjpeg"
		 DESCRIPTION: description what this feature provides
		 URL: home page
		 REQUIRED: TRUE or FALSE, indicating whether the feature is required
		 MIN_VERSION: minimum version number. empty string if unneeded
		 COMMENTS: More info you may want to provide.  empty string if unnecessary

	      MACRO_DISPLAY_FEATURE_LOG()

		 Call this to display the collected results.
		 Exits CMake with a FATAL error message if a required feature is missing

	      Example:

	      INCLUDE(MacroLogFeature)

	      FIND_PACKAGE(JPEG) MACRO_LOG_FEATURE(JPEG_FOUND  "libjpeg"  "Support  JPEG  images"
	      "http://www.ijg.org" TRUE "3.2a" "") ... MACRO_DISPLAY_FEATURE_LOG()

       MacroOptionalAddSubdirectory
	      MACRO_OPTIONAL_ADD_SUBDIRECTORY() combines ADD_SUBDIRECTORY() with an OPTION()

	      MACRO_OPTIONAL_ADD_SUBDIRECTORY(	<dir>  )  If you use MACRO_OPTIONAL_ADD_SUBDIREC-
	      TORY() instead of ADD_SUBDIRECTORY(), this will have two effects 1 - CMake will not
	      complain if the directory doesn't exist

		   This makes sense if you want to distribute just one of the subdirs
		   in a source package, e.g. just one of the subdirs in kdeextragear.

	      2 - If the directory exists, it will offer an option to skip the

		   subdirectory.
		   This is useful if you want to compile only a subset of all
		   directories.

	      If  the  CMake  variable DISABLE_ALL_OPTIONAL_SUBDIRECTORIES is set to TRUE for the
	      first CMake run on the project, all optional subdirectories  will  be  disabled  by
	      default (but can of course be enabled via the respective options). E.g. the follow-
	      ing will disable all optional subdirectories except the one named "kcalc":

		 $ cmake -DDISABLE_ALL_OPTIONAL_SUBDIRECTORIES=TRUE -DBUILD_kcalc=TRUE <srcdir>

       MacroOptionalDependPackage

	      Search if cmake module is installed in computer cmake will not fail but signal that
	      we  must	install  depend  package  before.  add as previously name of cmake module
	      "_name"  and  define  package  needed  "_module_needed"  if   return   DEPEND_PACK-
	      AGE_${_name}

       MacroOptionalFindPackage
	      MACRO_OPTIONAL_FIND_PACKAGE() combines FIND_PACKAGE() with an OPTION()

	      MACRO_OPTIONAL_FIND_PACKAGE(  <name>  [QUIT]  )  This  macro  is	a  combination of
	      OPTION() and FIND_PACKAGE(), it works  like  FIND_PACKAGE(),  but  additionally  it
	      automatically  creates  an  option  name WITH_<name>, which can be disabled via the
	      cmake GUI. or via -DWITH_<name>=OFF The standard <name>_FOUND variables can be used
	      in the same way as when using the normal FIND_PACKAGE()

       MacroPushRequiredVars

	      this     module	  defines     two    macros:	MACRO_PUSH_REQUIRED_VARS()    and
	      MACRO_POP_REQUIRED_VARS() use these if you call cmake macros which use any  of  the
	      CMAKE_REQUIRED_XXX variables

	      Usage:	       MACRO_PUSH_REQUIRED_VARS()	   SET(CMAKE_REQUIRED_DEFINITIONS
	      ${CMAKE_REQUIRED_DEFINITIONS}	 -DSOME_MORE_DEF)      CHECK_FUNCTION_EXISTS(...)
	      MACRO_POP_REQUIRED_VARS()

       MacroWriteBasicCMakeVersionFile

		MACRO_WRITE_BASIC_CMAKE_VERSION_FILE( _filename _major _minor _patch)
		  Writes a file for use as <package>ConfigVersion.cmake file to <_filename>.
		  See the documentation of FIND_PACKAGE() for details on this.
		  _filename is the output filename, it should be in the build tree.
		  _major is the major version number of the project to be installed
		  _minor is the minor version number of the project to be installed
		  _patch is the patch version number of the project to be installed

       NepomukAddOntologyClasses

	      Use the Nepomuk resource class generator to generate convinient Resource subclasses
	      from ontologies.

	      Usage:

		 NEPOMUK_ADD_ONTOLOGY_CLASSES(<sources-var>
		       [FAST]
		       [ONTOLOGIES] <onto-file1> [<onto-file2> ...]
		       [CLASSES <class1> [<class2> ...]]
		       [VISIBILITY <visibility-name>]
		     )

	      If FAST is specified the rcgen parameter --fast  will  be  used  which  results  in
	      resource	classes  not  based on Nepomuk::Resource but on a custom class which does
	      not perform any checks and simply writes the data to Nepomuk (hence the name fast).

	      The optional CLASSES parameter allows to specify the classes to be  generated  (RDF
	      URIs) in case one does not want all classes in the ontologies to be generated.

	      The  optional  VISIBILITY parameter can only be used in non-fast mode and allows to
	      set the gcc visibility to  make  the  generated  classes	usable	in  a  publically
	      exported	API. The <visibility-name> is used to create the name of the export macro
	      and the export include file. Thus, when  using  "VISIBILITY  foobar"  include  file
	      "foobar_export.h" needs to define FOOBAR_EXPORT.

	      Copyright (c) 2009 Sebastian Trueg <trueg@kde.org>

	      Redistribution  and  use	is allowed according to the terms of the BSD license. For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

       NepomukMacros

	      This file contains the following macros:

	      NEPOMUK_GENERATE_FROM_ONTOLOGY Parameters:

		 ontofile     - Path to the NRL ontology defining the resources to be generated.
		 targetdir    - Folder to which the generated sources should be written.
		 out_headers  - Variable which will be filled with the names of all generated headers.
		 out_sources  - Variable which will be filled with the names of all generated sources.
		 out_includes - Variable which will be filled with complete include statements of all
				generated resource classes.

	      In addition to the parameters an arbitrary number of template filenames can be  set
	      as arguments

	      In case of success NEPOMUK_RESOURCES_GENERATED is true, otherwise false

       PythonMacros

	      Python macros ~~~~~~~~~~~~~ Copyright (c) 2007, Simon Edwards <simon@simonzone.com>
	      Copyright (c) 2012, Luca Beltrame <lbeltrame@kde.org> Copyright (c) 2012, Rolf Eike
	      Beer <eike@sf-mail.de>

	      Redistribution  and  use	is allowed according to the terms of the BSD license. For
	      details see the accompanying COPYING-CMAKE-SCRIPTS file.

	      This file defines the following macros:

	      PYTHON_INSTALL (SOURCE_FILE DESTINATION_DIR)

		   Install the SOURCE_FILE, which is a Python .py file, into the
		   destination directory during install. The file will be byte compiled
		   and both the .py file and .pyc file will be installed.

       Qt4ConfigDependentSettings

	      This file is included by FindQt4.cmake, don't include it directly.

       Qt4Macros

	      This file is included by FindQt4.cmake, don't include it directly.

       SIPMacros

	      Macros for SIP ~~~~~~~~~~~~~~  Copyright	(c)  2007,  Simon  Edwards  <simon@simon-
	      zone.com>  Redistribution  and  use  is  allowed	according to the terms of the BSD
	      license. For details see the accompanying COPYING-CMAKE-SCRIPTS file.

	      SIP website: http://www.riverbankcomputing.co.uk/sip/index.php

	      This file defines the following macros:

	      ADD_SIP_PYTHON_MODULE (MODULE_NAME MODULE_SIP [library1, libaray2, ...])

		   Specifies a SIP file to be built into a Python module and installed.
		   MODULE_NAME is the name of Python module including any path name. (e.g.
		   os.sys, Foo.bar etc). MODULE_SIP the path and filename of the .sip file
		   to process and compile. libraryN are libraries that the Python module,
		   which is typically a shared library, should be linked to. The built
		   module will also be install into Python's site-packages directory.

	      The behaviour of the ADD_SIP_PYTHON_MODULE macro can be controlled by a  number  of
	      variables:

	      SIP_INCLUDES - List of directories which SIP will scan through when looking

		   for included .sip files. (Corresponds to the -I option for SIP.)

	      SIP_TAGS - List of tags to define when running SIP. (Corresponds to the -t

		   option for SIP.)

	      SIP_CONCAT_PARTS - An integer which defines the number of parts the C++ code

		   of each module should be split into. Defaults to 8. (Corresponds to the
		   -j option for SIP.)

	      SIP_DISABLE_FEATURES - List of feature names which should be disabled

		   running SIP. (Corresponds to the -x option for SIP.)

	      SIP_EXTRA_OPTIONS - Extra command line options which should be passed on to

		   SIP.

       Win32Macros

	      win32 macros

	      ADDEXPLORERWRAPPER(project)

	      Exists only under Win32 !

	      addExplorerWrapper  creates  batch  files for fast access  to the build environment
	      from the win32 explorer.

	      For mingw and nmake projects it opens a command shell, for Visual Studio IDE's  (at
	      least  tested  with  VS  8  2005) it opens the related .sln file with paths setting
	      specified at  configure time.

       create_exe_symlink

	      Create an executable symlink to a Python script. This also sets the target script's
	      permission bits.

SEE ALSO
       ccmake(1),  cpack(1),  ctest(1), cmakecommands(1), cmakecompat(1), cmakemodules(1), cmake-
       props(1), cmakevars(1)

       The following resources are available to get help using CMake:

       Home Page
	      http://www.cmake.org

	      The primary starting point for learning about CMake.

       Frequently Asked Questions
	      http://www.cmake.org/Wiki/CMake_FAQ

	      A Wiki is provided containing answers to frequently asked questions.

       Online Documentation
	      http://www.cmake.org/HTML/Documentation.html

	      Links to available documentation may be found on this web page.

       Mailing List
	      http://www.cmake.org/HTML/MailingLists.html

	      For help	and  discussion  about	using  cmake,  a  mailing  list  is  provided  at
	      cmake@cmake.org.	The list is member-post-only but one may sign up on the CMake web
	      page. Please first read the full documentation at http://www.cmake.org before post-
	      ing questions to the list.

cmake 2.8.11				  June 17, 2014 			      kdecmake(1)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 06:30 PM.

Unix & Linux Forums Content Copyright©1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password





Not a Forum Member?
Forgot Password?