Basic Cmake for Qt Users

Integrated Computer Solutions Inc. www.ics.com
CMake for QMake Users
Chris Rizzitello, ICS
September 22, 2022
1

About ICS
Delivering Smart Devices for a Connected World
● Founded in 1987
● Largest source of independent Qt expertise in North America
● Trusted Qt Service Partner since 2002
● Exclusive Open Enrollment Training Partner in North America
● Provides integrated custom software development and user experience (UX) design
● Embedded, touchscreen, mobile and desktop applications
● HQ in Waltham, MA with oﬃces in California, Canada, Europe
2
Boston UX
● Part of the ICS family, focusing on UX design
● Designs intuitive touchscreen interfaces for high-impact embedded
and connected medical, industrial and consumer devices

What is CMake
CMake is an open source, multi platform makefile tool that aids in the building
testing and packaging of the software.
- Generate native makefiles for the system
- Provide rules for deployment
- Easily find dependencies
- Highly configurable
- CMake projects can be opened in many IDEs including QtCreator
- QtCreator has basic support for CMake when adding and creating files
Qt6 will suggests CMake as its project type
3

Example CMake Project
#include <QtWidgets>
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
QPushButton button("Hello CMake");
QObject::connect(&button, &QPushButton::clicked, &app, &QApplication::exit);
button.show();
return app.exec();
}
main.cpp
We have the following code, let’s create a simple CMake project for it
4

Setting up a CMake project
5
Our Source Code folder looks like this:
Create a new ﬁle CMakeLists.txt (CaseSensitive)
our directory will now look like this:
NewProject/
NewProject/main.cpp
NewProject/
NewProject/CMakeLists.txt
NewProject/main.cpp

The First Lines of a main CMakeLists.txt
cmake_minimum_required(VERSION 3.21)
# This ﬁle will require cmake 3.21 to be processed
project(hello_cmake)
# Our project will be named "hello_cmake" (ONLY REQUIRED ITEM)
# Stored in a variable: CMAKE_PROJECT_NAME
6
The project name does not automatically set the name of any target.

Find Dependencies and Qt Modules
ﬁnd_package(Qt6 REQUIRED COMPONENTS
Widgets
)
7
The COMPONENTS are the Qt Modules that will be used for the project. “core” is
imported by all other components.
In Qmake project ﬁle this is equivalent to QT+=widgets

Creating a Target
target_link_libraries(hello_cmake PRIVATE Qt6::Core Qt6::Widgets)
8
For Qt 5.15 and Qt6 can be linked dynamically based on the version in use
Link with versionless Qt statements to enable this I.E “Qt::Core” or “Qt::Widgets”
add_execuitable is a “app” project
add_library is a “lib” project
Both calls set the name of the that target.
Target names can be used several other places, only after deﬁned
add_executable(hello_cmake main.cpp)

Generating the build and install info
install( TARGETS hello_cmake RUNTIME DESTINATION bin )
We can tell Cmake where to install stuff for us
9
TARGETS can have several
types
- ARCHIVE
- LIBRARY
- RUNTIME
- OBJECTS
- FRAMEWORK
- BUNDLE
- PRIVATE_HEADER
- PUBLIC_HEADER
- RESOURCE
Install
- TARGETS
- FILES
- DIRECTORY

CMake Install Prefix
All files are installed into the CMAKE_INSTALL_PREFIX (Default: /usr/local)
10
cmake -DCMAKE_INSTALL_PREFIX=<prefix_path> CMakeLists.txt
The prefix can be set in the CMakeLists.txt file. It will be used unless
overridden at configuration time.
set(CMAKE_INSTALL_PREFIX <prefix_path>)
At configuration time, the prefix can be changed with :

Setting Vars
#Set our C++ Standard to C++17, Project will use C++17 standard if possible
set(CMAKE_CXX_STANDARD 17)
# If the project uses features required from the standard, it needs to be set as required.
# In the event the system does not provide the selected standard, the conﬁguration will fail.
set(CMAKE_CXX_STANDARD_REQUIRED ON)
11
The following sets the variable to the given value :
set(MyVar 5)
Setting the C++ Standard requirement :
message(“The Value is ${MyVar}”)
Later you can use it like this

Qt Specific CMake Helpers
Normally you would have to make and custom_commands for CMake needs to
run moc, rcc and/or uic. With CMake 3.10+ you simply set these variables
12
# Automatically run MOC on the files that need it
set(CMAKE_AUTOMOC ON)
# Automatically run RCC on the files that need it (resource files)
set(CMAKE_AUTORCC ON)
# Automatically run UIC on the files that need it (UI files)
set(CMAKE_AUTOUIC ON)
With the above options qrc and ui files can be used like any other source
files.

QML Plugins
The QmlImportScanner module for Qt can be used to check and link all the QML
plugins that are needed for the target:
13
ﬁnd_package(Qt REQUIRED COMPONENTS
...
QmlImportScanner
)
qt_import_qml_plugins(target)

Creating configuration options
Options are easy to create and can change how a project is built.
Create an option in the CMakeLists.txt file
option(UseFooLib "Link with FooLib" OFF)
if (UseFooLib)
# Link with Foo lib
endif()
Set the option during configuration
cmake -DUseFooLib=ON CMakeLists.txt
14

Configuring files
CMake can also use templates to create files
project(MyCoolProject)
configure_file(file.in file.out @ONLY)
CMAKE_CURRENT_SOURCE_DIR/file.in
15
CMakeLists.txt
#define ProjectNAME “@CMAKE_PROJECT_NAME@”
CMAKE_CURRENT_BINARY_DIR/file.out
#define ProjectNAME “MyCoolProject”
CMake will will replace any valid CMake variable wrapped in ${VAR} or @VAR@ .
In the above example, since @ONLY is passed, CMake will only replace CMake variables
wrapped in the format @VAR@

Setting up a CMake project Recap
1. Set the minimum version of CMake needed to process the project
2. Set a project name
3. Find dependencies used to build the code
4. Add library or executable that uses the source code
5. Provide linking rules for the lib / exe
6. Optionally add install instructions for the new project
16
The CMakeLists.txt ﬁle in the project root folder should contain the following :

Setting up a CMake project: Sub folders?
1. Find new dependencies used to build the code in the directory
2. Set source ﬁles in this path
3. Add library or executable that uses the sources
4. Provide linking rules for the lib / exe
5. Optionally add install instructions this new component
6. Optionally link a library target with the another part of your project.
17
What about “subdir” projects? You can also use add_subdirectory(foo) to include a folder.
Any directory included with the add_subdirectory command must contain a CMakeLists.txt
File. This CMakeLists.txt will tell you how handle the source ﬁles in that directory.

Using the cmake command
The cmake command is used to parse the CMakeLists.txt files in your project.
Its most basic use is: This will create build files in source.
18
cmake CMakeLists.txt
Option Description
-S <path> Sets the source directory (-H before version 3.13)
-B <path> Set build path, default path is the current directory
-D<var>=<value> Set a variable's value to passed
-G <generator> Forces the use of a specific generator
--graphviz=<file> Create a graphviz of project dependencies
--help Show the help for cmake command (easy way to see generators on the system)

Shadow Building Steps
Shadow building is easy with cmake
1. cd <sourcePath>
2. cmake -S. -B<buildpath>
3. cmake --build <buildpath>
This will create all the generated build ﬁles in the “buildpath” , Make will build all ﬁles into
the build path when it’s run
19

CMake Times
20

Localization With Qt: Generating Ts Files CMAKE
21
set_directory_properties(PROPERTIES
CLEAN_NO_CUSTOM 1) #Do not remove *.ts on clean
find_package(QtLinguistTools)
set(needsTranslation
Mainwindow.cpp
… More source files
)
set(languageFiles
myApp_en.ts
myApp_fr.ts
myApp_de.ts
)
qt_create_translation(TSFiles
needsTranslation
languageFiles
)
add_custom_target(TRS ALL DEPENDS ${TSFiles})
find_package(QtLinguistTools)
qt_add_translation(QMFiles
mainwindow.cpp
myApp_en.ts
myApp_fr.ts
myApp_de.ts
)
add_custom_target(QMS ALL DEPENDS
${QMFiles}
)
21
qt_add_translation only runs lrelease,
requires pre-existing .ts files
qt_create_translation runs both lupdate
and lrelease

Find Dependencies and Qt Modules Revisited
##using Qt6?
find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(${CMAKE_PROJECT_NAME} PRIVATE Qt::Widgets)
## using Qt5?
find_package(Qt5 REQUIRED COMPONENTS Widgets)
## Qt6 but Qt5 if its not found
find_package(Qt NAMES Qt6 Qt5 REQUIRED COMPONENTS Widgets)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Widgets)
target_link_libraries(${CMAKE_PROJECT_NAME} PRIVATE Qt${QT_VERSION_MAJOR}::Widgets)
## Qt6, unless the user sets it to 5 when they configure
if(NOT QT_DEFAULT_MAJOR_VERSION)
set(QT_DEFAULT_MAJOR_VERSION 6 CACHE STRING "" FORCE)
endif()
find_package(Qt${QT_DEFAULT_MAJOR_VERSION} REQUIRED COMPONENTS Widgets)
22

CPack Making Packages
23

How Can I Be “CPack Ready”
Everything you want to install has install instructions
1. Targets use install(TARGET …)
2. Support ﬁles use install(FILES | DIRECTORY …)
24

Find macdeployqt / windeployqt
get_target_property(_qmake_executable Qt5::qmake IMPORTED_LOCATION)
get_filename_component(_qt_bin_dir "${_qmake_executable}" DIRECTORY)
find_program(MACDEPLOYQT macdeployqt HINTS "${_qt_bin_dir}")
find_program(WINDEPLOYQT windeployqt HINTS "${_qt_bin_dir}")
25
*Cmake has some native ways to find dependencies unfortunately they all currently fail to find the Qt
Plugins and at very least force you to make a list of all the plug-ins you need to ship.
For this reason its recommended that you use the *deployQt to gather the dependencies. This alone will
not run them for you but will let you use them in a post build or pre deployment via
add_custom_command similar to how we did w/ the translations in the cmake.

Generic CPack
set(CPACK_STRIP_FILES [TRUE | FALSE] )
set(CPACK_PACKAGE_NAME “PACKAGENAME”)
set(CPACK_RESOURCE_FILE_LICENSE “PATH TO LICENSE FILE”)
set(CPACK_PACKAGE_VERSION ${CMAKE_PROJECT_VERSION})
set(CPACK_GENERATOR “TGZ;....”)
…
INCLUDE (CPack) <- Last Line
26

CPack Archive Type Packages
Several types of archives can be generated.
27
Generator String Description
7Z Generate a 7-Zip Archive
TBZ2 Generate a B Zipped Tarball
TGZ Generate a Gnu Zipped Tarball
TXS Generate a LZMA Compressed Tarball
TZ Generate a Zip Compressed Tarball
ZIP Generate a Zip Archive
CPACK_ARCHIVE_FILE_NAME and CPACK_ARCHIVE_COMPONENT_INSTALL

CPACK Qt Installer Framework
Qt Installer can generate installer for Unix, MacOs and Windows.
1. Generator Name: “IFW”
Useful Vars to set:
● CPACK_IFW_PACKAGE_TITLE
● CPACK_IFW_PACKAGE_PUBLISHER
● CPACK_IFW_PACKAGE_ICON
● CPACK_IFW_PACKAGE_WINDOW_ICON
● CPACK_IFW_PACKAGE_LOGO
● CPACK_IFW_PACKAGE_RESOURCES
● CPACK_IFW_DOWNLOAD_ALL
● CPACK_IFW_PACKAGE_FILE_EXTENSTION
28
IFW Docs: https://cmake.org/cmake/help/latest/cpack_gen/ifw.html

CPACK DMG
DMG ﬁles are common on mac os as a method of deployment
1. Generator Name: “DragNDrop”
2. For single app install your .app to “.”
3. Run macdeployqt on the app to prepare for deployment
4. Backgrounds are possible Requires:
i. IMAGES VOLUME NAME MUST NOT CHANGE
ii. CPACK_DMG_BACKGROUND_IMAGE
iii. CPACK_DMG_DS_STORE <- DS_Store must be generated by Finder
29

CPACK NSIS
Nullsoft Scriptable Install System 3.0+ has to be installed.
Several Options are unique to the NSIS generator
set(CPACK_NSIS_MENU_LINKS “EXE” “LINKNAME”) to generate start menu links
CPACK_PACKAGE_INSTALL_DIRECTORY - The path to use for install
CPACK_NSIS_EXTRA_INSTALL_COMMANDS - addition nsis commands for install
CMAKE_NSIS_EXTRA_UNINSTALL_COMMANDS - additional uninstall nsis
commands
30

CPACK DEB
Build DEB Packages
Several Options are unique to the DEB generator
Set CPACK_DEBIAN_FILE_NAME to DEB-DEFAULT . This will set the generated name(s) to the
default scheme.
CPACK_DEBIAN_PACKAGE_SHLIBDEPS [ON | OFF] automatically generate packages depends list
CPACK_DEB_COMPONENT_INSTALL [ TRUE | FALSE ] Allow building of split packages
CPACK_DEBIAN_<COMPONENT>PACKAGE_NAME - set name for a components package
Many other component related vars.
REQUIRES:
VERSION MUST BE a valid semantic version
A CPACK_PACKAGE CONTACT or CPACK_DEBIAN_PACKAGE_MAINTAINER is set
31

Thanks for Attending
32
Any questions?

Basic Cmake for Qt Users

More Related Content

What's hot (20)

Similar to Basic Cmake for Qt Users (20)

More from ICS (20)

Recently uploaded (20)

Basic Cmake for Qt Users