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

510 lines
18 KiB
CMake
Raw Normal View History

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:
# Qt4Macros
# ---------
#
#
#
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.
#=============================================================================
# Copyright 2005-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
Modules: Fix spelling 'To distributed' -> 'To distribute'
2010-08-07 04:48:47 +04:00
# (To distribute this file outside of CMake, substitute the full
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
# License text for the above reference.)
######################################
#
# Macros for building Qt files
#
######################################
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
macro (QT4_EXTRACT_OPTIONS _qt4_files _qt4_options _qt4_target)
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(${_qt4_files})
set(${_qt4_options})
set(_QT4_DOING_OPTIONS FALSE)
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
set(_QT4_DOING_TARGET FALSE)
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
foreach(_currentArg ${ARGN})
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
if ("x${_currentArg}" STREQUAL "xOPTIONS")
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(_QT4_DOING_OPTIONS TRUE)
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
elseif ("x${_currentArg}" STREQUAL "xTARGET")
set(_QT4_DOING_TARGET 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 21:50:14 +04:00
else ()
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
if(_QT4_DOING_TARGET)
set(${_qt4_target} "${_currentArg}")
elseif(_QT4_DOING_OPTIONS)
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
list(APPEND ${_qt4_options} "${_currentArg}")
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
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 21:47:32 +04:00
list(APPEND ${_qt4_files} "${_currentArg}")
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 ()
endforeach()
endmacro ()
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
# macro used to create the names of output files preserving relative dirs
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
macro (QT4_MAKE_OUTPUT_FILE infile prefix ext outfile )
string(LENGTH ${CMAKE_CURRENT_BINARY_DIR} _binlength)
string(LENGTH ${infile} _infileLength)
set(_checkinfile ${CMAKE_CURRENT_SOURCE_DIR})
if(_infileLength GREATER _binlength)
string(SUBSTRING "${infile}" 0 ${_binlength} _checkinfile)
if(_checkinfile STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
file(RELATIVE_PATH rel ${CMAKE_CURRENT_BINARY_DIR} ${infile})
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
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 21:47:32 +04:00
file(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile})
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()
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
file(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile})
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()
Clean up usage of if(... MATCHES regex) followed string(REGEX REPLACE regex) The matches have already been calculated and can simply be taken from CMAKE_MATCH_n variables. This avoids multiple compilations of the same or very similar regular expressions.
2014-04-06 23:30:00 +04:00
if(WIN32 AND rel MATCHES "^([a-zA-Z]):(.*)$") # absolute path
set(rel "${CMAKE_MATCH_1}_${CMAKE_MATCH_2}")
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
set(_outfile "${CMAKE_CURRENT_BINARY_DIR}/${rel}")
string(REPLACE ".." "__" _outfile ${_outfile})
get_filename_component(outpath ${_outfile} PATH)
get_filename_component(_outfile ${_outfile} NAME_WE)
file(MAKE_DIRECTORY ${outpath})
set(${outfile} ${outpath}/${prefix}${_outfile}.${ext})
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
endmacro ()
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
macro (QT4_GET_MOC_FLAGS _moc_flags)
set(${_moc_flags})
get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES)
foreach(_current ${_inc_DIRS})
if("${_current}" MATCHES "\\.framework/?$")
string(REGEX REPLACE "/[^/]+\\.framework" "" framework_path "${_current}")
set(${_moc_flags} ${${_moc_flags}} "-F${framework_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 21:50:14 +04: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 21:47:32 +04:00
set(${_moc_flags} ${${_moc_flags}} "-I${_current}")
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()
endforeach()
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
get_directory_property(_defines COMPILE_DEFINITIONS)
foreach(_current ${_defines})
set(${_moc_flags} ${${_moc_flags}} "-D${_current}")
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
endforeach()
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(${_moc_flags} ${${_moc_flags}} -DWIN32)
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
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
endmacro()
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
# helper macro to set up a moc rule
Qt4Macros: Make QT4_CREATE_MOC_COMMAND a function QT4_CREATE_MOC_COMMAND is given a moc_flags argument that contains the COMPILE_DEFINITIONS and a potentially large list of include directories. Since it is a macro, the ${moc_flags} reference is replaced with this content and sent through cmMakefile::ExpandVariablesInString (EVIS). Since commit v3.0.0-rc1~138^2 (Qt4: Use generator expression in COMPILE_DEFINITIONS, 2014-01-13) the COMPILE_DEFINITIONS value contains a '$' so the EVIS fast-path is no longer used. Instead the full cmCommandArgumentParserHelper is now used on the large input, which is very slow (since it was originally created for hand-written code). Change QT4_CREATE_MOC_COMMAND to a function instead of a macro to avoid passing large content through EVIS. This makes it significantly faster.
2014-04-03 19:27:58 +04:00
function (QT4_CREATE_MOC_COMMAND infile outfile moc_flags moc_options moc_target)
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 Windows, create a parameters file to work around command line length limit
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
# Pass the parameters in a file. Set the working directory to
# be that containing the parameters file and reference it by
# just the file name. This is necessary because the moc tool on
# MinGW builds does not seem to handle spaces in the path to the
# file given with the @ syntax.
get_filename_component(_moc_outfile_name "${outfile}" NAME)
get_filename_component(_moc_outfile_dir "${outfile}" PATH)
if(_moc_outfile_dir)
set(_moc_working_dir WORKING_DIRECTORY ${_moc_outfile_dir})
endif()
set (_moc_parameters_file ${outfile}_parameters)
set (_moc_parameters ${moc_flags} ${moc_options} -o "${outfile}" "${infile}")
string (REPLACE ";" "\n" _moc_parameters "${_moc_parameters}")
if(moc_target)
Use a config-specific moc parameters file, if needed.
2013-12-12 21:22:17 +04:00
set (_moc_parameters_file ${_moc_parameters_file}$<$<BOOL:$<CONFIGURATION>>:_$<CONFIGURATION>>)
Qt4Macros: Simplify some variable population.
2013-07-26 11:35:57 +04:00
set(targetincludes "$<TARGET_PROPERTY:${moc_target},INCLUDE_DIRECTORIES>")
set(targetdefines "$<TARGET_PROPERTY:${moc_target},COMPILE_DEFINITIONS>")
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
set(targetincludes "$<$<BOOL:${targetincludes}>:-I$<JOIN:${targetincludes},\n-I>\n>")
set(targetdefines "$<$<BOOL:${targetdefines}>:-D$<JOIN:${targetdefines},\n-D>\n>")
file (GENERATE
OUTPUT ${_moc_parameters_file}
Qt4Macros: Remove undefined varible use. This may have been added in anticipation of processing COMPILE_OPTIONS, but as moc does not accept them, there is no need for it.
2013-07-26 11:34:05 +04:00
CONTENT "${targetdefines}${targetincludes}${_moc_parameters}\n"
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
)
set(targetincludes)
set(targetdefines)
else()
Qt4: write moc parameter file only when content has changed
2014-04-25 20:24:56 +04:00
set(CMAKE_CONFIGURABLE_FILE_CONTENT "${_moc_parameters}")
configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
"${_moc_parameters_file}" @ONLY)
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
endif()
set(_moc_extra_parameters_file @${_moc_parameters_file})
add_custom_command(OUTPUT ${outfile}
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::moc ${_moc_extra_parameters_file}
Qt4: Fix moc command dependencies for incremental build. Since commit v2.8.12~327^2 (Qt4Macros: Allow specifying a TARGET in invokations of macros., 2013-02-26), a parameters file is populated with moc arguments at generate-time. When the compile definitions or include directories change, the parameters file is updated but moc is not re-run in response. Fix that by making the moc invocation depend on the parameters file. Reported-At: https://bugreports.qt-project.org/browse/QTBUG-36970
2014-03-04 14:03:37 +04:00
DEPENDS ${infile} ${_moc_parameters_file}
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
${_moc_working_dir}
VERBATIM)
Qt4Macros: Make QT4_CREATE_MOC_COMMAND a function QT4_CREATE_MOC_COMMAND is given a moc_flags argument that contains the COMPILE_DEFINITIONS and a potentially large list of include directories. Since it is a macro, the ${moc_flags} reference is replaced with this content and sent through cmMakefile::ExpandVariablesInString (EVIS). Since commit v3.0.0-rc1~138^2 (Qt4: Use generator expression in COMPILE_DEFINITIONS, 2014-01-13) the COMPILE_DEFINITIONS value contains a '$' so the EVIS fast-path is no longer used. Instead the full cmCommandArgumentParserHelper is now used on the large input, which is very slow (since it was originally created for hand-written code). Change QT4_CREATE_MOC_COMMAND to a function instead of a macro to avoid passing large content through EVIS. This makes it significantly faster.
2014-04-03 19:27:58 +04:00
endfunction ()
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
macro (QT4_GENERATE_MOC infile outfile )
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
# get include dirs and flags
QT4_GET_MOC_FLAGS(moc_flags)
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
get_filename_component(abs_infile ${infile} ABSOLUTE)
set(_outfile "${outfile}")
if(NOT IS_ABSOLUTE "${outfile}")
set(_outfile "${CMAKE_CURRENT_BINARY_DIR}/${outfile}")
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()
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
if ("x${ARGV2}" STREQUAL "xTARGET")
set(moc_target ${ARGV3})
endif()
QT4_CREATE_MOC_COMMAND(${abs_infile} ${_outfile} "${moc_flags}" "" "${moc_target}")
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_source_files_properties(${outfile} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file
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
endmacro ()
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_WRAP_CPP(outfiles inputfile ... )
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
macro (QT4_WRAP_CPP outfiles )
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
# get include dirs
QT4_GET_MOC_FLAGS(moc_flags)
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
QT4_EXTRACT_OPTIONS(moc_files moc_options moc_target ${ARGN})
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
foreach (it ${moc_files})
get_filename_component(it ${it} ABSOLUTE)
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_MAKE_OUTPUT_FILE(${it} moc_ cxx outfile)
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
QT4_CREATE_MOC_COMMAND(${it} ${outfile} "${moc_flags}" "${moc_options}" "${moc_target}")
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(${outfiles} ${${outfiles}} ${outfile})
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
endforeach()
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
endmacro ()
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_WRAP_UI(outfiles inputfile ... )
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
macro (QT4_WRAP_UI outfiles )
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
QT4_EXTRACT_OPTIONS(ui_files ui_options ui_target ${ARGN})
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
foreach (it ${ui_files})
get_filename_component(outfile ${it} NAME_WE)
get_filename_component(infile ${it} ABSOLUTE)
set(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.h)
add_custom_command(OUTPUT ${outfile}
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::uic
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
ARGS ${ui_options} -o ${outfile} ${infile}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
MAIN_DEPENDENCY ${infile} VERBATIM)
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(${outfiles} ${${outfiles}} ${outfile})
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
endforeach ()
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
endmacro ()
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_ADD_RESOURCES(outfiles inputfile ... )
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
macro (QT4_ADD_RESOURCES outfiles )
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
QT4_EXTRACT_OPTIONS(rcc_files rcc_options rcc_target ${ARGN})
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
foreach (it ${rcc_files})
get_filename_component(outfilename ${it} NAME_WE)
get_filename_component(infile ${it} ABSOLUTE)
get_filename_component(rc_path ${infile} PATH)
set(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cxx)
Qt4Macros: Added support for generated resource files Using the QT4_ADD_RESOURCES() macro required the resource file to exist already for dependency scanning. This prevented the use of resource files that are generated by cmake because it needs the file before resolving the dependency. This patch adds support for generated resource files by not scanning the resource file for dependencies if it doesn't exist yet. The add_custom_command() to generate the resource file should add the dependencies on the files used by the resource file.
2012-05-29 19:45:03 +04: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(_RC_DEPENDS)
if(EXISTS "${infile}")
Qt4Macros: Added support for generated resource files Using the QT4_ADD_RESOURCES() macro required the resource file to exist already for dependency scanning. This prevented the use of resource files that are generated by cmake because it needs the file before resolving the dependency. This patch adds support for generated resource files by not scanning the resource file for dependencies if it doesn't exist yet. The add_custom_command() to generate the resource file should add the dependencies on the files used by the resource file.
2012-05-29 19:45:03 +04:00
# parse file for dependencies
# all files are absolute paths or relative to the location of the qrc file
Read entire Qt4 qrc file when parsing for depends info. The qrc file is an xml file, not line based, so the entire 'interesting' content to parse is not necessarily found by STRINGS and a regexp.
2012-08-30 11:47:42 +04:00
file(READ "${infile}" _RC_FILE_CONTENTS)
Qt4Macros: Fix recently broken resource file parsing Commit 4be67837 (read less from version headers into variables, 2012-08-19) switched from file(READ) and string(REGEX MATCHALL) to just file(STRINGS) to extract the list of resource <file> entries. However, the latter extracts entire lines that match the regex, not just the part that matches the regex, so the subsequent string(REGEX REPLACE) fails to match and replace anything. Return to the original parsing logic but replace file(READ) with file(STRINGS) to load a minimal part of the file before using string(REGEX MATCHALL) as before.
2012-08-22 16:33:12 +04:00
string(REGEX MATCHALL "<file[^<]+" _RC_FILES "${_RC_FILE_CONTENTS}")
foreach(_RC_FILE ${_RC_FILES})
string(REGEX REPLACE "^<file[^>]*>" "" _RC_FILE "${_RC_FILE}")
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 IS_ABSOLUTE "${_RC_FILE}")
set(_RC_FILE "${rc_path}/${_RC_FILE}")
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
set(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")
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
endforeach()
read less from version headers into variables Instead of reading the whole file using file(READ) and later matching on the whole file use file(STRINGS ... REGEX) to get only those lines we are interested in at all. This will make the list much smaller (good for debugging) and also the regular expressions will need to match on much smaller strings. Also unset the content variables once they are not used anymore.
2012-08-19 15:54:56 +04:00
unset(_RC_FILES)
Qt4Macros: Fix recently broken resource file parsing Commit 4be67837 (read less from version headers into variables, 2012-08-19) switched from file(READ) and string(REGEX MATCHALL) to just file(STRINGS) to extract the list of resource <file> entries. However, the latter extracts entire lines that match the regex, not just the part that matches the regex, so the subsequent string(REGEX REPLACE) fails to match and replace anything. Return to the original parsing logic but replace file(READ) with file(STRINGS) to load a minimal part of the file before using string(REGEX MATCHALL) as before.
2012-08-22 16:33:12 +04:00
unset(_RC_FILE_CONTENTS)
Qt4Macros: Added support for generated resource files Using the QT4_ADD_RESOURCES() macro required the resource file to exist already for dependency scanning. This prevented the use of resource files that are generated by cmake because it needs the file before resolving the dependency. This patch adds support for generated resource files by not scanning the resource file for dependencies if it doesn't exist yet. The add_custom_command() to generate the resource file should add the dependencies on the files used by the resource file.
2012-05-29 19:45:03 +04:00
# Since this cmake macro is doing the dependency scanning for these files,
# let's make a configured file and add it as a dependency so cmake is run
# again when dependencies need to be recomputed.
QT4_MAKE_OUTPUT_FILE("${infile}" "" "qrc.depends" out_depends)
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
configure_file("${infile}" "${out_depends}" COPY_ONLY)
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
else()
Qt4Macros: Added support for generated resource files Using the QT4_ADD_RESOURCES() macro required the resource file to exist already for dependency scanning. This prevented the use of resource files that are generated by cmake because it needs the file before resolving the dependency. This patch adds support for generated resource files by not scanning the resource file for dependencies if it doesn't exist yet. The add_custom_command() to generate the resource file should add the dependencies on the files used by the resource file.
2012-05-29 19:45:03 +04:00
# The .qrc file does not exist (yet). Let's add a dependency and hope
# that it will be generated later
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(out_depends)
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()
Qt4Macros: Added support for generated resource files Using the QT4_ADD_RESOURCES() macro required the resource file to exist already for dependency scanning. This prevented the use of resource files that are generated by cmake because it needs the file before resolving the dependency. This patch adds support for generated resource files by not scanning the resource file for dependencies if it doesn't exist yet. The add_custom_command() to generate the resource file should add the dependencies on the files used by the resource file.
2012-05-29 19:45:03 +04: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
add_custom_command(OUTPUT ${outfile}
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::rcc
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
ARGS ${rcc_options} -name ${outfilename} -o ${outfile} ${infile}
MAIN_DEPENDENCY ${infile}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
DEPENDS ${_RC_DEPENDS} "${out_depends}" VERBATIM)
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(${outfiles} ${${outfiles}} ${outfile})
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
endforeach ()
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
endmacro ()
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
macro(QT4_ADD_DBUS_INTERFACE _sources _interface _basename)
get_filename_component(_infile ${_interface} ABSOLUTE)
set(_header "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h")
set(_impl "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp")
set(_moc "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc")
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
get_source_file_property(_nonamespace ${_interface} NO_NAMESPACE)
if(_nonamespace)
set(_params -N -m)
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
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 21:47:32 +04:00
set(_params -m)
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()
Add features from KDE for arguments to qdbusxml2cpp.
2011-09-05 23:58:29 +04: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
get_source_file_property(_classname ${_interface} CLASSNAME)
if(_classname)
set(_params ${_params} -c ${_classname})
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()
Add features from KDE for arguments to qdbusxml2cpp.
2011-09-05 23:58:29 +04: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
get_source_file_property(_include ${_interface} INCLUDE)
if(_include)
set(_params ${_params} -i ${_include})
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
add_custom_command(OUTPUT "${_impl}" "${_header}"
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::qdbusxml2cpp ${_params} -p ${_basename} ${_infile}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
DEPENDS ${_infile} VERBATIM)
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_source_files_properties("${_impl}" PROPERTIES SKIP_AUTOMOC TRUE)
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
Qt4Macros: add some quotes to prevent damage from spaces in the paths
2012-06-20 15:29:45 +04:00
QT4_GENERATE_MOC("${_header}" "${_moc}")
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
list(APPEND ${_sources} "${_impl}" "${_header}" "${_moc}")
Qt4Macros: add some quotes to prevent damage from spaces in the paths
2012-06-20 15:29:45 +04:00
MACRO_ADD_FILE_DEPENDENCIES("${_impl}" "${_moc}")
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
endmacro()
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
macro(QT4_ADD_DBUS_INTERFACES _sources)
foreach (_current_FILE ${ARGN})
get_filename_component(_infile ${_current_FILE} ABSOLUTE)
get_filename_component(_basename ${_current_FILE} NAME)
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
# get the part before the ".xml" suffix
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
string(TOLOWER ${_basename} _basename)
string(REGEX REPLACE "(.*\\.)?([^\\.]+)\\.xml" "\\2" _basename ${_basename})
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_ADD_DBUS_INTERFACE(${_sources} ${_infile} ${_basename}interface)
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
endforeach ()
endmacro()
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
macro(QT4_GENERATE_DBUS_INTERFACE _header) # _customName OPTIONS -some -options )
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
QT4_EXTRACT_OPTIONS(_customName _qt4_dbus_options _qt4_dbus_target ${ARGN})
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
get_filename_component(_in_file ${_header} ABSOLUTE)
get_filename_component(_basename ${_header} NAME_WE)
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 (_customName)
allow absolute paths for dbus interface.
2010-12-23 19:21:56 +03:00
if (IS_ABSOLUTE ${_customName})
get_filename_component(_containingDir ${_customName} PATH)
if (NOT EXISTS ${_containingDir})
file(MAKE_DIRECTORY "${_containingDir}")
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
set(_target ${_customName})
allow absolute paths for dbus interface.
2010-12-23 19:21:56 +03: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 21:47:32 +04:00
set(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})
allow absolute paths for dbus interface.
2010-12-23 19:21:56 +03:00
endif()
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
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 21:47:32 +04:00
set(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml)
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
add_custom_command(OUTPUT ${_target}
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::qdbuscpp2xml ${_qt4_dbus_options} ${_in_file} -o ${_target}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
DEPENDS ${_in_file} VERBATIM
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
endmacro()
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
macro(QT4_ADD_DBUS_ADAPTOR _sources _xml_file _include _parentClass) # _optionalBasename _optionalClassName)
get_filename_component(_infile ${_xml_file} ABSOLUTE)
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(_optionalBasename "${ARGV4}")
if (_optionalBasename)
set(_basename ${_optionalBasename} )
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
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 21:47:32 +04:00
string(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _basename ${_infile})
string(TOLOWER ${_basename} _basename)
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(_optionalClassName "${ARGV5}")
set(_header "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h")
set(_impl "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp")
set(_moc "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc")
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(_optionalClassName)
add_custom_command(OUTPUT "${_impl}" "${_header}"
Qt4: Use correct qdbus executable in macro. Commit v3.0.0-rc1~71^2~9 (Qt4: Use IMPORTED executable names with custom commands., 2014-01-24) erroneusly changed this command to use the wrong target.
2014-03-10 14:49:58 +04:00
COMMAND Qt4::qdbusxml2cpp -m -a ${_basename} -c ${_optionalClassName} -i ${_include} -l ${_parentClass} ${_infile}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
DEPENDS ${_infile} VERBATIM
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
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 21:47:32 +04:00
add_custom_command(OUTPUT "${_impl}" "${_header}"
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::qdbusxml2cpp -m -a ${_basename} -i ${_include} -l ${_parentClass} ${_infile}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
DEPENDS ${_infile} VERBATIM
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
Qt4Macros: add some quotes to prevent damage from spaces in the paths
2012-06-20 15:29:45 +04:00
QT4_GENERATE_MOC("${_header}" "${_moc}")
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_source_files_properties("${_impl}" PROPERTIES SKIP_AUTOMOC TRUE)
Qt4Macros: add some quotes to prevent damage from spaces in the paths
2012-06-20 15:29:45 +04:00
MACRO_ADD_FILE_DEPENDENCIES("${_impl}" "${_moc}")
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
list(APPEND ${_sources} "${_impl}" "${_header}" "${_moc}")
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
endmacro()
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
macro(QT4_AUTOMOC)
Mark qt4_use_modules and qt4_automoc as obsolete. The QT_QMAKE_EXECUTABLE has to be passed through the cmake calls because the executable may not be in the PATH.
2013-07-04 12:00:27 +04:00
if(NOT CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.11)
Qt4Macros: Port to use message(DEPRECATION)
2013-09-17 21:11:39 +04:00
message(DEPRECATION "The qt4_automoc macro is obsolete. Use the CMAKE_AUTOMOC feature instead.")
Mark qt4_use_modules and qt4_automoc as obsolete. The QT_QMAKE_EXECUTABLE has to be passed through the cmake calls because the executable may not be in the PATH.
2013-07-04 12:00:27 +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
QT4_GET_MOC_FLAGS(_moc_INCS)
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(_matching_FILES )
foreach (_current_FILE ${ARGN})
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
get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE)
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 "SKIP_AUTOMOC" is set to true, we will not handle this file here.
# This is required to make uic work correctly:
# we need to add generated .cpp files to the sources (to compile them),
# but we cannot let automoc handle them, as the .cpp files don't exist yet when
# cmake is run for the very first time on them -> however the .cpp files might
# exist at a later run. at that time we need to skip them, so that we don't add two
# different rules for the same moc file
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
get_source_file_property(_skip ${_abs_FILE} SKIP_AUTOMOC)
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 _skip AND EXISTS ${_abs_FILE} )
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
file(READ ${_abs_FILE} _contents)
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
get_filename_component(_abs_PATH ${_abs_FILE} PATH)
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
string(REGEX MATCHALL "# *include +[^ ]+\\.moc[\">]" _match "${_contents}")
if(_match)
foreach (_current_MOC_INC ${_match})
string(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}")
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
get_filename_component(_basename ${_current_MOC} NAME_WE)
if(EXISTS ${_abs_PATH}/${_basename}.hpp)
set(_header ${_abs_PATH}/${_basename}.hpp)
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
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 21:47:32 +04:00
set(_header ${_abs_PATH}/${_basename}.h)
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
set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC})
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
QT4_CREATE_MOC_COMMAND(${_header} ${_moc} "${_moc_INCS}" "" "")
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
MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc})
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
endforeach ()
endif()
endif ()
endforeach ()
endmacro()
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
macro(QT4_CREATE_TRANSLATION _qm_files)
Qt4Macros: Allow specifying a TARGET in invokations of macros. That will allow things like this: find_package(Qt4) qt4_generate_moc(myfile.h moc_myfile.cpp TARGET foo) # Note, foo target doesn't # exist until below. add_library(foo ...) The qt4_generate_moc call would use the INCLUDE_DIRECTORIES from the foo target using generator expressions. Currently it reads the INCLUDE_DIRECTORIES directory property, meaning that include_directories() is required. Support for the TARGET is also added to qt4_wrap_cpp, but not qt4_automoc, as that is deprecated in favor of the AUTOMOC target property. The moc tool reports failure if the Q_INTERFACES macro is used with an argument which has not appeared with Q_DECLARE_INTERFACE, so that is the basis of the unit test. The command line arguments are now always written to a file, which is passed to moc as the @atfile. This was already the case on Windows, but now it is used everywhere. The reason for that is that it is not currently possible to expand the list of includes from a target directly in a add_custom_command invokation (though that may become possible in the future). There is not a big disadvantage to using the file anyway on unix, so having one code path instead of two is also a motivation.
2013-02-27 02:27:22 +04:00
QT4_EXTRACT_OPTIONS(_lupdate_files _lupdate_options _lupdate_target ${ARGN})
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(_my_sources)
set(_my_dirs)
set(_my_tsfiles)
set(_ts_pro)
foreach (_file ${_lupdate_files})
get_filename_component(_ext ${_file} EXT)
get_filename_component(_abs_FILE ${_file} ABSOLUTE)
if(_ext MATCHES "ts")
list(APPEND _my_tsfiles ${_abs_FILE})
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
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 21:47:32 +04:00
if(NOT _ext)
list(APPEND _my_dirs ${_abs_FILE})
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
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 21:47:32 +04:00
list(APPEND _my_sources ${_abs_FILE})
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()
endforeach()
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
foreach(_ts_file ${_my_tsfiles})
if(_my_sources)
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
# make a .pro file to call lupdate on, so we don't make our commands too
# long for some systems
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
get_filename_component(_ts_name ${_ts_file} NAME_WE)
set(_ts_pro ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_ts_name}_lupdate.pro)
set(_pro_srcs)
foreach(_pro_src ${_my_sources})
Qt4: make pro files generated for translations easier to read -use one line for each input file and include directory -remove duplicate include directories
2013-10-16 13:31:04 +04:00
set(_pro_srcs "${_pro_srcs} \\\n \"${_pro_src}\"")
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
endforeach()
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(_pro_includes)
get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES)
Qt4: make pro files generated for translations easier to read -use one line for each input file and include directory -remove duplicate include directories
2013-10-16 13:31:04 +04:00
list(REMOVE_DUPLICATES _inc_DIRS)
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
foreach(_pro_include ${_inc_DIRS})
get_filename_component(_abs_include "${_pro_include}" ABSOLUTE)
Qt4: make pro files generated for translations easier to read -use one line for each input file and include directory -remove duplicate include directories
2013-10-16 13:31:04 +04:00
set(_pro_includes "${_pro_includes} \\\n \"${_abs_include}\"")
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
endforeach()
Qt4: make pro files generated for translations easier to read -use one line for each input file and include directory -remove duplicate include directories
2013-10-16 13:31:04 +04:00
file(WRITE ${_ts_pro} "SOURCES =${_pro_srcs}\nINCLUDEPATH =${_pro_includes}\n")
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
add_custom_command(OUTPUT ${_ts_file}
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::lupdate
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
ARGS ${_lupdate_options} ${_ts_pro} ${_my_dirs} -ts ${_ts_file}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
DEPENDS ${_my_sources} ${_ts_pro} VERBATIM)
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
endforeach()
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_ADD_TRANSLATION(${_qm_files} ${_my_tsfiles})
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
endmacro()
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
macro(QT4_ADD_TRANSLATION _qm_files)
foreach (_current_FILE ${ARGN})
get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE)
get_filename_component(qm ${_abs_FILE} NAME_WE)
get_source_file_property(output_location ${_abs_FILE} OUTPUT_LOCATION)
if(output_location)
file(MAKE_DIRECTORY "${output_location}")
set(qm "${output_location}/${qm}.qm")
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
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 21:47:32 +04:00
set(qm "${CMAKE_CURRENT_BINARY_DIR}/${qm}.qm")
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
add_custom_command(OUTPUT ${qm}
Qt4: Use IMPORTED executable names with custom commands. Finding Qt 5 can overwrite the QT_MOC_EXECUTABLE variable with the moc from Qt 5. Use the IMPORTED target with the explicit version in the name to avoid that.
2014-01-24 16:00:48 +04:00
COMMAND Qt4::lrelease
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
ARGS ${_abs_FILE} -qm ${qm}
Fix path quoting in Qt4 macros Adding VERBATIM to the ADD_CUSTOM_COMMAND calls in the qt4 macros ensures that paths are properly quoted when passed to the shell. This fixes issues when building projects that contained paths with special characters (according to /bin/sh), such as parentheses or spaces.
2011-11-03 00:13:52 +04:00
DEPENDS ${_abs_FILE} VERBATIM
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(${_qm_files} ${${_qm_files}} ${qm})
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
endforeach ()
endmacro()
Add new qt4_use_modules function.
2012-08-09 01:31:52 +04:00
function(qt4_use_modules _target _link_type)
Mark qt4_use_modules and qt4_automoc as obsolete. The QT_QMAKE_EXECUTABLE has to be passed through the cmake calls because the executable may not be in the PATH.
2013-07-04 12:00:27 +04:00
if(NOT CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.11)
Qt4Macros: Port to use message(DEPRECATION)
2013-09-17 21:11:39 +04:00
message(DEPRECATION "The qt4_use_modules function is obsolete. Use target_link_libraries with IMPORTED targets instead.")
Mark qt4_use_modules and qt4_automoc as obsolete. The QT_QMAKE_EXECUTABLE has to be passed through the cmake calls because the executable may not be in the PATH.
2013-07-04 12:00:27 +04:00
endif()
Add new qt4_use_modules function.
2012-08-09 01:31:52 +04:00
if ("${_link_type}" STREQUAL "LINK_PUBLIC" OR "${_link_type}" STREQUAL "LINK_PRIVATE")
set(modules ${ARGN})
set(link_type ${_link_type})
else()
set(modules ${_link_type} ${ARGN})
endif()
foreach(_module ${modules})
string(TOUPPER ${_module} _ucmodule)
Qt4Macros: Handle Qt ActiveX libraries in qt4_use_modules. These libraries have non-conventional variable names.
2013-05-23 18:51:11 +04:00
set(_targetPrefix QT_QT${_ucmodule})
if (_ucmodule STREQUAL QAXCONTAINER OR _ucmodule STREQUAL QAXSERVER)
if (NOT QT_Q${_ucmodule}_FOUND)
message(FATAL_ERROR "Can not use \"${_module}\" module which has not yet been found.")
endif()
set(_targetPrefix QT_Q${_ucmodule})
else()
if (NOT QT_QT${_ucmodule}_FOUND)
message(FATAL_ERROR "Can not use \"${_module}\" module which has not yet been found.")
endif()
if ("${_ucmodule}" STREQUAL "MAIN")
message(FATAL_ERROR "Can not use \"${_module}\" module with qt4_use_modules.")
endif()
Add new qt4_use_modules function.
2012-08-09 01:31:52 +04:00
endif()
Qt4Macros: Handle Qt ActiveX libraries in qt4_use_modules. These libraries have non-conventional variable names.
2013-05-23 18:51:11 +04:00
target_link_libraries(${_target} ${link_type} ${${_targetPrefix}_LIBRARIES})
set_property(TARGET ${_target} APPEND PROPERTY INCLUDE_DIRECTORIES ${${_targetPrefix}_INCLUDE_DIR} ${QT_HEADERS_DIR} ${QT_MKSPECS_DIR}/default)
set_property(TARGET ${_target} APPEND PROPERTY COMPILE_DEFINITIONS ${${_targetPrefix}_COMPILE_DEFINITIONS})
Add new qt4_use_modules function.
2012-08-09 01:31:52 +04:00
endforeach()
endfunction()