Pagina Info over

Informatie over uw toepassing

Kirigami.AboutPage biedt u een pagina die de melding over copyright van de toepassing toont samen met hen die bijdroegen en enige informatie over op welk platform het draait.

Eerst gaan we ons bestand main.cpp uit de vorige inleidingen bewerken.

main.cpp

 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <QApplication>
#include <QQmlApplicationEngine>
#include <QtQml>
#include <QUrl>
#include <KAboutData>
#include <KLocalizedContext>
#include <KLocalizedString>

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

    QApplication app(argc, argv);

    KLocalizedString::setApplicationDomain("helloworld");
    QCoreApplication::setOrganizationName(QStringLiteral("KDE"));
    QCoreApplication::setOrganizationDomain(QStringLiteral("kde.org"));
    QCoreApplication::setApplicationName(QStringLiteral("Hello World"));

    if (qEnvironmentVariableIsEmpty("QT_QUICK_CONTROLS_STYLE")) {
        QQuickStyle::setStyle(QStringLiteral("org.kde.desktop"));
    }

    KAboutData aboutData(
        QStringLiteral("helloworld"),
        i18nc("@title", "Hello World"),
        QStringLiteral("1.0"),
        i18n("Hello world application"),
        KAboutLicense::GPL,
        i18n("(c) 2021"));

    aboutData.addAuthor(
        i18nc("@info:credit", "Your name"),
        i18nc("@info:credit", "Author Role"),
        QStringLiteral("your@email.com"),
        QStringLiteral("https://yourwebsite.com"));

    // Set aboutData as information about the app
    KAboutData::setApplicationData(aboutData);

    // Register a singleton that will be accessible from QML.
    qmlRegisterSingletonType(
        "org.kde.example", // How the import statement should look like
        1, 0, // Major and minor versions of the import
        "About", // The name of the QML object
        [](QQmlEngine* engine, QJSEngine *) -> QJSValue {
            // Here we retrieve our aboutData and give it to the QML engine
            // to turn it into a QML type
            return engine->toScriptValue(KAboutData::applicationData());
        }
    );

    // Load an application from a QML file
    QQmlApplicationEngine engine;

    engine.rootContext()->setContextObject(new KLocalizedContext(&engine));
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));

    if (engine.rootObjects().isEmpty()) {
        return -1;
    }

    return app.exec();
}

In het bestand main.cpp voegen we KAboutData is een kerncomponent van KDE Frameworks die ons informatie over onze toepassing laat opslaan. Deze informatie kan daarna opnieuw gebruikt worden door vele andere KDE Frameworks-componenten. We maken een nieuw exemplaar van een object aboutData met zijn tamelijk volledige standaard constructor en voegen informatie over de auteur toe.

Nadat alle vereiste informatie is gezet, roepen we KAboutData::setApplicationData aan om de eigenschappen van het object QApplication .

Daarna maken we een qmlRegisterSingletonType() . Deze wordt gebruikt om ons toe te staan de C++ code als een module in onze main.qml met import org.kde.example 1.0 te importeren.

Zijn eerste argument is de URI die gebruikt zal worden voor het importeren, het tweede en het derde argument zijn respectievelijk majeure en mineure versies, het vierde is het type naam, de naam die we zullen aanroepen bij toegang tot ons type About en het laatste is een referentie naar het C++ object dat wordt blootgesteld aan QML. In het laatste geval gebruiken we een lambda om ter plekke en exemplaar te maken van de aboutData van onze toepassing.

main.qml

 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import QtQuick 2.15
import QtQuick.Controls 2.15 as Controls
import QtQuick.Layouts 1.15
import org.kde.kirigami 2.20 as Kirigami

import org.kde.example 1.0

Kirigami.ApplicationWindow {
    id: root

    title: i18nc("@title:window", "Day Kountdown")

    globalDrawer: Kirigami.GlobalDrawer {
        isMenu: true
        actions: [
            Kirigami.Action {
                text: i18n("Quit")
                icon.name: "gtk-quit"
                shortcut: StandardKey.Quit
                onTriggered: Qt.quit()
            },

            Kirigami.Action { // <==== Action to open About page
                text: i18n("About")
                icon.name: "help-about"
                onTriggered: pageStack.layers.push(aboutPage)
            }
        ]
    }

    Component { // <==== Component that instantiates the Kirigami.AboutPage
        id: aboutPage

        Kirigami.AboutPage {
            aboutData: About
        }
    }

    ListModel {
        id: kountdownModel
    }

    AddEditSheet {
        id: addEditSheet
        onAdded: kountdownModel.append({
            "name": name,
            "description": description,
            "date": Date.parse(kdate)
        });
        onEdited: kountdownModel.set(index, {
            "name": name,
            "description": description,
            "date": Date.parse(kdate)
        });
        onRemoved: kountdownModel.remove(index, 1)
    }

    function openPopulatedSheet(mode, index = -1, listName = "", listDesc = "", listDate = "") {
        addEditSheet.mode = mode
        addEditSheet.index = index;
        addEditSheet.name = listName
        addEditSheet.description = listDesc
        addEditSheet.kdate = listDate

        addEditSheet.open()
    }


    pageStack.initialPage: Kirigami.ScrollablePage {
        title: i18nc("@title", "Kountdown")

        actions.main: Kirigami.Action {
            id: addAction
            icon.name: "list-add"
            text: i18nc("@action:button", "Add kountdown")
            onTriggered: openPopulatedSheet("add")
        }

        Kirigami.CardsListView {
            id: layout
            model: kountdownModel
            delegate: KountdownDelegate {}
        }
    }
}

Ten eerste gebruiken we het geïmporteerde dat we definiëren in het bestand main.cpp, namelijk org.kde.example. Daarna voegen we een Kirigami.Action toe aan onze global drawer die ons naar de pagina About (Info over) zendt en een component met een Kirigami.AboutPage erin aanmaakt, die een object KAboutData::applicationData() verwacht. We stellen precies dat zichtbaar in onze main.cpp en noemen het About, zodat we het hier kunnen doorgeven.

CMakeLists

In het bestand CMakeLists.txt in onze hoofdmap, gaan we na dat CoreAddons in uw aanroep find_package() aanwezig is. Het is nodig voor KAboutData .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
add_executable(helloworld)

target_sources(helloworld PRIVATE
    main.cpp
    resources.qrc
)

target_link_libraries(helloworld
    Qt${QT_MAJOR_VERSION}::Quick
    Qt${QT_MAJOR_VERSION}::Qml
    Qt${QT_MAJOR_VERSION}::Gui
    Qt${QT_MAJOR_VERSION}::QuickControls2
    Qt${QT_MAJOR_VERSION}::Widgets
    KF${QT_MAJOR_VERSION}::Kirigami2
    KF${QT_MAJOR_VERSION}::I18n
    KF${QT_MAJOR_VERSION}::CoreAddons
)

In het bestand CMakeLists.txt in de map src/, is niets nodig omdat we ter plekken een exemplaar van onze aboutData hebben gemaakt.

De toepassing uitvoeren

Als u nu uw toepassing uitvoert en de actie "Info over" aanklikt in de globale schuiflade zou u uw pagina Info over moeten zien.

Schermafdruk van de pagina Info over van Kirigami

Verbindingslogica naar uw QML gebruikersinterface

Introductie tot Kirigami add-ons