Pàgina «Quant al»

Informació sobre la vostra aplicació

La pàgina «Quant al» permet tenir una pàgina que mostra les notes dels drets d'autor de l'aplicació juntament amb els col·laboradors i certa informació sobre la plataforma en la qual s'està executant.

Primer, crearem dos fitxers a la carpeta src/ anomenats about.cpp i about.h.

about.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#pragma once

#include <QObject>
#include <KAboutData>

class AboutType : public QObject
{
    Q_OBJECT
    Q_PROPERTY(KAboutData aboutData READ aboutData CONSTANT)

public:
    // [[nodiscard]]: Compiler-Warnung, wenn Funktion von einer "discard-value-expression" aufgerufen wird
    // https://en.cppreference.com/w/cpp/language/expressions#Discarded-value_expressions
    [[nodiscard]] KAboutData aboutData() const
    {
        return KAboutData::applicationData();
    }
};

En el fitxer .h crearem la classe AboutType, la qual s'hereta des de QObject.

La macro Q_OBJECT li indica al compilador que aquesta classe empra senyals i ranures pròpies, la macro Q_PROPERTY es comporta com un membre de dades de classe, però té característiques addicionals, permetrà que el nostre codi QML tingui accés a aquesta classe.

El mètode aboutData retornarà les dades de l'aplicació des de KAboutData.

about.cpp

1
#include "about.h"

En el fitxer .cpp senzillament inclourem el fitxer .h.

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
#include <QApplication>
#include <QQmlApplicationEngine>
#include <QtQml>
#include <QUrl>
#include <KAboutData>
#include <KLocalizedContext>
#include <KLocalizedString>

#include "about.h"

int main(int argc, char *argv[])
{
    // enables High DPI scaling
    QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

    // create QApplication instance called "app"
    QApplication app(argc, argv);

    // set metadata relating to the application
    // QCoreApplication provides the event loop for applications, regardless if app has a GUI or not
    KLocalizedString::setApplicationDomain("helloworld");
    QCoreApplication::setOrganizationName(QStringLiteral("KDE"));
    QCoreApplication::setOrganizationDomain(QStringLiteral("kde.org"));
    QCoreApplication::setApplicationName(QStringLiteral("Hello World"));

    KAboutData aboutData(
                         // The program name used internally.
                         QStringLiteral("helloworld"),
                         // A displayable program name string.
                         i18nc("@title", "Hello World"),
                         // The program version string.
                         QStringLiteral("1.0"),
                         // Short description of what the app does.
                         i18n("Hello world application"),
                         // The license this code is released under.
                         KAboutLicense::GPL,
                         // Copyright Statement.
                         i18n("(c) 2021"));
    aboutData.addAuthor(i18nc("@info:credit", "Your name"), i18nc("@info:credit", "Author Role"), QStringLiteral("your@email.com"), QStringLiteral("https://yourwebsite.com"));
    KAboutData::setApplicationData(aboutData);

    // lets us load an application from a qml file
    QQmlApplicationEngine engine;

    qmlRegisterSingletonType<AboutType>("org.kde.example", 1, 0, "AboutType", [](QQmlEngine *engine, QJSEngine *scriptEngine) -> QObject * {
        Q_UNUSED(engine)
        Q_UNUSED(scriptEngine)

        return new AboutType();
    });

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

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

    return app.exec();
}

En el fitxer cpp incloem KAboutData i acabem de crear el fitxer .h, KAboutData és un component central dels Frameworks del KDE que emmagatzema la informació sobre una aplicació, la qual després pot ser reutilitzada per molts altres components dels Frameworks del KDE. Instanciem un objecte nou KAboutData amb el seu constructor predeterminat força complet i afegim la informació de l'autor.

Una vegada s'ha establert tota la informació requerida, cridem a KAboutData::setApplicationData per a inicialitzar les propietats de l'objecte QApplication .

Després de la definició QML Engine, crearem una qmlRegisterSingletonType, el primer argument és un URI, bàsicament un nom de paquet, el segon i el tercer arguments són les versions major i menor respectivament, el quart és el nom del tipus, el nom que cridarem en accedir als mètodes de AboutType.

En la lambda qmlRegisterSingletonType només retornem un objecte AboutType nou.

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
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
import QtQuick 2.6
import QtQuick.Controls 2.0 as Controls
import QtQuick.Layouts 1.2
import org.kde.kirigami 2.13 as Kirigami

import org.kde.example 1.0

// Base element, provides basic features needed for all kirigami applications
Kirigami.ApplicationWindow {
	// ID provides unique identifier to reference this element
	id: root
	
	// Window title
	title: i18nc("@title:window", "Day Kountdown")

	// Global drawer element with app-wide actions
	globalDrawer: Kirigami.GlobalDrawer {
		// Makes drawer a small menu rather than sliding pane
		isMenu: true
		actions: [
			Kirigami.Action {
				text: i18n("Quit")
				icon.name: "gtk-quit"
				shortcut: StandardKey.Quit
				onTriggered: Qt.quit()
			},
			Kirigami.Action {
				text: i18n("About")
				icon.name: "help-about"
				onTriggered: pageStack.layers.push(aboutPage)
			}
		]
	}

	Component {
		id: aboutPage

		Kirigami.AboutPage {
			aboutData: AboutType.aboutData
		}
	}

	
	// ListModel needed for ListView, contains elements to be displayed
	ListModel {
		id: kountdownModel
	}
	
	// Fetches item from addEditSheet.qml and does action on signal
	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 called by 'edit' button on card and by 'add'-Action
	function openPopulateSheet(mode, index = -1, listName = "", listDesc = "", listDate = "") {
		addEditSheet.mode = mode
		addEditSheet.index = index;
		addEditSheet.name = listName
		addEditSheet.description = listDesc
		addEditSheet.kdate = listDate

		addEditSheet.open()
	}


	// Initial page to be loaded on app load
	pageStack.initialPage: Kirigami.ScrollablePage {
		// Title for the current page, placed on the toolbar
		title: i18nc("@title", "Kountdown")

		// Kirigami.Action encapsulates a UI action. Inherits from QQC2 Action
		actions.main: Kirigami.Action {
			id: addAction
			// Name of icon associated with the action
			icon.name: "list-add"
			// Action text, i18n function returns translated string
			text: i18nc("@action:button", "Add kountdown")
			// What to do when triggering the action
			onTriggered: openPopulateSheet("add")
		}
		
		// List view for card elements
		Kirigami.CardsListView {
			id: layout
			// Model contains info to be displayed
			model: kountdownModel
			// Delegate is how the information will be presented in the ListView
			delegate: KountdownDelegate {}
		}
	}
}

Primer, importem el paquet que definim en el fitxer main.cpp, afegim una Kirigami.Action al nostre calaix global que ens enviarà a la pàgina quant al i crearem un component amb una Kirigami.AboutPage en ell, la pàgina Quant al només en té una propietat: aboutData, després li passarem AboutType.aboutData.

CMakeLists

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
cmake_minimum_required(VERSION 3.16)
project(helloworld)

set(KF_MIN_VERSION "5.68.0")
set(QT_MIN_VERSION "5.12.0")

find_package(ECM ${KF_MIN_VERSION} REQUIRED NO_MODULE)

set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDECompilerSettings NO_POLICY_SCOPE)

find_package(Qt5 ${QT_MIN_VERSION} REQUIRED NO_MODULE COMPONENTS Core Quick Test Gui QuickControls2 Widgets)
find_package(KF5 ${KF_MIN_VERSION} REQUIRED COMPONENTS Kirigami2 I18n CoreAddons)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_subdirectory(src)

feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)

En el fitxer CMakeLists.txt de la carpeta de nivell superior, afegiu CoreAddons al mòdul find_package.

1
2
add_executable(helloworld main.cpp about.cpp resources.qrc)
target_link_libraries(helloworld Qt5::Quick Qt5::Qml Qt5::Gui Qt5::QuickControls2 Qt5::Widgets KF5::Kirigami2 KF5::I18n KF5::CoreAddons)

En el fitxer CMakeLists.txt a la carpeta src, afegiu about.cpp al mòdul add_executable i KF5::CoreAddons al mòdul target_link_libraries.

Executar l'aplicació

Ara, si executeu la vostra aplicació i activeu l'acció «About» en el calaix global, s'hauria de mostrar la nostra pàgina.

Captura de pantalla d'una pàgina «Quant al» creada amb el Kirigami