kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Tests/QtAutogen/CMakeLists.txt

204 lines
7.3 KiB
CMake
Raw Normal View History

Tests/QtAutogen: Require CMake 3.1 to set policies everywhere We want CMP0020 set in the autorcc_depends test. Also the test should now only run when we can support per-config source files.
2015-04-16 20:57:17 +03:00
cmake_minimum_required(VERSION 3.1)
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
Rename the QtAutomoc tests to QtAutogen.
2013-10-11 16:17:32 +04:00
project(QtAutogen)
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
Tests/QtAutogen: Help Qt5Autogen test find Qt5 on Windows Set CMAKE_PREFIX_PATH to tell find_package(Qt5) where to look.
2015-04-16 20:54:54 +03:00
# Tell find_package(Qt5) where to find Qt.
if(QT_QMAKE_EXECUTABLE)
get_filename_component(Qt_BIN_DIR "${QT_QMAKE_EXECUTABLE}" PATH)
get_filename_component(Qt_PREFIX_DIR "${Qt_BIN_DIR}" PATH)
set(CMAKE_PREFIX_PATH ${Qt_PREFIX_DIR})
endif()
Add a test for Qt5Automoc The same source is used as for the Qt4Automoc test.
2013-03-16 18:52:18 +04:00
if (QT_TEST_VERSION STREQUAL 4)
find_package(Qt4 REQUIRED)
Test the use of target transitive compile definitions with moc.
2013-05-15 21:17:41 +04:00
# Include this directory before using the UseQt4 file.
add_subdirectory(defines_test)
Add a test for Qt5Automoc The same source is used as for the Qt4Automoc test.
2013-03-16 18:52:18 +04:00
include(UseQt4)
set(QT_QTCORE_TARGET Qt4::QtCore)
QtAutogen: Short-circut some logic when moc is not available. This is the case when AUTOMOC is false. This prevents creating rules to moc the files in the absense of moc.
2014-01-24 20:01:59 +04:00
macro(qtx_wrap_cpp)
qt4_wrap_cpp(${ARGN})
endmacro()
Add a test for Qt5Automoc The same source is used as for the Qt4Automoc test.
2013-03-16 18:52:18 +04:00
else()
if (NOT QT_TEST_VERSION STREQUAL 5)
message(SEND_ERROR "Invalid Qt version specified.")
endif()
find_package(Qt5Widgets REQUIRED)
set(QT_QTCORE_TARGET Qt5::Core)
include_directories(${Qt5Widgets_INCLUDE_DIRS})
set(QT_LIBRARIES Qt5::Widgets)
Tests: Don't hang when running Qt5Autogen built with GCC 5 (#15570). Since Qt 5.4.2, it is necessary to compile against Qt 5 with -fPIC and not -fPIE when using GCC 5. Not doing so results in a hanging test in this case, so use the PIC flag directly instead.
2015-06-21 15:50:50 +03:00
if(Qt5_POSITION_INDEPENDENT_CODE AND CMAKE_CXX_COMPILE_OPTIONS_PIC)
add_definitions(${CMAKE_CXX_COMPILE_OPTIONS_PIC})
Add a test for Qt5Automoc The same source is used as for the Qt4Automoc test.
2013-03-16 18:52:18 +04:00
endif()
QtAutogen: Short-circut some logic when moc is not available. This is the case when AUTOMOC is false. This prevents creating rules to moc the files in the absense of moc.
2014-01-24 20:01:59 +04:00
macro(qtx_wrap_cpp)
qt5_wrap_cpp(${ARGN})
endmacro()
Add a test for Qt5Automoc The same source is used as for the Qt4Automoc test.
2013-03-16 18:52:18 +04:00
endif()
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
QtAutogen: Add source files to target when only AUTORCC is used. Add missing entry to if condition.
2014-09-10 18:20:43 +04:00
add_executable(rcconly rcconly.cpp second_resource.qrc)
set_property(TARGET rcconly PROPERTY AUTORCC ON)
target_link_libraries(rcconly ${QT_QTCORE_TARGET})
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
include_directories(${CMAKE_CURRENT_BINARY_DIR})
automoc: add define to test which caused bug #13018 This does not really test that the bug is fixed, but at least it makes it easy to check manually whether the bug is there or not. I have to see whether I can build a test which does test that a target is not rebuilt everytime. Alex
2012-03-27 00:11:46 +04:00
add_definitions(-DFOO -DSomeDefine="Barx")
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
automoc: default to strict mode, use CMAKE_AUTOMOC_RELAXED_MODE automoc now defaults to strict mode, also with Qt4, i.e. it behaves as the documentation says by default. I also inverted the switch CMAKE_AUTOMOC_STRICT_MODE to CMAKE_AUTOMOC_RELAXED_MODE. Docs and test adapted accordingly. Alex
2011-12-14 01:11:47 +04:00
# enable relaxed mode so automoc can handle all the special cases:
set(CMAKE_AUTOMOC_RELAXED_MODE TRUE)
Add automatic uic invocation for Qt. The source files are already processed by cmQtAutomoc to look for moc includes, so extend that to also look for ui_ includes and find corresponding .ui files to process. This replaces the need to invoke qt4_wrap_ui(). As the ui files are not likely to be part of the SOURCES of the target, store the options associated with them separately in the cmMakefile for querying during the autogen run.
2013-07-25 11:24:53 +04:00
set(CMAKE_AUTOUIC ON)
Add automatic rcc invocation for Qt. This replaces the need to invoke qt4_add_resources by allowing adding the source .qrc file directly to the target sources.
2013-09-15 16:41:07 +04:00
set(CMAKE_AUTORCC ON)
Add automatic uic invocation for Qt. The source files are already processed by cmQtAutomoc to look for moc includes, so extend that to also look for ui_ includes and find corresponding .ui files to process. This replaces the need to invoke qt4_wrap_ui(). As the ui files are not likely to be part of the SOURCES of the target, store the options associated with them separately in the cmMakefile for querying during the autogen run.
2013-07-25 11:24:53 +04:00
Automoc: add OBJECT library to QtAutomoc test
2013-01-11 13:40:13 +04:00
# create an executable and two library targets, each requiring automoc:
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
add_library(codeeditorLib STATIC codeeditor.cpp)
Automoc: add OBJECT library to QtAutomoc test
2013-01-11 13:40:13 +04:00
add_library(privateSlot OBJECT private_slot.cpp)
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
QtAutogen: Process 'rcc --list' stdout and stderr separately (#15523) The stderr may have warning messages. We should not treat these lines as resource files. However, we must still recognize error message lines for missing resource files that may be generated. Extend the QtAutogen test to cover a generated resource as the only one listed in a .qrc file. This causes 'rcc --list' to print a warning to stderr that we now intend to ignore.
2015-04-20 23:42:19 +03:00
configure_file(generated_resource.qrc.in generated_resource.qrc @ONLY)
add_custom_command(
OUTPUT generated.txt
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/generated.txt.in" "${CMAKE_CURRENT_BINARY_DIR}/generated.txt"
DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/generated.txt.in"
)
cmQtAutogen: Allow specifying depends for autogen targets. Test this by generating files with a custom target, which moc requires to be present when it is run.
2013-11-18 11:09:56 +04:00
add_custom_target(generate_moc_input
QtAutogen: Process 'rcc --list' stdout and stderr separately (#15523) The stderr may have warning messages. We should not treat these lines as resource files. However, we must still recognize error message lines for missing resource files that may be generated. Extend the QtAutogen test to cover a generated resource as the only one listed in a .qrc file. This causes 'rcc --list' to print a warning to stderr that we now intend to ignore.
2015-04-20 23:42:19 +03:00
DEPENDS generated.txt
cmQtAutogen: Allow specifying depends for autogen targets. Test this by generating files with a custom target, which moc requires to be present when it is run.
2013-11-18 11:09:56 +04:00
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/myinterface.h.in" "${CMAKE_CURRENT_BINARY_DIR}"
COMMAND ${CMAKE_COMMAND} -E rename "${CMAKE_CURRENT_BINARY_DIR}/myinterface.h.in" "${CMAKE_CURRENT_BINARY_DIR}/myinterface.h"
)
QtAutogen: Fix AUTOGEN depends on custom command output with VS. Visual Studio is handled as a special case for autogen depends. However, the special handling works only for target dependencies, not file dependencies output by a custom command. Use a PRE_BUILD step only if all depends are targets.
2014-03-05 16:43:50 +04:00
add_custom_command(
OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/myotherinterface.h"
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/myotherinterface.h.in" "${CMAKE_CURRENT_BINARY_DIR}/myotherinterface.h"
DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/myotherinterface.h.in"
)
Tests/QtAutogen: Enable per-config source tests when possible Pass CMAKE_BUILD_TYPE into the test on generators that use it so that the per-config part of the test can activate as needed. Do not make the per-config part conditional on the Debug configuration because the generator expressions evaluate to empty in other configurations. Skip the per-config source case with the Ninja generator because it does not currently work. cmQtAutoGenerators::InitializeAutogenTarget needs to know the list of source files on a target, but generator expressions in the list cannot be evaluated until after CreateGeneratorTargets has been called. That cannot happen until after Autogen targets have been generated. It is a chicken-and-egg problem.
2015-04-16 20:30:32 +03:00
if (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_GENERATOR STREQUAL Ninja)
cmTarget: Make the source files depend on the config. Disallow the use of config-specific source files with the Visual Studio and Xcode generators. They don't have any way to represent the condition currently. Use the same common-config API in cmQtAutoGenerators. While it accepts config-specific files, it doesn't have to support multiple configurations yet. Loop over the configs in cmTargetTraceDependencies and cmGlobalGenerator::WriteSummary and consume all source files. Loop over the configs in cmComputeTargetDepends and compute the object library dependencies for each config.
2014-02-13 20:25:00 +04:00
set(debug_srcs "$<$<CONFIG:Debug>:debug_class.cpp>" $<$<CONFIG:Debug>:debug_resource.qrc>)
Tests/QtAutogen: Enable per-config source tests when possible Pass CMAKE_BUILD_TYPE into the test on generators that use it so that the per-config part of the test can activate as needed. Do not make the per-config part conditional on the Debug configuration because the generator expressions evaluate to empty in other configurations. Skip the per-config source case with the Ninja generator because it does not currently work. cmQtAutoGenerators::InitializeAutogenTarget needs to know the list of source files on a target, but generator expressions in the list cannot be evaluated until after CreateGeneratorTargets has been called. That cannot happen until after Autogen targets have been generated. It is a chicken-and-egg problem.
2015-04-16 20:30:32 +03:00
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:Debug>:TEST_DEBUG_CLASS>)
cmTarget: Make the source files depend on the config. Disallow the use of config-specific source files with the Visual Studio and Xcode generators. They don't have any way to represent the condition currently. Use the same common-config API in cmQtAutoGenerators. While it accepts config-specific files, it doesn't have to support multiple configurations yet. Loop over the configs in cmTargetTraceDependencies and cmGlobalGenerator::WriteSummary and consume all source files. Loop over the configs in cmComputeTargetDepends and compute the object library dependencies for each config.
2014-02-13 20:25:00 +04:00
endif()
QtAutoUic: Add a test for the regression in the parent commit.
2015-01-12 03:22:11 +03:00
# The -no-protection option disables the generation of include guards. Verify
# that setting the source file property has an effect by using this and
# issue an error in the preprocessor in calwidget.cpp if the include guard
# is defined.
set_source_files_properties(calwidget.ui PROPERTIES AUTOUIC_OPTIONS "-no-protection")
QtAutogen: Fix use of multiple ui files in a single target. Don't store a mapping of the directory to the ui file. The directory will be a unique key, allowing only one ui file to be specified. Use the source file name instead as the mapping key.
2014-03-25 04:26:27 +04:00
add_executable(QtAutogen main.cpp calwidget.cpp second_widget.cpp foo.cpp blub.cpp bar.cpp abc.cpp
QtAutogen: Process all ui files in a source file (#14981). Use a vector to store a list of matched ui_ includes, instead of overwriting the previous match.
2014-09-17 03:23:57 +04:00
multiplewidgets.cpp
Add automatic rcc invocation for Qt. This replaces the need to invoke qt4_add_resources by allowing adding the source .qrc file directly to the target sources.
2013-09-15 16:41:07 +04:00
xyz.cpp yaf.cpp gadget.cpp $<TARGET_OBJECTS:privateSlot>
cmTarget: Make the source files depend on the config. Disallow the use of config-specific source files with the Visual Studio and Xcode generators. They don't have any way to represent the condition currently. Use the same common-config API in cmQtAutoGenerators. While it accepts config-specific files, it doesn't have to support multiple configurations yet. Loop over the configs in cmTargetTraceDependencies and cmGlobalGenerator::WriteSummary and consume all source files. Loop over the configs in cmComputeTargetDepends and compute the object library dependencies for each config.
2014-02-13 20:25:00 +04:00
test.qrc second_resource.qrc resourcetester.cpp generated.cpp ${debug_srcs}
QtAutogen: Process 'rcc --list' stdout and stderr separately (#15523) The stderr may have warning messages. We should not treat these lines as resource files. However, we must still recognize error message lines for missing resource files that may be generated. Extend the QtAutogen test to cover a generated resource as the only one listed in a .qrc file. This causes 'rcc --list' to print a warning to stderr that we now intend to ignore.
2015-04-20 23:42:19 +03:00
${CMAKE_CURRENT_BINARY_DIR}/generated_resource.qrc
Add automatic rcc invocation for Qt. This replaces the need to invoke qt4_add_resources by allowing adding the source .qrc file directly to the target sources.
2013-09-15 16:41:07 +04:00
)
QtAutogen: Fix AUTOGEN depends on custom command output with VS. Visual Studio is handled as a special case for autogen depends. However, the special handling works only for target dependencies, not file dependencies output by a custom command. Use a PRE_BUILD step only if all depends are targets.
2014-03-05 16:43:50 +04:00
set_property(TARGET QtAutogen APPEND PROPERTY AUTOGEN_TARGET_DEPENDS generate_moc_input "${CMAKE_CURRENT_BINARY_DIR}/myotherinterface.h")
Automoc: add OBJECT library to QtAutomoc test
2013-01-11 13:40:13 +04:00
cmGlobalGenerator: Initialize generator targets on construction (#15729) The Ninja generator and Visual Studio generators are special-cased for the QtAutogen feature. In order to reduce the number of custom targets, the Visual Studio generators prefer to create custom commands instead, and in order to create appropriate Ninja files, generated rcc files are listed as byproducts. This requires the use of the GetConfigCommonSourceFiles API of the cmGeneratorTarget for those generators when initializing the autogen target. The initializer method is called from Compute() after the cmGeneratorTarget objects are created, however the initialization of the object directory occurs later in the InitGeneratorTargets method. That means that the resulting object locations are computed incorrectly and cached before the object directory is determined, so the generated buildsystem can not find the object files. The initialization of the object directory was split from the creation of cmGeneratorTarget instances in commit 0e0258c8 (cmGlobalGenerator: Split creation of generator object from initialization., 2015-07-25). The motivation for the split was to do only what is essential to do early in cases where cmGeneratorTargets need to be created at configure-time. That is required for the purpose of implementing policies CMP0024 and CMP0026, and for try_compile(LINK_LIBRARIES). However, the split was not really necessary. Compute the object directory in the cmGeneratorTarget constructor instead. The QtAutogen unit test already tests the use of TARGET_OBJECTS with AUTOMOC, and that test already passes on Ninja. The reason it already passes is that the QtAutogen target also uses the AUTORCC feature, and specifies several qrc files in its SOURCES. Later in the Compute algorithm (after the InitGeneratorTargets call), the rcc files are determined and target->AddSource is called. The AddSource call clears the previously mentioned cache of source files, causing it to be regenerated when next queried, this time taking account of the object directory. Extend the test suite with a new target which does not make use of AUTORCC with qrc files so that the test added alone would break without the fix in this commit.
2015-09-26 20:48:50 +03:00
add_executable(targetObjectsTest targetObjectsTest.cpp $<TARGET_OBJECTS:privateSlot>)
target_link_libraries(targetObjectsTest ${QT_LIBRARIES})
set_target_properties(
QtAutogen codeeditorLib privateSlot targetObjectsTest
PROPERTIES
AUTOMOC TRUE
)
Add a test for automoc The files are taken from the Qt examples. They are BSD licensed, so it should be fine. I only edited main.cpp to use both widgets. Alex
2011-08-16 04:10:45 +04:00
Tests: QtAutogen: Same source name in different directories test The test features multiple .cpp and .qrc files with the same name in different subdirectories. This requires AUTOMOC and AUTORCC to generate files with names that respect the path information of the source files.
2016-04-13 19:36:39 +03:00
# Test AUTOMOC and AUTORCC on source files with the same name
# but in different subdirectories
add_subdirectory(same_name)
Ensure that the build interface includes have been added. This is needed in the case that Automoc is used, as that calls GetIncludeDirectories, which may cache the resulting include dirs too early in the generate step. Also, because the automoc step is so early, we can't cache the include directories at that point. At that point the build interface of all dependencies are not populated yet, so we'd be caching the includes before appending the build interface. Only start caching when we're definitely generating the buildsystem. At that point, the includes should be stable. We still need to invoke AppendBuildInterfaceIncludes in the GlobalGenerator because the build interface includes affect mostly the dependencies of targets (such as the automoc targets), rather than the targets themselves, so the build interface needs to be appended for all targets before generation is done.
2013-02-07 22:35:00 +04:00
include(GenerateExportHeader)
# The order is relevant here. B depends on A, and B headers depend on A
Rename variable for including current directory in interfaces Rename the variable added by commit 9ce1b9ef (Add CMAKE_BUILD_INTERFACE_INCLUDES build-variable, 2012-11-25) to CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE to be more consistent with the existing CMAKE_INCLUDE_CURRENT_DIR variable. Suggested-by: Alex Neundorf <neundorf@kde.org>
2013-03-20 00:40:06 +04:00
# headers both subdirectories use CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE and we
Ensure that the build interface includes have been added. This is needed in the case that Automoc is used, as that calls GetIncludeDirectories, which may cache the resulting include dirs too early in the generate step. Also, because the automoc step is so early, we can't cache the include directories at that point. At that point the build interface of all dependencies are not populated yet, so we'd be caching the includes before appending the build interface. Only start caching when we're definitely generating the buildsystem. At that point, the includes should be stable. We still need to invoke AppendBuildInterfaceIncludes in the GlobalGenerator because the build interface includes affect mostly the dependencies of targets (such as the automoc targets), rather than the targets themselves, so the build interface needs to be appended for all targets before generation is done.
2013-02-07 22:35:00 +04:00
# test that CMAKE_AUTOMOC successfully reads the include directories
# for the build interface from those targets. There has previously been
# a bug where caching of the include directories happened before
# extracting the includes to pass to moc.
add_subdirectory(Bdir)
add_subdirectory(Adir)
add_library(libC SHARED libC.cpp)
set_target_properties(libC PROPERTIES AUTOMOC TRUE)
generate_export_header(libC)
target_link_libraries(libC LINK_PUBLIC libB)
Run the main executable created in the autogen tests. Don't try to show the windows, which would require a gui capable test machine, and that's not guaranteed. Automatically link to qtmain.a on Windows to avoid a policy warning. Set policy CMP0020 to NEW by increasing the required version. Don't attempt to run the test when using Windows.
2013-10-11 22:16:43 +04:00
target_link_libraries(QtAutogen codeeditorLib ${QT_LIBRARIES} libC)
automoc: Add source file to target early to set the linker language Previously, GetIncludeDirectories was called before calling target->AddSourceFile(mocCppSource). Since commit a1c4905f (Use the link information as a source of compile definitions and includes., 2013-02-12), the include directories are determined by the link information. Valid link information requires that the linker language can be determined, which depends on the source files languages and the dependent targets languages. In the case of the no_link_languages target in the unit test, there are no dependencies and the additional source file no_link_languages_automoc.cpp is added to the target at generate-time. That file can be used to determine the linker language, but it must be added to the target before calling GetIncludeDirectories.
2013-02-20 20:06:45 +04:00
QtAutogen: Only add source files to the target if AUTORCC is ON. The qtx_add_resources() macro adds the resource file to the output list to maintain file-level dependencies. Having the qrc file in a target sources is a precondition for AUTORCC to function. When processing the source files of a target, only add the generated qrc_<file>.cpp to the target sources if AUTORCC is ON. This avoids pre-porting conflict with the macro. Reported-by: Micha Hergarden
2014-02-05 12:55:51 +04:00
# Add not_generated_file.qrc to the source list to get the file-level
# dependency, but don't generate a c++ file from it. Disable the AUTORCC
# feature for this target. This tests that qrc files in the sources don't
# have an effect on generation if AUTORCC is off.
add_library(empty STATIC empty.cpp not_generated_file.qrc)
set_target_properties(empty PROPERTIES AUTORCC OFF)
automoc: Add source file to target early to set the linker language Previously, GetIncludeDirectories was called before calling target->AddSourceFile(mocCppSource). Since commit a1c4905f (Use the link information as a source of compile definitions and includes., 2013-02-12), the include directories are determined by the link information. Valid link information requires that the linker language can be determined, which depends on the source files languages and the dependent targets languages. In the case of the no_link_languages target in the unit test, there are no dependencies and the additional source file no_link_languages_automoc.cpp is added to the target at generate-time. That file can be used to determine the linker language, but it must be added to the target before calling GetIncludeDirectories.
2013-02-20 20:06:45 +04:00
set_target_properties(empty PROPERTIES AUTOMOC TRUE)
target_link_libraries(empty no_link_language)
add_library(no_link_language STATIC empty.h)
set_target_properties(no_link_language PROPERTIES AUTOMOC TRUE)
QtAutogen: Short-circut some logic when moc is not available. This is the case when AUTOMOC is false. This prevents creating rules to moc the files in the absense of moc.
2014-01-24 20:01:59 +04:00
QtAutogen: Make uic work even when the source is in a subdir. Modify the includedUis to store the path to the file which includes the ui file. Reuse that path to generate the output file from the uic process.
2014-02-02 16:19:27 +04:00
qtx_wrap_cpp(uicOnlyMoc sub/uiconly.h)
add_executable(uiconly sub/uiconly.cpp ${uicOnlyMoc})
QtAutogen: Short-circut some logic when moc is not available. This is the case when AUTOMOC is false. This prevents creating rules to moc the files in the absense of moc.
2014-01-24 20:01:59 +04:00
target_link_libraries(uiconly ${QT_LIBRARIES})
QtAutogen: Regenerate qrc files if their input changes (#15074) Get dependencies from the output of ``rcc --list`` if using Qt 5. Otherwise process the file in the same way as the qt4_add_resources macro. This does not work for RCC files which are generated. The cmake_autogen build step is implemented as a PRE_BUILD step of the target currently if possible, rather than a standalone custom target. This is to keep the number of (synthesized) custom targets that appear in the UI low, but in some cases it is necessary to fall back to a full custom target. Fall back to a full custom target for the VS builds if autorcc is used.
2014-09-17 04:42:30 +04:00
try_compile(RCC_DEPENDS
"${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends"
"${CMAKE_CURRENT_SOURCE_DIR}/autorcc_depends"
autorcc_depends
CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
Tests/QtAutogen: Help Qt5Autogen test find Qt5 on Windows Set CMAKE_PREFIX_PATH to tell find_package(Qt5) where to look.
2015-04-16 20:54:54 +03:00
"-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
QtAutogen: Regenerate qrc files if their input changes (#15074) Get dependencies from the output of ``rcc --list`` if using Qt 5. Otherwise process the file in the same way as the qt4_add_resources macro. This does not work for RCC files which are generated. The cmake_autogen build step is implemented as a PRE_BUILD step of the target currently if possible, rather than a standalone custom target. This is to keep the number of (synthesized) custom targets that appear in the UI low, but in some cases it is necessary to fall back to a full custom target. Fall back to a full custom target for the VS builds if autorcc is used.
2014-09-17 04:42:30 +04:00
OUTPUT_VARIABLE output
)
if (NOT RCC_DEPENDS)
message(SEND_ERROR "Initial build of autorcc_depends failed. Output: ${output}")
endif()
file(STRINGS "${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends/info_file.txt" qrc_files)
list(GET qrc_files 0 qrc_file1)
set(timeformat "%Y%j%H%M%S")
file(TIMESTAMP "${qrc_file1}" file1_before "${timeformat}")
execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep 1) # Ensure that the timestamp will change.
QtAutogen: Workaround rcc CRCRLF newlines on Windows (#15459) The 'rcc --list' operation may print newlines of the form CRCRLF, so strip any trailing CR characters found on each line. Update the Tests/QtAutogen test to use a resource named in a subdirectory. This causes 'rcc --list' to display a blank line and tests that it is correctly filtered out.
2015-04-16 19:51:05 +03:00
execute_process(COMMAND "${CMAKE_COMMAND}" -E touch "${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends/res1/input.txt")
QtAutogen: Regenerate qrc files if their input changes (#15074) Get dependencies from the output of ``rcc --list`` if using Qt 5. Otherwise process the file in the same way as the qt4_add_resources macro. This does not work for RCC files which are generated. The cmake_autogen build step is implemented as a PRE_BUILD step of the target currently if possible, rather than a standalone custom target. This is to keep the number of (synthesized) custom targets that appear in the UI low, but in some cases it is necessary to fall back to a full custom target. Fall back to a full custom target for the VS builds if autorcc is used.
2014-09-17 04:42:30 +04:00
execute_process(COMMAND "${CMAKE_COMMAND}" --build .
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends"
)
file(TIMESTAMP "${qrc_file1}" file1_step1 "${timeformat}")
if (NOT file1_step1 GREATER file1_before)
message(SEND_ERROR "file1 (${qrc_file1}) should have changed in the first step!")
endif()
QtAutogen: Always run autogen step even when rcc is enabled (#15608) In commit v3.2.0-rc1~480^2 (QtAutogen: Regenerate qrc files if their input changes, 2014-09-17) the "cmake -E cmake_autogen" rule was switched from always running to running as a custom command with dependencies if rcc is enabled. This is not correct because automoc always needs to re-run. Switch back to always running the command.
2015-06-19 16:38:04 +03:00
#-----------------------------------------------------------------------------
try_compile(MOC_RERUN
"${CMAKE_CURRENT_BINARY_DIR}/automoc_rerun"
"${CMAKE_CURRENT_SOURCE_DIR}/automoc_rerun"
automoc_rerun
CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
"-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
OUTPUT_VARIABLE output
)
if (NOT MOC_RERUN)
message(SEND_ERROR "Initial build of automoc_rerun failed. Output: ${output}")
endif()
configure_file(automoc_rerun/test1.h.in2 automoc_rerun/test1.h COPYONLY)
execute_process(COMMAND "${CMAKE_COMMAND}" --build .
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/automoc_rerun"
RESULT_VARIABLE automoc_rerun_result
)
if (automoc_rerun_result)
message(SEND_ERROR "Second build of automoc_rerun failed.")
endif()