cmake-qt - CMake Qt Features Reference
Please see following description for synopsis
CMAKE-QT(7) CMake CMAKE-QT(7)
NAME
cmake-qt - CMake Qt Features Reference
INTRODUCTION
CMake can find and use Qt 4 and Qt 5 libraries. The Qt 4 libraries are
found by the FindQt4 find-module shipped with CMake, whereas the Qt 5
libraries are found using "Config-file Packages" shipped with Qt 5. See
cmake-packages(7) for more information about CMake packages, and see
the Qt cmake manual for your Qt version.
Qt 4 and Qt 5 may be used together in the same CMake buildsystem:
cmake_minimum_required(VERSION 3.8.0 FATAL_ERROR)
project(Qt4And5)
set(CMAKE_AUTOMOC ON)
find_package(Qt5 COMPONENTS Widgets DBus REQUIRED)
add_executable(publisher publisher.cpp)
target_link_libraries(publisher Qt5::Widgets Qt5::DBus)
find_package(Qt4 REQUIRED)
add_executable(subscriber subscriber.cpp)
target_link_libraries(subscriber Qt4::QtGui Qt4::QtDBus)
A CMake target may not link to both Qt 4 and Qt 5. A diagnostic is
issued if this is attempted or results from transitive target depen-
dency evaluation.
QT BUILD TOOLS
Qt relies on some bundled tools for code generation, such as moc for
meta-object code generation, uic for widget layout and population, and
rcc for virtual file system content generation. These tools may be
automatically invoked by cmake(1) if the appropriate conditions are
met. The automatic tool invocation may be used with both Qt 4 and Qt
5.
AUTOMOC
The AUTOMOC target property controls whether cmake(1) inspects the C++
files in the target to determine if they require moc to be run, and to
create rules to execute moc at the appropriate time.
If a macro from AUTOMOC_MACRO_NAMES is found in a header file, moc will
be run on the file. The result will be put into a file named according
to moc_<basename>.cpp. If the macro is found in a C++ implementation
file, the moc output will be put into a file named according to <base-
name>.moc, following the Qt conventions. The <basename>.moc must be
included by the user in the C++ implementation file with a preprocessor
#include.
Included moc_*.cpp and *.moc files will be generated in the <AUTO-
GEN_BUILD_DIR>/include directory which is automatically added to the
target's INCLUDE_DIRECTORIES.
o This differs from CMake 3.7 and below; see their documentation for
details.
o For multi configuration generators, the include directory is <AUTO-
GEN_BUILD_DIR>/include_<CONFIG>.
o See AUTOGEN_BUILD_DIR.
Not included moc_<basename>.cpp files will be generated in custom fold-
ers to avoid name collisions and included in a separate file which is
compiled into the target, named either <AUTOGEN_BUILD_DIR>/mocs_compi-
lation.cpp or <AUTOGEN_BUILD_DIR>/mocs_compilation_$<CONFIG>.cpp.
o See AUTOGEN_BUILD_DIR.
The moc command line will consume the COMPILE_DEFINITIONS and
INCLUDE_DIRECTORIES target properties from the target it is being
invoked for, and for the appropriate build configuration.
The AUTOMOC target property may be pre-set for all following targets by
setting the CMAKE_AUTOMOC variable. The AUTOMOC_MOC_OPTIONS target
property may be populated to set options to pass to moc. The
CMAKE_AUTOMOC_MOC_OPTIONS variable may be populated to pre-set the
options for all following targets.
Additional macro names to search for can be added to AUTO-
MOC_MACRO_NAMES.
Additional moc dependency file names can be extracted from source code
by using AUTOMOC_DEPEND_FILTERS.
Source C++ files can be excluded from AUTOMOC processing by enabling
SKIP_AUTOMOC or the broader SKIP_AUTOGEN.
AUTOUIC
The AUTOUIC target property controls whether cmake(1) inspects the C++
files in the target to determine if they require uic to be run, and to
create rules to execute uic at the appropriate time.
If a preprocessor #include directive is found which matches
<path>ui_<basename>.h, and a <basename>.ui file exists, then uic will
be executed to generate the appropriate file. The <basename>.ui file
is searched for in the following places
1. <source_dir>/<basename>.ui
2. <source_dir>/<path><basename>.ui
3. <AUTOUIC_SEARCH_PATHS>/<basename>.ui
4. <AUTOUIC_SEARCH_PATHS>/<path><basename>.ui
where <source_dir> is the directory of the C++ file and
AUTOUIC_SEARCH_PATHS is a list of additional search paths.
The generated generated ui_*.h files are placed in the <AUTO-
GEN_BUILD_DIR>/include directory which is automatically added to the
target's INCLUDE_DIRECTORIES.
o This differs from CMake 3.7 and below; see their documentation for
details.
o For multi configuration generators, the include directory is <AUTO-
GEN_BUILD_DIR>/include_<CONFIG>.
o See AUTOGEN_BUILD_DIR.
The AUTOUIC target property may be pre-set for all following targets by
setting the CMAKE_AUTOUIC variable. The AUTOUIC_OPTIONS target prop-
erty may be populated to set options to pass to uic. The
CMAKE_AUTOUIC_OPTIONS variable may be populated to pre-set the options
for all following targets. The AUTOUIC_OPTIONS source file property
may be set on the <basename>.ui file to set particular options for the
file. This overrides options from the AUTOUIC_OPTIONS target property.
A target may populate the INTERFACE_AUTOUIC_OPTIONS target property
with options that should be used when invoking uic. This must be con-
sistent with the AUTOUIC_OPTIONS target property content of the depen-
der target. The CMAKE_DEBUG_TARGET_PROPERTIES variable may be used to
track the origin target of such INTERFACE_AUTOUIC_OPTIONS. This means
that a library which provides an alternative translation system for Qt
may specify options which should be used when running uic:
add_library(KI18n klocalizedstring.cpp)
target_link_libraries(KI18n Qt5::Core)
# KI18n uses the tr2i18n() function instead of tr(). That function is
# declared in the klocalizedstring.h header.
set(autouic_options
-tr tr2i18n
-include klocalizedstring.h
)
set_property(TARGET KI18n APPEND PROPERTY
INTERFACE_AUTOUIC_OPTIONS ${autouic_options}
)
A consuming project linking to the target exported from upstream auto-
matically uses appropriate options when uic is run by AUTOUIC, as a
result of linking with the IMPORTED target:
set(CMAKE_AUTOUIC ON)
# Uses a libwidget.ui file:
add_library(LibWidget libwidget.cpp)
target_link_libraries(LibWidget
KF5::KI18n
Qt5::Widgets
)
Source files can be excluded from AUTOUIC processing by enabling
SKIP_AUTOUIC or the broader SKIP_AUTOGEN.
AUTORCC
The AUTORCC target property controls whether cmake(1) creates rules to
execute rcc at the appropriate time on source files which have the suf-
fix .qrc.
add_executable(myexe main.cpp resource_file.qrc)
The AUTORCC target property may be pre-set for all following targets by
setting the CMAKE_AUTORCC variable. The AUTORCC_OPTIONS target prop-
erty may be populated to set options to pass to rcc. The
CMAKE_AUTORCC_OPTIONS variable may be populated to pre-set the options
for all following targets. The AUTORCC_OPTIONS source file property
may be set on the <name>.qrc file to set particular options for the
file. This overrides options from the AUTORCC_OPTIONS target property.
Source files can be excluded from AUTORCC processing by enabling
SKIP_AUTORCC or the broader SKIP_AUTOGEN.
THE <ORIGIN>_AUTOGEN TARGET
The moc and uic tools are executed as part of a synthesized <ORI-
GIN>_autogen custom target generated by CMake. By default that <ORI-
GIN>_autogen target inherits the dependencies of the <ORIGIN> target
(see AUTOGEN_ORIGIN_DEPENDS). Target dependencies may be added to the
<ORIGIN>_autogen target by adding them to the AUTOGEN_TARGET_DEPENDS
target property.
VISUAL STUDIO GENERATORS
When using the Visual Studio generators, CMake generates a PRE_BUILD
custom command instead of the <ORIGIN>_autogen custom target (for AUTO-
MOC and AUTOUIC). This isn't always possible though and an <ORI-
GIN>_autogen custom target is used, when either
o the <ORIGIN> target depends on GENERATED files which aren't excluded
from AUTOMOC and AUTOUIC by SKIP_AUTOMOC, SKIP_AUTOUIC, SKIP_AUTOGEN
or CMP0071
o AUTOGEN_TARGET_DEPENDS lists a source file
o CMAKE_GLOBAL_AUTOGEN_TARGET is enabled
QTMAIN.LIB ON WINDOWS
The Qt 4 and 5 IMPORTED targets for the QtGui libraries specify that
the qtmain.lib static library shipped with Qt will be linked by all
dependent executables which have the WIN32_EXECUTABLE enabled.
To disable this behavior, enable the Qt5_NO_LINK_QTMAIN target property
for Qt 5 based targets or QT4_NO_LINK_QTMAIN target property for Qt 4
based targets.
add_executable(myexe WIN32 main.cpp)
target_link_libraries(myexe Qt4::QtGui)
add_executable(myexe_no_qtmain WIN32 main_no_qtmain.cpp)
set_property(TARGET main_no_qtmain PROPERTY QT4_NO_LINK_QTMAIN ON)
target_link_libraries(main_no_qtmain Qt4::QtGui)
COPYRIGHT
2000-2021 Kitware, Inc. and Contributors
ATTRIBUTES
See attributes(7) for descriptions of the following attributes:
+---------------+-----------------------+
|ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+---------------+-----------------------+
|Availability | developer/build/cmake |
+---------------+-----------------------+
|Stability | Uncommitted |
+---------------+-----------------------+
NOTES
Source code for open source software components in Oracle Solaris can
be found at https://www.oracle.com/downloads/opensource/solaris-source-
code-downloads.html.
This software was built from source available at
https://github.com/oracle/solaris-userland. The original community
source was downloaded from
http://www.cmake.org/files/v3.21/cmake-3.21.0.tar.gz.
Further information about this software can be found on the open source
community website at http://www.cmake.org/.
3.21.0 Jun 27, 2022 CMAKE-QT(7)