Capire main.cpp

Il ruolo di main.cpp

Mentre QML viene usato come interfaccia per applicazioni in Kirigami, di solito il motore è scritto in C++: questo per poter sfruttare la velocità e la flessibilità del linguaggio. Sebbene nella pagina precedente abbiamo trattato QML in modo molto approfondito, dovremo acquisire una comprensione del codice del motore in C++ se vogliamo creare delle applicazioni che siano più utili di quelle che potremmo creare solamente con QML.

Qui esamineremo il file main.cpp che abbiamo creato nella pagina Getting Started in modo da poter comprendere meglio cosa sta succedendo nel file C++ centrale della nostra applicazione. Sebbene si tratti di un main.cpp di base, le funzionalità che esamineremo rimarranno essenziali indipendentemente dal tipo di applicazione che decidi di creare.

Che cosa fa

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

Per prima cosa dobbiamo includere una serie di Qt file header, permettendoci di utilizzare le loro funzioni. In questo caso, includiamo una serie di intestazioni Qt che gestiscono la logica dell'applicazione e ci consentono di leggere i file QML.

Creiamo quindi un'istanza QApplication che chiamiamo app. Per la chiamata è necessario passare argc e argv al costruttore.

Impostiamo inoltre alcuni metadati relativi all'applicazione. Questi includono l'organizzazione che ha creato l'applicazione, il sito Web dell'organizzazione e il nome dell'applicazione. Impostiamo queste proprietà chiamando QApplication, istanziando un oggetto che proviene da QCoreApplication e fornisce il loop di eventi per le applicazioni indipendentemente dal fatto che abbiano o meno una GUI (quindi se eseguissimo il nostro programma senza GUI, questi metadati verrebbero comunque impostati).

Per far sì che la nostra app abbia un bell'aspetto con le icone Breeze e lo stile Breeze di KDE su ambienti non Plasma come Windows o GNOME, dobbiamo fare tre cose:

• inizializza le strutture dei temi di KIconThemes su piattaforme in cui i temi delle icone non fanno parte del sistema (come Windows o MacOS) con KIconTheme::initTheme()
• imposta QStyle con QApplication::setStyle() per forzare Breeze invece dello stile della piattaforma nativa
• imposta lo stile dei controlli QtQuick con QQuickStyle::setStyle() per forzare Breeze con qqc2-desktop-style di KDE.

La chiamata a KIconTheme::initTheme() deve essere eseguita prima di creare QApplication e consente all'applicazione di trovare le icone Brezza da utilizzare. L'impostazione di QStyle su Brezza è necessaria perché abbiamo utilizzato QApplication per la nostra applicazione invece di QGuiApplication. I controlli effettivi dell'interfaccia nella finestra come pulsanti e caselle di controllo seguiranno Brezza utilizzando qqc2-desktop-style.

Il QQmlApplicationEngine ci consente di caricare un'applicazione da un file QML, cosa che faremo nella riga successiva. In engine.loadFromModule("org.kde.tutorial", "Main"); carichiamo il nostro QML dall'importazione URI definita in CMake.

Successivamente, controlliamo se il nostro motore ha caricato correttamente il file QML controllando che l'elenco rootObjects() del motore non sia vuoto. Possiamo quindi eseguire la nostra applicazione con app.exec().