My Qt 6.2 application continues to evolve. I’ve now named it USB Device Monitor, or udm. It has a dock that can be switched to either left or right side and a table in the center with specific Linux information replacing the text editing widget I had before. All of this is building on from the basic plumbing entry and my earlier utility to read Linux USB devices (see links below).

Comments will be shorter than usual, with code more than commentary.

cmake_minimum_required (VERSION 3.25.0)## Build requirements#include_directories( /usr/include/x86_64-linux-gnu/qt6/ /usr/include/x86_64-linux-gnu/qt6/QtCore/ /usr/include/x86_64-linux-gnu/qt6/QtGui/ /usr/include/x86_64-linux-gnu/qt6/QtWidgets/ )link_libraries( Qt6Core Qt6Widgets Qt6Gui )add_compile_options( -fPIC -std=c++20 )## Project specific#project (usb-device-monitor)add_executable (udmmain.cppMainWindow.cppAddCentralWidget.cppAddWindowFileMenu.cppAddDockingPanel.cppdevices.cpp)

The last third of the CMake file shows that MainWindow is a rename of AppWindow, and three new files have been added, AddCentralWidget, AddDockingPanel and devices.

#pragma once#include <QApplication>#include <QMainWindow>#include <QMenuBar>#include <QPlainTextEdit>#include <QSettings>#include <QString>#include <QDockWidget>#include <QCheckBox>#include <QComboBox>#include <QTableWidget>class AppWindow : public QMainWindow {public:const QString SCOPE_NAME{"Qt6BasedSoftware"};const QString APP_NAME{"USBDeviceMonitor"};const QString APP_GEOMETRY{"app/geometry"};const QString APP_STATE{"app/state"};const int INITIAL_WIDTH{900};const int INITIAL_HEIGHT{600};AppWindow();private:QTableWidget *table;QPlainTextEdit *textEdit;void addCentralWidget();void createFileMenu();QMenu *fileMenu;QAction *newAction;QAction *openAction;QAction *saveAction;QAction *saveAsAction;QAction *aboutAction;QAction *exitAction;void addDockingPanel();QDockWidget *dock;QCheckBox*cb1,*cb1x,*cb2,*cb2x,*cb3,*cb3x,*cb4,*cb4x;QComboBox *comboBox;void closeEvent(QCloseEvent*);};

#include <QScreen>#include <QSize>#include <QStatusBar>#include "MainWindow.hpp"AppWindow::AppWindow() {QCoreApplication::setOrganizationName(SCOPE_NAME);QCoreApplication::setApplicationName(APP_NAME);setWindowTitle(APP_NAME);addCentralWidget();createFileMenu();addDockingPanel();statusBar()->showMessage(tr("Statusbar Placeholder"));QSettings settings(QCoreApplication::organizationName(),QCoreApplication::applicationName());if (settings.contains(APP_GEOMETRY) and settings.contains(APP_STATE)) {restoreGeometry(settings.value(APP_GEOMETRY).toByteArray());restoreState(settings.value(APP_STATE).toByteArray());cb1->setChecked(settings.value("dock/cb1").toBool());cb2->setChecked(settings.value("dock/cb2").toBool());cb3->setChecked(settings.value("dock/cb3").toBool());cb4->setChecked(settings.value("dock/cb4").toBool());comboBox->setCurrentIndex(settings.value("dock/combo1").toInt());return;}QScreen *primaryScreen = QGuiApplication::primaryScreen();QSize screenSize = primaryScreen->availableSize();auto screenWidth  = screenSize.width();auto screenHeight = screenSize.height();auto upperLeftX  = (screenWidth - INITIAL_WIDTH)/2;auto upperLeftY = (screenHeight - INITIAL_HEIGHT)/2;setGeometry(upperLeftX, upperLeftY, INITIAL_WIDTH, INITIAL_HEIGHT);}void AppWindow::closeEvent(QCloseEvent *event) {QSettings settings(QCoreApplication::organizationName(),QCoreApplication::applicationName());settings.setValue(APP_GEOMETRY, saveGeometry());settings.setValue(APP_STATE, saveState());settings.setValue("dock/cb1",cb1->isChecked());settings.setValue("dock/cb2",cb2->isChecked());settings.setValue("dock/cb3",cb3->isChecked());settings.setValue("dock/cb4",cb4->isChecked());settings.setValue("dock/combo1", comboBox->currentIndex());QMainWindow::closeEvent(event);}

The biggest changes in MainWindow besides the renaming is in the constructor and closeEvent. The constructor now calls external class functions to build the subsystems used in the application, and then recalls saved state in order to put the application back the way it was when it was closed the time before. I made a change to the conditional if block by removing the else and adding a return at the end of the if block. I’ve developed an aversion to cascading conditional statements and the “pyramid of doom” that they can create. I now organize my tests such that if I need to check for the health of the application then I’ll check that first and bail if there’s a problem, or as in this case, put the most common action that should occur nearly all the time, perform that task and then leave. The use of if/else blocks might look proper to purists, but I’m no longer a purist.

The closeEvent now does a bit of state saving. I didn’t mention it in the last post, but for Linux the save file is located in $HOME/.config/Qt6BasedSoftware/ USBDeviceMonitor.conf. That folder and file are defined in SCOPE_NAME and APP_NAME, respectively, in MainWindow.hpp, lines 16 and 17.

#include <QStringList>#include <QHeaderView>#include <QTableWidgetItem>#include "MainWindow.hpp"#include "devices.hpp"void AppWindow::addCentralWidget() {table = new QTableWidget(this);table->setColumnCount(3);table->setRowCount(6);QStringList headers = {"Device", "Adapter Name", "Hex Identification"};table->setHorizontalHeaderLabels(headers);table->horizontalHeader()->setStretchLastSection(true);int row{0};for (auto [device, values] : getDevices()) {QString dev(device.c_str());QString v1(values[0].c_str());QString v2(values[1].c_str());table->setItem(row, 0, new QTableWidgetItem(dev));table->setItem(row, 1, new QTableWidgetItem(v1));table->setItem(row, 2, new QTableWidgetItem(v2));++row;}table->resizeColumnsToContents();setCentralWidget(table);}

The class function addCentralWidget creates a three column by six row table, looking pretty much like a spreadsheet, to contain the data that the class function getDevices finds in the Linux operating system. The first half of this function sets up the table while the second half formats the data returned by the call to getDevices. This is the minimum code necessary to just display the data. No other functionality is enabled.

#pragma once#include <array>#include <map>#include <string>#include <iostream>typedef std::map<std::string, std::array<std::string,2>> device_collection;device_collection getDevices();

#include <algorithm>#include <filesystem>#include <regex>#include "devices.hpp"using std::array;using std::string;using std::pair;using std::regex;using std::regex_search;using std::replace;using std::smatch;using std::filesystem::directory_iterator;using std::filesystem::path;using std::filesystem::read_symlink;void split(const string &subj, const regex &rgx, array<string, 2> &vars) {smatch match;regex_search(subj, match, rgx);vars[0] = subj.substr(0, match.position(0));replace(vars[0].begin(), vars[0].end(), '_', ' ');vars[1] = match.str(0).erase(0,1);vars[1].erase(vars[1].end()-1);}device_collection getDevices() {const string DEVICE_PATH{"/dev/serial/by-id/"};const regex hregex{"_[0-9A-Fa-f]+-"};device_collection devices;for (const auto &entry : directory_iterator(DEVICE_PATH)) {if (entry.is_symlink()) {string slink = read_symlink(entry).stem().generic_string();string sname = entry.path().stem().generic_string().erase(0,4);array<string, 2> results;split(sname, hregex, results);devices[slink] = results;}}return devices;}

This is the utility I wrote about a week back where I was trying to write the same utility in Python, C++, and Rust. The original C++ utility was stand-alone. I removed the main and the printout, and just converted it into a function that returned a collection of the processed data to be displayed in the QTableWidget.

#include <QGroupBox>#include <QVBoxLayout>#include <QDockWidget>#include <QGridLayout>#include "MainWindow.hpp"void AppWindow::addDockingPanel() {dock = new QDockWidget(tr("Docking Panel"), this, Qt::Widget);dock->setObjectName(tr("Docking_Panel"));dock->setFeatures(QDockWidget::DockWidgetMovable);dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);addDockWidget(Qt::LeftDockWidgetArea, dock);QWidget *mainWidget = new QWidget;QGridLayout *grid = new QGridLayout;mainWidget->setLayout(grid);QGroupBox *checkboxSelection = new QGroupBox(tr("Non-exclusive Checkboxes"));QVBoxLayout *cslayout = new QVBoxLayout;cb1 = new QCheckBox(tr("One"), this);cslayout->addWidget(cb1, 0, Qt::AlignLeft);cb2 = new QCheckBox(tr("Two"), this);cslayout->addWidget(cb2, 1, Qt::AlignLeft);cb3 = new QCheckBox(tr("Three"), this);cslayout->addWidget(cb3, 2, Qt::AlignLeft);cb4 = new QCheckBox(tr("Four"), this);cslayout->addWidget(cb4, 3, Qt::AlignLeft);checkboxSelection->setLayout(cslayout);grid->addWidget(checkboxSelection, 0, 0);QGroupBox *groupBox = new QGroupBox(tr("Dropdown"), dock);QVBoxLayout *layout = new QVBoxLayout();comboBox = new QComboBox();comboBox->addItem(tr("One"));comboBox->addItem(tr("Two"));comboBox->addItem(tr("Three"));comboBox->addItem(tr("Four"));layout->addWidget(comboBox);groupBox->setLayout(layout);grid->addWidget(groupBox, 1, 0);QWidget *filler = new QWidget;QVBoxLayout *flayout = new QVBoxLayout;flayout->addSpacerItem(new QSpacerItem(20, 800, QSizePolicy::Minimum,QSizePolicy::Expanding));filler->setLayout(flayout);grid->addWidget(filler);dock->setWidget(mainWidget);}

This creates a dockable panel that can be moved either to the right or the left of the main application. It does nothing but display a few controls. QDockWidget has changed a bit since Qt 4. In particular, I had to create a single widget to set within the QDockWidget instance; that’s what mainWidget is for. I also had to create a special widget to encapsulate the QSpacerItem in order for all the other widgets to line up properly and not waste space on the dock.

The class function createFileMenu hasn’t changed.

Not much to say at this point except that now I need to decide what real functionality I want to enable in this monitor, and then add controls that actually do something. A bit more state is going to have to be preserved. The utility is going to have to monitor the USB devices to indicate when devices are added or removed. And I’m going to want to add a column to each row to hold additional user added information (text). So a bit more work to do.

Links

building a simple qt 6 application — basic plumbing

python vs c++ vs rust — a personal adventure

I’m continuing to work on my simple Qt 6 application. I’ve begun to break up the source files into smaller compilation modules (files) that perform a specific task or small set of related tasks. This has allowed me to add the framework for the application to save its operating state and then recover it when it’s restarted. I want that capability because I hate applications that don’t pick up where I left off when I closed the application.

The first change has been to the CMake file, CMakeLists.txt.

cmake_minimum_required (VERSION 3.25.0)## Build requirements#include_directories( /usr/include/x86_64-linux-gnu/qt6/ /usr/include/x86_64-linux-gnu/qt6/QtCore/ /usr/include/x86_64-linux-gnu/qt6/QtGui/ /usr/include/x86_64-linux-gnu/qt6/QtWidgets/ )link_libraries( Qt6Core Qt6Widgets Qt6Gui )add_compile_options( -fPIC -std=c++20 )## Project specific#project (control-app)add_executable (control-appmain.cppAppWindow.cppAppWindowFileMenu.cpp)

The first change is the addition of two more include directories on lines 6 and 7. The add_executable CMake call now has three source files instead of the original one.

The next big change was to break up the original single source file into three. The original source file was renamed main.cpp, and the source that defined the AppWindow functionality was put into two files, one for the main part of AppWindow and the other for just creating the File menu structure. Let’s go in the file order of CMakeLists.txt.

The first file is main.cpp.

#include "AppWindow.hpp"int main(int argc, char **argv) {QApplication app (argc, argv);AppWindow window;window.show();return app.exec();}

This file is what is left of the original simple-app.cpp, stripped of everything not needed and renamed. The only functionality required of main is to instantiate AppWindow and then kick everything off with window.show().

#pragma once#include <QApplication>#include <QMainWindow>#include <QMenuBar>#include <QPlainTextEdit>#include <QSettings>#include <QString>class AppWindow : public QMainWindow {public:const QString SCOPE_NAME{"Qt6BasedSoftware"};const QString APP_NAME{"ControlApp"};const QString APPWIN_GEOMETRY{"AppWindow/geometry"};const QString APPWIN_STATE{"AppWindow/state"};const int INITIAL_WIDTH{800};const int INITIAL_HEIGHT{600};AppWindow();private:QSettings *settings;QPlainTextEdit *textEdit;void createFileMenu();QMenu *fileMenu;QAction *newAction;QAction *openAction;QAction *saveAction;QAction *saveAsAction;QAction *aboutAction;QAction *exitAction;void closeEvent(QCloseEvent*);};

If you compare this header file with the AppWindow class definition in simple-app.cpp, you’ll notice that the header file alone is longer than the original simple-app.cpp. At this point there aren’t all that many class functions; there’s the public constructor and then the private function createFileMenu which can only be called internally to the class, specifically from the constructor. The majority of the header file so far is primarily data structures, although I expect that will change as this application continues to evolve.

#include <QScreen>#include <QSize>#include <QStatusBar>#include <iostream>#include "AppWindow.hpp"AppWindow::AppWindow() {QCoreApplication::setOrganizationName(SCOPE_NAME);QCoreApplication::setApplicationName(APP_NAME);settings = new QSettings(SCOPE_NAME, APP_NAME);textEdit = new QPlainTextEdit;setCentralWidget(textEdit);createFileMenu();setWindowTitle(APP_NAME);statusBar()->showMessage(tr("Statusbar Placeholder"));if (settings->contains(APPWIN_GEOMETRY) and settings->contains(APPWIN_STATE)) {std::cout << APP_NAME.toStdString() << ": found full state\n";restoreGeometry(settings->value(APPWIN_GEOMETRY).toByteArray());restoreState(settings->value(APPWIN_STATE).toByteArray());}else {std::cout << APP_NAME.toStdString() << ": did not find full state\n";QScreen *primaryScreen = QGuiApplication::primaryScreen();QSize screenSize = primaryScreen->availableSize();auto screenWidth  = screenSize.width();auto screenHeight = screenSize.height();auto upperLeftX  = (screenWidth - INITIAL_WIDTH)/2;auto upperLeftY = (screenHeight - INITIAL_HEIGHT)/2;setGeometry(upperLeftX, upperLeftY, INITIAL_WIDTH, INITIAL_HEIGHT);}}void AppWindow::closeEvent(QCloseEvent *event) {std::cout << APP_NAME.toStdString() << ": close event\n";settings->setValue(APPWIN_GEOMETRY, saveGeometry());settings->setValue(APPWIN_STATE, saveState());QMainWindow::closeEvent(event);}

This is the meat of the application so far. There are two key sections, the constructor and the definition of function closeEvent.

The constructor sets up the overall environment for QSettings so that the application can save, and then recall, its state when it starts up and shuts down respectively. I followed the directions on the QSettings documentation page ( https://doc.qt.io/qt-6.2/qsettings.html ). Inside the constructor, starting on line 19, I check to see if the application geometry and state are available from a prior run. If they are not, then I default to a width and a height and a location that places the application squarely in the middle of the screen. If the geometry and state are loaded, however, the application goes back to the state that was last saved. Note that, on 13, that a QPlainTextEdit widget is set as the center widget for AppWindow. This is because Qt states that simply showing an empty QMainWindow isn’t supported (well, they won’t guarantee it works), so I added this widget just to fill the slot. In fact lines 13 through 16 are basically enabling the application (center widget, menu, window title and status line).

In order to make sure that the geometry and state or saved, I’ve redefined QMainWindow::closeEvent() such that everything is saved. After saving the call to QMainWindow::closeEvent() is chained to make sure that the Qt application closes properly.

#include "AppWindow.hpp"void AppWindow::createFileMenu() {fileMenu = menuBar()->addMenu(tr("&File"));newAction = new QAction(tr("&New"), this);fileMenu->addAction(newAction);openAction = new QAction(tr("&Open"), this);fileMenu->addAction(openAction);saveAction = new QAction(tr("&Save"), this);fileMenu->addAction(saveAction);saveAsAction = new QAction(tr("Save as"), this);fileMenu->addAction(saveAsAction);fileMenu->addSeparator();aboutAction = new QAction(tr("&About Qt"), this);connect(aboutAction, &QAction::triggered, qApp, &QApplication::aboutQt);fileMenu->addAction(aboutAction);fileMenu->addSeparator();exitAction = new QAction(tr("E&xit"), this);exitAction->setShortcuts(QKeySequence::Quit);connect(exitAction, &QAction::triggered, this, &QWidget::close);fileMenu->addAction(exitAction);}

The class function that builds the File menu is in its own compilation unit. I did this to keep any one source file from growing too large. I believe in fine granularity. As more menus are needed, and defined, they’ll go into their own files. Additional functionality will also go into their own unique files.

More to come…

Links

building a simple qt 6 application with cmake and make