Bekijken wat main.cpp doet

De rol van main.cpp

Terwijl QML gebruikt wordt voor de front-end van Kirigami toepassingen, wordt de backend gewoonlijk in C++ geschreven vanwege de snelheid en flexibiliteit van deze taal. Terwijl in vorige pagina's we QML behoorlijk in de diepte hebben gedekt, moeten we enig begrip krijgen van de C++ code van onze backend om toepassingen te maken die nuttiger zijn dan wat we kunnen bereiken met pure QML.

Hier gaan we het hebben over het bestand main.cpp dat we hebben gemaakt in de pagina Beginnen zodat we beter begrijpen wat er gaande is in het centrale C++ bestand van onze toepassing. Terwijl dit een basis main.cpp is, blijven de functies die we bespreken essentieel ongeacht het soort toepassing dat u beslist te maken.

Wat het doet

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <QApplication>
#include <QQmlApplicationEngine>
#include <QtQml>
#include <QUrl>
#include <QQuickStyle>
#include <KLocalizedContext>
#include <KLocalizedString>
#include <KIconTheme>

int main(int argc, char *argv[])
{
    KIconTheme::initTheme();
    QApplication app(argc, argv);
    KLocalizedString::setApplicationDomain("tutorial");
    QApplication::setOrganizationName(QStringLiteral("KDE"));
    QApplication::setOrganizationDomain(QStringLiteral("kde.org"));
    QApplication::setApplicationName(QStringLiteral("Kirigami Tutorial"));
    QApplication::setDesktopFileName(QStringLiteral("org.kde.tutorial"));

    QApplication::setStyle(QStringLiteral("breeze"));
    if (qEnvironmentVariableIsEmpty("QT_QUICK_CONTROLS_STYLE")) {
        QQuickStyle::setStyle(QStringLiteral("org.kde.desktop"));
    }

    QQmlApplicationEngine engine;

    engine.rootContext()->setContextObject(new KLocalizedContext(&engine));
    engine.loadFromModule("org.kde.tutorial", "Main");

    if (engine.rootObjects().isEmpty()) {
        return -1;
    }

    return app.exec();
}

Ten eerste moeten we een aantal Qt header-bestanden invoegen, zodat we hun functies kunnen gebruiken. In dit geval voegen we een aantal Qt headers in die toepassingslogica behandelen en ons QML-bestanden te laten lezen.

Daarna maken we een QApplication exemplaar die we app noemen. Doorgeven van argc en argv door aan de constructor is vereist voor de aanroep.

We stellen ook enige metagegevens in gerelateerd aan de toepassing. Dit omvat de organisatie die de toepassing maakt, de website van de organisatie en de naam van de toepassing. We stellen deze eigenschappen in door QCoreApplication aan te roepen, waarmee een object wordt gemaakt dat komt van QCoreApplication en de event loop levert voor toepassingen ongeacht of ze een GUI hebben of niet (dus als we ons programma zonder GUI uitvoeren, dan zouden deze metagegevens nog steeds zijn ingesteld).

Om ons programma er goed uit te laten zien met KDE's Breeze pictogrammen en Breeze stijl in een niet-Plasma omgeving zoals Windows of GNOME, moeten we drie dingen doen:

• De thema-faciliteiten van KIconThemes initialiseren voor platforms waar icon thema's geen onderdeel zijn van het systeem (zoals Windows of MacOS) met KIconTheme::initTheme()
• De QStyle met QApplication::setStyle() zo instellen om te forceren dat Breeze word gebruikt in plaats van de eigen platform stijl
• Met QQuickStyle::setStyle() QtQuick Controle instellen om met qqc2-desktop-style het gebruik van Breeze af te dwingen.

Het aanroepen van KIconTheme::initTheme() moet gedaan worden voor de initialisatie van QApplication zodat het programma de Breeze-pictogrammen kan vinden die het wil gebruiken. Het omschakelen van de QStyle naar Breeze is nodig omdat we QApplication voor ons programma gebruiken in plaats van QGuiApplication. De gebruikte interface regelt dat in het venster dingen zoals knoppen en keuzevakjes de Breeze toepassen door qqc2-desktop-style te gebruiken.

De QQmlApplicationEngine) laat ons een toepassing laden uit een QML-bestand, wat we in de volgende regel doen. In engine.loadFromModule("org.kde.tutorial", "Main"); laden we onze QML uit het importeren van de URI gedefinieerd in CMake.

Vervolgens controleren we of onze engine juist het QML-bestand geladen heeft door te controleren dat de rootObjects()-lijst van de engine niet leeg is. Daarna kunnen we onze toepassing uitvoeren met app.exec().