Ubuntu Manpage: ecm-find-modules - ECM Find Modules Reference

Provided by: extra-cmake-modules_5.68.0-0ubuntu1_amd64

NAME

       ecm-find-modules - ECM Find Modules Reference

INTRODUCTION

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

       To  use  ECM’s  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_modules 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 ECM’s find modules, and the NO_OVERRIDE argument can be  used
       to  ensure  that  if  CMake  ships  its  own  version of that find module, it will be used
       instead.

ALL FIND MODULES

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_directories()

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

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

Since pre-1.0.0.

FindFontconfig
Try to find Fontconfig. Once done this will define the following variables:

Fontconfig_FOUND
True if Fontconfig is available

Fontconfig_INCLUDE_DIRS
The include directory to use for the Fontconfig headers

Fontconfig_LIBRARIES
The Fontconfig libraries for linking

Fontconfig_DEFINITIONS
Compiler switches required for using Fontconfig

Fontconfig_VERSION
The version of Fontconfig that has been found

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

Fontconfig::Fontconfig

Since 5.57.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

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.

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>
[GENERATION_FLAGS <flags>])

Run gperf on <GperfInput> to generate <OutputFile>, adding it to the <OutputVariable>
variable which contains the source for the target where <OutputFile> is going to be built.
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.

FindIcoTool
Try to find icotool.

If the icotool executable is not in your PATH, you can provide an alternative 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 target:

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 kernel’s inotify on Linux systems.

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 Linux, the libraries and include directories are empty, even though Inotify_FOUND may
be set to TRUE. This is because no special includes or libraries are needed. On other
systems these may be needed to use inotify.

Since 5.32.0.

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

This will use the package config files provided by the individual frameworks. 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 target:

LibExiv2::LibExiv2
The Exiv2 library

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 target:

LibGit2::LibGit2
The libgit2 library

Since 1.3.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

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 components were passed
to OPTIONAL_COMPONENTS.

This module will define the following variables, independently of the components 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 PhoneNumber::<component> will be defined.

Since 5.54.0.

FindPng2Ico
Try to find png2ico.

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

This will define the following variables:

Png2Ico_FOUND
True if png2ico is available.

Png2Ico_EXECUTABLE
The png2ico executable.

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

Png2Ico::Png2Ico
The png2ico executable.

and the following variables:

Png2Ico_HAS_COLORS_ARGUMENT
Whether png2ico accepts a --colors argument. Matthias Benkmann’s tool does, while
the version of png2ico from the “KDE On Windows” (kdewin) project does not.

Png2Ico_HAS_RCFILE_ARGUMENT
Whether png2ico accepts an --rcfile argument. The version of png2ico from the “KDE
On Windows” (kdewin) project does, while Matthias Benkmann’s tool does not.

Since 1.7.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 components were passed
to OPTIONAL_COMPONENTS.

This module will define the following variables, independently of the components 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 imported 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::<component> will be
defined. This module will also attempt to determine Poppler_*_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 following variables:

PulseAudio_FOUND
True if the system has the PulseAudio library of at least the minimum version
specified by either the version parameter to find_package() 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 imported target:

Wayland::QtScanner
The qtwaylandscanner executable.

This module provides the following functions to generate C++ protocol implementations:

• ecm_add_qtwayland_client_protocol

• ecm_add_qtwayland_server_protocol

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

Generate C++ wrapper to Wayland client protocol files from <xmlfile> XML definition for
the <basename> interface and append those files to <source_files_var>. Pass the <prefix>
argument if the interface names don’t start with qt_ or wl_.

WaylandScanner is required and will be searched for.

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

Generate C++ wrapper to Wayland server protocol files from <xmlfile> XML definition for
the <basename> interface and append those files to <source_files_var>. Pass the <prefix>
argument if the interface names don’t start with qt_ or wl_.

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 target:

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 environment variable is
set, in which case it is up to package managers to perform this task).

Since pre-1.0.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 components were passed
to OPTIONAL_COMPONENTS.

This module will define the following variables, independently of the components 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 imported 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

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::<component> will be
defined. This module will also attempt to determine Wayland_*_VERSION variables for each
imported target, although Wayland_VERSION should normally be sufficient.

Since pre-1.0.0.

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 implementations:

• ecm_add_wayland_client_protocol

• ecm_add_wayland_server_protocol

ecm_add_wayland_client_protocol(<source_files_var>
PROTOCOL <xmlfile>
BASENAME <basename>)

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

ecm_add_wayland_server_protocol(<source_files_var>
PROTOCOL <xmlfile>
BASENAME <basename>)

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

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 target:

X11::XCB
The X11 XCB compatibility library

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
XEVIE XF86DRI XFIXES XINERAMA XINPUT
XKB XPRINT XTEST XV XVMC

If no components are specified, this module will act as though all components except
XINPUT (which is considered unstable) were passed to OPTIONAL_COMPONENTS.

This module will define the following variables, independently of the components 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 imported 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 variables for each imported target, although XCB_VERSION should
normally be sufficient.

Since pre-1.0.0.

COPYRIGHT

       KDE Developers

NAME

INTRODUCTION

ALL FIND MODULES

SEE ALSO

COPYRIGHT