Descubriendo main.cpp

El papel de main.cpp

Mientras que QML se usa para la interfaz de las aplicaciones de Kirigami, el motor se suele escribir en C++ gracias a la velocidad y flexibilidad de este lenguaje. Si bien en las páginas anteriores hemos cubierto QML con mucha profundidad, necesitaremos comprender nuestro código C++ del motor para crear aplicaciones que sean más útiles de lo que podemos lograr con QML puro.

Aquí repasaremos el archivo main.cpp que creamos en la página Primeros pasos para que podamos entender mejor lo que está sucediendo en el archivo central de C++ de nuestra aplicación. Aunque este es un main.cpp básico, las características que vamos a repasar seguirán siendo esenciales independientemente del tipo de aplicación que decida crear.

Lo que hace

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

Primero debemos incluir una serie de archivos de cabecera de Qt, lo que nos permite usar sus funciones. En este caso, incluimos una serie de cabeceras Qt que manejan la lógica de la aplicación y que nos permiten leer archivos QML.

A continuación creamos una instancia de una QApplication que llamaremos app. En esta llamada es necesario pasar argc y argv al constructor.

También definimos varios metadatos relacionados con la aplicación. Entre ellos, la organización que ha creado la aplicación, la página web de esta organización y el nombre de la aplicación. Definimos estas propiedades llamando a QApplication, creando una instancia de un objeto que viene de QCoreApplication y que proporciona el bucle de eventos de las aplicaciones, sin importar si disponen de una interfaz gráfica de usuario o no (de modo que si ejecutamos nuestro programa sin interfaz de usuario, estos metadatos también se definirían).

Para que nuestra aplicación se vea bien con los iconos Brisa y con el estilo Brisa de KDE en entornos distintos a Plasma, como Windows o GNOME, necesitamos hacer tres cosas:

• initialize the theming facilities of KIconThemes on platforms where icon themes aren't part of the system (like Windows or MacOS) with KIconTheme::initTheme()
• definir el QStyle con QApplication::setStyle() para forzar el estilo Brisa en lugar del estilo nativo de la plataforma,
• definir el estilo de los controles de QtQuick con QQuickStyle::setStyle() para forzar el uso de Brisa con qqc2-desktop-style de KDE.

The call to KIconTheme::initTheme() needs to be done before creating the QApplication and lets the app find Breeze icons to use. Setting the QStyle to Breeze is needed because we used QApplication for our app instead of QGuiApplication. Actual interface controls in the window like buttons and checkboxes will follow Breeze by using qqc2-desktop-style.

El QQmlApplicationEngine nos permite cargar una aplicación desde un archivo QML, lo que haremos en la siguiente línea. En engine.loadFromModule("org.kde.tutorial", "Main"); cargamos nuestro QML de la importación de URI definida en CMake.

Seguidamente, nos aseguramos de que nuestro motor ha cargado correctamente el archivo QML comprobando que la lista rootObjects() del motor no está vacía. En tal caso podemos ejecutar nuestra aplicación con app.exec().