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   FindIcoTool
201       Try to find icotool.
202
203       If the icotool executable is not in  your  PATH,  you  can  provide  an
204       alternative  name  or  full  path  location with the IcoTool_EXECUTABLE
205       variable.
206
207       This will define the following variables:
208
209       IcoTool_FOUND
210              True if icotool is available.
211
212       IcoTool_EXECUTABLE
213              The icotool executable.
214
215       If IcoTool_FOUND is TRUE, it will also define  the  following  imported
216       target:
217
218       IcoTool::IcoTool
219              The icotool executable.
220
221       Since 5.49.
222
223   FindInotify
224       Try to find inotify on this system. This finds:
225
226              · libinotiy on Unix like systems, or
227
228              · the kernel’s inotify on Linux systems.
229
230       This will define the following variables:
231
232       Inotify_FOUND
233              True if inotify is available
234
235       Inotify_LIBRARIES
236              This has to be passed to target_link_libraries()
237
238       Inotify_INCLUDE_DIRS
239              This has to be passed to target_include_directories()
240
241       On  Linux, the libraries and include directories are empty, even though
242       Inotify_FOUND may be set to TRUE. This is because no  special  includes
243       or  libraries  are  needed. On other systems these may be needed to use
244       inotify.
245
246       Since 5.32.0.
247
248   FindKF5
249       Find KDE Frameworks 5 with a single find_package() call.
250
251       This will use the package  config  files  provided  by  the  individual
252       frameworks.   For example, if you wish to find KArchive, which presents
253       itself to CMake as KF5Archive (ie:  you  would  do  find_package(KF5Ar‐
254       chive) to find it directly), you can do
255
256          find_package(KF5 COMPONENTS Archive)
257
258       If all the required components (those given in the COMPONENTS argument,
259       but not those given in the  OPTIONAL_COMPONENTS  argument)  are  found,
260       KF5_FOUND will be set to true. Otherwise, it will be set to false.
261
262       Since pre-1.0.0.
263
264   FindLibExiv2
265       Try to find the Exiv2 library.
266
267       This will define the following variables:
268
269       LibExiv2_FOUND
270              System has LibExiv2.
271
272       LibExiv2_VERSION
273              The version of LibExiv2.
274
275       LibExiv2_INCLUDE_DIRS
276              This  should  be  passed  to target_include_directories() if the
277              target is not used for linking.
278
279       LibExiv2_LIBRARIES
280              The  LibExiv2   library.    This   can   be   passed   to   tar‐
281              get_link_libraries() instead of the LibExiv2::LibExiv2 target
282
283       If LibExiv2_FOUND is TRUE, the following imported target will be avail‐
284       able:
285
286       LibExiv2::LibExiv2
287              The Exiv2 library
288
289       Since 5.53.0.
290
291   FindLibGit2
292       Try to find libgit2 on a Unix system.
293
294       This will define the following variables:
295
296       LIBGIT2_FOUND
297              True if (the requested version of) libgit2 is available
298
299       LIBGIT2_VERSION
300              The version of libgit2
301
302       LIBGIT2_LIBRARIES
303              This can be passed to  target_link_libraries()  instead  of  the
304              LibGit2::LibGit2 target
305
306       LIBGIT2_INCLUDE_DIRS
307              This  should  be  passed  to target_include_directories() if the
308              target is not used for linking
309
310       LIBGIT2_DEFINITIONS
311              This should be passed to target_compile_options() if the  target
312              is not used for linking
313
314       If  LIBGIT2_FOUND  is  TRUE, it will also define the following imported
315       target:
316
317       LibGit2::LibGit2
318              The libgit2 library
319
320       In general we recommend using the imported target, as it is  easier  to
321       use.   Bear  in mind, however, that if the target is in the link inter‐
322       face of an exported library, it must be made available by  the  package
323       config file.
324
325       Since 1.3.0.
326
327   FindOpenEXR
328       Try to find the OpenEXR libraries.
329
330       This will define the following variables:
331
332       OpenEXR_FOUND
333              True if OpenEXR is available
334
335       OpenEXR_LIBRARIES
336              Link to these to use OpenEXR
337
338       OpenEXR_INCLUDE_DIRS
339              Include directory for OpenEXR
340
341       OpenEXR_DEFINITIONS
342              Compiler flags required to link against OpenEXR
343
344       and the following imported targets:
345
346       OpenEXR::IlmImf
347              The OpenEXR core library
348
349       In  general  we recommend using the imported target, as it is easier to
350       use.  Bear in mind, however, that if the target is in the  link  inter‐
351       face  of  an exported library, it must be made available by the package
352       config file.
353
354       Since pre-1.0.0.
355
356   FindPhoneNumber
357       This module finds if PhoneNumber is installed.
358
359       This is a component-based find module, which makes use  of  the  COMPO‐
360       NENTS  and OPTIONAL_COMPONENTS arguments to find_module.  The following
361       components are available:
362          PhoneNumber GeoCoding
363
364       If no components are specified, this module will act as though all com‐
365       ponents were passed to OPTIONAL_COMPONENTS.
366
367       This  module  will define the following variables, independently of the
368       components searched for or found:
369
370       PhoneNumber_FOUND
371              True if (the requestion version of) PhoneNumber is available
372
373       For each searched-for components, PhoneNumber_<component>_FOUND will be
374       set  to  TRUE  if the corresponding library was found, and FALSE other‐
375       wise.  If PhoneNumber_<component>_FOUND is TRUE,  the  imported  target
376       PhoneNumber::<component> will be defined.
377
378       Since 5.54.0.
379
380   FindPng2Ico
381       Try to find png2ico.
382
383       If  the  png2ico  executable  is  not  in your PATH, you can provide an
384       alternative name or full  path  location  with  the  Png2Ico_EXECUTABLE
385       variable.
386
387       This will define the following variables:
388
389       Png2Ico_FOUND
390              True if png2ico is available.
391
392       Png2Ico_EXECUTABLE
393              The png2ico executable.
394
395       If  Png2Ico_FOUND  is  TRUE, it will also define the following imported
396       target:
397
398       Png2Ico::Png2Ico
399              The png2ico executable.
400
401       and the following variables:
402
403       Png2Ico_HAS_COLORS_ARGUMENT
404              Whether png2ico accepts a --colors argument. Matthias Benkmann’s
405              tool  does,  while  the version of png2ico from the “KDE On Win‐
406              dows” (kdewin) project does not.
407
408       Png2Ico_HAS_RCFILE_ARGUMENT
409              Whether png2ico accepts an --rcfile  argument.  The  version  of
410              png2ico  from  the “KDE On Windows” (kdewin) project does, while
411              Matthias Benkmann’s tool does not.
412
413       Since 1.7.0.
414
415   FindPoppler
416       Try to find Poppler.
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          Core  Cpp  Qt5  Qt4 Glib
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       Poppler_FOUND
431              TRUE if (the requested version of) Poppler is available
432
433       Poppler_VERSION
434              Found Poppler version
435
436       Poppler_TARGETS
437              A list of all targets imported by this module (note  that  there
438              may be more than the components that were requested)
439
440       Poppler_LIBRARIES
441              This  can  be  passed  to target_link_libraries() instead of the
442              imported targets
443
444       Poppler_INCLUDE_DIRS
445              This should be passed  to  target_include_directories()  if  the
446              targets are not used for linking
447
448       Poppler_DEFINITIONS
449              This should be passed to target_compile_options() if the targets
450              are not used for linking
451
452       For each searched-for components, Poppler_<component>_FOUND will be set
453       to  TRUE if the corresponding Poppler library was found, and FALSE oth‐
454       erwise.  If Poppler_<component>_FOUND is TRUE, the imported target Pop‐
455       pler::<component>  will  be  defined.  This module will also attempt to
456       determine  Poppler_*_VERSION  variables  for  each   imported   target,
457       although Poppler_VERSION should normally be sufficient.
458
459       In  general we recommend using the imported targets, as they are easier
460       to use and provide more control.  Bear in mind, however,  that  if  any
461       target is in the link interface of an exported library, it must be made
462       available by the package config file.
463
464       Since 5.19
465
466   FindPulseAudio
467       Try to locate the PulseAudio library.  If found, this will  define  the
468       following variables:
469
470       PulseAudio_FOUND
471              True  if  the  system has the PulseAudio library of at least the
472              minimum version specified by either  the  version  parameter  to
473              find_package() or the variable PulseAudio_MINIMUM_VERSION
474
475       PulseAudio_INCLUDE_DIRS
476              The PulseAudio include directory
477
478       PulseAudio_LIBRARIES
479              The PulseAudio libraries for linking
480
481       PulseAudio_MAINLOOP_LIBRARY
482              The libraries needed to use PulseAudio Mainloop
483
484       PulseAudio_VERSION
485              The version of PulseAudio that was found
486
487       PulseAudio_INCLUDE_DIR
488              Deprecated, use PulseAudio_INCLUDE_DIRS
489
490       PulseAudio_LIBRARY
491              Deprecated, use PulseAudio_LIBRARIES
492
493       If PulseAudio_FOUND is TRUE, it will also define the following imported
494       target:
495
496       PulseAudio::PulseAudio
497              The PulseAudio library
498
499       Since 5.41.0.
500
501   FindQtWaylandScanner
502       Try to find qtwaylandscanner.
503
504       If the qtwaylandscanner executable is not in your PATH, you can provide
505       an  alternative  name  or  full  path  location with the QtWaylandScan‐
506       ner_EXECUTABLE variable.
507
508       This will define the following variables:
509
510       QtWaylandScanner_FOUND
511              True if qtwaylandscanner is available
512
513       QtWaylandScanner_EXECUTABLE
514              The qtwaylandscanner executable.
515
516       If QtWaylandScanner_FOUND is TRUE, it will also  define  the  following
517       imported target:
518
519       Wayland::QtScanner
520              The qtwaylandscanner executable.
521
522       This  module  provides the following functions to generate C++ protocol
523       implementations:
524
525          · ecm_add_qtwayland_client_protocol
526
527          · ecm_add_qtwayland_server_protocol
528
529          ecm_add_qtwayland_client_protocol(<source_files_var>
530                                            PROTOCOL <xmlfile>
531                                            BASENAME <basename>
532                                            [PREFIX <prefix>])
533
534       Generate C++ wrapper to Wayland client protocol  files  from  <xmlfile>
535       XML  definition  for the <basename> interface and append those files to
536       <source_files_var>.  Pass the <prefix> argument if the interface  names
537       don’t start with qt_ or wl_.
538
539       WaylandScanner is required and will be searched for.
540
541          ecm_add_qtwayland_server_protocol(<source_files_var>
542                                            PROTOCOL <xmlfile>
543                                            BASENAME <basename>
544                                            [PREFIX <prefix>])
545
546       Generate  C++  wrapper  to Wayland server protocol files from <xmlfile>
547       XML definition for the <basename> interface and append those  files  to
548       <source_files_var>.   Pass the <prefix> argument if the interface names
549       don’t start with qt_ or wl_.
550
551       WaylandScanner is required and will be searched for.
552
553       Since 1.4.0.
554
555   FindSasl2
556       Try to find the SASL2 library.
557
558       This will define the following variables:
559
560       Sasl2_FOUND
561              System has SASL2.
562
563       Sasl2_VERSION
564              The version of SASL2.
565
566       Sasl2_INCLUDE_DIRS
567              This should be passed  to  target_include_directories()  if  the
568              target is not used for linking.
569
570       Sasl2_LIBRARIES
571              The    SASL2    library.    This   can   be   passed   to   tar‐
572              get_link_libraries() instead of the Sasl2::Sasl2 target
573
574       If Sasl2_FOUND is TRUE, the following imported target  will  be  avail‐
575       able:
576
577       Sasl2::Sasl2
578              The SASL2 library
579
580       Since 5.41.0.
581
582   FindSeccomp
583       Try  to  locate the libseccomp library.  If found, this will define the
584       following variables:
585
586       Seccomp_FOUND
587              True if the seccomp library is available
588
589       Seccomp_INCLUDE_DIRS
590              The seccomp include directories
591
592       Seccomp_LIBRARIES
593              The seccomp libraries for linking
594
595       If Seccomp_FOUND is TRUE, it will also define  the  following  imported
596       target:
597
598       Seccomp::Seccomp
599              The Seccomp library
600
601       Since 5.44.0.
602
603   FindSharedMimeInfo
604       Try to find the shared-mime-info package.
605
606       This will define the following variables:
607
608       SharedMimeInfo_FOUND
609              True if system has the shared-mime-info package
610
611       UPDATE_MIME_DATABASE_EXECUTABLE
612              The update-mime-database executable
613
614       and the following imported targets:
615
616       SharedMimeInfo::UpdateMimeDatabase
617              The update-mime-database executable
618
619       The follow macro is available:
620
621          update_xdg_mimetypes(<path>)
622
623       Updates  the  XDG  mime  database  at install time (unless the $DESTDIR
624       environment variable is set, in which case it is up to package managers
625       to perform this task).
626
627       Since pre-1.0.0.
628
629   FindUDev
630       Try to find the UDev library, once done this will define:
631
632          UDev_FOUND
633                 System has UDev.
634
635          UDev_INCLUDE_DIRS
636                 The libudev include directory.
637
638       UDev_LIBRARIES
639              The libudev libraries.
640
641       UDev_VERSION
642              The libudev version.
643
644       If UDev_FOUND is TRUE, the following imported target will be available:
645
646       UDev::UDev
647              The UDev library
648
649       Since 5.57.0.
650
651   FindWayland
652       Try to find Wayland.
653
654       This  is  a  component-based find module, which makes use of the COMPO‐
655       NENTS and OPTIONAL_COMPONENTS arguments to find_module.  The  following
656       components are available:
657
658          Client  Server  Cursor  Egl
659
660       If no components are specified, this module will act as though all com‐
661       ponents were passed to OPTIONAL_COMPONENTS.
662
663       This module will define the following variables, independently  of  the
664       components searched for or found:
665
666       Wayland_FOUND
667              TRUE if (the requested version of) Wayland is available
668
669       Wayland_VERSION
670              Found Wayland version
671
672       Wayland_TARGETS
673              A  list  of all targets imported by this module (note that there
674              may be more than the components that were requested)
675
676       Wayland_LIBRARIES
677              This can be passed to  target_link_libraries()  instead  of  the
678              imported targets
679
680       Wayland_INCLUDE_DIRS
681              This  should  be  passed  to target_include_directories() if the
682              targets are not used for linking
683
684       Wayland_DEFINITIONS
685              This should be passed to target_compile_options() if the targets
686              are not used for linking
687
688       For each searched-for components, Wayland_<component>_FOUND will be set
689       to TRUE if the corresponding Wayland library was found, and FALSE  oth‐
690       erwise.  If Wayland_<component>_FOUND is TRUE, the imported target Way‐
691       land::<component> will be defined.  This module will  also  attempt  to
692       determine   Wayland_*_VERSION   variables  for  each  imported  target,
693       although Wayland_VERSION should normally be sufficient.
694
695       In general we recommend using the imported targets, as they are  easier
696       to  use  and  provide more control.  Bear in mind, however, that if any
697       target is in the link interface of an exported library, it must be made
698       available by the package config file.
699
700       Since pre-1.0.0.
701
702   FindWaylandScanner
703       Try to find wayland-scanner.
704
705       If  the wayland-scanner executable is not in your PATH, you can provide
706       an alternative name or full path location with the  WaylandScanner_EXE‐
707       CUTABLE variable.
708
709       This will define the following variables:
710
711       WaylandScanner_FOUND
712              True if wayland-scanner is available.
713
714       WaylandScanner_EXECUTABLE
715              The wayland-scanner executable.
716
717       If  WaylandScanner_FOUND  is  TRUE,  it  will also define the following
718       imported target:
719
720       Wayland::Scanner
721              The wayland-scanner executable.
722
723       This module provides the following functions  to  generate  C  protocol
724       implementations:
725
726          · ecm_add_wayland_client_protocol
727
728          · ecm_add_wayland_server_protocol
729
730          ecm_add_wayland_client_protocol(<source_files_var>
731                                          PROTOCOL <xmlfile>
732                                          BASENAME <basename>)
733
734       Generate  Wayland  client  protocol files from <xmlfile> XML definition
735       for   the   <basename>   interface   and   append   those   files    to
736       <source_files_var>.
737
738          ecm_add_wayland_server_protocol(<source_files_var>
739                                          PROTOCOL <xmlfile>
740                                          BASENAME <basename>)
741
742       Generate  Wayland  server  protocol files from <xmlfile> XML definition
743       for   the   <basename>   interface   and   append   those   files    to
744       <source_files_var>.
745
746       Since 1.4.0.
747
748   FindX11_XCB
749       Try to find the X11 XCB compatibility library.
750
751       This will define the following variables:
752
753       X11_XCB_FOUND
754              True if (the requested version of) libX11-xcb is available
755
756       X11_XCB_VERSION
757              The version of libX11-xcb (this is not guaranteed to be set even
758              when X11_XCB_FOUND is true)
759
760       X11_XCB_LIBRARIES
761              This can be passed to  target_link_libraries()  instead  of  the
762              EGL::EGL target
763
764       X11_XCB_INCLUDE_DIR
765              This  should  be  passed  to target_include_directories() if the
766              target is not used for linking
767
768       X11_XCB_DEFINITIONS
769              This should be passed to target_compile_options() if the  target
770              is not used for linking
771
772       If  X11_XCB_FOUND  is  TRUE, it will also define the following imported
773       target:
774
775       X11::XCB
776              The X11 XCB compatibility library
777
778       In general we recommend using the imported target, as it is  easier  to
779       use.   Bear  in mind, however, that if the target is in the link inter‐
780       face of an exported library, it must be made available by  the  package
781       config file.
782
783       Since pre-1.0.0.
784
785   FindXCB
786       Try to find XCB.
787
788       This  is  a  component-based find module, which makes use of the COMPO‐
789       NENTS and OPTIONAL_COMPONENTS arguments to find_module.  The  following
790       components are available:
791
792          XCB
793          ATOM         AUX          COMPOSITE    CURSOR       DAMAGE
794          DPMS         DRI2         DRI3         EVENT        EWMH
795          GLX          ICCCM        IMAGE        KEYSYMS      PRESENT
796          RANDR        RECORD       RENDER       RENDERUTIL   RES
797          SCREENSAVER  SHAPE        SHM          SYNC         UTIL
798          XEVIE        XF86DRI      XFIXES       XINERAMA     XINPUT
799          XKB          XPRINT       XTEST        XV           XVMC
800
801       If no components are specified, this module will act as though all com‐
802       ponents except XINPUT (which is considered  unstable)  were  passed  to
803       OPTIONAL_COMPONENTS.
804
805       This  module  will define the following variables, independently of the
806       components searched for or found:
807
808       XCB_FOUND
809              True if (the requestion version of) xcb is available
810
811       XCB_VERSION
812              Found xcb version
813
814       XCB_TARGETS
815              A list of all targets imported by this module (note  that  there
816              may be more than the components that were requested)
817
818       XCB_LIBRARIES
819              This  can  be  passed  to target_link_libraries() instead of the
820              imported targets
821
822       XCB_INCLUDE_DIRS
823              This should be passed  to  target_include_directories()  if  the
824              targets are not used for linking
825
826       XCB_DEFINITIONS
827              This should be passed to target_compile_options() if the targets
828              are not used for linking
829
830       For each searched-for components, XCB_<component>_FOUND will be set  to
831       true  if  the corresponding xcb library was found, and false otherwise.
832       If XCB_<component>_FOUND is true, the imported target  XCB::<component>
833       will be defined.  This module will also attempt to determine XCB_*_VER‐
834       SION variables for each imported target,  although  XCB_VERSION  should
835       normally be sufficient.
836
837       In  general we recommend using the imported targets, as they are easier
838       to use and provide more control.  Bear in mind, however,  that  if  any
839       target is in the link interface of an exported library, it must be made
840       available by the package config file.
841
842       Since pre-1.0.0.
843

SEE ALSO

845       ecm(7), ecm-modules(7), ecm-kde-modules(7)
846
848       KDE Developers
849
850
851
852
8535.58                             May 14, 2019              ECM-FIND-MODULES(7)
Impressum