kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/Qt4ConfigDependentSettings....

291 lines
7.5 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 22:01:08 +03:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
#.rst:
# Qt4ConfigDependentSettings
# --------------------------
#
#
#
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# This file is included by FindQt4.cmake, don't include it directly.
###############################################
#
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
# configuration/system dependent settings
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
#
###############################################
# find dependencies for some Qt modules
# when doing builds against a static Qt, they are required
BUG: Fix #10021 don't specify libraries Qt depends on unless Qt is static.
2009-12-16 00:16:45 +03:00
# when doing builds against a shared Qt, they are not required
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# if a user needs the dependencies, and they couldn't be found, they can set
# the variables themselves.
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 21:47:32 +04:00
set(QT_QTGUI_LIB_DEPENDENCIES "")
set(QT_QTCORE_LIB_DEPENDENCIES "")
set(QT_QTNETWORK_LIB_DEPENDENCIES "")
set(QT_QTOPENGL_LIB_DEPENDENCIES "")
set(QT_QTDBUS_LIB_DEPENDENCIES "")
set(QT_QTHELP_LIB_DEPENDENCIES ${QT_QTCLUCENE_LIBRARY})
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
if(Q_WS_WIN)
Fix build issues cross compiling with static Qt. Also fix case where system jpeg, png, tiff libs are used.
2010-11-24 02:01:43 +03:00
# On Windows, qconfig.pri has "shared" for shared library builds
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 21:47:32 +04:00
if(NOT QT_CONFIG MATCHES "shared")
set(QT_IS_STATIC 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 21:50:14 +04:00
endif()
else()
BUG: Fix #10021 don't specify libraries Qt depends on unless Qt is static.
2009-12-16 00:16:45 +03:00
# On other platforms, check file extension to know if its static
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 21:47:32 +04:00
if(QT_QTCORE_LIBRARY_RELEASE)
get_filename_component(qtcore_lib_ext "${QT_QTCORE_LIBRARY_RELEASE}" EXT)
if("${qtcore_lib_ext}" STREQUAL "${CMAKE_STATIC_LIBRARY_SUFFIX}")
set(QT_IS_STATIC 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 21:50:14 +04:00
endif()
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 21:47:32 +04:00
if(QT_QTCORE_LIBRARY_DEBUG)
get_filename_component(qtcore_lib_ext "${QT_QTCORE_LIBRARY_DEBUG}" EXT)
if(${qtcore_lib_ext} STREQUAL ${CMAKE_STATIC_LIBRARY_SUFFIX})
set(QT_IS_STATIC 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 21:50:14 +04:00
endif()
endif()
endif()
BUG: Fix #10021 don't specify libraries Qt depends on unless Qt is static.
2009-12-16 00:16:45 +03:00
# build using shared Qt needs -DQT_DLL on Windows
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 21:47:32 +04:00
if(Q_WS_WIN AND NOT QT_IS_STATIC)
set(QT_DEFINITIONS ${QT_DEFINITIONS} -DQT_DLL)
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
if(NOT QT_IS_STATIC)
return()
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# QtOpenGL dependencies
ENH: Modify how OpenGL is searched for, that is, use FindOpenGL.cmake.
2010-03-17 07:28:03 +03:00
find_package(OpenGL)
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 21:47:32 +04:00
set (QT_QTOPENGL_LIB_DEPENDENCIES ${OPENGL_glu_LIBRARY} ${OPENGL_gl_LIBRARY})
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## system png
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "system-png")
Change Qt4ConfigDependentSettings to use more standard find modules. Let's use more standard find modules for Qt4 dependencies. Move a few from using pkg-config so we can do cross compiling the cmake way.
2010-06-25 06:30:50 +04:00
find_package(PNG)
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 21:47:32 +04:00
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${PNG_LIBRARY})
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
Fix build issues cross compiling with static Qt. Also fix case where system jpeg, png, tiff libs are used.
2010-11-24 02:01:43 +03:00
## system jpeg
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "system-jpeg")
Fix build issues cross compiling with static Qt. Also fix case where system jpeg, png, tiff libs are used.
2010-11-24 02:01:43 +03:00
find_package(JPEG)
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 21:47:32 +04:00
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${JPEG_LIBRARIES})
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 21:50:14 +04:00
endif()
Fix build issues cross compiling with static Qt. Also fix case where system jpeg, png, tiff libs are used.
2010-11-24 02:01:43 +03:00
## system tiff
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "system-tiff")
Fix build issues cross compiling with static Qt. Also fix case where system jpeg, png, tiff libs are used.
2010-11-24 02:01:43 +03:00
find_package(TIFF)
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 21:47:32 +04:00
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${TIFF_LIBRARIES})
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 21:50:14 +04:00
endif()
Fix build issues cross compiling with static Qt. Also fix case where system jpeg, png, tiff libs are used.
2010-11-24 02:01:43 +03:00
## system mng
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "system-mng")
Fix build issues cross compiling with static Qt. Also fix case where system jpeg, png, tiff libs are used.
2010-11-24 02:01:43 +03:00
find_library(MNG_LIBRARY NAMES mng)
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 21:47:32 +04:00
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${MNG_LIBRARY})
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# for X11, get X11 library 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 21:47:32 +04:00
if(Q_WS_X11)
find_package(X11)
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## X11 SM
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "x11sm")
if(X11_SM_LIB AND X11_ICE_LIB)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_SM_LIB} ${X11_ICE_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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## Xi
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "tablet")
if(X11_Xi_LIB)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_Xi_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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## Xrender
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "xrender")
if(X11_Xrender_LIB)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_Xrender_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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## Xrandr
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "xrandr")
if(X11_Xrandr_LIB)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_Xrandr_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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## Xcursor
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "xcursor")
if(X11_Xcursor_LIB)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_Xcursor_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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## Xinerama
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "xinerama")
if(X11_Xinerama_LIB)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_Xinerama_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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## Xfixes
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "xfixes")
if(X11_Xfixes_LIB)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_Xfixes_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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## fontconfig
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "fontconfig")
find_library(QT_FONTCONFIG_LIBRARY NAMES fontconfig)
mark_as_advanced(QT_FONTCONFIG_LIBRARY)
if(QT_FONTCONFIG_LIBRARY)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${QT_FONTCONFIG_LIBRARY})
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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
Change Qt4ConfigDependentSettings to use more standard find modules. Let's use more standard find modules for Qt4 dependencies. Move a few from using pkg-config so we can do cross compiling the cmake way.
2010-06-25 06:30:50 +04:00
## system-freetype
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "system-freetype")
Change Qt4ConfigDependentSettings to use more standard find modules. Let's use more standard find modules for Qt4 dependencies. Move a few from using pkg-config so we can do cross compiling the cmake way.
2010-06-25 06:30:50 +04:00
find_package(Freetype)
if(FREETYPE_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 21:47:32 +04:00
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${FREETYPE_LIBRARIES})
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 21:50:14 +04:00
endif()
endif()
Change Qt4ConfigDependentSettings to use more standard find modules. Let's use more standard find modules for Qt4 dependencies. Move a few from using pkg-config so we can do cross compiling the cmake way.
2010-06-25 06:30:50 +04:00
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## system-zlib
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "system-zlib")
Change Qt4ConfigDependentSettings to use more standard find modules. Let's use more standard find modules for Qt4 dependencies. Move a few from using pkg-config so we can do cross compiling the cmake way.
2010-06-25 06:30:50 +04:00
find_package(ZLIB)
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 21:47:32 +04:00
set(QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES} ${ZLIB_LIBRARIES})
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## openssl
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 21:47:32 +04:00
if(NOT Q_WS_WIN)
set(_QT_NEED_OPENSSL 0)
if(QT_VERSION_MINOR LESS 4 AND QT_QCONFIG MATCHES "openssl")
set(_QT_NEED_OPENSSL 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 21:50:14 +04: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 21:47:32 +04:00
if(QT_VERSION_MINOR GREATER 3 AND QT_QCONFIG MATCHES "openssl-linked")
set(_QT_NEED_OPENSSL 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 21:50:14 +04: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 21:47:32 +04:00
if(_QT_NEED_OPENSSL)
find_package(OpenSSL)
if(OPENSSL_LIBRARIES)
set(QT_QTNETWORK_LIB_DEPENDENCIES ${QT_QTNETWORK_LIB_DEPENDENCIES} ${OPENSSL_LIBRARIES})
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 21:50:14 +04:00
endif()
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## dbus
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "dbus")
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
find_library(QT_DBUS_LIBRARY NAMES dbus-1 )
if(QT_DBUS_LIBRARY)
set(QT_QTDBUS_LIB_DEPENDENCIES ${QT_QTDBUS_LIB_DEPENDENCIES} ${QT_DBUS_LIBRARY})
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 21:50:14 +04: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 21:47:32 +04:00
mark_as_advanced(QT_DBUS_LIBRARY)
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## glib
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "glib")
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# Qt 4.2.0+ uses glib-2.0
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 21:47:32 +04:00
find_library(QT_GLIB_LIBRARY NAMES glib-2.0 )
find_library(QT_GTHREAD_LIBRARY NAMES gthread-2.0 )
mark_as_advanced(QT_GLIB_LIBRARY)
mark_as_advanced(QT_GTHREAD_LIBRARY)
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
if(QT_GLIB_LIBRARY AND QT_GTHREAD_LIBRARY)
set(QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES}
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
${QT_GTHREAD_LIBRARY} ${QT_GLIB_LIBRARY})
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# Qt 4.5+ also links to gobject-2.0
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 21:47:32 +04:00
if(QT_VERSION_MINOR GREATER 4)
find_library(QT_GOBJECT_LIBRARY NAMES gobject-2.0 PATHS ${_glib_query_output} )
mark_as_advanced(QT_GOBJECT_LIBRARY)
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
if(QT_GOBJECT_LIBRARY)
set(QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES}
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
${QT_GOBJECT_LIBRARY})
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 21:50:14 +04:00
endif()
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
## clock-monotonic, just see if we need to link with rt
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 21:47:32 +04:00
if(QT_QCONFIG MATCHES "clock-monotonic")
set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_LIBRARIES rt)
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
CHECK_SYMBOL_EXISTS(_POSIX_TIMERS "unistd.h;time.h" QT_POSIX_TIMERS)
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 21:47:32 +04:00
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
if(QT_POSIX_TIMERS)
find_library(QT_RT_LIBRARY NAMES rt)
mark_as_advanced(QT_RT_LIBRARY)
if(QT_RT_LIBRARY)
set(QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES} ${QT_RT_LIBRARY})
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 21:50:14 +04:00
endif()
endif()
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 21:47:32 +04:00
if(Q_WS_X11)
Change to use FindX11.cmake. Should fix #9929.
2010-03-17 19:46:22 +03:00
# X11 libraries Qt always depends on
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 21:47:32 +04:00
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${X11_Xext_LIB} ${X11_X11_LIB})
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
Qt4: Fix typo setting a variable for FindThreads. Fixes bug 14055.
2013-04-02 17:46:51 +04:00
set(CMAKE_THREAD_PREFER_PTHREAD 1)
Remove macro for querying qmake for qmake variables. Remove last place for querying qmake values. Also removed internal macro to support querying qmake. Depends on findthreads-irix topic.
2010-06-12 23:00:08 +04:00
find_package(Threads)
if(CMAKE_USE_PTHREADS_INIT)
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 21:47:32 +04:00
set(QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES} ${CMAKE_THREAD_LIBS_INIT})
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
set (QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES} ${CMAKE_DL_LIBS})
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
if(Q_WS_WIN)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} imm32 winmm)
set(QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES} ws2_32)
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
if(Q_WS_MAC)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} "-framework Carbon")
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# Qt 4.0, 4.1, 4.2 use QuickTime
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 21:47:32 +04:00
if(QT_VERSION_MINOR LESS 3)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} "-framework QuickTime")
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00
# Qt 4.2+ use AppKit
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 21:47:32 +04:00
if(QT_VERSION_MINOR GREATER 1)
set(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} "-framework AppKit")
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03: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 21:47:32 +04:00
set(QT_QTCORE_LIB_DEPENDENCIES ${QT_QTCORE_LIB_DEPENDENCIES} "-framework ApplicationServices")
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 21:50:14 +04:00
endif()
Split some logic of FindQt4.cmake into separate files, which are included automatically. Qt4Macros.cmake: all the "public" macros of FindQt4.cmake Qt4ConfigDependentSettings.cmake: the code for detecting the Qt-configuration dependent additional libraries, e.g. when linking statically. There should be no functional changes in this patch. The patch reduces the length of FindQt4.cmake from 1700 lines to around 1000 lines, which is still long enough, but this should make the file a easier to handle (and it is similar to what we do in KDE with FindKDE4Internal.cmake and KDE4Macros.cmake) Ok by Clinton. Alex
2009-11-15 21:02:19 +03:00