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:

• iniciar el servicio de tematización de [KIconThemes](https://invent.kde. org/frameworks/kiconthemes) en las plataformas en las que los temas de iconos no forman parte del sistema (como Windows o macOS) con 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.

La llamada a KIconTheme::initTheme() se debe hacer antes de crear la QApplication y permite que la aplicación encuentre los iconos de Brisa para poder usarlos. Definir el QStyle a Brisa es necesario porque hemos usado QApplication para nuestra aplicación en lugar de QGuiApplication. Los controles reales de la interfaz de la ventana, como botones y casillas de verificación, usarán Brisa mediante 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().