C++/Qt/QML Patterns & Best Practices

cmake_minimum_required(VERSION 3.16)

project(MyApp VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Auto-run moc, uic, rcc
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)

# Component-based Qt discovery
find_package(Qt6 6.2 REQUIRED COMPONENTS
    Core Gui Widgets Network Sql
)

# Qt6 standard project setup
qt_standard_project_setup()

# Executable
qt_add_executable(myapp
    src/main.cpp
    src/mainwindow.cpp
    src/mainwindow.h
)

target_link_libraries(myapp PRIVATE
    Qt6::Core
    Qt6::Gui
    Qt6::Widgets
    Qt6::Network
)

# Install rules
install(TARGETS myapp
    BUNDLE DESTINATION .
    RUNTIME DESTINATION bin
    LIBRARY DESTINATION lib
)

qt_add_qml_module(myapp
    URI MyApp
    VERSION 1.0
    QML_FILES
        Main.qml
        pages/HomePage.qml
        pages/SettingsPage.qml
        components/StyledButton.qml
    RESOURCES
        images/logo.png
)

if(WIN32)
    target_sources(myapp PRIVATE
        widgets/d3dvideowidget.cpp
        widgets/d3dvideowidget.h
    )
elseif(APPLE)
    target_sources(myapp PRIVATE
        widgets/metalvideowidget.mm
        widgets/metalvideowidget.h
    )
else()
    target_sources(myapp PRIVATE
        widgets/openglvideowidget.cpp
        widgets/openglvideowidget.h
    )
endif()

qt_add_translations(myapp
    TS_FILES
        translations/myapp_en.ts
        translations/myapp_de.ts
        translations/myapp_tr.ts
)

# Root CMakeLists.txt
add_subdirectory(libs)
add_subdirectory(plugins)
add_subdirectory(krita)

// StyledButton.qml — custom component pattern
import QtQuick 2.15
import QtQuick.Controls 2.15

Button {
    id: control

    // Public properties
    property string accentColor: "#0078d7"
    property bool : false

    implicitHeight: 36
    padding: 12

    contentItem: Text {
        text: control.text
        font: control.font
        color: control.enabled ? "white" : "#888"
        horizontalAlignment: Text.AlignHCenter
        verticalAlignment: Text.AlignVCenter
        elide: Text.ElideRight
    }

    background: Rectangle {
        radius: control. ? height / 2 : 4
        color: !control.enabled ? "#444"
              : control.pressed ? Qt.darker(control.accentColor, 1.3)
              : control.hovered ? Qt.lighter(control.accentColor, 1.1)
              : control.accentColor

        border.width: !control.enabled ? 0 : 1
        border.color: control.accentColor

        Behavior on color { ColorAnimation { duration: 150 } }
    }
}

// SortedTaskModel — filter + sort proxy
class SortedTaskModel : public QSortFilterProxyModel {
    Q_OBJECT
    QML_ELEMENT

    Q_PROPERTY(QString filterText READ filterText
               WRITE setFilterText NOTIFY filterTextChanged)

public:
    bool filterAcceptsRow(int sourceRow,
        const QModelIndex &sourceParent) const override;

    QString filterText() const { return m_filterText; }
    void setFilterText(const QString &text) {
        if (m_filterText == text) return;
        m_filterText = text;
        invalidateFilter();
        emit filterTextChanged();
    }

signals:
    void filterTextChanged();

private:
    QString m_filterText;
};

#include 

class TestDataManager : public QObject {
    Q_OBJECT
private slots:
    void initTestCase();
    void cleanupTestCase();
    void testLoadData();
    void testSaveData_data();    // Data-driven testing
    void testSaveData();
};

void TestDataManager::testLoadData() {
    DataManager mgr;
    QSignalSpy spy(&mgr, &DataManager::dataLoaded);
    mgr.loadData(":/test_data/sample.json");
    QVERIFY(spy.wait(1000));  // Wait for async signal
    QCOMPARE(mgr.status(), QStringLiteral("Loaded"));
}

void TestDataManager::testSaveData_data() {
    QTest::addColumn("filename");
    QTest::addColumn("expected");
    QTest::newRow("valid") << "test.json" << true;
    QTest::newRow("invalid") << "" << false;
}

void TestDataManager::testSaveData() {
    QFETCH(QString, filename);
    QFETCH(bool, expected);
    DataManager mgr;
    QCOMPARE(mgr.saveData(filename), expected);
}

import QtTest 1.15

TestCase {
    name: "StyledButtonTests"
    when: windowShown

    function test_button_click() {
        var btn = createTemporaryObject(component, window,
            {text: "Test"})
        verify(btn)
        compare(btn.text, "Test")
        btn.clicked()
        // Verify signal
    }
}

# .github/workflows/build.yml
name: Build

on: [push, pull_request]

jobs:
  build:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        qt_version: ['6.7.*']
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Install Qt
        uses: jurplel/install-qt-action@v4
        with:
          version: ${{ matrix.qt_version }}
          modules: qtwebengine qt5compat qtmultimedia

      - name: Install Linux deps
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            libgl1-mesa-dev libxkbcommon-dev \
            libwayland-dev libpulse-dev

      - name: Configure
        run: cmake -B build -DCMAKE_BUILD_TYPE=Release

      - name: Build
        run: cmake --build build --parallel

      - name: Test
        run: ctest --test-dir build --output-on-failure

# Dockerfile for reproducible Qt builds
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y \
    cmake g++ qt6-base-dev qt6-declarative-dev
COPY . /src
WORKDIR /src
RUN cmake -B build -DCMAKE_BUILD_TYPE=Release && \
    cmake --build build --parallel

// worker.h — Worker object pattern
class ImageProcessor : public QObject {
    Q_OBJECT
public slots:
    void process(const QString &imagePath);

signals:
    void finished(const QImage &result);
    void error(const QString &message);
};

// In controller:
void Controller::startProcessing(const QString &path) {
    auto *worker = new ImageProcessor;
    worker->moveToThread(&m_workerThread);

    // Wire up signals
    connect(&m_workerThread, &QThread::finished,
            worker, &QObject::deleteLater);
    connect(worker, &ImageProcessor::finished,
            this, &Controller::handleResult);
    connect(this, &Controller::processImage,
            worker, &ImageProcessor::process);

    m_workerThread.start();
    emit processImage(path);  // Queued to worker thread
}

#include 
#include 

QFuture loadImageAsync(const QString &path) {
    return QtConcurrent::run([path]() -> QImage {
        return QImage(path);
    });
}

// Qt6 .then() chaining
loadImageAsync("photo.png").then([](QImage image) {
    displayLabel->setPixmap(QPixmap::fromImage(image));
});

// Multiple async operations with QCoro (third-party)
QCoro::Task fetchData() {
    auto *reply = co_await m_network.get(request);
    auto data = reply->readAll();
    co_await processAsync(data);
    emit ready(data);
}