We want to display some visual gauges and chart widgets, so create a new Qt widgets Application called ch02-sysinfo. As already discussed in Chapter 1, Get Your Qt Feet Wet, Qt Creator, will generate some files for us: main.cpp, MainWindow.h, MainWindow.cpp, and MainWindow.ui.

Before diving into the C++ code, we must think about the software's architecture. This project will handle multiple desktop platforms. Thanks to the combination of C++ and Qt, most of the source code will be common to all targets. However, to retrieve both the CPU and memory usage from the OS (operating system), we will use some platform-specific code.

To successfully achieve this task, we will use two design patterns:

• Strategy pattern: This is an interface that describes functionalities (for example, retrieve CPU usage) and specific behaviors (retrieve CPU usage...

Promises are made to be kept: we will now transform the SysInfo class into a singleton. C++ offers many ways to implement the singleton design pattern. We will explain one of them here. Open the SysInfo.h file and make the following changes:

class SysInfo 
{ 
public: 
    static SysInfo& instance(); 
    virtual ~SysInfo(); 
 
    virtual void init() = 0; 
    virtual double cpuLoadAverage() = 0; 
    virtual double memoryUsed() = 0; 
 
protected: 
    explicit SysInfo(); 
 
private: 
    SysInfo(const SysInfo& rhs); 
    SysInfo& operator=(const SysInfo& rhs); 
}; 

The singleton must guarantee that there will be only one instance of the class and that this instance will be easily accessible from a single access point.

So the first thing to do is to change the visibility of the constructor to protected. This way, only this...

The core part is ready. It's now time to create a UI for this project and Qt Charts can help us with this task. Qt Charts is a module that provides a set of easy-to-use chart components, such as line chart, area chart, spline chart, and pie chart.

Qt Charts was previously a commercial-only Qt module. Since Qt 5.7, the module is now included in Qt on GPLv3 license for open source users. If you are stuck on Qt 5.6, you can build the module by yourself from sources. More information can be found at https://github.com/qtproject/qtcharts.

The aim now is to create two Qt widgets, CpuWidget and MemoryWidget, to display nice Qt charts of the CPU and the memory used. These two widgets will share a lot of common tasks, so we will first create an abstract class, SysInfoWidget:

Then the two actual widgets will inherit from the SysInfoWidget class and perform their...

Now that the SysInfoWidget base class is ready, let's implement its first child class: CpuWidget. We will now use the Qt Charts API to display a good-looking widget. The average CPU load will be displayed in a pie graph with a hole in the center, like a partly-eaten donut where the eaten part is the percentage of the CPU used. The first step is to add a new C++ class, named CpuWidget, and make it inherit SysInfoWidget:

#include "SysInfoWidget.h" 
 
class CpuWidget : public SysInfoWidget 
{ 
public: 
    explicit CpuWidget(QWidget* parent = 0); 
}; 

In the constructor, the only parameter needed is QWidget* parent. Since we provided default values for the startDelayMs and updateSeriesDelayMs variables in the SysInfoWidget class, we get the best possible behavior; there is no need to remember it when subclassing SysInfoWidget, but it is still...

Our second SysInfoWidget is a MemoryWidget class. This widget will display a history of the data so that we can see how the memory consumption evolves over time. To display this data, we will use a QLineSeries class from the Qt Chart module. Create the MemoryWidget class and follow the same pattern we used for CpuWidget:

#include <QtCharts/QLineSeries> 
 
#include "SysInfoWidget.h" 
 
class MemoryWidget : public SysInfoWidget 
{ 
    Q_OBJECT 
public: 
    explicit MemoryWidget(QWidget *parent = 0); 
 
protected slots: 
    void updateSeries() override; 
 
private: 
    QtCharts::QLineSeries* mSeries; 
    qint64 mPointPositionX; 
}; 

Instead of a being QPieSeries*, mSeries is a type of QLineSeries* that will be linked to the chart object in a very similar fashion to MemoryWidget.cpp:

#include "MemoryWidget.h" 
#include <QtCharts...

When you click on the Build button, what exactly is Qt Creator doing? How does Qt handle the compilation of the different platforms with a single .pro file? What does the Q_OBJECT macro imply, exactly? We will dig into each of these questions in the following sections. Our example case will be the SysInfo application we just completed and we will study what Qt is doing under the hood.

We can start this study by digging into the .pro file. It is the main entry point for compiling any Qt project. Basically, a .pro file is a qmake project file that describes the sources and headers used by the project. It is a platform-agnostic definition of a Makefile. First, we can cover the different qmake keywords used in the ch02-sysinfo application:

#------------------------------------------------- 
# 
# Project created by QtCreator 2016-03-24T16:25:01 
# 
#--------...

As we said earlier, qmake is the foundation of the Qt framework compilation system. In Qt Creator, when you click on the Build button, qmake is invoked. Let's study what qmake is doing by calling it ourselves on the command-line interface (CLI).

Create a temporary directory where you will store the generated files. We are working on a Linux box, but this is transposable on any OS. We will choose /tmp/sysinfo. Using the CLI, navigate to this new directory and execute the following command:

/path/to/qt/installation/5.7/gcc_64/bin/qmake -makefile -o Makefile /path/to/sysinfoproject/ch02-sysinfo.pro

This command will execute qmake in the -makefile mode to generate a Makefile based on your sysinfo.pro file. If you skim through the Makefile content, you will see many things we covered earlier in the .pro section, such as the link to Qt modules, headers of...

The Qt building system should be clearer now. Still, the Q_OBJECT macro and the signal/slot/emit keywords are still black boxes. Let's dive into Q_OBJECT. You can Ctrl + click on the macro name, or select it and press F2 to go to its declaration.

The truth lies in the source code; Q_OBJECT is defined in the qobjectdefs.h file (in Qt 5.7):

#define Q_OBJECT \ 
public: \ 
    // skipped details 
    static const QMetaObject staticMetaObject; \ 
    virtual const QMetaObject *metaObject() const; \ 
    virtual void *qt_metacast(const char *); \ 
    virtual int qt_metacall(QMetaObject::Call, int, void **); \ 
    QT_TR_FUNCTIONS \ 
private: \ 
    // skipped details  
qt_static_metacall(QObject *, QMetaObject::Call, int, void **); 

This macro defines some static functions and static QMetaObject. The body of these static functions is implemented...

In this chapter, we created a cross-platform SysInfo application. We covered the singleton and the strategy pattern to have neat code organization with platform-specific code. You learned to use the Qt Charts module to display system information in real time. Finally, we took a deep dive into the qmake command to see how Qt implements the signal/slot mechanism and to see what is hidden behind Qt-specific keywords (emit, signals, and slots).

By now, you should have a clear picture of how Qt works and how you can tackle a cross-platform application. In the next chapter, we will look at how you can split a bigger project in order to keep your sanity as a maintainer. We will study a fundamental pattern in Qt—the Model/View—and discover how to use a database with Qt.