Provided by: kdelibs5-dev_4.8.2-0ubuntu1_amd64 bug

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
       settings.

       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(ModuleName).

         Custom CMake Modules - Additional Modules for CMake.

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

       CMakeParseArguments

              CMAKE_PARSE_ARGUMENTS(<prefix>            <options>            <one_value_keywords>
              <multi_value_keywords> args...)

              CMAKE_PARSE_ARGUMENTS()  is  intended to be used in macros or functions for parsing
              the arguments given to that macro or  function.  It  processes  the  arguments  and
              defines a set of variables which hold the values of the respective options.

              The <options> argument contains all options for the respective macro, i.e. keywords
              which can be used when calling the macro without any value following, like e.g. the
              OPTIONAL keyword of the install() command.

              The  <one_value_keywords>  argument  contains all keywords for this macro which are
              followed by one value, like e.g. DESTINATION keyword of the install() command.

              The <multi_value_keywords> argument contains all keywords for this macro which  can
              be  followed by more than one value, like e.g. the TARGETS or FILES keywords of the
              install() command.

              When done, CMAKE_PARSE_ARGUMENTS() will have  defined  for  each  of  the  keywords
              listed  in  <options>,  <one_value_keywords>  and <multi_value_keywords> a variable
              composed of the given <prefix> followed by "_"  and  the  name  of  the  respective
              keyword.  These  variables  will  then  hold the respective value from the argument
              list. For the <options> keywords this will be TRUE or FALSE.

              All remaining arguments are collected in  a  variable  <prefix>_UNPARSED_ARGUMENTS,
              this  can  be  checked  afterwards  to  see  whether  your  macro  was  called with
              unrecognized parameters.

              As an example here a my_install() macro, which takes similar arguments as the  real
              install() command:

                 function(MY_INSTALL)
                   set(options OPTIONAL FAST)
                   set(oneValueArgs DESTINATION RENAME)
                   set(multiValueArgs TARGETS CONFIGURATIONS)
                   cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
                   ...

              Assume my_install() has been called like this:

                 my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)

              After  the  cmake_parse_arguments()  call  the  macro  will  have set the following
              variables:

                 MY_INSTALL_OPTIONAL = TRUE
                 MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
                 MY_INSTALL_DESTINATION = "bin"
                 MY_INSTALL_RENAME = "" (was not used)
                 MY_INSTALL_TARGETS = "foo;bar"
                 MY_INSTALL_CONFIGURATIONS = "" (was not used)
                 MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"

              You can the continue and process these variables.

              Keywords terminate lists of values, e.g.  if  directly  after  a  one_value_keyword
              another recognized keyword follows, this is interpreted as the beginning of the new
              option.  E.g.  my_install(TARGETS  foo  DESTINATION  OPTIONAL)  would   result   in
              MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would be empty
              and MY_INSTALL_OPTIONAL would be set to TRUE therefor.

       CheckCXXSourceCompiles
              macro which checks if the source code compiles

              CHECK_CXX_SOURCE_COMPILES(SOURCE VAR)

                SOURCE - source code to try to compile
                VAR    - variable to store whether the source code compiled

              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
                CMAKE_REQUIRED_LIBRARIES = list of libraries to link

       CheckCXXSourceRuns
              Check if the C++ source code provided in the SOURCE argument compiles and runs.

              CHECK_CXX_SOURCE_RUNS(SOURCE VAR)

                SOURCE - source code to try to compile
                VAR    - variable to store the result, 1 for success, empty for failure

              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
                CMAKE_REQUIRED_LIBRARIES = list of libraries to link

       CheckCXXSymbolExists
              Check if the symbol exists in include files, in C++ mode

              Forked off  cmake's  CheckSymbolExists.cmake  CHECK_CXX_SYMBOL_EXISTS(SYMBOL  FILES
              VARIABLE)

                SYMBOL   - symbol
                FILES    - include files to check
                VARIABLE - variable to return 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
                CMAKE_REQUIRED_LIBRARIES = list of libraries to link

       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

              ##########################################################    ########  DEPRECATED,
              use                FindQImageBlitz                instead                 #########
              ##########################################################   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.

       FindBoost
              Try to find Boost include dirs and libraries

              Please  see the Documentation for Boost in the CMake Manual for details This module
              only forwards to the one included in cmake for compatibility reasons.

       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
              syntax, e.g. find_package(DBusMenuQt 0.6)

              WARNING: versions below 0.4.0 cannot be checked for. So  if  you  want  to  have  a
              version 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  compatiblity,  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 additionaly 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

       FindFreetype
              Try to find the freetype library

              Once done this will define

                FREETYPE_FOUND - system has Freetype
                FREETYPE_INCLUDE_DIRS - the FREETYPE include directories
                FREETYPE_LIBRARIES - Link these to use FREETYPE
                FREETYPE_INCLUDE_DIR - internal

       FindGIF
              Try to find GIF

              Once done this will define

                GIF_FOUND - system has GIF
                GIF_INCLUDE_DIR - the GIF include directory
                GIF_LIBRARIES - Libraries needed to use GIF
                GIF_DEFINITIONS - Compiler switches required for using GIF

       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_compiler executable
                KDE4_AUTOMOC_EXECUTABLE  - the kde4automoc executable, deprecated, use AUTOMOC4_EXECUTABLE instead
                KDE4_MEINPROC_EXECUTABLE - the meinproc4 executable
                KDE4_MAKEKDEWIDGETS_EXECUTABLE - the makekdewidgets executable

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

                KDE4_KDECORE_LIBRARY     - the kdecore library
                KDE4_KDEUI_LIBRARY       - the kdeui library
                KDE4_KIO_LIBRARY         - the kio library
                KDE4_KPARTS_LIBRARY      - the kparts library
                KDE4_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
              directories for files of the package which is using this  module.  These  variables
              don't  say  anything  about the location of the installed KDE. They can be relative
              (to CMAKE_INSTALL_PREFIX) or absolute. 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
              BUNDLE_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 makekdewidgets 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
                  directoy 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 optimisation, 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 apropriate 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

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

              Once done this will define

                KDCRAW_FOUND - system has libkdcraw
                KDCRAW_INCLUDE_DIR - the libkdcraw include directory
                KDCRAW_LIBRARIES - Link these to use libkdcraw
                KDCRAW_DEFINITIONS - Compiler switches required for using libkdcraw

       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
              Try to find the Kipi library

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

              Once done this will define

                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

       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
              syntax, 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).

       FindLibXml2
              Try to find LibXml2

              Once done this will define

                LIBXML2_FOUND - System has LibXml2
                LIBXML2_INCLUDE_DIR - The LibXml2 include directory
                LIBXML2_LIBRARIES - The libraries needed to use LibXml2
                LIBXML2_DEFINITIONS - Compiler switches required for using LibXml2
                LIBXML2_XMLLINT_EXECUTABLE - The XML checking tool xmllint coming with LibXml2

       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

       FindOpenSSL
              Try to find the OpenSSL encryption library

              Once done this will define

                OPENSSL_FOUND - system has the OpenSSL library
                OPENSSL_INCLUDE_DIR - the OpenSSL include directory
                OPENSSL_LIBRARIES - The libraries needed to use OpenSSL
                OPENSSL_EAY_LIBRARIES - The additional libraries needed to use OpenSSL on windows

       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

       FindPackageHandleStandardArgs

              FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ... )

              This function is intended to be used in FindXXX.cmake modules files. It handles the
              REQUIRED,  QUIET  and version-related arguments to FIND_PACKAGE(). It also sets the
              <UPPERCASED_NAME>_FOUND variable. The package is considered found if all  variables
              <var1>... listed contain valid results, e.g. valid filepaths.

              There  are two modes of this function. The first argument in both modes is the name
              of the Find-module where it is called (in original casing).

              The first simple mode looks like this:

                  FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> (DEFAULT_MSG|"Custom failure message") <var1>...<varN> )

              If the variables <var1> to <varN> are all valid, then <UPPERCASED_NAME>_FOUND  will
              be  set to TRUE. If DEFAULT_MSG is given as second argument, then the function will
              generate itself useful success and error messages. You can  also  supply  a  custom
              error message for the failure case. This is not recommended.

              The second mode is more powerful and also supports version checking:

                  FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME [REQUIRED_VARS <var1>...<varN>]
                                                         [VERSION_VAR   <versionvar>
                                                         [FAIL_MESSAGE "Custom failure message"] )

              As  above,  if <var1> through <varN> are all valid, <UPPERCASED_NAME>_FOUND will be
              set to TRUE. Via FAIL_MESSAGE a custom failure message can be specified, if this is
              not  used, the default message will be displayed. Following VERSION_VAR the name of
              the variable can be specified which holds the version of the package which has been
              found.  If  this  is  done,  this version will be checked against the (potentially)
              specified required version used in the find_package() call. The  EXACT  keyword  is
              also  handled.  The default messages include information about the required version
              and the version which has been actually found, both if the version is ok or not.

              Example for mode 1:

                  FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2  DEFAULT_MSG  LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)

              LibXml2 is considered to be found, if both LIBXML2_LIBRARY and  LIBXML2_INCLUDE_DIR
              are  valid. Then also LIBXML2_FOUND is set to TRUE. If it is not found and REQUIRED
              was used, it fails with FATAL_ERROR, independent whether QUIET was used or not.  If
              it is found, success will be reported, including the content of <var1>. On repeated
              Cmake runs, the same message won't be printed again.

              Example for mode 2:

                  FIND_PACKAGE_HANDLE_STANDARD_ARGS(BISON  REQUIRED_VARS BISON_EXECUTABLE
                                                           VERSION_VAR BISON_VERSION)

              In this case, BISON is considered to be  found  if  the  variable(s)  listed  after
              REQUIRED_VAR are all valid, i.e. BISON_EXECUTABLE in this case. Also the version of
              BISON will be checked by using the version contained  in  BISON_VERSION.  Since  no
              FAIL_MESSAGE is given, the default messages will be printed.

       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

       FindPkgConfig
              a pkg-config module for CMake

              Usage:

                 pkg_check_modules(<PREFIX> [REQUIRED] [QUIET] <MODULE> [<MODULE>]*)
                   checks for all the given modules

                 pkg_search_module(<PREFIX> [REQUIRED] [QUIET] <MODULE> [<MODULE>]*)
                   checks for given modules and uses the first working one

              When the 'REQUIRED' argument was set, macros will fail with an error when module(s)
              could not be found

              When the 'QUIET' argument is set, no status messages will be printed.

              It sets the following variables:

                 PKG_CONFIG_FOUND         ... true if pkg-config works on the system
                 PKG_CONFIG_EXECUTABLE    ... pathname of the pkg-config program
                 <PREFIX>_FOUND           ... set to 1 if module(s) exist

              For the following variables two sets of values exist; first one is the  common  one
              and  has  the  given PREFIX. The second set contains flags which are given out when
              pkgconfig was called with the '--static' option.

                 <XPREFIX>_LIBRARIES      ... only the libraries (w/o the '-l')
                 <XPREFIX>_LIBRARY_DIRS   ... the paths of the libraries (w/o the '-L')
                 <XPREFIX>_LDFLAGS        ... all required linker flags
                 <XPREFIX>_LDFLAGS_OTHER  ... all other linker flags
                 <XPREFIX>_INCLUDE_DIRS   ... the '-I' preprocessor flags (w/o the '-I')
                 <XPREFIX>_CFLAGS         ... all required cflags
                 <XPREFIX>_CFLAGS_OTHER   ... the other compiler flags

                 <XPREFIX> = <PREFIX>        for common case
                 <XPREFIX> = <PREFIX>_STATIC for static linking

              There are some special variables  whose  prefix  depends  on  the  count  of  given
              modules.  When  there  is only one module, <PREFIX> stays unchanged. When there are
              multiple modules, the prefix will be changed to <PREFIX>_<MODNAME>:

                 <XPREFIX>_VERSION    ... version of the module
                 <XPREFIX>_PREFIX     ... prefix-directory of the module
                 <XPREFIX>_INCLUDEDIR ... include-dir of the module
                 <XPREFIX>_LIBDIR     ... lib-dir of the module

                 <XPREFIX> = <PREFIX>  when |MODULES| == 1, else
                 <XPREFIX> = <PREFIX>_<MODNAME>

              A <MODULE> parameter can have the following formats:

                 {MODNAME}            ... matches any version
                 {MODNAME}>={VERSION} ... at least version <VERSION> is required
                 {MODNAME}={VERSION}  ... exactly version <VERSION> is required
                 {MODNAME}<={VERSION} ... modules must not be newer than <VERSION>

              Examples

                 pkg_check_modules (GLIB2   glib-2.0)

                 pkg_check_modules (GLIB2   glib-2.0>=2.10)
                   requires at least version 2.10 of glib2 and defines e.g.
                     GLIB2_VERSION=2.10.3

                 pkg_check_modules (FOO     glib-2.0>=2.10 gtk+-2.0)
                   requires both glib2 and gtk2, and defines e.g.
                     FOO_glib-2.0_VERSION=2.10.3
                     FOO_gtk+-2.0_VERSION=2.8.20

                 pkg_check_modules (XRENDER REQUIRED xrender)
                   defines e.g.:
                     XRENDER_LIBRARIES=Xrender;X11
                     XRENDER_STATIC_LIBRARIES=Xrender;X11;pthread;Xau;Xdmcp

                 pkg_search_module (BAR     libxml-2.0 libxml2 libxml>=2)

       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
              syntax, 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
              syntax, e.g. find_package(PolkitQt 1.0) For compatiblity, 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
              syntax, 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 comparision 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
              variable.

              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_package()-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_VERSION.

              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_QT3SUPPORT_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 comparision 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
              semantic  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 compatiblity, 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.sourceforge.net )

              Once done this will define

                STRIGI_FOUND - system has Strigi
                STRIGI_INCLUDE_DIR - the Strigi include directory
                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

       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
              CONDITION 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 featue 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_SUBDIRECTORY() 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
              following 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_PACKAGE_${_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>

              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 DESINATION_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@simonzone.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),
       cmakeprops(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
              posting questions to the list.

       Summary of helpful links:

         Home: http://www.cmake.org
         Docs: http://www.cmake.org/HTML/Documentation.html
         Mail: http://www.cmake.org/HTML/MailingLists.html
         FAQ:  http://www.cmake.org/Wiki/CMake_FAQ