Kirigami med Rust
Installera Kirigami
Innan vi börjar måste vi installera Kirigami och Rust på datorn.
sudo pacman -S cargo cmake extra-cmake-modules kirigami breeze qqc2-desktop-style | |
sudo zypper install cargo cmake kf6-extra-cmake-modules kf6-kirigami-devel qt6-quickcontrols2-devel kf6-qqc2-desktop-style | |
sudo dnf install cargo cmake extra-cmake-modules kf6-kirigami2-devel kf6-qqc2-desktop-style |
Ytterligare information för andra distributioner finns här.
Projektstruktur
Först skapar vi vår projektkatalog (du kan använda kommandona nedan). Vi kallar vår kirigami_rust/
.
kirigami_rust/
├── CMakeLists.txt
├── Cargo.toml
├── build.rs
├── org.kde.kirigami_rust.desktop
└── src/
├── main.rs
└── qml/
└── Main.qml
Projektet använder CMake för att anropa Cargo, som i sin tur bygger projektet.
Om CMake och Cargo
Det här är inte det traditionella sättet att bygga ett Rust-projekt: tekniskt sett behövs bara Cargo för att bygga det, vanligtvis med cargo build
och cargo run
.
För skrivbordsprogram behövs dock CMake (eller motsvarande program som Meson som används av GNOME eller Just som används av COSMIC) för installation eftersom Cargo saknar de nödvändiga funktionerna för att installera skrivbordsprogram med grafiskt användargränssnitt.
Projektet kallas kirigami_rust
och det genererar en körbar fil som heter kirigami_hello
.
💡 Tips
För att snabbt skapa katalogstrukturen, kör bara:mkdir -p kirigami_rust/src/qml/
.org.kde.kirigami_rust.desktop
Det primära syftet med Desktop Entry-filer är att visa programmet i programstart på Linux. En annan anledning att ha dem är att ha fönsterikoner på Wayland, eftersom de måste tala om för sammansättningen att "det här fönstret hör ihop med den här ikonen".
Det måste följa ett omvänt domännamnsschema följt av tillägget .desktop
såsom org.kde.kirigami_rust.desktop
:
|
|
CMakeLists.txt
Filen CMakeLists.txt
används för att köra Cargo och för att installera nödvändiga filer tillsammans med vårt program. Den tillhandahåller också vissa livskvalitetsfunktioner, som att se till att Kirigami installeras under kompilering och för att signalera till Linux-distributioner att installera nödvändiga beroenden med programmet.
|
|
Det första vi gör är att lägga till KDE:s Extra CMake Modules (ECM) i vårt projekt så att vi kan använda ecm_find_qml_module för att kontrollera att Kirigami är installerat när vi försöker bygga programmet, och om det inte är det misslyckas programmet omedelbart. En annan användbar ECM-funktion är ECMUninstallTarget, som gör det möjligt att enkelt avinstallera programmet med CMake om så önskas.
Vi använder också CMake find_package() för att säkerställa att vi har qqc2-desktop-style, KDE:s QML-stil för skrivbordet. Det är en av de två anledningarna till att vi använder CMake i den här handledningen.
Vanligtvis byggs Rust-projekt med Cargo, och det är inte annorlunda här. Vi skapar ett mål som helt enkelt kör Cargo när det körs, och markerar det med ALL
så att det normalt byggs. Cargo bygger den körbara filen inuti CMake binärkatalogen (vanligtvis build/
).
För mer information om CMake, mål och binärkatalogen, se Bygga KDE-programvara manuellt.
Efter det installerar vi helt enkelt den körbara filen kirigami_rust
som genererats av Cargo i binärkatalogen och installerar den i BINDIR
, som vanligtvis är /usr/bin
, /usr/local/bin
eller ~/.local/bin
. Vi installerar också den nödvändiga skrivbordsfilen i APPDIR
, som vanligtvis är /usr/share/applications
eller ~/.local/share/applications
. Det är den andra anledningen till att vi använder CMake i den här handledningen.
För mer information om var KDE-programvara är installerad, se Bygga KDE-programvara manuellt: Installationssteget.
Nu när vi har tagit hand om CMake, låt oss titta på filerna vi ska spendera den största delen av tiden att arbeta med.
Cargo.toml
Därefter har vi en väldigt enkel Cargo.toml
:
|
|
Den består av projektets metadata och en lista över beroenden som hämtas automatiskt av Cargo, nämligen cxx
och cxx-qt
, vilka är nödvändiga för att köra Qt-program skrivna i Rust.
build.rs
Medan man vanligtvis registrerar QML-element med QML_ELEMENT och ecm_add_qml_module med hjälp av deklarativ registrering i C++, måste man deklarera det i ett byggskript build.rs i Rust:
|
|
Det är nödvändigt för att göra QML-filen tillgänglig för startpunkten i vårt program, main.rs
.
src/main.rs
Filen kirigami_rust/src/main.rs
initierar projektet och laddar sedan QML-filen, som programmets användargränssnitt består av.
|
|
Den första delen som är markerad med Rust-makrot #[cxx_qt::bridge] skapar bara ett QObject från en Rust-struktur. Den behövs bara för att slutföra användningen av QmlModule i det tidigare byggskriptet build.rs
. Den spelar en större roll i en framtida handledning som lär ut hur man exponerar Rust-kod i QML, men för tillfället kan du ignorera det.
Efter det börjar den viktiga delen:
Raderna 12-13 importerar de nödvändiga Qt-biblioteken som exponeras via cxx-qt.
Vi skapar först en ny instans av en QApplication
och utför sedan några integreringar på raderna 20-26.
Sedan kommer den del som faktiskt skapar programfönstret:
|
|
Den långa webbadressen qrc:/qt/qml/org/kde/tutorial/src/qml/Main.qml
motsvarar filen Main.qml
enligt Qt:s resurssystem, och följer det här schemat: <resurs_prefix><import_webbadress><QML_katalog><fil>
.
Med andra ord: det vanliga resursprefixet qrc:/qt/qml/
+ importsökvägen org/kde/tutorial
(anges i build.rs
, separerade med snedstreck istället för punkter) + QML-katalogen src/qml/
+ QML-filen Main.qml
.
src/qml/Main.qml
|
|
Här är stället där vi hanterar vårt förgrundsprogram.
Om du kan lite Javascript ser mycket av QML bekant ut (även om det har sina egenheter). Qt:s dokumentation har en omfattande mängd material om språket om du känner för att prova något på egen hand. Genom alla de här handledningarna kommer vi att fokusera mycket av vår uppmärksamhet på vår QML-kod, där vi kan använda Kirigami för att få ut så mycket som möjligt av den.
Låt oss för tillfället fokusera på Main.qml
. Först importerar vi ett antal viktiga moduler:
- QtQuick, standardbiblioteket som används i QML-program.
- QtQuick Controls, som tillhandahåller ett antal standardkontroller som vi kan använda för att göra vårt program interaktivt.
- QtQuick Layouts, som tillhandahåller verktyg för att placera komponenter inom programmets fönster.
- Kirigami, som tillhandahåller ett antal komponenter lämpade för att skapa program som fungerar över apparater av olika form och storlek.
Anmärkning
Att placera QtQuick-kontroller och Kirigami-import i separata namnrymder med nyckelordetas
är bästa praxis för att säkerställa att inga komponenter med samma namn kan orsaka konflikt. Du kan se olika namn för QtQuick Controls i verkligheten, såsom "QQC" eller "QQC2". Vi använder "Controls" i handledningen för tydlighetens skull.Sedan kommer vi till vårt baselement, Kirigami.ApplicationWindow som tillhandahåller några grundfunktioner nödvändiga för alla Kirigami-program. Det är fönstret som kommer att innehålla alla våra sidor, huvuddelen av vårt användargränssnitt.
Vi ställer sedan in fönstrets egenskap id
till 'root'. Identifierare är användbara eftersom de låter oss referera till en komponent unikt, även om vi har flera av samma typ.
Vi ställer också in fönstrets egenskap title
till "Hello World".
Därefter anger vi första sidan i vår sidstapel. Del flesta Kirigami-program är organiserade som en stapel av sidor, där varje sida innehåller relaterade komponenter anpassade för en viss uppgift. För närvarande låter vi det vara enkelt, och håller oss till en enda sida. pageStack är en sidstapel som initialt är tom som Kirigami.ApplicationWindow tillhandahåller, och med pageStack.initialPage: Kirigami.Page {...}
ställer vi in den första sidan som presenteras när programmet laddas i en Kirigami.Page. Sidan står för allt vårt innehåll.
Slutligen inkluderar vi en Controls.Label på vår sida, som låter oss placera text på den. Vi använder anchors.centerIn: parent
för att centrera vår beteckning horisontellt och vertikalt inom vårt överliggande element. I det här fallet är det överliggande elementet för Controls.Label
vår Kirigami.Page. Det sista vi behöver göra är att ange texten: text: "Hello World!"
.
Kompilera och installera programmet
Den genererade körbara filen kirigami_hello
finns i build/debug/kirigami_hello
och man kan köra den direkt eller med cargo run
, men den saknar en fönsterikon. För att åtgärda det installerar vi först programmet.
Kör följande:
cmake -B build --install-prefix ~/.local
cmake --build build/
cmake --install build/
Med det första kommandot söker CMake efter Kirigami och qqc2-desktop-style.
Med det andra kommandot bygger CMake målet kirigami_rust
, som bara anropar cargo build --target-dir build/
. Steget tar en stund att slutföra, men nästa gång det andra CMake-kommandot upprepas går det snabbare eller så behöver det inte alls kompileras.
I det tredje steget installerar CMake den körbara filen kirigami_hello
i ~/.local/bin/kirigami_hello
och skrivbordsfilen i ~/.local/share/applications
, och en ny post med namnet "Kirigami Tutorial in Rust" visas i menyn.
Öppna menyalternativet och voilà! Nu dyker ditt allra första Kirigami-program upp framför dina ögon.
För att köra den nya QML-applikationen i mobilläge kan man använda QT_QUICK_CONTROLS_MOBILE=1
:
QT_QUICK_CONTROLS_MOBILE=1 kirigami_hello
Om du har kompilerat projektet manuellt med CMake och av någon anledning vill avinstallera projektet kan du köra:
cmake --build build/ --target uninstall