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:

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 class and the child classes will be allowed to call the constructor.

Since only one instance of the object must exist...

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, pie chart, and so on.

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 specific tasks.

Create a new C++ class called SysInfoWidget with QWidget as a base class. Some enhancements must...

Now that the base class SysInfoWidget 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 a QWidget* parent. Since we provided default values for the startDelayMs and updateSeriesDelayMs variables in SysInfoWidget class, we get the best possible behavior; there is no need to remember it when subclassing SysInfoWidget, but it is still easy to override it if need be.

The next step is to override the updateSeries() function from the SysInfoWidget class and start using...

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 a QPieSeries*, mSeries is a type of QLineSeries* which will be linked to the chart object in a very similar fashion to MemoryWidget.cpp:

#include "MemoryWidget.h" 
#include <QtCharts/QAreaSeries> 
 
using namespace QtCharts; 
 
const int CHART_X_RANGE_COUNT = 50; 
const int CHART_X_RANGE_MAX = CHART_X_RANGE_COUNT...