reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-23 19:49:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
615950dfb6
CMake/Modules/FindX11.cmake

824 lines
32 KiB
CMake
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 19:01:08 +00:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
#[=======================================================================[.rst:
FindX11
-------
Find X11 installation
Try to find X11 on UNIX systems. The following values are defined
::
X11_FOUND - True if X11 is available
X11_INCLUDE_DIR - include directories to use X11
X11_LIBRARIES - link against these to use X11
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
and also the following more fine grained variables and targets:
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
::
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
X11_ICE_INCLUDE_PATH, X11_ICE_LIB, X11_ICE_FOUND, X11::ICE
X11_SM_INCLUDE_PATH, X11_SM_LIB, X11_SM_FOUND, X11::SM
X11_X11_INCLUDE_PATH, X11_X11_LIB, X11::X11
FindX11: fix some formatting in the documentation
2018-11-12 19:17:53 +00:00
X11_Xaccessrules_INCLUDE_PATH,
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
X11_Xaccessstr_INCLUDE_PATH, X11_Xaccess_FOUND
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
X11_Xau_INCLUDE_PATH, X11_Xau_LIB, X11_Xau_FOUND, X11::Xau
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
X11_xcb_INCLUDE_PATH, X11_xcb_LIB, X11_xcb_FOUND, X11::xcb
X11_X11_xcb_INCLUDE_PATH, X11_X11_xcb_LIB, X11_X11_xcb_FOUND, X11::X11_xcb
X11_xcb_icccm_INCLUDE_PATH, X11_xcb_icccm_LIB, X11_xcb_icccm_FOUND, X11::xcb_icccm
X11_xcb_xkb_INCLUDE_PATH, X11_xcb_xkb_LIB, X11_xcb_xkb_FOUND, X11::xcb_xkb
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
X11_Xcomposite_INCLUDE_PATH, X11_Xcomposite_LIB, X11_Xcomposite_FOUND, X11::Xcomposite
X11_Xcursor_INCLUDE_PATH, X11_Xcursor_LIB, X11_Xcursor_FOUND, X11::Xcursor
X11_Xdamage_INCLUDE_PATH, X11_Xdamage_LIB, X11_Xdamage_FOUND, X11::Xdamage
X11_Xdmcp_INCLUDE_PATH, X11_Xdmcp_LIB, X11_Xdmcp_FOUND, X11::Xdmcp
X11_Xext_INCLUDE_PATH, X11_Xext_LIB, X11_Xext_FOUND, X11::Xext
X11_Xxf86misc_INCLUDE_PATH, X11_Xxf86misc_LIB, X11_Xxf86misc_FOUND, X11::Xxf86misc
X11_Xxf86vm_INCLUDE_PATH, X11_Xxf86vm_LIB X11_Xxf86vm_FOUND, X11::Xxf86vm
X11_Xfixes_INCLUDE_PATH, X11_Xfixes_LIB, X11_Xfixes_FOUND, X11::Xfixes
X11_Xft_INCLUDE_PATH, X11_Xft_LIB, X11_Xft_FOUND, X11::Xft
X11_Xi_INCLUDE_PATH, X11_Xi_LIB, X11_Xi_FOUND, X11::Xi
X11_Xinerama_INCLUDE_PATH, X11_Xinerama_LIB, X11_Xinerama_FOUND, X11::Xinerama
X11_Xkb_INCLUDE_PATH,
X11_Xkblib_INCLUDE_PATH, X11_Xkb_FOUND, X11::Xkb
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
X11_xkbcommon_INCLUDE_PATH, X11_xkbcommon_LIB, X11_xkbcommon_FOUND, X11::xkbcommon
X11_xkbcommon_X11_INCLUDE_PATH,X11_xkbcommon_X11_LIB,X11_xkbcommon_X11_FOUND,X11::xkbcommon_X11
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
X11_xkbfile_INCLUDE_PATH, X11_xkbfile_LIB, X11_xkbfile_FOUND, X11::xkbfile
X11_Xmu_INCLUDE_PATH, X11_Xmu_LIB, X11_Xmu_FOUND, X11::Xmu
X11_Xpm_INCLUDE_PATH, X11_Xpm_LIB, X11_Xpm_FOUND, X11::Xpm
X11_Xtst_INCLUDE_PATH, X11_Xtst_LIB, X11_Xtst_FOUND, X11::Xtst
X11_Xrandr_INCLUDE_PATH, X11_Xrandr_LIB, X11_Xrandr_FOUND, X11::Xrandr
X11_Xrender_INCLUDE_PATH, X11_Xrender_LIB, X11_Xrender_FOUND, X11::Xrender
X11_XRes_INCLUDE_PATH, X11_XRes_LIB, X11_XRes_FOUND, X11::XRes
X11_Xss_INCLUDE_PATH, X11_Xss_LIB, X11_Xss_FOUND, X11::Xss
X11_Xt_INCLUDE_PATH, X11_Xt_LIB, X11_Xt_FOUND, X11::Xt
X11_Xutil_INCLUDE_PATH, X11_Xutil_FOUND, X11::Xutil
X11_Xv_INCLUDE_PATH, X11_Xv_LIB, X11_Xv_FOUND, X11::Xv
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
X11_dpms_INCLUDE_PATH, (in X11_Xext_LIB), X11_dpms_FOUND
X11_XShm_INCLUDE_PATH, (in X11_Xext_LIB), X11_XShm_FOUND
X11_Xshape_INCLUDE_PATH, (in X11_Xext_LIB), X11_Xshape_FOUND
X11_XSync_INCLUDE_PATH, (in X11_Xext_LIB), X11_XSync_FOUND
#]=======================================================================]
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (UNIX)
set(X11_FOUND 0)
ENH: make sure frameworks are not searched for x header files
2006-04-14 19:08:25 +00:00
# X11 is never a framework and some header files may be
# found in tcl on the mac
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(CMAKE_FIND_FRAMEWORK_SAVE ${CMAKE_FIND_FRAMEWORK})
set(CMAKE_FIND_FRAMEWORK NEVER)
Find*: Make find_package(.. QUIET) affect Check* modules. Fixes issues #14812 and #14813 where find_package(OpenMP QUIET) and find_package(Qt4 QUIET) would still print out messages when calling check*() functions. Also a partial fix for #14445 where building CMake (without cmake-gui) when Qt5 is installed and Qt4 is not installed and warnings come out of FindQt4.cmake.
2014-03-30 02:22:54 +00:00
set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
set(CMAKE_REQUIRED_QUIET ${X11_FIND_QUIETLY})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_INC_SEARCH_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
/usr/pkg/xorg/include
Remove trailing whitespace Alex
2011-08-03 20:32:28 +00:00
/usr/X11R6/include
/usr/X11R7/include
Try to fix FindX11
2002-11-05 12:15:42 +00:00
/usr/include/X11
Remove trailing whitespace Alex
2011-08-03 20:32:28 +00:00
/usr/openwin/include
/usr/openwin/share/include
Try to fix FindX11
2002-11-05 12:15:42 +00:00
/opt/graphics/OpenGL/include
FindX11: Search in /opt/X11 for OS X 10.8 (#14232) As of Mac OS X 10.8, X11 is no longer installed under /usr/X11, but under /opt/X11.
2013-06-19 18:43:00 +00:00
/opt/X11/include
Try to fix FindX11
2002-11-05 12:15:42 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_LIB_SEARCH_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
/usr/pkg/xorg/lib
Copied the X11 PNG and ZLIB functoinality from VXL
2002-09-02 19:46:04 +00:00
/usr/X11R6/lib
ENH: also search in /usr/X11R7, remove /usr/lib and /usr/local/lib, they are part of the standard search paths (partly sync wih KDE) Alex
2008-08-16 11:38:12 +00:00
/usr/X11R7/lib
Remove trailing whitespace Alex
2011-08-03 20:32:28 +00:00
/usr/openwin/lib
FindX11: Search in /opt/X11 for OS X 10.8 (#14232) As of Mac OS X 10.8, X11 is no longer installed under /usr/X11, but under /opt/X11.
2013-06-19 18:43:00 +00:00
/opt/X11/lib
Module to search for the installation of X11
2001-11-11 04:01:06 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_X11_INCLUDE_PATH X11/X.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xlib_INCLUDE_PATH X11/Xlib.h ${X11_INC_SEARCH_PATH})
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
# Look for includes; keep the list sorted by name of the cmake *_INCLUDE_PATH
# variable (which doesn't need to match the include file name).
Remove trailing whitespace Alex
2011-08-03 20:32:28 +00:00
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
# Solaris lacks XKBrules.h, so we should skip kxkbd there.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_ICE_INCLUDE_PATH X11/ICE/ICE.h ${X11_INC_SEARCH_PATH})
find_path(X11_SM_INCLUDE_PATH X11/SM/SM.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xaccessrules_INCLUDE_PATH X11/extensions/XKBrules.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xaccessstr_INCLUDE_PATH X11/extensions/XKBstr.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xau_INCLUDE_PATH X11/Xauth.h ${X11_INC_SEARCH_PATH})
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
find_path(X11_xcb_INCLUDE_PATH xcb/xcb.h ${X11_INC_SEARCH_PATH})
find_path(X11_X11_xcb_INCLUDE_PATH X11/Xlib-xcb.h ${X11_INC_SEARCH_PATH})
find_path(X11_xcb_icccm_INCLUDE_PATH xcb/xcb_icccm.h ${X11_INC_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_Xcomposite_INCLUDE_PATH X11/extensions/Xcomposite.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xcursor_INCLUDE_PATH X11/Xcursor/Xcursor.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xdamage_INCLUDE_PATH X11/extensions/Xdamage.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xdmcp_INCLUDE_PATH X11/Xdmcp.h ${X11_INC_SEARCH_PATH})
FindX11: find Xext.h
2018-11-12 20:49:33 +00:00
find_path(X11_Xext_INCLUDE_PATH X11/extensions/Xext.h ${X11_INC_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_dpms_INCLUDE_PATH X11/extensions/dpms.h ${X11_INC_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
find_path(X11_Xxf86misc_INCLUDE_PATH X11/extensions/xf86misc.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xxf86vm_INCLUDE_PATH X11/extensions/xf86vmode.h ${X11_INC_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_Xfixes_INCLUDE_PATH X11/extensions/Xfixes.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xft_INCLUDE_PATH X11/Xft/Xft.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xi_INCLUDE_PATH X11/extensions/XInput.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xinerama_INCLUDE_PATH X11/extensions/Xinerama.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xkb_INCLUDE_PATH X11/extensions/XKB.h ${X11_INC_SEARCH_PATH})
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
find_path(X11_xkbcommon_INCLUDE_PATH xkbcommon/xkbcommon.h ${X11_INC_SEARCH_PATH})
find_path(X11_xkbcommon_X11_INCLUDE_PATH xkbcommon/xkbcommon-x11.h ${X11_INC_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_Xkblib_INCLUDE_PATH X11/XKBlib.h ${X11_INC_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
find_path(X11_xkbfile_INCLUDE_PATH X11/extensions/XKBfile.h ${X11_INC_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_Xmu_INCLUDE_PATH X11/Xmu/Xmu.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xpm_INCLUDE_PATH X11/xpm.h ${X11_INC_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
find_path(X11_Xtst_INCLUDE_PATH X11/extensions/XTest.h ${X11_INC_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_XShm_INCLUDE_PATH X11/extensions/XShm.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xrandr_INCLUDE_PATH X11/extensions/Xrandr.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xrender_INCLUDE_PATH X11/extensions/Xrender.h ${X11_INC_SEARCH_PATH})
find_path(X11_XRes_INCLUDE_PATH X11/extensions/XRes.h ${X11_INC_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
find_path(X11_Xss_INCLUDE_PATH X11/extensions/scrnsaver.h ${X11_INC_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_path(X11_Xshape_INCLUDE_PATH X11/extensions/shape.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xutil_INCLUDE_PATH X11/Xutil.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xt_INCLUDE_PATH X11/Intrinsic.h ${X11_INC_SEARCH_PATH})
find_path(X11_Xv_INCLUDE_PATH X11/extensions/Xvlib.h ${X11_INC_SEARCH_PATH})
find_path(X11_XSync_INCLUDE_PATH X11/extensions/sync.h ${X11_INC_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
# Backwards compatibility.
set(X11_Xinput_INCLUDE_PATH "${X11_Xi_INCLUDE_PATH}")
set(X11_xf86misc_INCLUDE_PATH "${X11_Xxf86misc_INCLUDE_PATH}")
set(X11_xf86vmode_INCLUDE_PATH "${X11_Xxf8vm_INCLUDE_PATH}")
set(X11_Xkbfile_INCLUDE_PATH "${X11_xkbfile_INCLUDE_PATH}")
set(X11_XTest_INCLUDE_PATH "${X11_Xtst_INCLUDE_PATH}")
set(X11_Xscreensaver_INCLUDE_PATH "${X11_Xss_INCLUDE_PATH}")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(X11_X11_LIB X11 ${X11_LIB_SEARCH_PATH})
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
# Find additional X libraries. Keep list sorted by library name.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(X11_ICE_LIB ICE ${X11_LIB_SEARCH_PATH})
find_library(X11_SM_LIB SM ${X11_LIB_SEARCH_PATH})
find_library(X11_Xau_LIB Xau ${X11_LIB_SEARCH_PATH})
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
find_library(X11_xcb_LIB xcb ${X11_LIB_SEARCH_PATH})
find_library(X11_X11_xcb_LIB X11-xcb ${X11_LIB_SEARCH_PATH})
find_library(X11_xcb_icccm_LIB xcb-icccm ${X11_LIB_SEARCH_PATH})
find_library(X11_xcb_xkb_LIB xcb-xkb ${X11_LIB_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(X11_Xcomposite_LIB Xcomposite ${X11_LIB_SEARCH_PATH})
find_library(X11_Xcursor_LIB Xcursor ${X11_LIB_SEARCH_PATH})
find_library(X11_Xdamage_LIB Xdamage ${X11_LIB_SEARCH_PATH})
find_library(X11_Xdmcp_LIB Xdmcp ${X11_LIB_SEARCH_PATH})
find_library(X11_Xext_LIB Xext ${X11_LIB_SEARCH_PATH})
find_library(X11_Xfixes_LIB Xfixes ${X11_LIB_SEARCH_PATH})
find_library(X11_Xft_LIB Xft ${X11_LIB_SEARCH_PATH})
find_library(X11_Xi_LIB Xi ${X11_LIB_SEARCH_PATH})
find_library(X11_Xinerama_LIB Xinerama ${X11_LIB_SEARCH_PATH})
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
find_library(X11_xkbcommon_LIB xkbcommon ${X11_LIB_SEARCH_PATH})
find_library(X11_xkbcommon_X11_LIB xkbcommon-x11 ${X11_LIB_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
find_library(X11_xkbfile_LIB xkbfile ${X11_LIB_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(X11_Xmu_LIB Xmu ${X11_LIB_SEARCH_PATH})
find_library(X11_Xpm_LIB Xpm ${X11_LIB_SEARCH_PATH})
find_library(X11_Xrandr_LIB Xrandr ${X11_LIB_SEARCH_PATH})
find_library(X11_Xrender_LIB Xrender ${X11_LIB_SEARCH_PATH})
find_library(X11_XRes_LIB XRes ${X11_LIB_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
find_library(X11_Xss_LIB Xss ${X11_LIB_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(X11_Xt_LIB Xt ${X11_LIB_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
find_library(X11_Xtst_LIB Xtst ${X11_LIB_SEARCH_PATH})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
find_library(X11_Xv_LIB Xv ${X11_LIB_SEARCH_PATH})
find_library(X11_Xxf86misc_LIB Xxf86misc ${X11_LIB_SEARCH_PATH})
find_library(X11_Xxf86vm_LIB Xxf86vm ${X11_LIB_SEARCH_PATH})
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
# Backwards compatibility.
set(X11_Xinput_LIB "${X11_Xi_LIB}")
set(X11_Xkbfile_LIB "${X11_xkbfile_LIB}")
set(X11_XTest_LIB "${X11_Xtst_LIB}")
set(X11_Xscreensaver_LIB "${X11_Xss_LIB}")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_LIBRARY_DIR "")
if(X11_X11_LIB)
get_filename_component(X11_LIBRARY_DIR ${X11_X11_LIB} PATH)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_INCLUDE_DIR) # start with empty list
if(X11_X11_INCLUDE_PATH)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_X11_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_Xlib_INCLUDE_PATH)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xlib_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_Xutil_INCLUDE_PATH)
set(X11_Xutil_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xutil_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_Xshape_INCLUDE_PATH)
set(X11_Xshape_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xshape_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_LIBRARIES) # start with empty list
if(X11_X11_LIB)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_LIBRARIES ${X11_X11_LIB})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_Xext_LIB)
set(X11_Xext_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_LIBRARIES ${X11_Xext_LIB})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_Xt_LIB AND X11_Xt_INCLUDE_PATH)
set(X11_Xt_FOUND TRUE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_Xft_LIB AND X11_Xft_INCLUDE_PATH)
FindX11: require Freetype and Fontconfig for Xft The Xft header includes headers from freetype and fontconfig, so they are necessary for its use.
2018-11-12 20:50:05 +00:00
find_package(Freetype QUIET)
find_package(Fontconfig QUIET)
FindFontconfig: Convert module variables to camel case Our documented standard for find module variable names is to match the case of the find module package name. This was overlooked when the module was added by commit 84e7920b3a (FindFontconfig: Add module to find Fontconfig, 2018-09-27, v3.14.0-rc1~523^2). The module was released with the upper case names in CMake 3.14.0, so fix it to have camel case names in 3.14.1. This is incompatible but anyone using a given release series should be using the latest patch on it and we've made breaking fixups on newly released features like this before. Reported-by: Christophe Giboudeaux <christophe@krop.fr> Fixes: #19094
2019-03-26 17:44:52 +00:00
if (FREETYPE_FOUND AND Fontconfig_FOUND)
FindX11: require Freetype and Fontconfig for Xft The Xft header includes headers from freetype and fontconfig, so they are necessary for its use.
2018-11-12 20:50:05 +00:00
set(X11_Xft_FOUND TRUE)
endif ()
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xft_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_Xv_LIB AND X11_Xv_INCLUDE_PATH)
set(X11_Xv_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xv_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xau_LIB AND X11_Xau_INCLUDE_PATH)
set(X11_Xau_FOUND TRUE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
if (X11_xcb_LIB AND X11_xcb_INCLUDE_PATH)
set(X11_xcb_FOUND TRUE)
endif ()
if (X11_X11_xcb_LIB AND X11_X11_xcb_INCLUDE_PATH)
set(X11_X11_xcb_FOUND TRUE)
endif ()
if (X11_xcb_icccm_LIB AND X11_xcb_icccm_INCLUDE_PATH)
set(X11_xcb_icccm_FOUND TRUE)
endif ()
if (X11_xcb_xkb_LIB)
set(X11_xcb_xkb_FOUND TRUE)
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xdmcp_INCLUDE_PATH AND X11_Xdmcp_LIB)
set(X11_Xdmcp_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xdmcp_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xaccessrules_INCLUDE_PATH AND X11_Xaccessstr_INCLUDE_PATH)
set(X11_Xaccess_FOUND TRUE)
set(X11_Xaccess_INCLUDE_PATH ${X11_Xaccessstr_INCLUDE_PATH})
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xaccess_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xpm_INCLUDE_PATH AND X11_Xpm_LIB)
set(X11_Xpm_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xpm_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xcomposite_INCLUDE_PATH AND X11_Xcomposite_LIB)
set(X11_Xcomposite_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xcomposite_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xdamage_INCLUDE_PATH AND X11_Xdamage_LIB)
set(X11_Xdamage_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xdamage_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_XShm_INCLUDE_PATH)
set(X11_XShm_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_XShm_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
if (X11_Xtst_INCLUDE_PATH AND X11_Xtst_LIB)
set(X11_Xtst_FOUND TRUE)
# Backwards compatibility.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_XTest_FOUND TRUE)
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xtst_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xi_INCLUDE_PATH AND X11_Xi_LIB)
set(X11_Xi_FOUND TRUE)
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
# Backwards compatibility.
set(X11_Xinput_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xi_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xinerama_INCLUDE_PATH AND X11_Xinerama_LIB)
set(X11_Xinerama_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xinerama_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xfixes_INCLUDE_PATH AND X11_Xfixes_LIB)
set(X11_Xfixes_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xfixes_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xrender_INCLUDE_PATH AND X11_Xrender_LIB)
set(X11_Xrender_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xrender_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_XRes_INCLUDE_PATH AND X11_XRes_LIB)
set(X11_XRes_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_XRes_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xrandr_INCLUDE_PATH AND X11_Xrandr_LIB)
set(X11_Xrandr_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xrandr_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
if (X11_Xxf86misc_INCLUDE_PATH AND X11_Xxf86misc_LIB)
set(X11_Xxf86misc_FOUND TRUE)
# Backwards compatibility.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_xf86misc_FOUND TRUE)
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xxf86misc_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
if (X11_Xxf86vm_INCLUDE_PATH AND X11_Xxf86vm_LIB)
set(X11_Xxf86vm_FOUND TRUE)
# Backwards compatibility.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_xf86vmode_FOUND TRUE)
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xxf86vm_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xcursor_INCLUDE_PATH AND X11_Xcursor_LIB)
set(X11_Xcursor_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xcursor_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
if (X11_Xss_INCLUDE_PATH AND X11_Xss_LIB)
set(X11_Xss_FOUND TRUE)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_Xscreensaver_FOUND TRUE)
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xss_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_dpms_INCLUDE_PATH)
set(X11_dpms_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_dpms_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xkb_INCLUDE_PATH AND X11_Xkblib_INCLUDE_PATH AND X11_Xlib_INCLUDE_PATH)
set(X11_Xkb_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xkb_INCLUDE_PATH} )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
if (X11_xkbcommon_INCLUDE_PATH AND X11_xkbcommon_LIB)
set(X11_xkbcommon_FOUND TRUE)
endif ()
if (X11_xkbcommon_X11_INCLUDE_PATH AND X11_xkbcommon_X11_LIB)
set(X11_xkbcommon_X11_FOUND TRUE)
endif ()
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
if (X11_xkbfile_INCLUDE_PATH AND X11_xkbfile_LIB AND X11_Xlib_INCLUDE_PATH)
set(X11_xkbfile_FOUND TRUE)
# Backwards compatibility.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_Xkbfile_FOUND TRUE)
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_xkbfile_INCLUDE_PATH} )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_Xmu_INCLUDE_PATH AND X11_Xmu_LIB)
set(X11_Xmu_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_Xmu_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_XSync_INCLUDE_PATH)
set(X11_XSync_FOUND TRUE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_INCLUDE_DIR ${X11_XSync_INCLUDE_PATH})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_ICE_LIB AND X11_ICE_INCLUDE_PATH)
set(X11_ICE_FOUND TRUE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_SM_LIB AND X11_SM_INCLUDE_PATH)
set(X11_SM_FOUND TRUE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
Also search for libxkbfile, XSync and SM include dir Alex
2011-08-03 20:33:18 +00:00
FindX11: remove duplicates from X11 include path list (#13316) Most if not all X11 includes are typically in the same directory, so this usually returns a huge list with only very few different entries.
2012-08-13 17:39:30 +00:00
# Most of the X11 headers will be in the same directories, avoid
# creating a huge list of duplicates.
FindX11: avoid calling list(REMOVE_DUPLICATES) on an empty list
2012-08-15 17:28:50 +00:00
if (X11_INCLUDE_DIR)
list(REMOVE_DUPLICATES X11_INCLUDE_DIR)
endif ()
Also search for libxkbfile, XSync and SM include dir Alex
2011-08-03 20:33:18 +00:00
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
# Deprecated variable for backwards compatibility with CMake 1.4
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_X11_INCLUDE_PATH AND X11_LIBRARIES)
set(X11_FOUND 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Attempt to fix build problem on some platforms
2003-01-29 14:06:46 +00:00
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
find_package_handle_standard_args(X11
REQUIRED_VARS X11_X11_INCLUDE_PATH X11_X11_LIB
HANDLE_COMPONENTS)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(X11_FOUND)
Find* (and some other): use ${CMAKE_CURRENT_LIST_DIR} in include() This solves a lots of warnings, e.g. in the FindModulesExecuteAll test. If the installed version on the system is rather old this may even lead to bugs, e.g. https://bugs.gentoo.org/show_bug.cgi?id=436540
2012-11-03 20:35:44 +00:00
include(${CMAKE_CURRENT_LIST_DIR}/CheckFunctionExists.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CheckLibraryExists.cmake)
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# Translated from an autoconf-generated configure script.
# See libs.m4 in autoconf's m4 directory.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if($ENV{ISC} MATCHES "^yes$")
set(X11_X_EXTRA_LIBS -lnsl_s -linet)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_X_EXTRA_LIBS "")
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# See if XOpenDisplay in X11 works by itself.
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("${X11_LIBRARIES}" "XOpenDisplay" "${X11_LIBRARY_DIR}" X11_LIB_X11_SOLO)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT X11_LIB_X11_SOLO)
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# Find library needed for dnet_ntoa.
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("dnet" "dnet_ntoa" "" X11_LIB_DNET_HAS_DNET_NTOA)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_LIB_DNET_HAS_DNET_NTOA)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_X_EXTRA_LIBS -ldnet)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else ()
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("dnet_stub" "dnet_ntoa" "" X11_LIB_DNET_STUB_HAS_DNET_NTOA)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_LIB_DNET_STUB_HAS_DNET_NTOA)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_X_EXTRA_LIBS -ldnet_stub)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif ()
endif()
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# Find library needed for gethostbyname.
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_function_exists("gethostbyname" CMAKE_HAVE_GETHOSTBYNAME)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT CMAKE_HAVE_GETHOSTBYNAME)
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("nsl" "gethostbyname" "" CMAKE_LIB_NSL_HAS_GETHOSTBYNAME)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (CMAKE_LIB_NSL_HAS_GETHOSTBYNAME)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_X_EXTRA_LIBS -lnsl)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
else ()
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("bsd" "gethostbyname" "" CMAKE_LIB_BSD_HAS_GETHOSTBYNAME)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (CMAKE_LIB_BSD_HAS_GETHOSTBYNAME)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_X_EXTRA_LIBS -lbsd)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif ()
endif()
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# Find library needed for connect.
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_function_exists("connect" CMAKE_HAVE_CONNECT)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT CMAKE_HAVE_CONNECT)
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("socket" "connect" "" CMAKE_LIB_SOCKET_HAS_CONNECT)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (CMAKE_LIB_SOCKET_HAS_CONNECT)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(INSERT X11_X_EXTRA_LIBS 0 -lsocket)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif()
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# Find library needed for remove.
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_function_exists("remove" CMAKE_HAVE_REMOVE)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT CMAKE_HAVE_REMOVE)
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("posix" "remove" "" CMAKE_LIB_POSIX_HAS_REMOVE)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (CMAKE_LIB_POSIX_HAS_REMOVE)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_X_EXTRA_LIBS -lposix)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif()
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# Find library needed for shmat.
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_function_exists("shmat" CMAKE_HAVE_SHMAT)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(NOT CMAKE_HAVE_SHMAT)
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("ipc" "shmat" "" CMAKE_LIB_IPS_HAS_SHMAT)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (CMAKE_LIB_IPS_HAS_SHMAT)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(APPEND X11_X_EXTRA_LIBS -lipc)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif()
endif()
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if (X11_ICE_FOUND)
FindX11: use lowercase function names
2018-11-12 16:50:52 +00:00
check_library_exists("ICE" "IceConnectionNumber" "${X11_LIBRARY_DIR}"
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
CMAKE_LIB_ICE_HAS_ICECONNECTIONNUMBER)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
if(CMAKE_LIB_ICE_HAS_ICECONNECTIONNUMBER)
set (X11_X_PRE_LIBS ${X11_ICE_LIB})
if(X11_SM_LIB)
FindX11: use `list(APPEND)` for clearer code
2018-11-12 16:56:32 +00:00
list(INSERT X11_X_PRE_LIBS 0 ${X11_SM_LIB})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif()
endif()
endif ()
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
# Build the final list of libraries.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(X11_LIBRARIES ${X11_X_PRE_LIBS} ${X11_LIBRARIES} ${X11_X_EXTRA_LIBS})
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
if (NOT TARGET X11::X11)
add_library(X11::X11 UNKNOWN IMPORTED)
set_target_properties(X11::X11 PROPERTIES
IMPORTED_LOCATION "${X11_X11_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_X11_INCLUDE_PATH}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
endif ()
ENH: FindX11.cmake module now almost fully duplicates old configure functionality.
2002-12-17 16:55:54 +00:00
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
if (X11_ICE_FOUND AND NOT TARGET X11::ICE)
add_library(X11::ICE UNKNOWN IMPORTED)
set_target_properties(X11::ICE PROPERTIES
IMPORTED_LOCATION "${X11_ICE_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_ICE_INCLUDE_PATH}")
endif ()
if (X11_SM_FOUND AND NOT TARGET X11::SM)
add_library(X11::SM UNKNOWN IMPORTED)
set_target_properties(X11::SM PROPERTIES
IMPORTED_LOCATION "${X11_SM_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_SM_INCLUDE_PATH}")
endif ()
if (X11_Xau_FOUND AND NOT TARGET X11::Xau)
add_library(X11::Xau UNKNOWN IMPORTED)
set_target_properties(X11::Xau PROPERTIES
IMPORTED_LOCATION "${X11_Xau_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xau_INCLUDE_PATH}")
endif ()
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
if (X11_xcb_FOUND AND NOT TARGET X11::xcb)
add_library(X11::xcb UNKNOWN IMPORTED)
set_target_properties(X11::xcb PROPERTIES
IMPORTED_LOCATION "${X11_xcb_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_xcb_INCLUDE_PATH}")
endif ()
if (X11_X11_xcb_FOUND AND NOT TARGET X11::X11_xcb)
add_library(X11::X11_xcb UNKNOWN IMPORTED)
set_target_properties(X11::X11_xcb PROPERTIES
IMPORTED_LOCATION "${X11_X11_xcb_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_X11_xcb_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::xcb;X11::X11")
endif ()
if (X11_xcb_icccm_FOUND AND NOT TARGET X11::xcb_icccm)
add_library(X11::xcb_icccm UNKNOWN IMPORTED)
set_target_properties(X11::xcb_icccm PROPERTIES
IMPORTED_LOCATION "${X11_xcb_icccm_LIB}"
INTERFACE_LINK_LIBRARIES "X11::xcb")
endif ()
if (X11_xcb_xkb_FOUND AND NOT TARGET X11::xcb_xkb)
add_library(X11::xcb_xkb UNKNOWN IMPORTED)
set_target_properties(X11::xcb_xkb PROPERTIES
IMPORTED_LOCATION "${X11_xcb_xkb_LIB}"
INTERFACE_LINK_LIBRARIES "X11::xcb")
endif ()
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
if (X11_Xcomposite_FOUND AND NOT TARGET X11::Xcomposite)
add_library(X11::Xcomposite UNKNOWN IMPORTED)
set_target_properties(X11::Xcomposite PROPERTIES
IMPORTED_LOCATION "${X11_Xcomposite_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xcomposite_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
if (X11_Xcursor_FOUND AND NOT TARGET X11::Xcursor)
add_library(X11::Xcursor UNKNOWN IMPORTED)
set_target_properties(X11::Xcursor PROPERTIES
IMPORTED_LOCATION "${X11_Xcursor_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xcursor_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xrender;X11::Xfixes;X11::X11")
endif ()
if (X11_Xdamage_FOUND AND NOT TARGET X11::Xdamage)
add_library(X11::Xdamage UNKNOWN IMPORTED)
set_target_properties(X11::Xdamage PROPERTIES
IMPORTED_LOCATION "${X11_Xdamage_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xdamage_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xfixes;X11::X11")
endif ()
if (X11_Xdmcp_FOUND AND NOT TARGET X11::Xdmcp)
add_library(X11::Xdmcp UNKNOWN IMPORTED)
set_target_properties(X11::Xdmcp PROPERTIES
IMPORTED_LOCATION "${X11_Xdmcp_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xdmcp_INCLUDE_PATH}")
endif ()
if (X11_Xext_FOUND AND NOT TARGET X11::Xext)
add_library(X11::Xext UNKNOWN IMPORTED)
set_target_properties(X11::Xext PROPERTIES
IMPORTED_LOCATION "${X11_Xext_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xext_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
if (X11_Xxf86misc_FOUND AND NOT TARGET X11::Xxf86misc)
add_library(X11::Xxf86misc UNKNOWN IMPORTED)
set_target_properties(X11::Xxf86misc PROPERTIES
IMPORTED_LOCATION "${X11_Xxf86misc_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xxf86misc_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11;X11::Xext")
endif ()
if (X11_Xxf86vm_FOUND AND NOT TARGET X11::Xxf86vm)
add_library(X11::Xxf86vm UNKNOWN IMPORTED)
set_target_properties(X11::Xxf86vm PROPERTIES
IMPORTED_LOCATION "${X11_Xxf86vm_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xxf86vm_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11;X11::Xext")
endif ()
if (X11_Xfixes_FOUND AND NOT TARGET X11::Xfixes)
add_library(X11::Xfixes UNKNOWN IMPORTED)
set_target_properties(X11::Xfixes PROPERTIES
IMPORTED_LOCATION "${X11_Xfixes_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xfixes_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
if (X11_Xft_FOUND AND NOT TARGET X11::Xft)
add_library(X11::Xft UNKNOWN IMPORTED)
set_target_properties(X11::Xft PROPERTIES
IMPORTED_LOCATION "${X11_Xft_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xft_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xrender;X11::X11;Fontconfig::Fontconfig;Freetype::Freetype")
endif ()
if (X11_Xi_FOUND AND NOT TARGET X11::Xi)
add_library(X11::Xi UNKNOWN IMPORTED)
set_target_properties(X11::Xi PROPERTIES
IMPORTED_LOCATION "${X11_Xi_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xi_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xext;X11::X11")
endif ()
if (X11_Xinerama_FOUND AND NOT TARGET X11::Xinerama)
add_library(X11::Xinerama UNKNOWN IMPORTED)
set_target_properties(X11::Xinerama PROPERTIES
IMPORTED_LOCATION "${X11_Xinerama_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xinerama_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xext;X11::X11")
endif ()
if (X11_Xkb_FOUND AND NOT TARGET X11::Xkb)
add_library(X11::Xkb INTERFACE IMPORTED)
set_target_properties(X11::Xkb PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xkb_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
if (X11_xkbcommon_FOUND AND NOT TARGET X11::xkbcommon)
add_library(X11::xkbcommon UNKNOWN IMPORTED)
set_target_properties(X11::xkbcommon PROPERTIES
IMPORTED_LOCATION "${X11_xkbcommon_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_xkbcommon_INCLUDE_PATH}")
endif ()
if (X11_xkbcommon_X11_FOUND AND NOT TARGET X11::xkbcommon_X11)
add_library(X11::xkbcommon_X11 UNKNOWN IMPORTED)
set_target_properties(X11::xkbcommon_X11 PROPERTIES
IMPORTED_LOCATION "${X11_xkbcommon_X11_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_xkbcommon_X11_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11;X11::xkbcommon")
endif ()
FindX11: add imported targets These imported targets are fine-grained and recommended over the global `X11_LIBRARIES` and `X11_INCLUDE_DIR` variables.
2018-11-12 20:51:08 +00:00
if (X11_xkbfile_FOUND AND NOT TARGET X11::xkbfile)
add_library(X11::xkbfile UNKNOWN IMPORTED)
set_target_properties(X11::xkbfile PROPERTIES
IMPORTED_LOCATION "${X11_xkbfile_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_xkbfile_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
if (X11_Xmu_FOUND AND NOT TARGET X11::Xmu)
add_library(X11::Xmu UNKNOWN IMPORTED)
set_target_properties(X11::Xmu PROPERTIES
IMPORTED_LOCATION "${X11_Xmu_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xmu_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xt;X11::Xext;X11::X11")
endif ()
if (X11_Xpm_FOUND AND NOT TARGET X11::Xpm)
add_library(X11::Xpm UNKNOWN IMPORTED)
set_target_properties(X11::Xpm PROPERTIES
IMPORTED_LOCATION "${X11_Xpm_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xpm_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
if (X11_Xtst_FOUND AND NOT TARGET X11::Xtst)
add_library(X11::Xtst UNKNOWN IMPORTED)
set_target_properties(X11::Xtst PROPERTIES
IMPORTED_LOCATION "${X11_Xtst_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xtst_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xi;X11::Xext;X11::X11")
endif ()
if (X11_Xrandr_FOUND AND NOT TARGET X11::Xrandr)
add_library(X11::Xrandr UNKNOWN IMPORTED)
set_target_properties(X11::Xrandr PROPERTIES
IMPORTED_LOCATION "${X11_Xrandr_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xrandr_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xrender;X11::Xext;X11::X11")
endif ()
if (X11_Xrender_FOUND AND NOT TARGET X11::Xrender)
add_library(X11::Xrender UNKNOWN IMPORTED)
set_target_properties(X11::Xrender PROPERTIES
IMPORTED_LOCATION "${X11_Xrender_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xrender_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
if (X11_XRes_FOUND AND NOT TARGET X11::XRes)
add_library(X11::XRes UNKNOWN IMPORTED)
set_target_properties(X11::XRes PROPERTIES
IMPORTED_LOCATION "${X11_XRes_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_XRes_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xext;X11::X11")
endif ()
if (X11_Xss_FOUND AND NOT TARGET X11::Xss)
add_library(X11::Xss UNKNOWN IMPORTED)
set_target_properties(X11::Xss PROPERTIES
IMPORTED_LOCATION "${X11_Xss_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xss_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xext;X11::X11")
endif ()
if (X11_Xt_FOUND AND NOT TARGET X11::Xt)
add_library(X11::Xt UNKNOWN IMPORTED)
set_target_properties(X11::Xt PROPERTIES
IMPORTED_LOCATION "${X11_Xt_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xt_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::ICE;X11::SM;X11::X11")
endif ()
if (X11_Xutil_FOUND AND NOT TARGET X11::Xutil)
add_library(X11::Xutil INTERFACE IMPORTED)
set_target_properties(X11::Xutil PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xutil_INCLUDE_PATH}"
# libX11 contains the implementations for functions in the Xutil.h
# header.
INTERFACE_LINK_LIBRARIES "X11::X11")
endif ()
if (X11_Xv_FOUND AND NOT TARGET X11::Xv)
add_library(X11::Xv UNKNOWN IMPORTED)
set_target_properties(X11::Xv PROPERTIES
IMPORTED_LOCATION "${X11_Xv_LIB}"
INTERFACE_INCLUDE_DIRECTORIES "${X11_Xv_INCLUDE_PATH}"
INTERFACE_LINK_LIBRARIES "X11::Xext;X11::X11")
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
mark_as_advanced(
Fix FindX11 to match convention
2003-01-08 16:45:48 +00:00
X11_X11_INCLUDE_PATH
X11_X11_LIB
FindX11: find Xext.h
2018-11-12 20:49:33 +00:00
X11_Xext_INCLUDE_PATH
Fix FindX11 to match convention
2003-01-08 16:45:48 +00:00
X11_Xext_LIB
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xau_LIB
ENH: more consistence among the X11 components Alex
2007-06-08 14:28:52 +00:00
X11_Xau_INCLUDE_PATH
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
X11_xcb_LIB
X11_xcb_INCLUDE_PATH
X11_xcb_xkb_LIB
X11_X11_xcb_LIB
X11_X11_xcb_INCLUDE_PATH
Fix FindX11 to match convention
2003-01-08 16:45:48 +00:00
X11_Xlib_INCLUDE_PATH
X11_Xutil_INCLUDE_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xcomposite_INCLUDE_PATH
X11_Xcomposite_LIB
X11_Xfixes_LIB
X11_Xfixes_INCLUDE_PATH
X11_Xrandr_LIB
X11_Xrandr_INCLUDE_PATH
X11_Xdamage_LIB
X11_Xdamage_INCLUDE_PATH
X11_Xrender_LIB
X11_Xrender_INCLUDE_PATH
Modules: Add XRes to FindX11.cmake
2011-11-09 11:22:32 +00:00
X11_XRes_LIB
X11_XRes_INCLUDE_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xxf86misc_LIB
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
X11_Xxf86misc_INCLUDE_PATH
fix #6976: FindX11 also searches for X11_Xxf86vm_LIB This contains a change, which changes the behaviour a bit: now X11_xf86vmode_FOUND is only set to TRUE and the include directory is added to X11_INCLUDE_DIR, if additionally to X11_xf86vmode_INCLUDE_PATH also X11_Xxf86vm_LIB has been found. I hope this doesn't cause regressions somewhere. Alex
2012-02-16 08:36:27 +00:00
X11_Xxf86vm_LIB
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
X11_Xxf86vm_INCLUDE_PATH
Add support for libXi.
2010-03-17 16:45:24 +00:00
X11_Xi_LIB
X11_Xi_INCLUDE_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xinerama_LIB
X11_Xinerama_INCLUDE_PATH
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
X11_Xtst_LIB
X11_Xtst_INCLUDE_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xcursor_LIB
X11_Xcursor_INCLUDE_PATH
X11_dpms_INCLUDE_PATH
X11_Xt_LIB
ENH: more consistence among the X11 components Alex
2007-06-08 14:28:52 +00:00
X11_Xt_INCLUDE_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xdmcp_LIB
Fix FindX11 to match convention
2003-01-08 16:45:48 +00:00
X11_LIBRARIES
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xaccessrules_INCLUDE_PATH
X11_Xaccessstr_INCLUDE_PATH
X11_Xdmcp_INCLUDE_PATH
X11_Xkb_INCLUDE_PATH
X11_Xkblib_INCLUDE_PATH
FindX11: Find additional libraries With this change, FindLibrary(X11) learns about the following libraries: * xcb * X11-xcb * xcb-icccm * xcb-xkb * xkbcommon * xkbcommon-X11
2019-11-29 19:08:46 +00:00
X11_xkbcommon_INCLUDE_PATH
X11_xkbcommon_LIB
X11_xkbcommon_X11_INCLUDE_PATH
X11_xkbcommon_X11_LIB
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
X11_xkbfile_INCLUDE_PATH
X11_xkbfile_LIB
FindX11: also search for Xmu (#12447)
2012-02-08 19:15:20 +00:00
X11_Xmu_INCLUDE_PATH
X11_Xmu_LIB
FindX11: match variables with library names This deprecates various variables, but provides them for backwards compatibility.
2018-11-12 19:18:34 +00:00
X11_Xss_INCLUDE_PATH
X11_Xss_LIB
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
X11_Xpm_INCLUDE_PATH
X11_Xpm_LIB
X11_Xft_LIB
X11_Xft_INCLUDE_PATH
X11_Xshape_INCLUDE_PATH
X11_Xv_LIB
X11_Xv_INCLUDE_PATH
X11_XShm_INCLUDE_PATH
X11_ICE_LIB
X11_ICE_INCLUDE_PATH
ENH: X11_SM_LIB should be advanced as well
2008-05-03 19:27:40 +00:00
X11_SM_LIB
Also search for libxkbfile, XSync and SM include dir Alex
2011-08-03 20:33:18 +00:00
X11_SM_INCLUDE_PATH
X11_XSync_INCLUDE_PATH
ENH: mostly synced with FindX11.cmake from KDE svn: now also searches for a lot of additional X11 libs, like Xv, Xau, Xrandr and others Alex
2007-05-30 16:09:34 +00:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:47:32 +00:00
set(CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_SAVE})
Find*: Make find_package(.. QUIET) affect Check* modules. Fixes issues #14812 and #14813 where find_package(OpenMP QUIET) and find_package(Qt4 QUIET) would still print out messages when calling check*() functions. Also a partial fix for #14445 where building CMake (without cmake-gui) when Qt5 is installed and Qt4 is not installed and warnings come out of FindQt4.cmake.
2014-03-30 02:22:54 +00:00
set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 17:50:14 +00:00
endif ()
Reference in New Issue Copy Permalink