Understanding CMakeLists
Getting to grips with how CMakeLists.txt files work
Last updated
Getting to grips with how CMakeLists.txt files work
Last updated
In our introductory tutorial, we used as the build system for our application, but we only really paid close attention to one of our CMakeLists.txt files. Here, we're going to go over how it works in a bit more detail.
CMake is useful because it allows us to automate much of the stuff that needs to be done before compilation.
You might remember this CMakeLists.txt file from the first tutorial:
The first line, cmake_minimum_required() sets the version of CMake we will be calling.
After that, project(kirigami-tutorial) defines the name of the project.
The following section is important, because it specifies which dependencies we'll be bringing in at compile time. Let's look at the first:
REQUIRED tells CMake to exit with an error if the package cannot be found.
COMPONENTS is a parameter that precedes the specific components of the framework we will include.
Each word after COMPONENTS refers to a specific component of the library.
The install line instructs CMake to install the desktop file in ${KDE_INSTALL_APPDIR}, which on Linux translates to $XDG_DATA_DIRS/applications, usually /usr/share/applications, and on Windows translates to C:/Program Files/${PROJECT_NAME}/bin/data/applications:
The final line lets CMake print out which packages it has found, and it makes compilation fail immediately if it encounters an error:
And above that, add_subdirectory(src) points CMake into the src/ directory, where it finds another CMakeLists.txt file.
While the first file handled metadata and finding libraries, this one will consist of handling dependencies and installing the application. It has the following CMake calls:
ecm_add_qml_module() creates a QML module target that will be accessible via the "org.kde.tutorial" import.
ecm_target_qml_sources() adds QML files to the module.
The requirement for this file to be read by CMake is adding a call to add_subdirectory() in the src/CMakeLists.txt pointing to it.
You can then just install the target as before.
This setup will be useful when developing most Kirigami apps.
Then we get to a section where we include a number of necessary CMake and KDE settings by using . They provide a set of useful utilities:
provides convenience variables such as ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}, ${KDE_INSTALL_QMLDIR}, ${KDE_INSTALL_BINDIR} and ${KDE_INSTALL_LIBDIR}.
provides things like CMAKE_AUTORCC ON, an uninstall target that can be used with cmake --build build/ --target uninstall, and ENABLE_CLAZY.
provides a minimum C++ standard, compiler flags such as -pedantic, and best practices macros like -DQT_NO_CAST_FROM_ASCII to require explicit conversions such as QStringLiteral().
provides a way to ensure a runtime QML dependency is found at compile time.
provides CMake commands like ecm_add_qml_module() and ecm_target_qml_sources().
finds and loads the external library and its components.
If you are looking to add any components listed in the to your application, you may check the right sidebar for how to add the component with CMake. For instance, for , you will find something like find_package(KF6Kirigami), which with the addition of ECM becomes:
creates the executable target we will use to run our project.
adds C++ source files to the executable target.
links the C++ libraries used in our code to our executable. Kirigami is not included here because we are using only its QML module.
installs the executable to the system.
The documentation for the two ECM commands can be found in the .
The call to ecm_add_qml_module() was used here to modify the traditional C++ source code executable target and turn it into something that can accept QML files and C++ source code that is accessible from QML in what is called . This means the QML files are run directly as part of the application, which is often the case for applications.
You may also create a separate QML module that does not use the executable as backing target using ecm_add_qml_module(). In this case, you'd create a library target using , link it to an existing executable target using target_link_libraries(), and in addition to installing the library with install() you will need to finalize the QML module with so it can generate two files: qmldir and qmltypes. These files are used by QtQuick applications to find separate QML modules.
The method for creating a separate QML module is better exemplified in .
These are additions provided by extra-cmake-modules to make the use of (the ) easier.
The documentation for all three commands can be found in the .
In the tutorial about , a new CMake file was introduced to allow for separate QML modules:
We create a new target called kirigami-hello-components and then turn it into a QML module using under the import name org.kde.tutorial.components and add the relevant QML files.
The call to generates a new target called kirigami-hello-components. This target will have its own set of source code files, QML files, link its own libraries and so on, but it needs to be linked to the executable, but once it is compiled it needs to be linked to the executable created in the src/CMakeLists.txt. This is done by adding the target name to the list of libraries that will be linked to the executable in target_link_libraries().
The call to ecm_add_qml_module() changes the library to allow it to accept QML files as before, but this time we need to use . When the executable is used as a backing target (like with kirigami-hello) it doesn't need to generate plugin code since it's built into the executable; with separate QML modules like kirigami-hello-components the plugin code is necessary.
Upstream Qt's by default generates a plugin together with the QML module, but KDE's ecm_add_qml_module() by default does not for backwards compatibility.
Another thing that is necessary for separate QML modules is to finalize the target. This mainly means CMake generates two files, , which describe the QML modules we have and exports their symbols for use in the library. They are important when installing your application so that the executable being run is able to find where the QML files for each module are, so they are automatically added to the target.
Next time you need to add more QML files, remember to include them in this file. C++ files that use the keyword which we will see much later in the tutorial can also be added here using target_sources(). You can logically separate your code by creating more QML modules with different imports as needed.