Descobrindo o main.cpp

Compreendendo o arquivo central do nosso código de backend

O papel do main.cpp

Embora o QML seja usado para o front-end de aplicativos Kirigami, o back-end é geralmente escrito em C++, graças à velocidade e flexibilidade dessa linguagem. Embora nas páginas anteriores tenhamos abordado o QML com bastante profundidade, precisaremos obter uma compreensão do nosso código C++ de back-end para criar aplicativos que sejam mais úteis do que o que podemos alcançar com QML puro.

Aqui, revisaremos o arquivo main.cpp que criamos na página Introdução para que possamos entender melhor o que está acontecendo no arquivo C++ central do nosso aplicativo. Embora este seja um main.cpp básico, os recursos que abordaremos permanecerão essenciais, independentemente do tipo de aplicativo que você decidir criar.

O que ele faz

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

Primeiro, precisamos incluir uma série de arquivos de cabeçalho do Qt, permitindo-nos usar suas funções. Neste caso, incluímos uma série de cabeçalhos do Qt que lidam com a lógica da aplicação e que nos permitem ler arquivos QML.

Em seguida, criamos uma instância de QApplication que chamamos de app. Passar argc e argv para o construtor é necessário para a chamada.

Também definimos alguns metadados relacionados ao aplicativo. Estes incluem a organização que criou o aplicativo, o site da organização e o nome do aplicativo. Definimos essas propriedades chamando QApplication, instanciando um objeto que vem de QCoreApplication e fornece o loop de eventos para aplicativos, independentemente de terem ou não uma interface gráfica (GUI) (portanto, se executássemos nosso programa sem a GUI, esses metadados ainda seriam definidos).

Para que nosso aplicativo tenha uma boa aparência com os ícones Breeze e o estilo Breeze do KDE em ambientes que não sejam Plasma, como Windows ou GNOME, precisamos fazer três coisas:

inicializar os recursos de temas do KIconThemes em plataformas onde os temas de ícones não fazem parte do sistema (como Windows ou MacOS) com KIconTheme::initTheme()
definir o QStyle com QApplication::setStyle() para forçar o Breeze em vez do estilo nativo da plataforma
definir o estilo dos controles QtQuick com QQuickStyle::setStyle() para forçar o Breeze com o qqc2-desktop-style do KDE

A chamada para KIconTheme::initTheme() precisa ser feita antes da criação do QApplication e permite que o aplicativo encontre os ícones do Breeze para usar. Definir o QStyle para Breeze é necessário porque usamos QApplication para nosso aplicativo em vez de QGuiApplication. Os controles de interface reais na janela, como botões e caixas de seleção, seguirão o Breeze usando qqc2-desktop-style.

O QQmlApplicationEngine nos permite carregar um aplicativo a partir de um arquivo QML, o que faremos na próxima linha. Em engine.loadFromModule("org.kde.tutorial", "Main");, carregamos nosso QML a partir da importação URI definida no CMake.

Em seguida, verificamos se nosso mecanismo carregou corretamente o arquivo QML, verificando se a lista rootObjects() do mecanismo não está vazia. Podemos então executar nossa aplicação com app.exec().

Compreendendo o CMakeLists

Página Sobre