Förstå sig på main.cpp

Rollen som main.cpp har

Medan QML används för förgrunden i Kirigami-program, är bakgrundskoden oftast skriven i C++ tack vare språkets snabbhet och flexibilitet. Medan vi har täckt QML på djupet på de tidigare sidorna, behöver vi förstå vår C++ bakgrundskod för att kunna skapa program som är användbarare än vad vi kan åstadkomma med ren QML.

Här går vi igenom filen main.cpp vi skapade på sidan Komma igång så att vi bättre förstår vad som händer i programmets centrala C++ fil. Även om det är en grundläggande main.cpp, förblir funktionerna vi går igenom väsentliga oberoende av vilket sorts program du bestämmer dig för att skapa.

Vad den gör

 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();
}

Först måste vi inkludera ett antal Qt deklarationsfiler, vilket låter oss använda deras funktioner. I detta fall, inkluderade vi ett antal Qt deklarationsfiler som hanterar programlogik, och låter oss läsa QML-filer.

Därefter skapar vi en instans av QApplication , som vi kallar app. Att skicka argc och argv till konstruktorn krävs för anropet.

Vi anger också in en del metadata för programmet. De inkluderar organisationen som skapade programmet, organisationens webbplats och namnet på programmet. Vi anger egenskaperna genom att anropa QApplication , för att instansiera ett objekt som kommer från QCoreApplication och som tillhandahåller händelseslingan för program oavsett om de har ett grafiskt användargränssnitt eller inte (så om vi körde vårt program utan grafiskt användargränssnitt, skulle metadata fortfarande användas).

För att få vårt program att se bra ut med KDE:s Breeze-ikoner och Breeze-stil på andra miljöer än Plasma, såsom Windows eller GNOME måste vi göra tre saker:

• initiera temafunktionerna i KIconThemes på plattformar där ikonteman inte är en del av systemet (som Windows eller MacOS) med KIconTheme::initTheme()
• ställa in QStyle med QApplication::setStyle() för att tvinga användning av Breeze istället för den inbyggda plattformsstilen
• ställa in stilen QtQuick Controls med QQuickStyle::setStyle() för att tvinga användning av Breeze med KDE:s qqc2-desktop-style

Anropet till KIconTheme::initTheme() måste göras innan QApplication skapas och låter programmet hitta Breeze-ikoner att använda. Att ställa in QStyle till Breeze behövs eftersom vi använde QApplication för vårt program istället för QGuiApplication . De verkliga gränssnittsobjekten i fönstret som knappar och kryssrutor följer Breeze genom att använda qqc2-desktop-style.

QQmlApplicationEngine låter oss ladda ett program från en QML-fil, vilket vi gör på nästa rad. Med engine.loadFromModule("org.kde.tutorial", "Main"); laddar vi vår QML från webbadressen import definierad i CMake.

Därefter kontrollerar vi om vårt gränssnitt har läst in QML-filen riktigt genom att kontrollera att gränssnittets lista rootObjects() inte är tom. Vi kan därefter köra vårt program med app.exec() .