Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ECM-FIND-MODULES(7)	       Extra CMake Modules	     ECM-FIND-MODULES(7)

NAME
     ecm-find-modules - ECM Find Modules Reference

INTRODUCTION
     Find modules are used by the CMake find_package command to search for pack-
     ages  that  do not provide their own CMake package config files. CMake pro-
     vides an extensive set of find modules, and Extra CMake Modules (ECM)  adds
     to that.

     To  use ECMas find modules, you need to tell CMake to find the ECM package,
     and then add either ${ECM_MODULE_PATH}  or  ${ECM_FIND_MODULE_DIR}  to  the
     CMAKE_MODULE_PATH variable:

	find_package(ECM REQUIRED NO_MODULE)
	set(CMAKE_MODULE_PATH ${ECM_FIND_MODULE_DIR})

     Using ${ECM_MODULE_PATH} will also make the modules intended for direct use
     by CMake scripts available (see ecm-modules(7) and ecm-kde-modules(7)).

     You  can also make local copies of find modules using the ecm_use_find_mod-
     ules function from ECMUseFindModules, which is automatically included  when
     ECM is found:

	find_package(ECM REQUIRED NO_MODULE)
	ecm_use_find_modules(
	    DIR "${CMAKE_BINARY_DIR}/cmake"
	    MODULES FindEGL.cmake
	)
	set(CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}/cmake")

     This  allows selective use of ECMas find modules, and the NO_OVERRIDE argu-
     ment can be used to ensure that if CMake ships its own version of that find
     module, it will be used instead.

ALL FIND MODULES
   Find7Zip
     Try to find 7-Zip.

     If the 7-Zip executable is not in your PATH, you can provide an alternative
     name or full path location with the 7Zip_EXECUTABLE variable.

     This will define the following variables:

     7Zip_FOUND
	    TRUE if 7-Zip is available

     7Zip_EXECUTABLE
	    Path to 7-Zip executable

     If 7Zip_FOUND is TRUE, it will also define the following imported target:

     7Zip::7Zip
	    Path to 7-Zip executable

     NOTE:
	It will see to only find the original  7-Zip,  not  one  of  the   p7zip
	forks.

     Since 5.113.0.

   Find7z
     Try to find 7z.

     If  the  7z  executable is not in your PATH, you can provide an alternative
     name or full path location with the 7z_EXECUTABLE variable.

     This will define the following variables:

     7z_FOUND
	    TRUE if 7z is available

     7z_EXECUTABLE
	    Path to 7z executable

     If 7z_FOUND is TRUE, it will also define the following imported target:

     7z::7z
	    Path to 7z executable

     NOTE:
	Only works on Windows.

     Deprecated: since 5.113, use  Find7Zip.

     Since 5.85.0.

   FindCanberra
     Try to find Canberra event sound library.

     This will define the following variables:

     Canberra_FOUND
	    True if (the requested version of) Canberra is available

     Canberra_VERSION
	    The version of Canberra

     Canberra_LIBRARIES
	    The libraries of Canberra for use with target_link_libraries()

     Canberra_INCLUDE_DIRS
	    The include dirs of Canberra for  use  with  target_include_directo-
	    ries()

     If  Canberra_FOUND is TRUE, it will also define the following imported tar-
     get:

     Canberra::Canberra
	    The Canberra library

     In general we recommend using the imported target, as it is easier to  use.
     Bear  in  mind,  however, that if the target is in the link interface of an
     exported library, it must be made available by the package config file.

     Since 5.56.0.

   FindEGL
     Try to find EGL.

     This will define the following variables:

     EGL_FOUND
	    True if (the requested version of) EGL is available

     EGL_VERSION
	    The version of EGL; note that this is the API version defined in the
	    headers, rather than the version of the implementation (eg: Mesa)

     EGL_LIBRARIES
	    This  can  be  passed  to  target_link_libraries()	instead  of  the
	    EGL::EGL target

     EGL_INCLUDE_DIRS
	    This  should be passed to target_include_directories() if the target
	    is not used for linking

     EGL_DEFINITIONS
	    This should be passed to target_compile_options() if the  target  is
	    not used for linking

     If EGL_FOUND is TRUE, it will also define the following imported target:

     EGL::EGL
	    The EGL library

     In  general we recommend using the imported target, as it is easier to use.
     Bear in mind, however, that if the target is in the link  interface  of  an
     exported library, it must be made available by the package config file.

     Since pre-1.0.0.

   FindFFmpeg
     Try to find FFmpeg components.

     The following components are available:

	AVCODEC  AVFILTER    AVDEVICE  AVFORMAT
	AVUTIL	 SWRESAMPLE  SWSCALE   POSTPROCESS

     If  no components are specified in the find_module call, the following ones
     will be chosen as default:

	AVFORMAT AVUTIL AVCODEC

   Imported Targets
     This module provides the following imported targets, if found:

     FFmpeg::FFmpeg
	    For all the required FFmpeg components

     FFmpeg::<component>
	    For each <component> that was found

   Result Variables
     This will define the following variables:

     FFMPEG_FOUND
	    System has the all required components.

     FFMPEG_INCLUDE_DIRS
	    Include directory necessary for using the required components  head-
	    ers.

     FFMPEG_LIBRARIES
	    Link these to use the required FFmpeg components.

     FFMPEG_DEFINITIONS
	    Compiler switches required for using the required FFmpeg components.

     Additionally  for	each  of the components, the following variables will be
     defined:

     <component>_FOUND
	    True if (the requestion version of) <component> is available

     <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 (NOTE: always empty on Windows)

     As the versions of the various FFmpeg components differ  for  a  given  re-
     lease,  and  CMake supports only one common version for all components, use
     the following to specify required versions for multiple components:

	find_package(FFmpeg 57.48 COMPONENTS AVCODEC)
	find_package(FFmpeg 57.40 COMPONENTS AVFORMAT)
	find_package(FFmpeg 55.27 COMPONENTS AVUTIL)

     NOTE: version checking is skipped on Windows

     Since 6.20.0.

   FindGLIB2
     Try to locate the GLib2 library.  If found, this will define the  following
     variables:

     GLIB2_FOUND
	    True if the GLib2 library is available

     GLIB2_INCLUDE_DIRS
	    The GLib2 include directories

     GLIB2_LIBRARIES
	    The GLib2 libraries for linking

     GLIB2_INCLUDE_DIR
	    Deprecated, use GLIB2_INCLUDE_DIRS

     GLIB2_LIBRARY
	    Deprecated, use GLIB2_LIBRARIES

     If GLIB2_FOUND is TRUE, it will also define the following imported target:

     GLIB2::GLIB2
	    The GLIB2 library

     GLIB2::GTHREAD2
	    The GThread2 library (since 6.7.0)

     GLIB2::GOBJECT
	    The GObject library (since 6.7.0)

     GLIB2::GIO
	    The GIO library (since 6.7.0)

     Since 5.41.0.

   FindGperf
     Try to find GNU gperf.

     If the gperf executable is not in your PATH, you can provide an alternative
     name or full path location with the Gperf_EXECUTABLE variable.

     This will define the following variables:

     Gperf_FOUND
	    True if gperf is available.

     Gperf_EXECUTABLE
	    The gperf executable.

     Gperf_VERSION
	    The gperf version. (since 5.85)

     If Gperf_FOUND is TRUE, it will also define the following imported target:

     GPerf::Gperf
	    The gperf executable.

     and the following public function:

	ecm_gperf_generate(<GperfInput> <OutputFile> <OutputVariable(|target (since 5.83))>
			   [GENERATION_FLAGS <flags>])

     Run  gperf on <GperfInput> to generate <OutputFile>, adding it to the <Out-
     putVariable> variable which contains the source for the target where  <Out-
     putFile> is going to be built or, since KF 5.83, if the given argument is a
     target,  to the list of private sources of that target. The target must not
     be an alias. The optional GENERATION_FLAGS argument is needed to pass extra
     parameters to gperf (note you cannot override that way the output file).

     A simple invocation would be:

	ecm_gperf_generate(simple.gperf ${CMAKE_CURRENT_BINARY_DIR}/simple.h MySources)

     Since 5.35.0.

   FindGradle
     Provides the ability to build Android AAR libraries using Gradle.

     This relies on the Qt provided Gradle, so a Qt for Android installation  is
     required.

	gradle_add_aar(<target>
		       BUIDLFILE build.gradle
		       NAME <aar-name>)

     This builds an Android AAR library using the given build.gradle file.

	gradle_install_aar(<target>
			   DESTINATION <dest>)

     Installs a Android AAR library that has been created with gradle_add_aar.

     Since 5.76.0.

   FindIcoTool
     Try to find icotool.

     If  the icotool executable is not in your PATH, you can provide an alterna-
     tive name or full path location with the IcoTool_EXECUTABLE variable.

     This will define the following variables:

     IcoTool_FOUND
	    True if icotool is available.

     IcoTool_EXECUTABLE
	    The icotool executable.

     If IcoTool_FOUND is TRUE, it will also define the following  imported  tar-
     get:

     IcoTool::IcoTool
	    The icotool executable.

     Since 5.49.

   FindInotify
     Try to find inotify on this system. This finds:

	    * libinotify on Unix like systems, or

	    * the kernelas inotify.

     This will define the following variables:

     Inotify_FOUND
	    True if inotify is available

     Inotify_LIBRARIES
	    This has to be passed to target_link_libraries()

     Inotify_INCLUDE_DIRS
	    This has to be passed to target_include_directories()

     On  some platforms like Linux and SunOS, the libraries and include directo-
     ries are empty, even though Inotify_FOUND may be set to TRUE. This  is  be-
     cause  no	special includes or libraries are needed. On other systems these
     may be needed to use inotify.

     Since 5.32.0.

   FindIsoCodes
     Try to find iso-codes data files.	Once done this will define:

     IsoCodes_FOUND
	    Whether the system has iso-codes

     IsoCodes_PREFIX
	    The location in which the iso-codes data files are found

     IsoCodes_DOMAINS
	    The available domains provided by iso-codes

     Since 5.80.0.

   FindKF5
     Find KDE Frameworks 5 with a single find_package() call.

     This will use the package config files provided by  the  individual  frame-
     works.  For example, if you wish to find KArchive, which presents itself to
     CMake  as	KF5Archive (ie: you would do find_package(KF5Archive) to find it
     directly), you can do

	find_package(KF5 COMPONENTS Archive)

     If all the required components (those given in the COMPONENTS argument, but
     not those given in the OPTIONAL_COMPONENTS argument) are  found,  KF5_FOUND
     will be set to true. Otherwise, it will be set to false.

     Since pre-1.0.0.

   FindLibExiv2
     Try to find the Exiv2 library.

     This will define the following variables:

     LibExiv2_FOUND
	    True if (the requested version of) Exiv2 is available

     LibExiv2_VERSION
	    The version of Exiv2

     LibExiv2_INCLUDE_DIRS
	    The include dirs of Exiv2 for use with target_include_directories()

     LibExiv2_LIBRARIES
	    The Exiv2 library for use with target_link_libraries().  This can be
	    passed  to target_link_libraries() instead of the LibExiv2::LibExiv2
	    target

     If LibExiv2_FOUND is TRUE, it will also define the following imported  tar-
     get:

     LibExiv2::LibExiv2
	    The Exiv2 library

     In  general we recommend using the imported target, as it is easier to use.
     Bear in mind, however, that if the target is in the link  interface  of  an
     exported library, it must be made available by the package config file.

     Since 5.53.0.

   FindLibGit2
     Try to find libgit2 on a Unix system.

     This will define the following variables:

     LIBGIT2_FOUND
	    True if (the requested version of) libgit2 is available

     LIBGIT2_VERSION
	    The version of libgit2

     LIBGIT2_LIBRARIES
	    This  can  be  passed  to  target_link_libraries()	instead  of  the
	    LibGit2::LibGit2 target

     LIBGIT2_INCLUDE_DIRS
	    This should be passed to target_include_directories() if the  target
	    is not used for linking

     LIBGIT2_DEFINITIONS
	    This  should  be passed to target_compile_options() if the target is
	    not used for linking

     If LIBGIT2_FOUND is TRUE, it will also define the following  imported  tar-
     get:

     LibGit2::LibGit2
	    The libgit2 library

     In  general we recommend using the imported target, as it is easier to use.
     Bear in mind, however, that if the target is in the link  interface  of  an
     exported library, it must be made available by the package config file.

     Since 1.3.0.

   FindLibMount
     Try  to find the libmount library (part of util-linux), once done this will
     define:

     LibMount_FOUND
	    LibMount was found on the system.

     LibMount_INCLUDE_DIRS
	    The libmount include directory.

     LibMount_LIBRARIES
	    The libmount libraries.

     LibMount_VERSION
	    The libmount version.

     If LibMount_FOUND is TRUE, it will also define the following imported  tar-
     get:

     LibMount::LibMount
	    The libmount library

     Since 5.83.0

   FindLibcap
     Try to find the setcap binary and cap libraries

     This will define:

     Libcap_FOUND
	    system has the cap library and setcap binary

     Libcap_LIBRARIES
	    cap libraries to link against

     SETCAP_EXECUTABLE
	    path of the setcap binary

     In addition, the following targets are defined:
	    Libcap::SetCapabilities

     Since 5.80.0

   FindOpenEXR
     Try to find the OpenEXR libraries.

     This will define the following variables:

     OpenEXR_FOUND
	    True if OpenEXR is available

     OpenEXR_LIBRARIES
	    Link to these to use OpenEXR

     OpenEXR_INCLUDE_DIRS
	    Include directory for OpenEXR

     OpenEXR_DEFINITIONS
	    Compiler flags required to link against OpenEXR

     and the following imported targets:

     OpenEXR::IlmImf
	    The OpenEXR core library

     In  general we recommend using the imported target, as it is easier to use.
     Bear in mind, however, that if the target is in the link  interface  of  an
     exported library, it must be made available by the package config file.

     Since pre-1.0.0.

   FindPhoneNumber
     Try to find PhoneNumber.

     This  is  a  component-based find module, which makes use of the COMPONENTS
     and OPTIONAL_COMPONENTS arguments to find_module.	The following components
     are available:

	PhoneNumber  GeoCoding

     If no components are specified, this module will act as though  all  compo-
     nents were passed to OPTIONAL_COMPONENTS.

     This  module will define the following variables, independently of the com-
     ponents searched for or found:

     PhoneNumber_FOUND
	    True if (the requestion version of) PhoneNumber is available

     For each searched-for components, PhoneNumber_<component>_FOUND will be set
     to TRUE if the corresponding library was found, and  FALSE  otherwise.   If
     PhoneNumber_<component>_FOUND   is  TRUE,	the  imported  target  PhoneNum-
     ber::<component> will be defined.

     Since 5.54.0.

   FindPoppler
     Try to find Poppler.

     This is a component-based find module, which makes use  of  the  COMPONENTS
     and OPTIONAL_COMPONENTS arguments to find_module.	The following components
     are available:

	Core  Cpp  Qt5	Qt4  Glib

     If  no  components are specified, this module will act as though all compo-
     nents were passed to OPTIONAL_COMPONENTS.

     This module will define the following variables, independently of the  com-
     ponents searched for or found:

     Poppler_FOUND
	    TRUE if (the requested version of) Poppler is available

     Poppler_VERSION
	    Found Poppler version

     Poppler_TARGETS
	    A  list  of all targets imported by this module (note that there may
	    be more than the components that were requested)

     Poppler_LIBRARIES
	    This can be passed to target_link_libraries()  instead  of	the  im-
	    ported targets

     Poppler_INCLUDE_DIRS
	    This should be passed to target_include_directories() if the targets
	    are not used for linking

     Poppler_DEFINITIONS
	    This should be passed to target_compile_options() if the targets are
	    not used for linking

     For  each searched-for components, Poppler_<component>_FOUND will be set to
     TRUE if the corresponding Poppler library was found, and  FALSE  otherwise.
     If  Poppler_<component>_FOUND is TRUE, the imported target Poppler::<compo-
     nent> will be defined.  This module will also  attempt  to  determine  Pop-
     pler_*_VERSION variables for each imported target, although Poppler_VERSION
     should normally be sufficient.

     In  general  we recommend using the imported targets, as they are easier to
     use and provide more control.  Bear in mind, however, that if any target is
     in the link interface of an exported library, it must be made available  by
     the package config file.

     Since 5.19

   FindPulseAudio
     Try  to locate the PulseAudio library.  If found, this will define the fol-
     lowing variables:

     PulseAudio_FOUND
	    True if the system has the PulseAudio library of at least the  mini-
	    mum  version specified by either the version parameter to find_pack-
	    age() or the variable PulseAudio_MINIMUM_VERSION

     PulseAudio_INCLUDE_DIRS
	    The PulseAudio include directory

     PulseAudio_LIBRARIES
	    The PulseAudio libraries for linking

     PulseAudio_MAINLOOP_LIBRARY
	    The libraries needed to use PulseAudio Mainloop

     PulseAudio_VERSION
	    The version of PulseAudio that was found

     PulseAudio_INCLUDE_DIR
	    Deprecated, use PulseAudio_INCLUDE_DIRS

     PulseAudio_LIBRARY
	    Deprecated, use PulseAudio_LIBRARIES

     If PulseAudio_FOUND is TRUE, it will also	define	the  following	imported
     target:

     PulseAudio::PulseAudio
	    The PulseAudio library

     Since 5.41.0.

   FindQtWaylandScanner
     Try to find qtwaylandscanner.

     If  the qtwaylandscanner executable is not in your PATH, you can provide an
     alternative name or full path location with the QtWaylandScanner_EXECUTABLE
     variable.

     This will define the following variables:

     QtWaylandScanner_FOUND
	    True if qtwaylandscanner is available

     QtWaylandScanner_EXECUTABLE
	    The qtwaylandscanner executable.

     If QtWaylandScanner_FOUND is TRUE, it will also define  the  following  im-
     ported target:

     Wayland::QtScanner
	    The qtwaylandscanner executable.

     This  module  provides the following functions to generate C++ protocol im-
     plementations:

	* ecm_add_qtwayland_client_protocol

	* ecm_add_qtwayland_server_protocol

	ecm_add_qtwayland_client_protocol(<target>
					  PROTOCOL <xmlfile>
					  BASENAME <basename>
					  [PREFIX <prefix>]
					  [PRIVATE_CODE])

	ecm_add_qtwayland_client_protocol(<source_files_var>
					  PROTOCOL <xmlfile>
					  BASENAME <basename>
					  [PREFIX <prefix>]
					  [PRIVATE_CODE])

     Generate C++ wrapper to Wayland client protocol files  from  <xmlfile>  XML
     definition   for  the  <basename>	interface  and	append	those  files  to
     <source_files_var> or <target>.  Pass the <prefix> argument if  the  inter-
     face  names  donat  start	with  qt_  or  wl_.  PRIVATE_CODE instructs way-
     land-scanner to hide marshalling code from the  compiled  DSO  for  use  in
     other DSOs. The default is to export this code.

     WaylandScanner is required and will be searched for.

	ecm_add_qtwayland_server_protocol(<target>
					  PROTOCOL <xmlfile>
					  BASENAME <basename>
					  [PREFIX <prefix>]
					  [PRIVATE_CODE])

	ecm_add_qtwayland_server_protocol(<source_files_var>
					  PROTOCOL <xmlfile>
					  BASENAME <basename>
					  [PREFIX <prefix>]
					  [PRIVATE_CODE])

     Generate  C++  wrapper  to Wayland server protocol files from <xmlfile> XML
     definition  for  the  <basename>  interface  and  append  those  files   to
     <source_files_var>  or  <target>.	Pass the <prefix> argument if the inter-
     face names donat start  with  qt_	or  wl_.   PRIVATE_CODE  instructs  way-
     land-scanner  to  hide  marshalling  code	from the compiled DSO for use in
     other DSOs. The default is to export this code.

     WaylandScanner is required and will be searched for.

     Since 1.4.0.

   FindSasl2
     Try to find the SASL2 library.

     This will define the following variables:

     Sasl2_FOUND
	    System has SASL2.

     Sasl2_VERSION
	    The version of SASL2.

     Sasl2_INCLUDE_DIRS
	    This should be passed to target_include_directories() if the  target
	    is not used for linking.

     Sasl2_LIBRARIES
	    The  SASL2	library.   This can be passed to target_link_libraries()
	    instead of the Sasl2::Sasl2 target

     If Sasl2_FOUND is TRUE, the following imported target will be available:

     Sasl2::Sasl2
	    The SASL2 library

     Since 5.41.0.

   FindSeccomp
     Try to locate the libseccomp library.

     This will define the following variables:

     Seccomp_FOUND
	    True if the seccomp library is available

     Seccomp_INCLUDE_DIRS
	    The seccomp include directories

     Seccomp_LIBRARIES
	    The seccomp libraries for linking

     If Seccomp_FOUND is TRUE, it will also define the following  imported  tar-
     get:

     Seccomp::Seccomp
	    The Seccomp library

     Since 5.44.0.

   FindSharedMimeInfo
     Try to find the shared-mime-info package.

     This will define the following variables:

     SharedMimeInfo_FOUND
	    True if system has the shared-mime-info package

     UPDATE_MIME_DATABASE_EXECUTABLE
	    The update-mime-database executable

     and the following imported targets:

     SharedMimeInfo::UpdateMimeDatabase
	    The update-mime-database executable

     The follow macro is available:

	update_xdg_mimetypes(<path>)

     Updates the XDG mime database at install time (unless the $DESTDIR environ-
     ment variable is set, in which case it is up to package managers to perform
     this task).

     Since pre-1.0.0.

   FindTaglib
     Try to find the Taglib library.

     This will define the following variables:

     Taglib_FOUND
	    True  if  the  system has the taglib library of at least the minimum
	    version specified by the version parameter to find_package()

     Taglib_INCLUDE_DIRS
	    The taglib include dirs for use with target_include_directories

     Taglib_LIBRARIES
	    The taglib libraries for use with target_link_libraries()

     Taglib_VERSION
	    The version of taglib that was found

     If Taglib_FOUND is TRUE, it will also define the following imported target:

     Taglib::Taglib
	    The Taglib library

     Since 5.72.0

   FindUDev
     Try to find the UDev library.

     This will define the following variables:

     UDev_FOUND
	    System has UDev.

     UDev_INCLUDE_DIRS
	    The libudev include directory.

     UDev_LIBRARIES
	    The libudev libraries.

     UDev_VERSION
	    The libudev version.

     If UDev_FOUND is TRUE, it will also define the following imported target:

     UDev::UDev
	    The UDev library

     Since 5.57.0.

   FindWayland
     Try to find Wayland.

     This is a component-based find module, which makes use  of  the  COMPONENTS
     and OPTIONAL_COMPONENTS arguments to find_module.	The following components
     are available:

	Client	Server	Cursor	Egl

     If  no  components are specified, this module will act as though all compo-
     nents were passed to OPTIONAL_COMPONENTS.

     This module will define the following variables, independently of the  com-
     ponents searched for or found:

     Wayland_FOUND
	    TRUE if (the requested version of) Wayland is available

     Wayland_VERSION
	    Found Wayland version

     Wayland_TARGETS
	    A  list  of all targets imported by this module (note that there may
	    be more than the components that were requested)

     Wayland_LIBRARIES
	    This can be passed to target_link_libraries()  instead  of	the  im-
	    ported targets

     Wayland_INCLUDE_DIRS
	    This should be passed to target_include_directories() if the targets
	    are not used for linking

     Wayland_DEFINITIONS
	    This should be passed to target_compile_options() if the targets are
	    not used for linking

     Wayland_DATADIR
	    The core wayland protocols data directory Since 5.73.0

     For  each searched-for components, Wayland_<component>_FOUND will be set to
     TRUE if the corresponding Wayland library was found, and  FALSE  otherwise.
     If  Wayland_<component>_FOUND is TRUE, the imported target Wayland::<compo-
     nent> will be defined.  This module will also  attempt  to  determine  Way-
     land_*_VERSION variables for each imported target, although Wayland_VERSION
     should normally be sufficient.

     In  general  we recommend using the imported targets, as they are easier to
     use and provide more control.  Bear in mind, however, that if any target is
     in the link interface of an exported library, it must be made available  by
     the package config file.

     Since pre-1.0.0.

   FindWaylandProtocols
     Try to find wayland-protocols on a Unix system.

     This will define the following variables:

     WaylandProtocols_FOUND
	    True if (the requested version of) wayland-protocols is available

     WaylandProtocols_VERSION
	    The version of wayland-protocols

     WaylandProtocols_DATADIR
	    The wayland protocols data directory

   FindWaylandScanner
     Try to find wayland-scanner.

     If  the  wayland-scanner executable is not in your PATH, you can provide an
     alternative name or full path location with  the  WaylandScanner_EXECUTABLE
     variable.

     This will define the following variables:

     WaylandScanner_FOUND
	    True if wayland-scanner is available.

     WaylandScanner_EXECUTABLE
	    The wayland-scanner executable.

     If WaylandScanner_FOUND is TRUE, it will also define the following imported
     target:

     Wayland::Scanner
	    The wayland-scanner executable.

     This  module provides the following functions to generate C protocol imple-
     mentations:

	* ecm_add_wayland_client_protocol

	* ecm_add_wayland_server_protocol

	ecm_add_wayland_client_protocol(<target>
					PROTOCOL <xmlfile>
					BASENAME <basename>
					[PRIVATE_CODE])

	ecm_add_wayland_client_protocol(<source_files_var>
					PROTOCOL <xmlfile>
					BASENAME <basename>
					[PRIVATE_CODE])

     Generate Wayland client protocol files from <xmlfile>  XML  definition  for
     the  <basename>  interface  and append those files to <source_files_var> or
     <target>.

     PRIVATE_CODE instructs wayland-scanner to hide marshalling  code  from  the
     compiled DSO for use in other DSOs. The default is to export this code.

	ecm_add_wayland_server_protocol(<target>
					PROTOCOL <xmlfile>
					BASENAME <basename>
					[PRIVATE_CODE])

	ecm_add_wayland_server_protocol(<source_files_var>
					PROTOCOL <xmlfile>
					BASENAME <basename>
					[PRIVATE_CODE])

     Generate  Wayland	server	protocol files from <xmlfile> XML definition for
     the <basename> interface and append those files  to  <source_files_var>  or
     <target>.

     PRIVATE_CODE  instructs  wayland-scanner  to hide marshalling code from the
     compiled DSO for use in other DSOs. The default is to export this code.

     Since 1.4.0.

   FindX11_XCB
     Try to find the X11 XCB compatibility library.

     This will define the following variables:

     X11_XCB_FOUND
	    True if (the requested version of) libX11-xcb is available

     X11_XCB_VERSION
	    The version of libX11-xcb (this is not guaranteed  to  be  set  even
	    when X11_XCB_FOUND is true)

     X11_XCB_LIBRARIES
	    This  can  be  passed  to  target_link_libraries()	instead  of  the
	    EGL::EGL target

     X11_XCB_INCLUDE_DIR
	    This should be passed to target_include_directories() if the  target
	    is not used for linking

     X11_XCB_DEFINITIONS
	    This  should  be passed to target_compile_options() if the target is
	    not used for linking

     If X11_XCB_FOUND is TRUE, it will also define the following  imported  tar-
     get:

     X11::XCB
	    The X11 XCB compatibility library

     In  general we recommend using the imported target, as it is easier to use.
     Bear in mind, however, that if the target is in the link  interface  of  an
     exported library, it must be made available by the package config file.

     Since pre-1.0.0.

   FindXCB
     Try to find XCB.

     This  is  a  component-based find module, which makes use of the COMPONENTS
     and OPTIONAL_COMPONENTS arguments to find_module.	The following components
     are available:

	XCB
	ATOM	     AUX	  COMPOSITE    CURSOR	    DAMAGE
	DPMS	     DRI2	  DRI3	       EVENT	    EWMH
	GLX	     ICCCM	  IMAGE        KEYSYMS	    PRESENT
	RANDR	     RECORD	  RENDER       RENDERUTIL   RES
	SCREENSAVER  SHAPE	  SHM	       SYNC	    UTIL
	XF86DRI      XFIXES	  XINERAMA     XINPUT	    XKB
	XTEST	     XV 	  XVMC

     If no components are specified, this module will act as though  all  compo-
     nents were passed to OPTIONAL_COMPONENTS. Before 5.82 this excluded XINPUT.
     Since 5.82 all components are searched for.

     This  module will define the following variables, independently of the com-
     ponents searched for or found:

     XCB_FOUND
	    True if (the requestion version of) xcb is available

     XCB_VERSION
	    Found xcb version

     XCB_TARGETS
	    A list of all targets imported by this module (note that  there  may
	    be more than the components that were requested)

     XCB_LIBRARIES
	    This  can  be  passed  to target_link_libraries() instead of the im-
	    ported targets

     XCB_INCLUDE_DIRS
	    This should be passed to target_include_directories() if the targets
	    are not used for linking

     XCB_DEFINITIONS
	    This should be passed to target_compile_options() if the targets are
	    not used for linking

     For each searched-for components, XCB_<component>_FOUND will be set to true
     if the corresponding xcb  library	was  found,  and  false  otherwise.   If
     XCB_<component>_FOUND is true, the imported target XCB::<component> will be
     defined.	This  module  will also attempt to determine XCB_*_VERSION vari-
     ables for each imported target, although  XCB_VERSION  should  normally  be
     sufficient.

     In  general  we recommend using the imported targets, as they are easier to
     use and provide more control.  Bear in mind, however, that if any target is
     in the link interface of an exported library, it must be made available  by
     the package config file.

     Since pre-1.0.0.

   Findepoxy
     Try to find libepoxy on a Unix system.

     This will define the following variables:

     epoxy_FOUND
	    True if (the requested version of) libepoxy is available

     epoxy_VERSION
	    The version of libepoxy

     epoxy_LIBRARIES
	    This  should  be  passed to target_link_libraries() if the target is
	    not used for linking

     epoxy_INCLUDE_DIRS
	    This should be passed to target_include_directories() if the  target
	    is not used for linking

     epoxy_DEFINITIONS
	    This  should  be passed to target_compile_options() if the target is
	    not used for linking

     epoxy_HAS_GLX
	    True if GLX support is available

     If epoxy_FOUND is TRUE, it will also define the following imported target:

     epoxy::epoxy
	    The epoxy library

     In general we recommend using the imported target, as it is easier to  use.
     Bear  in  mind,  however, that if the target is in the link interface of an
     exported library, it must be made available by the package config file.

   Findgzip
     Try to find gzip.

     If the gzip executable is not in your PATH, you can provide an  alternative
     name or full path location with the gzip_EXECUTABLE variable.

     This will define the following variables:

     gzip_FOUND
	    TRUE if gzip is available

     gzip_EXECUTABLE
	    Path to gzip executable

     If gzip_FOUND is TRUE, it will also define the following imported target:

     gzip::gzip
	    Path to gzip executable

     Since 5.85.0.

SEE ALSO
     ecm(7), ecm-modules(7), ecm-kde-modules(7)

COPYRIGHT
     KDE Developers

6.28				  Jul 31, 2026		     ECM-FIND-MODULES(7)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=ecm-find-modules&sektion=7&manpath=FreeBSD+Ports+15.1.quarterly>

home | help