FindQt4

This module finds Qt4, a cross-platform application development framework for creating graphical user interfaces and applications. It defines a number of imported targets, macros, and variables to use Qt4 in the project.

Note

This module is for Qt version 4. As of Qt version 5, the Qt upstream also provides an exported configuration to find Qt. New code should follow the cmake-qt(7) instead of using this module.

To detect the Qt4 package, the Qt4 qmake tool is required and must be available in the system path.

Note

When using Imported Targets, the qtmain.lib static library is automatically linked on Windows for WIN32 executables. To disable this globally, set the QT4_NO_LINK_QTMAIN variable before finding Qt4. To disable this for a particular executable, set the QT4_NO_LINK_QTMAIN target property to TRUE on that executable.

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 filesystem content generation. These tools may be automatically invoked by cmake(1) if the appropriate conditions are met. See cmake-qt(7) for more.

Imported Targets

Qt libraries can be linked using their corresponding IMPORTED target with the target_link_libraries() command:

target_link_libraries(myexe Qt4::QtGui Qt4::QtXml)

Linking to an imported target automatically applies the correct include directories and compile definitions when building myexe.

Imported targets also manage their dependencies, so listing Qt4::QtCore is unnecessary if another Qt library depends on it. Likewise, Qt4::QtGui is automatically included when linking Qt4::QtDeclarative. Targets can be checked for existence using if(TARGET) command.

If both debug and release versions of a Qt toolkit library are available, CMake selects the appropriate one based on the build configuration.

This module provides the following imported targets, if found:

Qt4::QtCore: The QtCore target
Qt4::QtGui: The QtGui target
Qt4::Qt3Support: The Qt3Support target
Qt4::QtAssistant: The QtAssistant target
Qt4::QtAssistantClient: The QtAssistantClient target
Qt4::QAxContainer: The QAxContainer target (Windows only)
Qt4::QAxServer: The QAxServer target (Windows only)
Qt4::QtDBus: The QtDBus target
Qt4::QtDeclarative: The QtDeclarative target
Qt4::QtDesigner: The QtDesigner target
Qt4::QtDesignerComponents: The QtDesignerComponents target
Qt4::QtHelp: The QtHelp target
Qt4::QtMotif: The QtMotif target
Qt4::QtMultimedia: The QtMultimedia target
Qt4::QtNetwork: The QtNetwork target
Qt4::QtNsPlugin: The QtNsPlugin target
Qt4::QtOpenGL: The QtOpenGL target
Qt4::QtScript: The QtScript target
Qt4::QtScriptTools: The QtScriptTools target
Qt4::QtSql: The QtSql target
Qt4::QtSvg: The QtSvg target
Qt4::QtTest: The QtTest target
Qt4::QtUiTools: The QtUiTools target
Qt4::QtWebKit: The QtWebKit target
Qt4::QtXml: The QtXml target
Qt4::QtXmlPatterns: The QtXmlPatterns target
Qt4::phonon: The phonon target

Result Variables

This module sets the following variables:

Qt4_FOUND: Boolean whether Qt4 has been found. If false, don't try to use Qt4.
QT_FOUND: Boolean whether Qt4 has been found. If false, don't try to use Qt4. This variable is for compatibility with other Qt find modules.
QT4_FOUND: Boolean whether Qt4 has been found. If false, don't try to use Qt4. This variable is for backward compatibility only.
QT_VERSION_MAJOR: The major version of Qt found.
QT_VERSION_MINOR: The minor version of Qt found.
QT_VERSION_PATCH: The patch version of Qt found.

Hints

QT4_NO_LINK_QTMAIN: If set to boolean true before finding Qt4, it globally disables linking qtmain.lib static library on Windows.

Macros

In some cases it can be necessary or useful to invoke the Qt build tools in a more-manual way. This module provides the following macros to add targets for such uses:

qt4_wrap_cpp

Creates build rules for running moc on a given list of input files:

qt4_wrap_cpp(<variable> <files>... [TARGET <target>] [OPTIONS <options>...])

This macro creates build rules for processing a list of input files <files> that contain Qt classes with the Q_OBJECT declaration. Per-directory preprocessor definitions are also added.

<variable>: Name of a variable where a list of generated output files is stored.
<files>: One or more input source files.
TARGET: If specified, the INTERFACE_INCLUDE_DIRECTORIES and INTERFACE_COMPILE_DEFINITIONS target properties from the <target> are passed to moc.
OPTIONS: Optional list of options given to moc, such as those found when executing moc -help.

Note

Instead of using qt4_wrap_cpp(), the CMAKE_AUTOMOC variable can be set to process source files with moc automatically.

qt4_wrap_ui

Creates build rules for running uic on a given list of Qt designer ui input files:

qt4_wrap_ui(<variable> <files>... [OPTIONS <options>...])

<variable>: Name of a variable where a list of generated output filenames is stored.
<files>: One or more Qt designer ui input source files.
OPTIONS: Optional list of options given to uic, such as those found when executing uic -help.

Note

Instead of using qt4_wrap_ui(), the CMAKE_AUTOUIC variable can be set to process ui files with uic automatically.

qt4_add_resources

Creates build rules for running rcc on a given list of input Qt resource files:

qt4_add_resources(<variable> <files>... [OPTIONS <options>...])

<variable>: Name of a variable where a list of generated output filenames is stored.
<files>: One or more Qt resource input source files.
OPTIONS: Optional list of options given to rcc, such as those found when executing rcc -help.

Note

Instead of using qt4_add_resources(), the CMAKE_AUTORCC variable can be set to process resource files with rcc automatically.

qt4_generate_moc

Creates a build rule that generates output file by running moc on a given input file.

qt4_generate_moc(<input-file> <output-file> [TARGET <target>])

This macro creates a build rule for <input-file> to generate <output-file>. Use this if for some reason qt4_wrap_cpp() isn't feasible, e.g. because a custom filename is needed for the moc file or similar.

TARGET: If specified, the INTERFACE_INCLUDE_DIRECTORIES and INTERFACE_COMPILE_DEFINITIONS target properties from the <target> are passed to moc.

qt4_add_dbus_interface

Creates the interface header and implementation files from an interface XML file:

qt4_add_dbus_interface(<variable> <interface-file> <basename>)

This macro creates the interface header (<basename>.h) and implementation files (<basename>.{cpp,moc}) from the given interface XML file <interface-file> and adds it to the variable which contains a list of sources (specified as variable name <variable>).

Additional parameters can be passed to the qdbusxml2cpp call by setting the following source file properties on the input file <interface-file>:

INCLUDE: The given file will be included in the generate interface header.
CLASSNAME: The name of the generated class.
NO_NAMESPACE: The generated class will not be wrapped in a namespace.

qt4_add_dbus_interfaces

Creates the interface header and implementation files from multiple interface XML files:

qt4_add_dbus_interfaces(<variable> <interface-files>...)

This macro creates the interface header and implementation files for all listed interface XML files <interface-files>. The basename will be automatically determined from the name of the XML file. The resulting output files list is stored in a variable <variable>.

The source file properties described for qt4_add_dbus_interface() also apply here.

qt4_add_dbus_adaptor

Generates an adaptor class for a D-Bus interface:

qt4_add_dbus_adaptor(<variable> <xmlfile> <parent-header> <parent-classname>
                     [<basename>] [<classname>])

Creates a D-Bus adaptor (header and implementation file) from the XML file describing the interface, and adds it to the list of sources. The adaptor forwards the calls to a parent class, defined in <parent-header> and named <parent-classname>. The generated filenames will be <basename>adaptor.{cpp,h} where <basename> defaults to the basename of the XML file if not given. If <classname> is provided, then it will be used as the classname of the adaptor itself. Generated filenames are stored in a variable <variable>.

qt4_generate_dbus_interface

Generates a D-Bus XML interface file from a given header file:

qt4_generate_dbus_interface(<header> [<interface>] [OPTIONS <options>...])

This macro creates a build rule to extract declaration from the given <header> file to generate a corresponding XML interface file.

<header>: Path to header file from which XML interface file is generated.
<interface>: Path to the generated XML interface file. If this optional argument is omitted, the name of the interface file is constructed from the basename of the header with the suffix .xml appended. A relative path is interpreted as relative to CMAKE_CURRENT_BINARY_DIR.
OPTIONS: A list of options that may be given to qdbuscpp2xml, such as those found when executing qdbuscpp2xml --help.

qt4_create_translation

Creates build rules for generating TS and QM files:

qt4_create_translation(<qm-files-var> <directories>... <sources>...
                       <ts-files>... [OPTIONS <options>...])

This macro creates build rules to generate TS (Translation Source files .ts) files via lupdate and QM (Qt Message files .qm) files via lrelease from the given <directories> and/or <sources>. The TS files are created and/or updated in the source tree (unless given with full paths). The QM files are generated in the build tree.

<qm-files-var>: A list of generated QM files is stored in this variable. Updating the translations can be done by adding the <qm-files-var> to the source list of the project library/executable, so they are always updated, or by adding a custom target to control when they get updated/generated.
<directories>: A list of directories containing source files.
<sources>: A list of source files.
<ts-files>: A list of TS (Translation Source) files.
OPTIONS: Optional list of flags passed to lupdate, such as -extensions, to specify file extensions for directory scanning.

qt4_add_translation

Creates build rules for generating QM files from the given TS files:

qt4_add_translation(<qm-files-var> <ts-files>...)

This macro creates build rules for generating QM files from the given TS files and stores a list of generated filenames of QM files in the <qm-files-var> variable. The <ts-files> must exist and are not updated in any way.

qt4_automoc

Deprecated since version 2.8.11: Use feature provided by the CMAKE_AUTOMOC variable instead.

Runs moc on input files:

qt4_automoc(<source-files>... [TARGET <target>])

This macro can be used to have moc automatically handled. For example, if there are foo.h and foo.cpp files, and in foo.h a class uses the Q_OBJECT preprocessor macro, moc has to run on it. If using qt4_wrap_cpp() isn't wanted (however, it is reliable and mature), the #include "foo.moc" can be inserted in foo.cpp and then foo.cpp given as argument to qt4_automoc(). This will scan all listed files <source-files> at configuration phase for such included moc files and if it finds them, a rule is generated to run moc at build time on the accompanying header file foo.h. If a source file has the SKIP_AUTOMOC property set, file will be ignored by this macro.

TARGET: If specified, the INTERFACE_INCLUDE_DIRECTORIES and INTERFACE_COMPILE_DEFINITIONS target properties from the <target> are passed to moc.

qt4_use_modules

Deprecated since version 2.8.11: Use target_link_libraries() with Imported Targets instead.

Provides Qt modules to a project for linking them to a target:

qt4_use_modules(<target> [<LINK_PUBLIC|LINK_PRIVATE>] <modules>...)

This function makes <target> use the <modules> from Qt. Using a Qt module means to link to the library, add the relevant include directories for the module, and add the relevant compiler defines for using the module. Modules are roughly equivalent to Qt4 components.

LINK_PUBLIC or LINK_PRIVATE: Optional linking mode, used as the corresponding argument in the target_link_libraries() call.

For example, calling qt4_use_modules(myexe Core Gui Declarative) will use the QtCore, QtGui and QtDeclarative components on the project target myexe.

Examples

Typical usage to find Qt4, could be something like:

set(CMAKE_AUTOMOC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
find_package(Qt4 4.4.3 REQUIRED QtGui QtXml)
add_executable(myexe main.cpp)
target_link_libraries(myexe PRIVATE Qt4::QtGui Qt4::QtXml)