1ECM-FIND-MODULES(7)           Extra CMake Modules          ECM-FIND-MODULES(7)
2
3
4

NAME

6       ecm-find-modules - ECM Find Modules Reference
7

INTRODUCTION

9       Find  modules  are used by the CMake find_package command to search for
10       packages that do not provide their  own  CMake  package  config  files.
11       CMake  provides  an extensive set of find modules, and Extra CMake Mod‐
12       ules (ECM) adds to that.
13
14       To use ECM’s find modules, you need to tell CMake to find the ECM pack‐
15       age,  and  then add either ${ECM_MODULE_PATH} or ${ECM_FIND_MODULE_DIR}
16       to the CMAKE_MODULE_PATH variable:
17
18          find_package(ECM REQUIRED NO_MODULE)
19          set(CMAKE_MODULE_PATH ${ECM_FIND_MODULE_DIR})
20
21       Using ${ECM_MODULE_PATH} will also make the modules intended for direct
22       use  by  CMake  scripts  available (see ecm-modules(7) and ecm-kde-mod‐
23       ules(7)).
24
25       You  can  also  make  local  copies   of   find   modules   using   the
26       ecm_use_find_modules function from ECMUseFindModules, which is automat‐
27       ically included when ECM is found:
28
29          find_package(ECM REQUIRED NO_MODULE)
30          ecm_use_find_modules(
31              DIR "${CMAKE_BINARY_DIR}/cmake"
32              MODULES FindEGL.cmake
33          )
34          set(CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}/cmake")
35
36       This allows selective use of ECM’s find modules,  and  the  NO_OVERRIDE
37       argument  can  be used to ensure that if CMake ships its own version of
38       that find module, it will be used instead.
39

ALL FIND MODULES

41   FindCanberra
42       Try to find Canberra event sound library.
43
44       This will define the following variables:
45
46       Canberra_FOUND
47              True if (the requested version of) Canberra is available
48
49       Canberra_VERSION
50              The version of Canberra
51
52       Canberra_LIBRARIES
53              The libraries of Canberra for use with target_link_libraries()
54
55       Canberra_INCLUDE_DIRS
56              The include dirs of Canberra for use with  target_include_direc‐
57              tories()
58
59       If  Canberra_FOUND  is TRUE, it will also define the following imported
60       target:
61
62       Canberra::Canberra
63              The Canberra library
64
65       In general we recommend using the imported target, as it is  easier  to
66       use.   Bear  in mind, however, that if the target is in the link inter‐
67       face of an exported library, it must be made available by  the  package
68       config file.
69
70       Since 5.56.0.
71
72   FindEGL
73       Try to find EGL.
74
75       This will define the following variables:
76
77       EGL_FOUND
78              True if (the requested version of) EGL is available
79
80       EGL_VERSION
81              The version of EGL; note that this is the API version defined in
82              the headers, rather than the version of the implementation  (eg:
83              Mesa)
84
85       EGL_LIBRARIES
86              This  can  be  passed  to target_link_libraries() instead of the
87              EGL::EGL target
88
89       EGL_INCLUDE_DIRS
90              This should be passed  to  target_include_directories()  if  the
91              target is not used for linking
92
93       EGL_DEFINITIONS
94              This  should be passed to target_compile_options() if the target
95              is not used for linking
96
97       If EGL_FOUND is TRUE, it will also define the following  imported  tar‐
98       get:
99
100       EGL::EGL
101              The EGL library
102
103       In  general  we recommend using the imported target, as it is easier to
104       use.  Bear in mind, however, that if the target is in the  link  inter‐
105       face  of  an exported library, it must be made available by the package
106       config file.
107
108       Since pre-1.0.0.
109
110   FindFontconfig
111       Try to find Fontconfig.  Once done this will define the following vari‐
112       ables:
113
114       Fontconfig_FOUND
115              True if Fontconfig is available
116
117       Fontconfig_INCLUDE_DIRS
118              The include directory to use for the Fontconfig headers
119
120       Fontconfig_LIBRARIES
121              The Fontconfig libraries for linking
122
123       Fontconfig_DEFINITIONS
124              Compiler switches required for using Fontconfig
125
126       Fontconfig_VERSION
127              The version of Fontconfig that has been found
128
129       If Fontconfig_FOUND is TRUE, it will also define the following imported
130       target:
131
132       Fontconfig::Fontconfig
133
134       Since 5.57.0.
135
136   FindGLIB2
137       Try to locate the GLib2 library.  If found, this will define  the  fol‐
138       lowing variables:
139
140       GLIB2_FOUND
141              True if the GLib2 library is available
142
143       GLIB2_INCLUDE_DIRS
144              The GLib2 include directories
145
146       GLIB2_LIBRARIES
147              The GLib2 libraries for linking
148
149       GLIB2_INCLUDE_DIR
150              Deprecated, use GLIB2_INCLUDE_DIRS
151
152       GLIB2_LIBRARY
153              Deprecated, use GLIB2_LIBRARIES
154
155       If GLIB2_FOUND is TRUE, it will also define the following imported tar‐
156       get:
157
158       GLIB2::GLIB2
159              The GLIB2 library
160
161       Since 5.41.0.
162
163   FindGperf
164       Try to find GNU gperf.
165
166       If the gperf executable is not in your PATH, you can provide an  alter‐
167       native name or full path location with the Gperf_EXECUTABLE variable.
168
169       This will define the following variables:
170
171       Gperf_FOUND
172              True if gperf is available.
173
174       Gperf_EXECUTABLE
175              The gperf executable.
176
177       If Gperf_FOUND is TRUE, it will also define the following imported tar‐
178       get:
179
180       GPerf::Gperf
181              The gperf executable.
182
183       and the following public function:
184
185          ecm_gperf_generate(<GperfInput> <OutputFile> <OutputVariable>
186                             [GENERATION_FLAGS <flags>])
187
188       Run gperf on <GperfInput> to generate <OutputFile>, adding  it  to  the
189       <OutputVariable>  variable  which  contains  the  source for the target
190       where <OutputFile> is going to be built.  The optional GENERATION_FLAGS
191       argument  is  needed to pass extra parameters to gperf (note you cannot
192       override that way the output file).
193
194       A simple invocation would be:
195
196          ecm_gperf_generate(simple.gperf ${CMAKE_CURRENT_BINARY_DIR}/simple.h MySources)
197
198       Since 5.35.0.
199
200   FindGradle
201       Provides the ability to build Android AAR libraries using Gradle.
202
203       This relies on the Qt provided Gradle, so a Qt for Android installation
204       is required.
205
206          gradle_add_aar(<target>
207                         BUIDLFILE build.gradle
208                         NAME <aar-name>)
209
210       This builds an Android AAR library using the given build.gradle file.
211
212          gradle_install_aar(<target>
213                             DESTINATION <dest>)
214
215       Installs  a  Android  AAR  library  that  has  been  created  with gra‐
216       dle_add_aar.
217
218       Since 5.76.0.
219
220   FindIcoTool
221       Try to find icotool.
222
223       If the icotool executable is not in your PATH, you can provide  an  al‐
224       ternative  name or full path location with the IcoTool_EXECUTABLE vari‐
225       able.
226
227       This will define the following variables:
228
229       IcoTool_FOUND
230              True if icotool is available.
231
232       IcoTool_EXECUTABLE
233              The icotool executable.
234
235       If IcoTool_FOUND is TRUE, it will also define  the  following  imported
236       target:
237
238       IcoTool::IcoTool
239              The icotool executable.
240
241       Since 5.49.
242
243   FindInotify
244       Try to find inotify on this system. This finds:
245
246              • libinotify on Unix like systems, or
247
248              • the kernel’s inotify on Linux systems.
249
250       This will define the following variables:
251
252       Inotify_FOUND
253              True if inotify is available
254
255       Inotify_LIBRARIES
256              This has to be passed to target_link_libraries()
257
258       Inotify_INCLUDE_DIRS
259              This has to be passed to target_include_directories()
260
261       On  Linux, the libraries and include directories are empty, even though
262       Inotify_FOUND may be set to TRUE. This is because no  special  includes
263       or  libraries  are  needed. On other systems these may be needed to use
264       inotify.
265
266       Since 5.32.0.
267
268   FindIsoCodes
269       Try to find iso-codes data files.  Once done this will define:
270
271       IsoCodes_FOUND
272              Whether the system has iso-codes
273
274       IsoCodes_PREFIX
275              The location in which the iso-codes data files are found
276
277       IsoCodes_DOMAINS
278              The available domains provided by iso-codes
279
280       Since 5.80.0.
281
282   FindKF5
283       Find KDE Frameworks 5 with a single find_package() call.
284
285       This will use the package  config  files  provided  by  the  individual
286       frameworks.   For example, if you wish to find KArchive, which presents
287       itself to CMake as KF5Archive (ie:  you  would  do  find_package(KF5Ar‐
288       chive) to find it directly), you can do
289
290          find_package(KF5 COMPONENTS Archive)
291
292       If all the required components (those given in the COMPONENTS argument,
293       but not those given in the  OPTIONAL_COMPONENTS  argument)  are  found,
294       KF5_FOUND will be set to true. Otherwise, it will be set to false.
295
296       Since pre-1.0.0.
297
298   FindLibExiv2
299       Try to find the Exiv2 library.
300
301       This will define the following variables:
302
303       LibExiv2_FOUND
304              True if (the requested version of) Exiv2 is available
305
306       LibExiv2_VERSION
307              The version of Exiv2
308
309       LibExiv2_INCLUDE_DIRS
310              The  include  dirs of Exiv2 for use with target_include_directo‐
311              ries()
312
313       LibExiv2_LIBRARIES
314              The Exiv2 library for use  with  target_link_libraries().   This
315              can   be   passed  to  target_link_libraries()  instead  of  the
316              LibExiv2::LibExiv2 target
317
318       If LibExiv2_FOUND is TRUE, it will also define the  following  imported
319       target:
320
321       LibExiv2::LibExiv2
322              The Exiv2 library
323
324       In  general  we recommend using the imported target, as it is easier to
325       use.  Bear in mind, however, that if the target is in the  link  inter‐
326       face  of  an exported library, it must be made available by the package
327       config file.
328
329       Since 5.53.0.
330
331   FindLibGit2
332       Try to find libgit2 on a Unix system.
333
334       This will define the following variables:
335
336       LIBGIT2_FOUND
337              True if (the requested version of) libgit2 is available
338
339       LIBGIT2_VERSION
340              The version of libgit2
341
342       LIBGIT2_LIBRARIES
343              This can be passed to  target_link_libraries()  instead  of  the
344              LibGit2::LibGit2 target
345
346       LIBGIT2_INCLUDE_DIRS
347              This  should  be  passed  to target_include_directories() if the
348              target is not used for linking
349
350       LIBGIT2_DEFINITIONS
351              This should be passed to target_compile_options() if the  target
352              is not used for linking
353
354       If  LIBGIT2_FOUND  is  TRUE, it will also define the following imported
355       target:
356
357       LibGit2::LibGit2
358              The libgit2 library
359
360       In general we recommend using the imported target, as it is  easier  to
361       use.   Bear  in mind, however, that if the target is in the link inter‐
362       face of an exported library, it must be made available by  the  package
363       config file.
364
365       Since 1.3.0.
366
367   FindLibcap
368       Try to find the setcap binary and cap libraries
369
370       This will define:
371
372       Libcap_FOUND
373              system has the cap library and setcap binary
374
375       Libcap_LIBRARIES
376              cap libraries to link against
377
378       SETCAP_EXECUTABLE
379              path of the setcap binary
380
381       In addition, the following targets are defined:
382              Libcap::SetCapabilities
383
384       Since 5.80.0
385
386   FindOpenEXR
387       Try to find the OpenEXR libraries.
388
389       This will define the following variables:
390
391       OpenEXR_FOUND
392              True if OpenEXR is available
393
394       OpenEXR_LIBRARIES
395              Link to these to use OpenEXR
396
397       OpenEXR_INCLUDE_DIRS
398              Include directory for OpenEXR
399
400       OpenEXR_DEFINITIONS
401              Compiler flags required to link against OpenEXR
402
403       and the following imported targets:
404
405       OpenEXR::IlmImf
406              The OpenEXR core library
407
408       In  general  we recommend using the imported target, as it is easier to
409       use.  Bear in mind, however, that if the target is in the  link  inter‐
410       face  of  an exported library, it must be made available by the package
411       config file.
412
413       Since pre-1.0.0.
414
415   FindPhoneNumber
416       Try to find PhoneNumber.
417
418       This is a component-based find module, which makes use  of  the  COMPO‐
419       NENTS  and OPTIONAL_COMPONENTS arguments to find_module.  The following
420       components are available:
421
422          PhoneNumber  GeoCoding
423
424       If no components are specified, this module will act as though all com‐
425       ponents were passed to OPTIONAL_COMPONENTS.
426
427       This  module  will define the following variables, independently of the
428       components searched for or found:
429
430       PhoneNumber_FOUND
431              True if (the requestion version of) PhoneNumber is available
432
433       For each searched-for components, PhoneNumber_<component>_FOUND will be
434       set  to  TRUE  if the corresponding library was found, and FALSE other‐
435       wise.  If PhoneNumber_<component>_FOUND is TRUE,  the  imported  target
436       PhoneNumber::<component> will be defined.
437
438       Since 5.54.0.
439
440   FindPoppler
441       Try to find Poppler.
442
443       This  is  a  component-based find module, which makes use of the COMPO‐
444       NENTS and OPTIONAL_COMPONENTS arguments to find_module.  The  following
445       components are available:
446
447          Core  Cpp  Qt5  Qt4  Glib
448
449       If no components are specified, this module will act as though all com‐
450       ponents were passed to OPTIONAL_COMPONENTS.
451
452       This module will define the following variables, independently  of  the
453       components searched for or found:
454
455       Poppler_FOUND
456              TRUE if (the requested version of) Poppler is available
457
458       Poppler_VERSION
459              Found Poppler version
460
461       Poppler_TARGETS
462              A  list  of all targets imported by this module (note that there
463              may be more than the components that were requested)
464
465       Poppler_LIBRARIES
466              This can be passed to target_link_libraries() instead of the im‐
467              ported targets
468
469       Poppler_INCLUDE_DIRS
470              This  should  be  passed  to target_include_directories() if the
471              targets are not used for linking
472
473       Poppler_DEFINITIONS
474              This should be passed to target_compile_options() if the targets
475              are not used for linking
476
477       For each searched-for components, Poppler_<component>_FOUND will be set
478       to TRUE if the corresponding Poppler library was found, and FALSE  oth‐
479       erwise.  If Poppler_<component>_FOUND is TRUE, the imported target Pop‐
480       pler::<component> will be defined.  This module will  also  attempt  to
481       determine  Poppler_*_VERSION  variables  for  each imported target, al‐
482       though Poppler_VERSION should normally be sufficient.
483
484       In general we recommend using the imported targets, as they are  easier
485       to  use  and  provide more control.  Bear in mind, however, that if any
486       target is in the link interface of an exported library, it must be made
487       available by the package config file.
488
489       Since 5.19
490
491   FindPulseAudio
492       Try  to  locate the PulseAudio library.  If found, this will define the
493       following variables:
494
495       PulseAudio_FOUND
496              True if the system has the PulseAudio library of  at  least  the
497              minimum  version  specified  by  either the version parameter to
498              find_package() or the variable PulseAudio_MINIMUM_VERSION
499
500       PulseAudio_INCLUDE_DIRS
501              The PulseAudio include directory
502
503       PulseAudio_LIBRARIES
504              The PulseAudio libraries for linking
505
506       PulseAudio_MAINLOOP_LIBRARY
507              The libraries needed to use PulseAudio Mainloop
508
509       PulseAudio_VERSION
510              The version of PulseAudio that was found
511
512       PulseAudio_INCLUDE_DIR
513              Deprecated, use PulseAudio_INCLUDE_DIRS
514
515       PulseAudio_LIBRARY
516              Deprecated, use PulseAudio_LIBRARIES
517
518       If PulseAudio_FOUND is TRUE, it will also define the following imported
519       target:
520
521       PulseAudio::PulseAudio
522              The PulseAudio library
523
524       Since 5.41.0.
525
526   FindQtWaylandScanner
527       Try to find qtwaylandscanner.
528
529       If the qtwaylandscanner executable is not in your PATH, you can provide
530       an alternative name or full path location with the QtWaylandScanner_EX‐
531       ECUTABLE variable.
532
533       This will define the following variables:
534
535       QtWaylandScanner_FOUND
536              True if qtwaylandscanner is available
537
538       QtWaylandScanner_EXECUTABLE
539              The qtwaylandscanner executable.
540
541       If  QtWaylandScanner_FOUND  is  TRUE, it will also define the following
542       imported target:
543
544       Wayland::QtScanner
545              The qtwaylandscanner executable.
546
547       This module provides the following functions to generate  C++  protocol
548       implementations:
549
550ecm_add_qtwayland_client_protocol
551
552ecm_add_qtwayland_server_protocol
553
554          ecm_add_qtwayland_client_protocol(<source_files_var>
555                                            PROTOCOL <xmlfile>
556                                            BASENAME <basename>
557                                            [PREFIX <prefix>])
558
559       Generate  C++  wrapper  to Wayland client protocol files from <xmlfile>
560       XML definition for the <basename> interface and append those  files  to
561       <source_files_var>.   Pass the <prefix> argument if the interface names
562       don’t start with qt_ or wl_.
563
564       WaylandScanner is required and will be searched for.
565
566          ecm_add_qtwayland_server_protocol(<source_files_var>
567                                            PROTOCOL <xmlfile>
568                                            BASENAME <basename>
569                                            [PREFIX <prefix>])
570
571       Generate C++ wrapper to Wayland server protocol  files  from  <xmlfile>
572       XML  definition  for the <basename> interface and append those files to
573       <source_files_var>.  Pass the <prefix> argument if the interface  names
574       don’t start with qt_ or wl_.
575
576       WaylandScanner is required and will be searched for.
577
578       Since 1.4.0.
579
580   FindSasl2
581       Try to find the SASL2 library.
582
583       This will define the following variables:
584
585       Sasl2_FOUND
586              System has SASL2.
587
588       Sasl2_VERSION
589              The version of SASL2.
590
591       Sasl2_INCLUDE_DIRS
592              This  should  be  passed  to target_include_directories() if the
593              target is not used for linking.
594
595       Sasl2_LIBRARIES
596              The SASL2  library.   This  can  be  passed  to  target_link_li‐
597              braries() instead of the Sasl2::Sasl2 target
598
599       If  Sasl2_FOUND  is  TRUE, the following imported target will be avail‐
600       able:
601
602       Sasl2::Sasl2
603              The SASL2 library
604
605       Since 5.41.0.
606
607   FindSeccomp
608       Try to locate the libseccomp library.
609
610       This will define the following variables:
611
612       Seccomp_FOUND
613              True if the seccomp library is available
614
615       Seccomp_INCLUDE_DIRS
616              The seccomp include directories
617
618       Seccomp_LIBRARIES
619              The seccomp libraries for linking
620
621       If Seccomp_FOUND is TRUE, it will also define  the  following  imported
622       target:
623
624       Seccomp::Seccomp
625              The Seccomp library
626
627       Since 5.44.0.
628
629   FindSharedMimeInfo
630       Try to find the shared-mime-info package.
631
632       This will define the following variables:
633
634       SharedMimeInfo_FOUND
635              True if system has the shared-mime-info package
636
637       UPDATE_MIME_DATABASE_EXECUTABLE
638              The update-mime-database executable
639
640       and the following imported targets:
641
642       SharedMimeInfo::UpdateMimeDatabase
643              The update-mime-database executable
644
645       The follow macro is available:
646
647          update_xdg_mimetypes(<path>)
648
649       Updates  the XDG mime database at install time (unless the $DESTDIR en‐
650       vironment variable is set, in which case it is up to  package  managers
651       to perform this task).
652
653       Since pre-1.0.0.
654
655   FindTaglib
656       Try to find the Taglib library.
657
658       This will define the following variables:
659
660       Taglib_FOUND
661              True  if the system has the taglib library of at least the mini‐
662              mum version specified by the version parameter to find_package()
663
664       Taglib_INCLUDE_DIRS
665              The taglib include dirs for use with target_include_directories
666
667       Taglib_LIBRARIES
668              The taglib libraries for use with target_link_libraries()
669
670       Taglib_VERSION
671              The version of taglib that was found
672
673       If Taglib_FOUND is TRUE, it will also  define  the  following  imported
674       target:
675
676       Taglib::Taglib
677              The Taglib library
678
679       Since 5.72.0
680
681   FindUDev
682       Try to find the UDev library.
683
684       This will define the following variables:
685
686       UDev_FOUND
687              System has UDev.
688
689       UDev_INCLUDE_DIRS
690              The libudev include directory.
691
692       UDev_LIBRARIES
693              The libudev libraries.
694
695       UDev_VERSION
696              The libudev version.
697
698       If  UDev_FOUND is TRUE, it will also define the following imported tar‐
699       get:
700
701       UDev::UDev
702              The UDev library
703
704       Since 5.57.0.
705
706   FindWayland
707       Try to find Wayland.
708
709       This is a component-based find module, which makes use  of  the  COMPO‐
710       NENTS  and OPTIONAL_COMPONENTS arguments to find_module.  The following
711       components are available:
712
713          Client  Server  Cursor  Egl
714
715       If no components are specified, this module will act as though all com‐
716       ponents were passed to OPTIONAL_COMPONENTS.
717
718       This  module  will define the following variables, independently of the
719       components searched for or found:
720
721       Wayland_FOUND
722              TRUE if (the requested version of) Wayland is available
723
724       Wayland_VERSION
725              Found Wayland version
726
727       Wayland_TARGETS
728              A list of all targets imported by this module (note  that  there
729              may be more than the components that were requested)
730
731       Wayland_LIBRARIES
732              This can be passed to target_link_libraries() instead of the im‐
733              ported targets
734
735       Wayland_INCLUDE_DIRS
736              This should be passed  to  target_include_directories()  if  the
737              targets are not used for linking
738
739       Wayland_DEFINITIONS
740              This should be passed to target_compile_options() if the targets
741              are not used for linking
742
743       Wayland_DATADIR
744              The core wayland protocols data directory Since 5.73.0
745
746       For each searched-for components, Wayland_<component>_FOUND will be set
747       to  TRUE if the corresponding Wayland library was found, and FALSE oth‐
748       erwise.  If Wayland_<component>_FOUND is TRUE, the imported target Way‐
749       land::<component>  will  be  defined.  This module will also attempt to
750       determine Wayland_*_VERSION variables for  each  imported  target,  al‐
751       though Wayland_VERSION should normally be sufficient.
752
753       In  general we recommend using the imported targets, as they are easier
754       to use and provide more control.  Bear in mind, however,  that  if  any
755       target is in the link interface of an exported library, it must be made
756       available by the package config file.
757
758       Since pre-1.0.0.
759
760   FindWaylandProtocols
761       Try to find wayland-protocols on a Unix system.
762
763       This will define the following variables:
764
765       WaylandProtocols_FOUND
766              True if (the requested version of) wayland-protocols  is  avail‐
767              able
768
769       WaylandProtocols_VERSION
770              The version of wayland-protocols
771
772       WaylandProtocols_DATADIR
773              The wayland protocols data directory
774
775   FindWaylandScanner
776       Try to find wayland-scanner.
777
778       If  the wayland-scanner executable is not in your PATH, you can provide
779       an alternative name or full path location with the  WaylandScanner_EXE‐
780       CUTABLE variable.
781
782       This will define the following variables:
783
784       WaylandScanner_FOUND
785              True if wayland-scanner is available.
786
787       WaylandScanner_EXECUTABLE
788              The wayland-scanner executable.
789
790       If  WaylandScanner_FOUND is TRUE, it will also define the following im‐
791       ported target:
792
793       Wayland::Scanner
794              The wayland-scanner executable.
795
796       This module provides the following functions to generate C protocol im‐
797       plementations:
798
799ecm_add_wayland_client_protocol
800
801ecm_add_wayland_server_protocol
802
803          ecm_add_wayland_client_protocol(<source_files_var>
804                                          PROTOCOL <xmlfile>
805                                          BASENAME <basename>)
806
807       Generate  Wayland  client  protocol files from <xmlfile> XML definition
808       for   the   <basename>   interface   and   append   those   files    to
809       <source_files_var>.
810
811          ecm_add_wayland_server_protocol(<source_files_var>
812                                          PROTOCOL <xmlfile>
813                                          BASENAME <basename>)
814
815       Generate  Wayland  server  protocol files from <xmlfile> XML definition
816       for   the   <basename>   interface   and   append   those   files    to
817       <source_files_var>.
818
819       Since 1.4.0.
820
821   FindX11_XCB
822       Try to find the X11 XCB compatibility library.
823
824       This will define the following variables:
825
826       X11_XCB_FOUND
827              True if (the requested version of) libX11-xcb is available
828
829       X11_XCB_VERSION
830              The version of libX11-xcb (this is not guaranteed to be set even
831              when X11_XCB_FOUND is true)
832
833       X11_XCB_LIBRARIES
834              This can be passed to  target_link_libraries()  instead  of  the
835              EGL::EGL target
836
837       X11_XCB_INCLUDE_DIR
838              This  should  be  passed  to target_include_directories() if the
839              target is not used for linking
840
841       X11_XCB_DEFINITIONS
842              This should be passed to target_compile_options() if the  target
843              is not used for linking
844
845       If  X11_XCB_FOUND  is  TRUE, it will also define the following imported
846       target:
847
848       X11::XCB
849              The X11 XCB compatibility library
850
851       In general we recommend using the imported target, as it is  easier  to
852       use.   Bear  in mind, however, that if the target is in the link inter‐
853       face of an exported library, it must be made available by  the  package
854       config file.
855
856       Since pre-1.0.0.
857
858   FindXCB
859       Try to find XCB.
860
861       This  is  a  component-based find module, which makes use of the COMPO‐
862       NENTS and OPTIONAL_COMPONENTS arguments to find_module.  The  following
863       components are available:
864
865          XCB
866          ATOM         AUX          COMPOSITE    CURSOR       DAMAGE
867          DPMS         DRI2         DRI3         EVENT        EWMH
868          GLX          ICCCM        IMAGE        KEYSYMS      PRESENT
869          RANDR        RECORD       RENDER       RENDERUTIL   RES
870          SCREENSAVER  SHAPE        SHM          SYNC         UTIL
871          XEVIE        XF86DRI      XFIXES       XINERAMA     XINPUT
872          XKB          XPRINT       XTEST        XV           XVMC
873
874       If no components are specified, this module will act as though all com‐
875       ponents except XINPUT (which is considered unstable) were passed to OP‐
876       TIONAL_COMPONENTS.
877
878       This  module  will define the following variables, independently of the
879       components searched for or found:
880
881       XCB_FOUND
882              True if (the requestion version of) xcb is available
883
884       XCB_VERSION
885              Found xcb version
886
887       XCB_TARGETS
888              A list of all targets imported by this module (note  that  there
889              may be more than the components that were requested)
890
891       XCB_LIBRARIES
892              This can be passed to target_link_libraries() instead of the im‐
893              ported targets
894
895       XCB_INCLUDE_DIRS
896              This should be passed  to  target_include_directories()  if  the
897              targets are not used for linking
898
899       XCB_DEFINITIONS
900              This should be passed to target_compile_options() if the targets
901              are not used for linking
902
903       For each searched-for components, XCB_<component>_FOUND will be set  to
904       true  if  the corresponding xcb library was found, and false otherwise.
905       If XCB_<component>_FOUND is true, the imported target  XCB::<component>
906       will be defined.  This module will also attempt to determine XCB_*_VER‐
907       SION variables for each imported target,  although  XCB_VERSION  should
908       normally be sufficient.
909
910       In  general we recommend using the imported targets, as they are easier
911       to use and provide more control.  Bear in mind, however,  that  if  any
912       target is in the link interface of an exported library, it must be made
913       available by the package config file.
914
915       Since pre-1.0.0.
916
917   Findepoxy
918       Try to find libepoxy on a Unix system.
919
920       This will define the following variables:
921
922       epoxy_FOUND
923              True if (the requested version of) libepoxy is available
924
925       epoxy_VERSION
926              The version of libepoxy
927
928       epoxy_LIBRARIES
929              This should be passed to target_link_libraries() if  the  target
930              is not used for linking
931
932       epoxy_INCLUDE_DIRS
933              This  should  be  passed  to target_include_directories() if the
934              target is not used for linking
935
936       epoxy_DEFINITIONS
937              This should be passed to target_compile_options() if the  target
938              is not used for linking
939
940       epoxy_HAS_GLX
941              True if GLX support is available
942
943       If epoxy_FOUND is TRUE, it will also define the following imported tar‐
944       get:
945
946       epoxy::epoxy
947              The epoxy library
948
949       In general we recommend using the imported target, as it is  easier  to
950       use.   Bear  in mind, however, that if the target is in the link inter‐
951       face of an exported library, it must be made available by  the  package
952       config file.
953

SEE ALSO

955       ecm(7), ecm-modules(7), ecm-kde-modules(7)
956
958       KDE Developers
959
960
961
962
9635.82                             May 03, 2021              ECM-FIND-MODULES(7)
Impressum