FindTclStub
TCL_STUB_LIBRARY_DEBUG and TK_STUB_LIBRARY_DEBUG were removed.
This module finds Tcl stub libraries. It first finds Tcl include files and libraries by calling FindTCL.cmake. How to Use the Tcl Stubs Library:
Using Stub Libraries:
This code sets the following variables:

  TCL_STUB_LIBRARY       = path to Tcl stub library
  TK_STUB_LIBRARY        = path to Tk stub library
  TTK_STUB_LIBRARY       = path to ttk stub library

In an effort to remove some clutter and clear up some issues for people who are not necessarily Tcl/Tk gurus/developpers, some variables were moved or removed. Changes compared to CMake 2.4 are:

   => these libs are not packaged by default with Tcl/Tk distributions.
      Even when Tcl/Tk is built from source, several flavors of debug libs
      are created and there is no real reason to pick a single one
      specifically (say, amongst tclstub84g, tclstub84gs, or tclstub84sgx).
      Let's leave that choice to the user by allowing him to assign
      TCL_STUB_LIBRARY to any Tcl library, debug or not.

FindTclsh
Find tclsh
This module finds if TCL 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:

  TCLSH_FOUND = TRUE if tclsh has been found
  TCL_TCLSH = the path to the tclsh executable

In cygwin, look for the cygwin version first. Don't look for it later to avoid finding the cygwin version on a Win32 build.

FindThreads
This module determines the thread library of the system.
The following variables are set

  CMAKE_THREAD_LIBS_INIT     - the thread library
  CMAKE_USE_SPROC_INIT       - are we using sproc?
  CMAKE_USE_WIN32_THREADS_INIT - using WIN32 threads?
  CMAKE_USE_PTHREADS_INIT    - are we using pthreads
  CMAKE_HP_PTHREADS_INIT     - are we using hp pthreads

For systems with multiple thread libraries, caller can set

  CMAKE_THREAD_PREFER_PTHREAD

FindUnixCommands
Find unix commands from cygwin
This module looks for some usual Unix commands.

FindVTK
Find a VTK installation or build tree.
The following variables are set if VTK is found. If VTK is not found, VTK_FOUND is set to false.

  VTK_FOUND         - Set to true when VTK is found.
  VTK_USE_FILE      - CMake file to use VTK.
  VTK_MAJOR_VERSION - The VTK major version number.
  VTK_MINOR_VERSION - The VTK minor version number
                       (odd non-release).
  VTK_BUILD_VERSION - The VTK patch level
                       (meaningless for odd minor).
  VTK_INCLUDE_DIRS  - Include directories for VTK
  VTK_LIBRARY_DIRS  - Link directories for VTK libraries
  VTK_KITS          - List of VTK kits, in CAPS
                      (COMMON,IO,) etc.
  VTK_LANGUAGES     - List of wrapped languages, in CAPS
                      (TCL, PYHTON,) etc.

The following cache entries must be set by the user to locate VTK:

  VTK_DIR  - The directory containing VTKConfig.cmake.
             This is either the root of the build tree,
             or the lib/vtk directory.  This is the
             only cache entry.

The following variables are set for backward compatibility and should not be used in new code:

  USE_VTK_FILE - The full path to the UseVTK.cmake file.
                 This is provided for backward
                 compatibility.  Use VTK_USE_FILE
                 instead.

FindWget
Find wget
This module looks for wget. This module defines the following values:

  WGET_EXECUTABLE: the full path to the wget tool.
  WGET_FOUND: True if wget has been found.

FindWish
Find wish installation
This module finds if TCL 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:

  TK_WISH = the path to the wish executable

if UNIX is defined, then it will look for the cygwin version first

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: Include paths: 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_Xxf86vm_LIB     X11_xf86vmode_FOUND
                X11_Xfixes_INCLUDE_PATH,       X11_Xfixes_LIB,     X11_Xfixes_FOUND
                X11_Xft_INCLUDE_PATH,          X11_Xft_LIB,        X11_Xft_FOUND
                X11_Xi_INCLUDE_PATH,           X11_Xi_LIB,         X11_Xi_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_Xmu_INCLUDE_PATH,          X11_Xmu_LIB,        X11_Xmu_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

FindXMLRPC
Find xmlrpc
Find the native XMLRPC headers and libraries.

  XMLRPC_INCLUDE_DIRS      - where to find xmlrpc.h, etc.
  XMLRPC_LIBRARIES         - List of libraries when using xmlrpc.
  XMLRPC_FOUND             - True if xmlrpc found.

XMLRPC modules may be specified as components for this find module. Modules may be listed by running "xmlrpc-c-config". Modules include:

  c++            C++ wrapper code
  libwww-client  libwww-based client
  cgi-server     CGI-based server
  abyss-server   ABYSS-based server

Typical usage:

  find_package(XMLRPC REQUIRED libwww-client)

FindZLIB
Find zlib
Find the native ZLIB includes and library. Once done this will define

  ZLIB_INCLUDE_DIRS   - where to find zlib.h, etc.
  ZLIB_LIBRARIES      - List of libraries when using zlib.
  ZLIB_FOUND          - True if zlib found.

  ZLIB_VERSION_STRING - The version of zlib found (x.y.z)
  ZLIB_VERSION_MAJOR  - The major version of zlib
  ZLIB_VERSION_MINOR  - The minor version of zlib
  ZLIB_VERSION_PATCH  - The patch version of zlib
  ZLIB_VERSION_TWEAK  - The tweak version of zlib

The following variable are provided for backward compatibility

  ZLIB_MAJOR_VERSION  - The major version of zlib
  ZLIB_MINOR_VERSION  - The minor version of zlib
  ZLIB_PATCH_VERSION  - The patch version of zlib

An includer may set ZLIB_ROOT to a zlib installation root to tell this module where to look.

Findosg
NOTE: It is highly recommended that you use the new FindOpenSceneGraph.cmake introduced in CMake 2.6.3 and not use this Find module directly.
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osg This module defines
OSG_FOUND - Was the Osg found? OSG_INCLUDE_DIR - Where to find the headers OSG_LIBRARIES - The libraries to link against for the OSG (use this)
OSG_LIBRARY - The OSG library OSG_LIBRARY_DEBUG - The OSG debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgAnimation
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgAnimation This module defines
OSGANIMATION_FOUND - Was osgAnimation found? OSGANIMATION_INCLUDE_DIR - Where to find the headers OSGANIMATION_LIBRARIES - The libraries to link against for the OSG (use this)
OSGANIMATION_LIBRARY - The OSG library OSGANIMATION_LIBRARY_DEBUG - The OSG debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgDB
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgDB This module defines
OSGDB_FOUND - Was osgDB found? OSGDB_INCLUDE_DIR - Where to find the headers OSGDB_LIBRARIES - The libraries to link against for the osgDB (use this)
OSGDB_LIBRARY - The osgDB library OSGDB_LIBRARY_DEBUG - The osgDB debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgFX
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgFX This module defines
OSGFX_FOUND - Was osgFX found? OSGFX_INCLUDE_DIR - Where to find the headers OSGFX_LIBRARIES - The libraries to link against for the osgFX (use this)
OSGFX_LIBRARY - The osgFX library OSGFX_LIBRARY_DEBUG - The osgFX debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgGA
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgGA This module defines
OSGGA_FOUND - Was osgGA found? OSGGA_INCLUDE_DIR - Where to find the headers OSGGA_LIBRARIES - The libraries to link against for the osgGA (use this)
OSGGA_LIBRARY - The osgGA library OSGGA_LIBRARY_DEBUG - The osgGA debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgIntrospection
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgINTROSPECTION This module defines
OSGINTROSPECTION_FOUND - Was osgIntrospection found? OSGINTROSPECTION_INCLUDE_DIR - Where to find the headers OSGINTROSPECTION_LIBRARIES - The libraries to link for osgIntrospection (use this)
OSGINTROSPECTION_LIBRARY - The osgIntrospection library OSGINTROSPECTION_LIBRARY_DEBUG - The osgIntrospection debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgManipulator
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgManipulator This module defines
OSGMANIPULATOR_FOUND - Was osgManipulator found? OSGMANIPULATOR_INCLUDE_DIR - Where to find the headers OSGMANIPULATOR_LIBRARIES - The libraries to link for osgManipulator (use this)
OSGMANIPULATOR_LIBRARY - The osgManipulator library OSGMANIPULATOR_LIBRARY_DEBUG - The osgManipulator debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgParticle
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgParticle This module defines
OSGPARTICLE_FOUND - Was osgParticle found? OSGPARTICLE_INCLUDE_DIR - Where to find the headers OSGPARTICLE_LIBRARIES - The libraries to link for osgParticle (use this)
OSGPARTICLE_LIBRARY - The osgParticle library OSGPARTICLE_LIBRARY_DEBUG - The osgParticle debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgPresentation
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgPresentation This module defines
OSGPRESENTATION_FOUND - Was osgPresentation found? OSGPRESENTATION_INCLUDE_DIR - Where to find the headers OSGPRESENTATION_LIBRARIES - The libraries to link for osgPresentation (use this)
OSGPRESENTATION_LIBRARY - The osgPresentation library OSGPRESENTATION_LIBRARY_DEBUG - The osgPresentation debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing. Modified to work with osgPresentation by Robert Osfield, January 2012.

FindosgProducer
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgProducer This module defines
OSGPRODUCER_FOUND - Was osgProducer found? OSGPRODUCER_INCLUDE_DIR - Where to find the headers OSGPRODUCER_LIBRARIES - The libraries to link for osgProducer (use this)
OSGPRODUCER_LIBRARY - The osgProducer library OSGPRODUCER_LIBRARY_DEBUG - The osgProducer debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgQt
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgQt This module defines
OSGQT_FOUND - Was osgQt found? OSGQT_INCLUDE_DIR - Where to find the headers OSGQT_LIBRARIES - The libraries to link for osgQt (use this)
OSGQT_LIBRARY - The osgQt library OSGQT_LIBRARY_DEBUG - The osgQt debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing. Modified to work with osgQt by Robert Osfield, January 2012.

FindosgShadow
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgShadow This module defines
OSGSHADOW_FOUND - Was osgShadow found? OSGSHADOW_INCLUDE_DIR - Where to find the headers OSGSHADOW_LIBRARIES - The libraries to link for osgShadow (use this)
OSGSHADOW_LIBRARY - The osgShadow library OSGSHADOW_LIBRARY_DEBUG - The osgShadow debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgSim
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgSim This module defines
OSGSIM_FOUND - Was osgSim found? OSGSIM_INCLUDE_DIR - Where to find the headers OSGSIM_LIBRARIES - The libraries to link for osgSim (use this)
OSGSIM_LIBRARY - The osgSim library OSGSIM_LIBRARY_DEBUG - The osgSim debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgTerrain
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgTerrain This module defines
OSGTERRAIN_FOUND - Was osgTerrain found? OSGTERRAIN_INCLUDE_DIR - Where to find the headers OSGTERRAIN_LIBRARIES - The libraries to link for osgTerrain (use this)
OSGTERRAIN_LIBRARY - The osgTerrain library OSGTERRAIN_LIBRARY_DEBUG - The osgTerrain debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgText
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgText This module defines
OSGTEXT_FOUND - Was osgText found? OSGTEXT_INCLUDE_DIR - Where to find the headers OSGTEXT_LIBRARIES - The libraries to link for osgText (use this)
OSGTEXT_LIBRARY - The osgText library OSGTEXT_LIBRARY_DEBUG - The osgText debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgUtil
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgUtil This module defines
OSGUTIL_FOUND - Was osgUtil found? OSGUTIL_INCLUDE_DIR - Where to find the headers OSGUTIL_LIBRARIES - The libraries to link for osgUtil (use this)
OSGUTIL_LIBRARY - The osgUtil library OSGUTIL_LIBRARY_DEBUG - The osgUtil debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgViewer
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgViewer This module defines
OSGVIEWER_FOUND - Was osgViewer found? OSGVIEWER_INCLUDE_DIR - Where to find the headers OSGVIEWER_LIBRARIES - The libraries to link for osgViewer (use this)
OSGVIEWER_LIBRARY - The osgViewer library OSGVIEWER_LIBRARY_DEBUG - The osgViewer debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgVolume
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgVolume This module defines
OSGVOLUME_FOUND - Was osgVolume found? OSGVOLUME_INCLUDE_DIR - Where to find the headers OSGVOLUME_LIBRARIES - The libraries to link for osgVolume (use this)
OSGVOLUME_LIBRARY - The osgVolume library OSGVOLUME_LIBRARY_DEBUG - The osgVolume debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
Created by Eric Wing.

FindosgWidget
This is part of the Findosg* suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. You must also opt into OpenGL and OpenThreads (and Producer if needed) as these modules won't do it for you. This is to allow you control over your own system piece by piece in case you need to opt out of certain components or change the Find behavior for a particular module (perhaps because the default FindOpenGL.cmake module doesn't work with your system as an example). If you want to use a more convenient module that includes everything, use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
Locate osgWidget This module defines
OSGWIDGET_FOUND - Was osgWidget found? OSGWIDGET_INCLUDE_DIR - Where to find the headers OSGWIDGET_LIBRARIES - The libraries to link for osgWidget (use this)
OSGWIDGET_LIBRARY - The osgWidget library OSGWIDGET_LIBRARY_DEBUG - The osgWidget debug library
$OSGDIR is an environment variable that would correspond to the ./configure --prefix=$OSGDIR used in building osg.
FindosgWidget.cmake tweaked from Findosg* suite as created by Eric Wing.

Findosg_functions
This CMake file contains two macros to assist with searching for OSG libraries and nodekits. Please see FindOpenSceneGraph.cmake for full documentation.

FindwxWidgets
Find a wxWidgets (a.k.a., wxWindows) installation.
This module finds if wxWidgets is installed and selects a default configuration to use. wxWidgets is a modular library. To specify the modules that you will use, you need to name them as components to the package:
find_package(wxWidgets COMPONENTS core base ...)
There are two search branches: a windows style and a unix style. For windows, the following variables are searched for and set to defaults in case of multiple choices. Change them if the defaults are not desired (i.e., these are the only variables you should change to select a configuration):

  wxWidgets_ROOT_DIR      - Base wxWidgets directory
                            (e.g., C:/wxWidgets-2.6.3).
  wxWidgets_LIB_DIR       - Path to wxWidgets libraries
                            (e.g., C:/wxWidgets-2.6.3/lib/vc_lib).
  wxWidgets_CONFIGURATION - Configuration to use
                            (e.g., msw, mswd, mswu, mswunivud, etc.)
  wxWidgets_EXCLUDE_COMMON_LIBRARIES
                          - Set to TRUE to exclude linking of
                            commonly required libs (e.g., png tiff
                            jpeg zlib regex expat).

For unix style it uses the wx-config utility. You can select between debug/release, unicode/ansi, universal/non-universal, and static/shared in the QtDialog or ccmake interfaces by turning ON/OFF the following variables:

  wxWidgets_USE_DEBUG
  wxWidgets_USE_UNICODE
  wxWidgets_USE_UNIVERSAL
  wxWidgets_USE_STATIC

There is also a wxWidgets_CONFIG_OPTIONS variable for all other options that need to be passed to the wx-config utility. For example, to use the base toolkit found in the /usr/local path, set the variable (before calling the FIND_PACKAGE command) as such:

  set(wxWidgets_CONFIG_OPTIONS --toolkit=base --prefix=/usr)

The following are set after the configuration is done for both windows and unix style:

  wxWidgets_FOUND            - Set to TRUE if wxWidgets was found.
  wxWidgets_INCLUDE_DIRS     - Include directories for WIN32
                               i.e., where to find "wx/wx.h" and
                               "wx/setup.h"; possibly empty for unices.
  wxWidgets_LIBRARIES        - Path to the wxWidgets libraries.
  wxWidgets_LIBRARY_DIRS     - compile time link dirs, useful for
                               rpath on UNIX. Typically an empty string
                               in WIN32 environment.
  wxWidgets_DEFINITIONS      - Contains defines required to compile/link
                               against WX, e.g. WXUSINGDLL
  wxWidgets_DEFINITIONS_DEBUG- Contains defines required to compile/link
                               against WX debug builds, e.g. __WXDEBUG__
  wxWidgets_CXX_FLAGS        - Include dirs and compiler flags for
                               unices, empty on WIN32. Essentially
                               "`wx-config --cxxflags`".
  wxWidgets_USE_FILE         - Convenience include file.

Sample usage:

   # Note that for MinGW users the order of libs is important!
   find_package(wxWidgets COMPONENTS net gl core base)
   if(wxWidgets_FOUND)
     include(${wxWidgets_USE_FILE})
     # and for each of your dependent executable/library targets:
     target_link_libraries(<YourTarget> ${wxWidgets_LIBRARIES})
   endif()

If wxWidgets is required (i.e., not an optional part):

   find_package(wxWidgets REQUIRED net gl core base)
   include(${wxWidgets_USE_FILE})
   # and for each of your dependent executable/library targets:
   target_link_libraries(<YourTarget> ${wxWidgets_LIBRARIES})

FindwxWindows
Find wxWindows (wxWidgets) installation
This module finds if wxWindows/wxWidgets is installed and determines where the include files and libraries are. It also determines what the name of the library is. Please note this file is DEPRECATED and replaced by FindwxWidgets.cmake. This code sets the following variables:

  WXWINDOWS_FOUND     = system has WxWindows
  WXWINDOWS_LIBRARIES = path to the wxWindows libraries
                        on Unix/Linux with additional
                        linker flags from
                        "wx-config --libs"
  CMAKE_WXWINDOWS_CXX_FLAGS  = Compiler flags for wxWindows,
                               essentially "`wx-config --cxxflags`"
                               on Linux
  WXWINDOWS_INCLUDE_DIR      = where to find "wx/wx.h" and "wx/setup.h"
  WXWINDOWS_LINK_DIRECTORIES = link directories, useful for rpath on
                                Unix
  WXWINDOWS_DEFINITIONS      = extra defines

OPTIONS If you need OpenGL support please

  set(WXWINDOWS_USE_GL 1)

in your CMakeLists.txt *before* you include this file.

  HAVE_ISYSTEM      - true required to replace -I by -isystem on g++

For convenience include Use_wxWindows.cmake in your project's CMakeLists.txt using include(${CMAKE_CURRENT_LIST_DIR}/Use_wxWindows.cmake).
USAGE

  set(WXWINDOWS_USE_GL 1)
  find_package(wxWindows)

NOTES wxWidgets 2.6.x is supported for monolithic builds e.g. compiled in wx/build/msw dir as:

  nmake -f makefile.vc BUILD=debug SHARED=0 USE_OPENGL=1 MONOLITHIC=1

DEPRECATED

  CMAKE_WX_CAN_COMPILE
  WXWINDOWS_LIBRARY
  CMAKE_WX_CXX_FLAGS
  WXWINDOWS_INCLUDE_PATH

AUTHOR Jan Woetzel <> (07/2003-01/2006)

FortranCInterface
Fortran/C Interface Detection
This module automatically detects the API by which C and Fortran languages interact. Variables indicate if the mangling is found:

   FortranCInterface_GLOBAL_FOUND = Global subroutines and functions
   FortranCInterface_MODULE_FOUND = Module subroutines and functions
                                    (declared by "MODULE PROCEDURE")

A function is provided to generate a C header file containing macros to mangle symbol names:

   FortranCInterface_HEADER(<file>
                            [MACRO_NAMESPACE <macro-ns>]
                            [SYMBOL_NAMESPACE <ns>]
                            [SYMBOLS [<module>:]<function> ...])

It generates in <file> definitions of the following macros:

   #define FortranCInterface_GLOBAL (name,NAME) ...
   #define FortranCInterface_GLOBAL_(name,NAME) ...
   #define FortranCInterface_MODULE (mod,name, MOD,NAME) ...
   #define FortranCInterface_MODULE_(mod,name, MOD,NAME) ...

These macros mangle four categories of Fortran symbols, respectively:

   - Global symbols without '_': call mysub()
   - Global symbols with '_'   : call my_sub()
   - Module symbols without '_': use mymod; call mysub()
   - Module symbols with '_'   : use mymod; call my_sub()

If mangling for a category is not known, its macro is left undefined. All macros require raw names in both lower case and upper case. The MACRO_NAMESPACE option replaces the default "FortranCInterface_" prefix with a given namespace "<macro-ns>".
The SYMBOLS option lists symbols to mangle automatically with C preprocessor definitions:

   <function>          ==> #define <ns><function> ...
   <module>:<function> ==> #define <ns><module>_<function> ...

If the mangling for some symbol is not known then no preprocessor definition is created, and a warning is displayed. The SYMBOL_NAMESPACE option prefixes all preprocessor definitions generated by the SYMBOLS option with a given namespace "<ns>".
Example usage:

   include(FortranCInterface)
   FortranCInterface_HEADER(FC.h MACRO_NAMESPACE "FC_")

This creates a "FC.h" header that defines mangling macros FC_GLOBAL(), FC_GLOBAL_(), FC_MODULE(), and FC_MODULE_().
Example usage:

   include(FortranCInterface)
   FortranCInterface_HEADER(FCMangle.h
                            MACRO_NAMESPACE "FC_"
                            SYMBOL_NAMESPACE "FC_"
                            SYMBOLS mysub mymod:my_sub)

This creates a "FCMangle.h" header that defines the same FC_*() mangling macros as the previous example plus preprocessor symbols FC_mysub and FC_mymod_my_sub.
Another function is provided to verify that the Fortran and C/C++ compilers work together:

   FortranCInterface_VERIFY([CXX] [QUIET])

It tests whether a simple test executable using Fortran and C (and C++ when the CXX option is given) compiles and links successfully. The result is stored in the cache entry FortranCInterface_VERIFIED_C (or FortranCInterface_VERIFIED_CXX if CXX is given) as a boolean. If the check fails and QUIET is not given the function terminates with a FATAL_ERROR message describing the problem. The purpose of this check is to stop a build early for incompatible compiler combinations. The test is built in the Release configuration.
FortranCInterface is aware of possible GLOBAL and MODULE manglings for many Fortran compilers, but it also provides an interface to specify new possible manglings. Set the variables

   FortranCInterface_GLOBAL_SYMBOLS
   FortranCInterface_MODULE_SYMBOLS

before including FortranCInterface to specify manglings of the symbols "MySub", "My_Sub", "MyModule:MySub", and "My_Module:My_Sub". For example, the code:

   set(FortranCInterface_GLOBAL_SYMBOLS mysub_ my_sub__ MYSUB_)
     #                                  ^^^^^  ^^^^^^   ^^^^^
   set(FortranCInterface_MODULE_SYMBOLS
       __mymodule_MOD_mysub __my_module_MOD_my_sub)
     #   ^^^^^^^^     ^^^^^   ^^^^^^^^^     ^^^^^^
   include(FortranCInterface)

tells FortranCInterface to try given GLOBAL and MODULE manglings. (The carets point at raw symbol names for clarity in this example but are not needed.)

GNUInstallDirs
Define GNU standard installation directories
Provides install directory variables as defined for GNU software:
Inclusion of this module defines the following variables:

  CMAKE_INSTALL_<dir>      - destination for files of a given type
  CMAKE_INSTALL_FULL_<dir> - corresponding absolute path

where <dir> is one of:

  BINDIR           - user executables (bin)
  SBINDIR          - system admin executables (sbin)
  LIBEXECDIR       - program executables (libexec)
  SYSCONFDIR       - read-only single-machine data (etc)
  SHAREDSTATEDIR   - modifiable architecture-independent data (com)
  LOCALSTATEDIR    - modifiable single-machine data (var)
  LIBDIR           - object code libraries (lib or lib64 or lib/<multiarch-tuple> on Debian)
  INCLUDEDIR       - C header files (include)
  OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
  DATAROOTDIR      - read-only architecture-independent data root (share)
  DATADIR          - read-only architecture-independent data (DATAROOTDIR)
  INFODIR          - info documentation (DATAROOTDIR/info)
  LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
  MANDIR           - man documentation (DATAROOTDIR/man)
  DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)

Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION options of install() commands for the corresponding file type. If the includer does not define a value the above-shown default will be used and the value will appear in the cache for editing by the user. Each CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed from the corresponding destination by prepending (if necessary) the value of CMAKE_INSTALL_PREFIX.

GenerateExportHeader
Function for generation of export macros for libraries
This module provides the function GENERATE_EXPORT_HEADER() and the accompanying ADD_COMPILER_EXPORT_FLAGS() function.
The GENERATE_EXPORT_HEADER function can be used to generate a file suitable for preprocessor inclusion which contains EXPORT macros to be used in library classes.
GENERATE_EXPORT_HEADER( LIBRARY_TARGET

             [BASE_NAME <base_name>]
             [EXPORT_MACRO_NAME <export_macro_name>]
             [EXPORT_FILE_NAME <export_file_name>]
             [DEPRECATED_MACRO_NAME <deprecated_macro_name>]
             [NO_EXPORT_MACRO_NAME <no_export_macro_name>]
             [STATIC_DEFINE <static_define>]
             [NO_DEPRECATED_MACRO_NAME <no_deprecated_macro_name>]
             [DEFINE_NO_DEPRECATED]
             [PREFIX_NAME <prefix_name>]

)
ADD_COMPILER_EXPORT_FLAGS( [<output_variable>] )
By default GENERATE_EXPORT_HEADER() generates macro names in a file name determined by the name of the library. The ADD_COMPILER_EXPORT_FLAGS function adds -fvisibility=hidden to CMAKE_CXX_FLAGS if supported, and is a no-op on Windows which does not need extra compiler flags for exporting support. You may optionally pass a single argument to ADD_COMPILER_EXPORT_FLAGS that will be populated with the required CXX_FLAGS required to enable visibility support for the compiler/architecture in use.
This means that in the simplest case, users of these functions will be equivalent to:

   add_compiler_export_flags()
   add_library(somelib someclass.cpp)
   generate_export_header(somelib)
   install(TARGETS somelib DESTINATION ${LIBRARY_INSTALL_DIR})
   install(FILES
    someclass.h
    ${PROJECT_BINARY_DIR}/somelib_export.h DESTINATION ${INCLUDE_INSTALL_DIR}
   )

And in the ABI header files:

   #include "somelib_export.h"
   class SOMELIB_EXPORT SomeClass {
     ...
   };

The CMake fragment will generate a file in the ${CMAKE_CURRENT_BINARY_DIR} called somelib_export.h containing the macros SOMELIB_EXPORT, SOMELIB_NO_EXPORT, SOMELIB_DEPRECATED, SOMELIB_DEPRECATED_EXPORT and SOMELIB_DEPRECATED_NO_EXPORT. The resulting file should be installed with other headers in the library.
The BASE_NAME argument can be used to override the file name and the names used for the macros

   add_library(somelib someclass.cpp)
   generate_export_header(somelib
     BASE_NAME other_name
   )

Generates a file called other_name_export.h containing the macros OTHER_NAME_EXPORT, OTHER_NAME_NO_EXPORT and OTHER_NAME_DEPRECATED etc.
The BASE_NAME may be overridden by specifiying other options in the function. For example:

   add_library(somelib someclass.cpp)
   generate_export_header(somelib
     EXPORT_MACRO_NAME OTHER_NAME_EXPORT
   )

creates the macro OTHER_NAME_EXPORT instead of SOMELIB_EXPORT, but other macros and the generated file name is as default.

   add_library(somelib someclass.cpp)
   generate_export_header(somelib
     DEPRECATED_MACRO_NAME KDE_DEPRECATED
   )

creates the macro KDE_DEPRECATED instead of SOMELIB_DEPRECATED.
If LIBRARY_TARGET is a static library, macros are defined without values.
If the same sources are used to create both a shared and a static library, the uppercased symbol ${BASE_NAME}_STATIC_DEFINE should be used when building the static library

   add_library(shared_variant SHARED ${lib_SRCS})
   add_library(static_variant ${lib_SRCS})
   generate_export_header(shared_variant BASE_NAME libshared_and_static)
   set_target_properties(static_variant PROPERTIES
     COMPILE_FLAGS -DLIBSHARED_AND_STATIC_STATIC_DEFINE)

This will cause the export macros to expand to nothing when building the static library.
If DEFINE_NO_DEPRECATED is specified, then a macro ${BASE_NAME}_NO_DEPRECATED will be defined This macro can be used to remove deprecated code from preprocessor output.

   option(EXCLUDE_DEPRECATED "Exclude deprecated parts of the library" FALSE)
   if (EXCLUDE_DEPRECATED)
     set(NO_BUILD_DEPRECATED DEFINE_NO_DEPRECATED)
   endif()
   generate_export_header(somelib ${NO_BUILD_DEPRECATED})

And then in somelib:

   class SOMELIB_EXPORT SomeClass
   {
   public:
   #ifndef SOMELIB_NO_DEPRECATED
     SOMELIB_DEPRECATED void oldMethod();
   #endif
   };

   #ifndef SOMELIB_NO_DEPRECATED
   void SomeClass::oldMethod() {  }
   #endif

If PREFIX_NAME is specified, the argument will be used as a prefix to all generated macros.
For example:

   generate_export_header(somelib PREFIX_NAME VTK_)

Generates the macros VTK_SOMELIB_EXPORT etc.

GetPrerequisites
Functions to analyze and list executable file prerequisites.
This module provides functions to list the .dll, .dylib or .so files that an executable or shared library file depends on. (Its prerequisites.)
It uses various tools to obtain the list of required shared library files:

   dumpbin (Windows)
   objdump (MinGW on Windows)
   ldd (Linux/Unix)
   otool (Mac OSX)

The following functions are provided by this module:

   get_prerequisites
   list_prerequisites
   list_prerequisites_by_glob
   gp_append_unique
   is_file_executable
   gp_item_default_embedded_path
     (projects can override with gp_item_default_embedded_path_override)
   gp_resolve_item
     (projects can override with gp_resolve_item_override)
   gp_resolved_file_type
     (projects can override with gp_resolved_file_type_override)
   gp_file_type

Requires CMake 2.6 or greater because it uses function, break, return and PARENT_SCOPE.

  GET_PREREQUISITES(<target> <prerequisites_var> <exclude_system> <recurse>
                    <exepath> <dirs>)

Get the list of shared library files required by <target>. The list in the variable named <prerequisites_var> should be empty on first entry to this function. On exit, <prerequisites_var> will contain the list of required shared library files.
<target> is the full path to an executable file. <prerequisites_var> is the name of a CMake variable to contain the results. <exclude_system> must be 0 or 1 indicating whether to include or exclude "system" prerequisites. If <recurse> is set to 1 all prerequisites will be found recursively, if set to 0 only direct prerequisites are listed. <exepath> is the path to the top level executable used for @executable_path replacment on the Mac. <dirs> is a list of paths where libraries might be found: these paths are searched first when a target without any path info is given. Then standard system locations are also searched: PATH, Framework locations, /usr/lib...

  LIST_PREREQUISITES(<target> [<recurse> [<exclude_system> [<verbose>]]])

Print a message listing the prerequisites of <target>.
<target> is the name of a shared library or executable target or the full path to a shared library or executable file. If <recurse> is set to 1 all prerequisites will be found recursively, if set to 0 only direct prerequisites are listed. <exclude_system> must be 0 or 1 indicating whether to include or exclude "system" prerequisites. With <verbose> set to 0 only the full path names of the prerequisites are printed, set to 1 extra informatin will be displayed.

  LIST_PREREQUISITES_BY_GLOB(<glob_arg> <glob_exp>)

Print the prerequisites of shared library and executable files matching a globbing pattern. <glob_arg> is GLOB or GLOB_RECURSE and <glob_exp> is a globbing expression used with "file(GLOB" or "file(GLOB_RECURSE" to retrieve a list of matching files. If a matching file is executable, its prerequisites are listed.
Any additional (optional) arguments provided are passed along as the optional arguments to the list_prerequisites calls.

  GP_APPEND_UNIQUE(<list_var> <value>)

Append <value> to the list variable <list_var> only if the value is not already in the list.

  IS_FILE_EXECUTABLE(<file> <result_var>)

Return 1 in <result_var> if <file> is a binary executable, 0 otherwise.

  GP_ITEM_DEFAULT_EMBEDDED_PATH(<item> <default_embedded_path_var>)

Return the path that others should refer to the item by when the item is embedded inside a bundle.
Override on a per-project basis by providing a project-specific gp_item_default_embedded_path_override function.

  GP_RESOLVE_ITEM(<context> <item> <exepath> <dirs> <resolved_item_var>)

Resolve an item into an existing full path file.
Override on a per-project basis by providing a project-specific gp_resolve_item_override function.

  GP_RESOLVED_FILE_TYPE(<original_file> <file> <exepath> <dirs> <type_var>)

Return the type of <file> with respect to <original_file>. String describing type of prerequisite is returned in variable named <type_var>.
Use <exepath> and <dirs> if necessary to resolve non-absolute <file> values -- but only for non-embedded items.
Possible types are:

   system
   local
   embedded
   other

Override on a per-project basis by providing a project-specific gp_resolved_file_type_override function.

  GP_FILE_TYPE(<original_file> <file> <type_var>)

Return the type of <file> with respect to <original_file>. String describing type of prerequisite is returned in variable named <type_var>.
Possible types are:

   system
   local
   embedded
   other

InstallRequiredSystemLibraries
By including this file, all library files listed in the variable CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS will be installed with install(PROGRAMS ...) into bin for WIN32 and lib for non-WIN32. If CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP is set to TRUE before including this file, then the INSTALL command is not called. The user can use the variable CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS to use a custom install command and install them however they want. If it is the MSVC compiler, then the microsoft run time libraries will be found and automatically added to the CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS, and installed. If CMAKE_INSTALL_DEBUG_LIBRARIES is set and it is the MSVC compiler, then the debug libraries are installed when available. If CMAKE_INSTALL_DEBUG_LIBRARIES_ONLY is set then only the debug libraries are installed when both debug and release are available. If CMAKE_INSTALL_MFC_LIBRARIES is set then the MFC run time libraries are installed as well as the CRT run time libraries. If CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION is set then the libraries are installed to that directory rather than the default. If CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS is NOT set, then this file warns about required files that do not exist. You can set this variable to ON before including this file to avoid the warning. For example, the Visual Studio Express editions do not include the redistributable files, so if you include this file on a machine with only VS Express installed, you'll get the warning.

MacroAddFileDependencies
MACRO_ADD_FILE_DEPENDENCIES(<_file> depend_files...)
Using the macro MACRO_ADD_FILE_DEPENDENCIES() is discouraged. There are usually better ways to specify the correct dependencies.
MACRO_ADD_FILE_DEPENDENCIES(<_file> depend_files...) is just a convenience wrapper around the OBJECT_DEPENDS source file property. You can just use set_property(SOURCE <file> APPEND PROPERTY OBJECT_DEPENDS depend_files) instead.

ProcessorCount
ProcessorCount(var)
Determine the number of processors/cores and save value in ${var}
Sets the variable named ${var} to the number of physical cores available on the machine if the information can be determined. Otherwise it is set to 0. Currently this functionality is implemented for AIX, cygwin, FreeBSD, HPUX, IRIX, Linux, Mac OS X, QNX, Sun and Windows.
This function is guaranteed to return a positive integer (>=1) if it succeeds. It returns 0 if there's a problem determining the processor count.
Example use, in a ctest -S dashboard script:

   include(ProcessorCount)
   ProcessorCount(N)
   if(NOT N EQUAL 0)
     set(CTEST_BUILD_FLAGS -j${N})
     set(ctest_test_args ${ctest_test_args} PARALLEL_LEVEL ${N})
   endif()

This function is intended to offer an approximation of the value of the number of compute cores available on the current machine, such that you may use that value for parallel building and parallel testing. It is meant to help utilize as much of the machine as seems reasonable. Of course, knowledge of what else might be running on the machine simultaneously should be used when deciding whether to request a machine's full capacity all for yourself.

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.

SelectLibraryConfigurations
select_library_configurations( basename )
This macro takes a library base name as an argument, and will choose good values for basename_LIBRARY, basename_LIBRARIES, basename_LIBRARY_DEBUG, and basename_LIBRARY_RELEASE depending on what has been found and set. If only basename_LIBRARY_RELEASE is defined, basename_LIBRARY will be set to the release value, and basename_LIBRARY_DEBUG will be set to basename_LIBRARY_DEBUG-NOTFOUND. If only basename_LIBRARY_DEBUG is defined, then basename_LIBRARY will take the debug value, and basename_LIBRARY_RELEASE will be set to basename_LIBRARY_RELEASE-NOTFOUND.
If the generator supports configuration types, then basename_LIBRARY and basename_LIBRARIES will be set with debug and optimized flags specifying the library to be used for the given configuration. If no build type has been set or the generator in use does not support configuration types, then basename_LIBRARY and basename_LIBRARIES will take only the release value, or the debug value if the release one is not set.

SquishTestScript
This script launches a GUI test using Squish. You should not call the script directly; instead, you should access it via the SQUISH_ADD_TEST macro that is defined in FindSquish.cmake.
This script starts the Squish server, launches the test on the client, and finally stops the squish server. If any of these steps fail (including if the tests do not pass) then a fatal error is raised.

TestBigEndian
Define macro to determine endian type
Check if the system is big endian or little endian

  TEST_BIG_ENDIAN(VARIABLE)
  VARIABLE - variable to store the result to

TestCXXAcceptsFlag
Test CXX compiler for a flag
Check if the CXX compiler accepts a flag

  Macro CHECK_CXX_ACCEPTS_FLAG(FLAGS VARIABLE) -
     checks if the function exists
  FLAGS - the flags to try
  VARIABLE - variable to store the result

TestForANSIForScope
Check for ANSI for scope support
Check if the compiler restricts the scope of variables declared in a for-init-statement to the loop body.

  CMAKE_NO_ANSI_FOR_SCOPE - holds result

TestForANSIStreamHeaders
Test for compiler support of ANSI stream headers iostream, etc.
check if the compiler supports the standard ANSI iostream header (without the .h)

  CMAKE_NO_ANSI_STREAM_HEADERS - defined by the results

TestForSSTREAM
Test for compiler support of ANSI sstream header
check if the compiler supports the standard ANSI sstream header

  CMAKE_NO_ANSI_STRING_STREAM - defined by the results

TestForSTDNamespace
Test for std:: namespace support
check if the compiler supports std:: on stl classes

  CMAKE_NO_STD_NAMESPACE - defined by the results

UseEcos
This module defines variables and macros required to build eCos application.
This file contains the following macros: ECOS_ADD_INCLUDE_DIRECTORIES() - add the eCos include dirs ECOS_ADD_EXECUTABLE(name source1 ... sourceN ) - create an eCos executable ECOS_ADJUST_DIRECTORY(VAR source1 ... sourceN ) - adjusts the path of the source files and puts the result into VAR
Macros for selecting the toolchain: ECOS_USE_ARM_ELF_TOOLS() - enable the ARM ELF toolchain for the directory where it is called ECOS_USE_I386_ELF_TOOLS() - enable the i386 ELF toolchain for the directory where it is called ECOS_USE_PPC_EABI_TOOLS() - enable the PowerPC toolchain for the directory where it is called
It contains the following variables: ECOS_DEFINITIONS ECOSCONFIG_EXECUTABLE ECOS_CONFIG_FILE - defaults to ecos.ecc, if your eCos configuration file has a different name, adjust this variable for internal use only:

  ECOS_ADD_TARGET_LIB

UseJava
Use Module for Java
This file provides functions for Java. It is assumed that FindJava.cmake has already been loaded. See FindJava.cmake for information on how to load Java into your CMake project.
add_jar(target_name

         [SOURCES] source1 [source2 ...] [resource1 ...]
         [INCLUDE_JARS jar1 [jar2 ...]]
         [ENTRY_POINT entry]
         [VERSION version]
         [OUTPUT_NAME name]
         [OUTPUT_DIR dir]
        )

This command creates a <target_name>.jar. It compiles the given source files (source) and adds the given resource files (resource) to the jar file. If only resource files are given then just a jar file is created. The list of include jars are added to the classpath when compiling the java sources and also to the dependencies of the target. INCLUDE_JARS also accepts other target names created by add_jar. For backwards compatibility, jar files listed as sources are ignored (as they have been since the first version of this module).
The default OUTPUT_DIR can also be changed by setting the variable CMAKE_JAVA_TARGET_OUTPUT_DIR.
Additional instructions:

   To add compile flags to the target you can set these flags with
   the following variable:

       set(CMAKE_JAVA_COMPILE_FLAGS -nowarn)

   To add a path or a jar file to the class path you can do this
   with the CMAKE_JAVA_INCLUDE_PATH variable.

       set(CMAKE_JAVA_INCLUDE_PATH /usr/share/java/shibboleet.jar)

   To use a different output name for the target you can set it with:

       add_jar(foobar foobar.java OUTPUT_NAME shibboleet.jar)

   To use a different output directory than CMAKE_CURRENT_BINARY_DIR
   you can set it with:

       add_jar(foobar foobar.java OUTPUT_DIR ${PROJECT_BINARY_DIR}/bin)

   To define an entry point in your jar you can set it with the ENTRY_POINT
   named argument:

       add_jar(example ENTRY_POINT com/examples/MyProject/Main)

   To add a VERSION to the target output name you can set it using
   the VERSION named argument to add_jar. This will create a jar file with the
   name shibboleet-1.0.0.jar and will create a symlink shibboleet.jar
   pointing to the jar with the version information.

       add_jar(shibboleet shibbotleet.java VERSION 1.2.0)

    If the target is a JNI library, utilize the following commands to
    create a JNI symbolic link:

       set(CMAKE_JNI_TARGET TRUE)
       add_jar(shibboleet shibbotleet.java VERSION 1.2.0)
       install_jar(shibboleet ${LIB_INSTALL_DIR}/shibboleet)
       install_jni_symlink(shibboleet ${JAVA_LIB_INSTALL_DIR})

    If a single target needs to produce more than one jar from its
    java source code, to prevent the accumulation of duplicate class
    files in subsequent jars, set/reset CMAKE_JAR_CLASSES_PREFIX prior
    to calling the add_jar() function:

       set(CMAKE_JAR_CLASSES_PREFIX com/redhat/foo)
       add_jar(foo foo.java)

       set(CMAKE_JAR_CLASSES_PREFIX com/redhat/bar)
       add_jar(bar bar.java)

Target Properties:

   The add_jar() functions sets some target properties. You can get these
   properties with the
      get_property(TARGET <target_name> PROPERTY <propery_name>)
   command.

   INSTALL_FILES      The files which should be installed. This is used by
                      install_jar().
   JNI_SYMLINK        The JNI symlink which should be installed.
                      This is used by install_jni_symlink().
   JAR_FILE           The location of the jar file so that you can include
                      it.
   CLASS_DIR          The directory where the class files can be found. For
                      example to use them with javah.

find_jar(<VAR>

          name | NAMES name1 [name2 ...]
          [PATHS path1 [path2 ... ENV var]]
          [VERSIONS version1 [version2]]
          [DOC "cache documentation string"]
         )

This command is used to find a full path to the named jar. A cache entry named by <VAR> is created to stor the result of this command. If the full path to a jar is found the result is stored in the variable and the search will not repeated unless the variable is cleared. If nothing is found, the result will be <VAR>-NOTFOUND, and the search will be attempted again next time find_jar is invoked with the same variable. The name of the full path to a file that is searched for is specified by the names listed after NAMES argument. Additional search locations can be specified after the PATHS argument. If you require special a version of a jar file you can specify it with the VERSIONS argument. The argument after DOC will be used for the documentation string in the cache.
install_jar(TARGET_NAME DESTINATION)
This command installs the TARGET_NAME files to the given DESTINATION. It should be called in the same scope as add_jar() or it will fail.
install_jni_symlink(TARGET_NAME DESTINATION)
This command installs the TARGET_NAME JNI symlinks to the given DESTINATION. It should be called in the same scope as add_jar() or it will fail.
create_javadoc(<VAR>

                PACKAGES pkg1 [pkg2 ...]
                [SOURCEPATH <sourcepath>]
                [CLASSPATH <classpath>]
                [INSTALLPATH <install path>]
                [DOCTITLE "the documentation title"]
                [WINDOWTITLE "the title of the document"]
                [AUTHOR TRUE|FALSE]
                [USE TRUE|FALSE]
                [VERSION TRUE|FALSE]
               )

Create java documentation based on files or packages. For more details please read the javadoc manpage.
There are two main signatures for create_javadoc. The first signature works with package names on a path with source files:

   Example:
   create_javadoc(my_example_doc
     PACKAGES com.exmaple.foo com.example.bar
     SOURCEPATH "${CMAKE_CURRENT_SOURCE_DIR}"
     CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
     WINDOWTITLE "My example"
     DOCTITLE "<h1>My example</h1>"
     AUTHOR TRUE
     USE TRUE
     VERSION TRUE
   )

The second signature for create_javadoc works on a given list of files.

   create_javadoc(<VAR>
                  FILES file1 [file2 ...]
                  [CLASSPATH <classpath>]
                  [INSTALLPATH <install path>]
                  [DOCTITLE "the documentation title"]
                  [WINDOWTITLE "the title of the document"]
                  [AUTHOR TRUE|FALSE]
                  [USE TRUE|FALSE]
                  [VERSION TRUE|FALSE]
                 )

Example:

   create_javadoc(my_example_doc
     FILES ${example_SRCS}
     CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
     WINDOWTITLE "My example"
     DOCTITLE "<h1>My example</h1>"
     AUTHOR TRUE
     USE TRUE
     VERSION TRUE
   )

Both signatures share most of the options. These options are the same as what you can find in the javadoc manpage. Please look at the manpage for CLASSPATH, DOCTITLE, WINDOWTITLE, AUTHOR, USE and VERSION.
The documentation will be by default installed to

   ${CMAKE_INSTALL_PREFIX}/share/javadoc/<VAR>

if you don't set the INSTALLPATH.

UseJavaClassFilelist
This script create a list of compiled Java class files to be added to a jar file. This avoids including cmake files which get created in the binary directory.

UseJavaSymlinks
Helper script for UseJava.cmake

UsePkgConfig
Obsolete pkg-config module for CMake, use FindPkgConfig instead.
This module defines the following macro:
PKGCONFIG(package includedir libdir linkflags cflags)
Calling PKGCONFIG will fill the desired information into the 4 given arguments, e.g. PKGCONFIG(libart-2.0 LIBART_INCLUDE_DIR LIBART_LINK_DIR LIBART_LINK_FLAGS LIBART_CFLAGS) if pkg-config was NOT found or the specified software package doesn't exist, the variable will be empty when the function returns, otherwise they will contain the respective information

UseQt4
Use Module for QT4
Sets up C and C++ to use Qt 4. It is assumed that FindQt.cmake has already been loaded. See FindQt.cmake for information on how to load Qt 4 into your CMake project.

UseSWIG
SWIG module for CMake
Defines the following macros:

   SWIG_ADD_MODULE(name language [ files ])
     - Define swig module with given name and specified language
   SWIG_LINK_LIBRARIES(name [ libraries ])
     - Link libraries to swig module

All other macros are for internal use only. To get the actual name of the swig module, use: ${SWIG_MODULE_${name}_REAL_NAME}. Set Source files properties such as CPLUSPLUS and SWIG_FLAGS to specify special behavior of SWIG. Also global CMAKE_SWIG_FLAGS can be used to add special flags to all swig calls. Another special variable is CMAKE_SWIG_OUTDIR, it allows one to specify where to write all the swig generated module (swig -outdir option) The name-specific variable SWIG_MODULE_<name>_EXTRA_DEPS may be used to specify extra dependencies for the generated modules. If the source file generated by swig need some special flag you can use set_source_files_properties( ${swig_generated_file_fullname}

        PROPERTIES COMPILE_FLAGS "-bla")

Use_wxWindows
---------------------------------------------------
This convenience include finds if wxWindows is installed and set the appropriate libs, incdirs, flags etc. author Jan Woetzel <jw -at- mip.informatik.uni-kiel.de> (07/2003) USAGE:

   just include Use_wxWindows.cmake
   in your projects CMakeLists.txt

include( ${CMAKE_MODULE_PATH}/Use_wxWindows.cmake)

   if you are sure you need GL then

set(WXWINDOWS_USE_GL 1)

   *before* you include this file.

UsewxWidgets
Convenience include for using wxWidgets library.
Determines if wxWidgets was FOUND and sets the appropriate libs, incdirs, flags, etc. INCLUDE_DIRECTORIES and LINK_DIRECTORIES are called.
USAGE

  # Note that for MinGW users the order of libs is important!
  find_package(wxWidgets REQUIRED net gl core base)
  include(${wxWidgets_USE_FILE})
  # and for each of your dependent executable/library targets:
  target_link_libraries(<YourTarget> ${wxWidgets_LIBRARIES})

DEPRECATED

  LINK_LIBRARIES is not called in favor of adding dependencies per target.

AUTHOR

  Jan Woetzel <jw -at- mip.informatik.uni-kiel.de>

WriteBasicConfigVersionFile

  WRITE_BASIC_CONFIG_VERSION_FILE( filename VERSION major.minor.patch COMPATIBILITY (AnyNewerVersion|SameMajorVersion) )

Deprecated, see WRITE_BASIC_PACKAGE_VERSION_FILE(), it is identical.