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)