Getting Started Programming with QML/hu
Az alant olvasható leírás rev. 0.2 verziót visel, ezzel is jelezve, hogy a jövőben szeretnénk még csiszolni rajta :)
Bevezetés a QML programozásba
Üdvözöllek a QML világában, mely egy UI leíró nyelv! Ebben a bevezetőben egy egyszerű szövegszerkesztő alkalmazást fogunk létrehozni a QML segítségével. Ezen útmutató olvasása után már készen fogsz állni, hogy kifejleszd a saját alkalmazásaidat a QML és a Qt keretrendszer segítségével.
Felhasználói felület létrehozása QML nyelven
Példa alkalmazásunk egy egyszerű szövegszerkesztő lesz, amely alkalmas egyszerű szövegfájlok megnyitására illetve alapvető szerkesztési műveletek elvégzésére. A leírás első részében a program felhasználói felületét tervezzük meg a QML leírónyelv segítségével. A második részben a fájlok betöltése és elmentése lesz implementálva C++ nyelven. A Qt Meta-Object System [doc.qt.nokia.com] segítségével a C++ függvényeket olyan tulajdonságokként ábrázolhatjuk, melyeket a QML elemek is képesek használni. QML és Qt C++ használatával hatékonyan szétválaszthatjuk a kezelői felület felépítését és a program logikáját.
QML példakódunk futtatásához csupán adjuk meg argumentumként a qmlviewer [doc.qt.nokia.com] programnak a QML fájlunkat. Ezen útmutató C++ része feltételezi, hogy az olvasó le tud fordítani egy Qt-ban írt programot.
Az útmutató fejezetei:
- Nyomógomb és menü létrehozása
- Menüsáv implementálása
- Szövegszerkesztő létrehozása
- A szövegszerkesztő küllemének megteremtése
- QML kibővítése Qt C++ segítségével
Nyomógomb és menü létrehozása
Alapelemek – a gomb
Szövegszerkesztőnket egy gomb létrehozásával kezdjük. Ha funkcionálisan nézzük, akkor a gomb rendelkezik egy egér számára érzékeny területtel és egy felirattal. A gombok akkor hajtják végre a feladatokat, ha a felhasználó rájuk klikkel. QML-ben a legalapvetőbb vizuális elem a Rectangle [doc.qt.nokia.com]. A Rectangle elem tulajdonságokkal rendelkezik, hogy beállíthassunk az elem megjelenését és elhelyezkedését.
Először az import Qt 4.7 sor engedélyezi a qmlviewer eszköznek, hogy betöltse azokat a QML elemeket, melyeket később használni fogunk. Ennek a sornak szerepelnie kell minden QML fájlban! Figyeljük meg, hogy a Qt modulok verzióját az import utasítás már tartalmazza!
Ez az egyszerű Rectangle rendelkezik egy egyedi azonosítóval, simplebutton, amely az id tulajdonsághoz kötődik. A Rectangle elem tulajdonságaihoz értékeket rendelünk a tulajdonság kilistázásakor, ekkor a kettőspont után áll az érték. A mintakódban a grey (szürke) színt rendeltük a Rectangle color tulajdonságához. Hasonlóan járunk el a Rectangle width és height tulajdonságainak esetében.
A Text elem egy nem szerkeszthető szövegmező. Nevezzük el buttonlabel-ként ezt a Text elemet. A szövegmezőben lévő szöveget a Text tulajdonság segítségével módosíthatjuk. A feliratot a Rectangle tárolja és hogy középre igazítsuk, a Text elem anchors tuljadonságát a szülőjéhez rendeljük, ami itt most a simplebutton. Az anchor-ok (kapcsok) olykor más elemek anchor-jaihoz kötődnek, hogy leegyszerűsítsék az elrendezést.
Most mentsük el a kódot SimpleButton.qml néven. Futtassuk a qmlviewer-t a fájlunkat argumentumként megadva. Egy szürke téglalapot fogunk látni, benne a feliratunkkal.
A gombnyomás funkciójának implementálására használhatjuk a QML eseménykezelő metódusát. A QML esemény kezelése nagyon hasonlít a Qt signal and slot mechanizmusára. Példánkban az onClicked handlerben kezeljük le az eseményt.
Létrehozunk egy MouseArea elemet a simplebutton-on belül. A MouseArea elem meghatározza azt az interaktív területet, ahol érzékelni fogjuk majd az egérkattintásokat. Gombunk esetében az egész MouseArea-t a szülőjéhez kapcsoljuk, ami most a simplebutton. Az anchors.fill szintaktika is egy mód, hogy elérjünk egy bizonyos tulajdonságot (fill), az anchors tulajdonságokon belül. A QML kapocs alapú vázat használ, ahol az egyes elemek más elemekhez kapcsolhatók, így robosztus vázakat hozhatunk létre.
A MouseArea-nak sok jelfeldolgozója ún. handler-je van, amelyek a meghatározott MouseArea határain belül történő egér események hatására hívódnak meg. Ezek közül az egyik az onClicked, amely a gomb megnyomásakor hívódik meg, alapértelmezésben ez itt a bal gomb. Műveleteket is köthetünk az onClicked handler-jéhez. A példánkban, a console.log() szöveget ír a kimenetre, akárhányszor ráklikkelünk a MouseArea területére. A console.log() függvény egy nagyon hasznos eszköz hibakeresésre, segítségével bármit kiírathatunk a konzolba.
A SimpleButton.qml kódja már képes arra, hogy megjelenítsen egy gombot és szöveget írjon képernyőre klikkeléskor.
Egy teljesen működő gomb a Button.qml fájlban található. Ebben a leírásban szereplő kódrészlet mellőz néhány részletet, mert azokat már vagy tárgyaltuk az előzőekben vagy irreleváns a kód értelmezése szempontjából.
Egyedi tulajdonságokat a tulajdonság típus név szintaktikával tudunk deklarálni. Kódunkban a color típusú buttonColor tulajdonsághoz a „lightblue”-t rendeljük. A buttonColor később lesz használva egy kiegészítő műveletben, hogy meghatározzuk a gomb kitöltési színét. Megemlítendő, hogy értékadás az = jellel is történhet a kettőspont helyett. Az egyedi tulajdonságok lehetővé teszik, hogy belső elemek kívülről hozzáférhetőek legyenek, a Rectangle hatósugarán kívül is. A QML-nek megvannak a maga alaptípusai, mint az int, a real, a string, vagy az általános konténertípus a variant.
Színeket hozzáadva az onEntered és az onExited jelkezelőkhöz, a gomb szegélye sárgává fog válni, amikor az egér a gomb fölé ér, és visszaáll az eredeti színre, ha a kurzor távozik a területéről.
Egy buttonClick() signalt is deklarálunk a Button.qml-ben a signal neve elé tett signal kulcsszóval. Minden signal-nak automatikusan létrejön a handler-je, „on”-al kezdődő nevekkel. Így értelemszerűen az onButtonClicked a buttonClicked handler-je. Ezután az onButtonClicked-edet összekötjük egy művelettel, hogy az megfelelően működhessen. A mi gomb-példánkban egérkattintásra az onClicked handlerje szimplán meg fogja hívni az onButtonClick függvényt, mely megjelenít egy szöveget. Az onButtonClick lehetővé teszi, hogy külső objektumok könnyedén hozzáférjenek a Button klikkelési területéhez. Például egy elemnek több MouseArea deklarációja is van és a ButtonClick signal jobban el tudja végezni a megkülönböztetést a több MouseArea handler között.
Most már megvan az alaptudásunk, hogy implementáljunk olyan elemeket QML-ben, melyek képesek lekezelni alap egérműveleteket. Hozzunk létre egy Text feliratot egy Rectangle-ben, szabjuk testre a tulajdonságait és implementáljuk az egérmozgásokra válaszoló műveleteit. Ez az alapelv, hogy elemeket hozunk létre más elemeken belül, végig fogja kísérni a szövegszerkesztő programunkat. Ám ez a gomb haszontalan, amíg nem műveletek ellátására szolgáló komponensként használjuk. A következő részben létrehozunk egy menüt, mely több ilyen gombot is tartalmazni fog.
Menü létrehozása
Eddig a részig áttekintettük, hogyan hozzunk létre elemeket és kössünk hozzájuk műveleteket egy QML fájlon belül. Ebben a fejezetben megtanuljuk, hogyan importáljunk QML elemeket és hogyan használjuk fel ezeket a komponenseket újra, hogy újabb komponenseket hozzunk létre.
Egy menü egy lista tartalmát jeleníti meg, mindegyik elemnek megvan a lehetősége, hogy végrehajtson egy feladatot. QML-ben sokféleképpen hozhatunk létre menüket. Először egy, a gombokat tartalmazó menüt fogunk készíteni, melyek különböző műveleteket hajtanak majd végre. A menü kódja a FileMenu.qml-ben található.
A fent használt szintaktika megmutatja, hogyan használjuk az import parancsot. Olyan JavaScript vagy QML fájlok használatakor van szükségünk rá, melyek nem ugyanabban a mappában vannak. Mivel a Button.qml ugyanabban a mappában van, mint a FileMenu.qml, így nem kell importálnunk a button.qml-t, hogy használhassuk. Azonnal létrehozhatunk egy Button elemet a Button { } függvényt deklarálva, hasonlóan a Rectangle { }-hoz.
A FileMenu.qml-ben deklaráljunk egy Row elemen belül 3 Button elemet. A Row egy pozícionáló elem, ami egy vízszintes sorban rendezi el a gyerekeit.
A Button deklarációja a Button.qml-ben van, ami ugyan az a Button.qml, amit mi az előző fejezetben használtunk. Új tulajdonságkötéseket deklarálhatunk az újonnan létrehozott gombokban, hatékonyan felülírva a Button.qml-ben beállított tulajdonságokat. Az Exit gomb megnyomásának hatására ki fog lépni a program és bezárja az ablakot. Gondoljuk végig, hogy a Button.qml-ben lévő onButtonClick signal handler is meg lesz hívva az exitButton-ban lévő onButtonClick handleren kívül.
A Row.t a Rectangle.en belül deklaráljuk, ezzel létrehozunk egy Rectangle- tárolót a gombok sorának. A második _Rectangle létrehozása a menü gombjainak egy sorban történő tárolására indirekt módon történik. A Edit menü nagyon hasonló ebben a fázisban. Ez a menu is 3 gombot fog tartalmazni a következő nevekkel: Copy, Paste, Select All.
Most, hogy tudjuk hogyan importáljuk és szabjuk testre az előzőleg már létrehozott komponenseiket, már elkészíthetjük a menüsorunkat, mely a menüpontok kiválasztására szolgáló gombokból fog állni. Nézzük meg, hogyan rendszerezzük adatainkat a QML-ben!
A menüsor implementálása
Szövegszerkesztőnknek meg kell tudni jelenítenie a menüket a menüsorból. A menüsoron kiválaszthatja a felhasználó, hogy melyik menüt jelenítse meg a program. A menük közötti váltásból következik, hogy az egy sorba rendezésnél bonyolultabb struktúrával fog rendelkezni a menünk.
Adatmodellek (Data Models) és adatnézetek (Data Views) használata:
Különböző Data View [doc.qt.nokia.com] -kal rendelkezik a QML a Data Model [doc.qt.nokia.com] -ek megjelenítésére. Menüsorunk listaként fogja megjeleníteni a kiválasztott menüt egy fejléccel, ahol többi menü nevét soroljuk fel vízszintesen. A menülistánk egy VisualItemModel [doc.qt.nokia.com] -ben lesz deklarálva, mely olyan elemeket tartalmaz, melyek már eleve rendelkeznek valamilyen megjelenéssel, mint például egy Rectangle vagy egy importált UI elem. Más modell típusoknak, mint például a ListModel [doc.qt.nokia.com], egy megbízott kell, hogy megjelenítse az adatait. Két vizuális elemet deklarálunk a menuListModel-ünkben, a FileMenu-t és az EditMenu-t. Testreszabjuk a két menüt és megjelenítjük őket a ListView [doc.qt.nokia.com] -val. A Menubar.qml fájlunk tartalmazza a QML deklarálását és egy egyszerű szerkesztői menüt, melyet az EditMenu.qml-ben hoztunk létre.
A ListView elem egy megbízotton keresztül fogja megjeleníteni a modellünket. A megbízott lehet hogy meghatározza, hogy például egy sorban vagy egy hálóban jelenítse meg az elemeket. A mi menuListModel-ünknek már vannak látható elemei, így nekünk nem kell megbízottat deklarálnunk hozzá.
A Flickable [doc.qt.nokia.com] -ből örököljük a ListView-unkat, ezzel a listánk reagálhat majd az egérmozdulatokra és más gesztusokra. Fenti kódunk utolsó része beállítja a Flickable tuljadonságait, hogy létrehozzunk a nézetünk kívánt kinetikus mozgását. A highLightMovementDuration tuljadonság meghatározza, hogy meddig tartson a kinetikus transzformáció. Egy nagyobb highLightMovementDuration érték lassabb menüváltást fog eredményezni. A ListView a modell minden egyes elemét egy indexszel látja el a deklarálásuk sorrendjében, melyeket ezeken az indexeken keresztül érhetünk el. A currentIndex értékének megváltoztatásával a ListView egy másik elemét jelöljük ki. A menüsor fejlécére is hatással lesz ez az effektus. Két gomb van egy sorban, melyek mindketten megváltozatják a megjelenített menüt, ha rájuk klikkelünk. A filebutton-ra kattintva megjelenik a fálj menü, az index pedig 0 lesz, mivel a FileMenu-t deklaráltuk először. A labelList rectangle-jének van egy z értéke, mely itt 1, ezzel jelölve, hogy ezt a menüsor előtt jelenítjük meg. Minél nagyobb a z értéke, annál előrébb foglal helyet a képernyőre merőleges síkban. A z alapértelmezett értéke 0.
A létrehozott menüsorunkon vagy a felette lévő két gomb valamelyikére klikkelve megjeleníthetjük a menüket. Így egy intuitív és interaktív menüválasztó képernyőt alkottunk.
A szövegszerkesztő megalkotása
TextArea deklarálása
Szövegszerkesztőnk mindaddig nem szövegszerkesztő, amíg nem tartalmaz egy szerkeszthető szövegmezőt.
A QML TextEdit [doc.qt.nokia.com] eleme egy többsoros szövegmező létrehozását teszi lehetővé. A TextEdit különbözik a Text [doc.qt.nokia.com] elemtől, melyet a felhasználó nem szerkeszthet direkt módon.
A szerkesztőnek megvan a saját betűszín tulajdonsága is. A TextArea egy flickable mezőn belül van, mely görgetni fogja a szöveget, ha a szövegkurzor a látható mezőn kívül van. Az ensureVisibility() függvény fogja leellenőrizni, hogy a kurzor rectangle-je kívül van-e a látható szegélyeken, és ha igen, akkor ennek megfelelően fogja mozgatni a szövegmezőt. A QML JavaScript szintaktikát használ a kódjaihoz, és ahogy már korábban említettük, importálhatunk és használhatunk is Javascript fájlokat egy QML fájlon belül.
Komponensek kombinálása a szövegszerkesztőhöz
Most már készen állunk, hogy létrehozzuk szövegszerkesztőnket a QML segítségével. Programunk két fő komponensből áll, az általunk létrehozott menüsorból és egy szövegmezőből. A QML lehetővé teszi, hogy újrafelhasználjuk komponenseinket azok importálásával és testreszabásával ha szükséges, ezzel is egyszerűbbé téve a kódunkat. A szövegszerkesztőnk egyharmadát a menüsor, kétharmadát a szövegmez fogja elfoglalni. A menüsor minden más elem előtt fog megjelenni.
Újrafelhasznált komponenseikkel sokkal egyszerűbbnek tűnik a TextEditor forráskódja. Ezután testreszabhatjuk a fő alkalmazásunkat anélkül, hogy az előre definiál tulajdonságok miatt kellene aggódnunk. Ezzel a módszerrel könnyedén hozhatunk létre programvázakat és interfészeket.
Szövegszerkesztőnk megjelenésének testreszabása
A Drawer Interface implementálása
A szövegszerkesztőnk egyszerűen néz ki, most már a megjelenését is testre kellene szabnunk. A QML-t használva átmeneteket és animációkat deklarálhatunk a szövegszerkesztőnkhöz. Menüsorunk elfoglalja az ablak egyharmadát, így jó lenne, ha csak akkor jelenne meg, ha mi akarjuk.
Hozzáadhatunk egy rajzoló interfészt, amely összecsukja illetve megjeleníti a menüsort klikkeléskor. Jelen esetben egy kis rectange.t használtunk, mely reagál az egérkattintásokra. A drawer, akárcsak az maga az alkalmazás, két állapottal rendelkezik, egy nyitottal és egy zárttal. A drawer elem egy kis magasságú rectangle, amihez kapcsolunk egy [ttp://doc.qt.nokia.com/4.7/qml-image.html Image] [doc.qt.nokia.com] elemet, egy kis nyíl ikont jelenítve meg középen a rectangle-ön belül. A drawer meghatározza az program állapotát, ahogy a felhasználó rákattint a kis nyílra.
Ez az állapot egy sor konfigurációs beállítás, melyeket State [doc.qt.nokia.com] elemeken keresztül deklarálunk. A különböző állapotok a state tulajdonsághoz kötődnek és kilistázhatjuk őket onnan. Az alkalmazásunkban két állapot, a DRAWER_CLOSED és a DRAWER_OPEN lesz. Az elemek konfigurációja a PropertyChanges [doc.qt.nokia.com] elemben lesznek deklarálva. A DRAWER_OPEN állapotban 4 elem tulajdonsága fog megváltozni. A menuBar y tulajdonsága 0-ra fog változni. Hasonlóképpen, a textArea pozíciója lejjebb fog kerül, ha a DRAWER_OPEN állapot az aktív. A textArea, a drawer és a drawer ikonja fog változáson keresztülmenni, hogy elérje a megfelelő állapotot.
Az állapotváltozások azonnaliak, ám az átmenetnek ennél finomabbaknak kell lenniük. A Transition [doc.qt.nokia.com] elemben határozzuk meg a különböző állapotok közötti átmeneteket, amelyet ezután az elem transitions tulajdonságához rendelhetjük. A szövegszerkesztőnknek állapotátmenete lesz, akár DROWER_OPEN-re akár DROWER_CLOSED-ra módosul az állapota. Fontos, hogy az átmeneteknek rendelkezniük kell egy from (honnan) és egy to (hová) állapottal, de jelen esetben használhatunk csillagot * is, jelölve, hogy ez itt minden átmenetre vonatkozik. Az átmenetek során animációkat rendelhetünk a tulajdonság változásokhoz. A menüsorunk y : 0-ból y : x helyre ugrik, de ezt a mozgást leanimálhatjuk a NumberAnimation [doc.qt.nokia.com] elem használatával. A cél elem tulajdonságait úgy állítjuk be, hogy annak mozgása egy meghatározott idő alatt, egy előre meghatározott csillapított görbe mentén animálódjon. Ez a csillapított görbe fogja szabályozni az animáció tulajdonságait az állapotváltozások között. Ez az ún. easing curve most az Easing.OutQuint [doc.qt.nokia.com] lesz, amely lelassítja az elem mozgását az animáció vége felé. Bővebb információért érdemes elolvasni a QML’s Animation [doc.qt.nokia.com] c. leírást.
Egy másik módja a tulajdonságváltozások animálásnak egy Behavior [doc.qt.nokia.com] elem deklarálása. Egy átmenet csak állapotváltozások alatt működik, míg a Behavior hozzárendelhető egy egyszerű tulajdonságváltozáshoz is. A szövegszerkesztőnkben a nyílnak van egy NumberAnimation-ja, mely leanimálja annak rotation tulajdonságát valahányszor megváltozik az.
Térjünk vissza a komponenseinkhez az állapotokról és az animációkról megszerzett tudásunkkal, most már szebbé tehetjük azok megjelenését. A Button.qml-ben a gomb lenyomásához color és scale tulajdonságokat adhatunk. A szín típusokat a ColorAnimation [doc.qt.nokia.com] fogja animálni, míg a számokat a NumberAnimation. Az alant látható on propertyName szintakszis hasznos lehet, ha csak egyetlen tulajdonságra akarunk utalni.
Még mutatósabbá tehetjük QML komponenseinket, ha olyan effektusokat adunk hozzájuk, mint a gradiens vagy az átlátszóság. Egy Gradient [doc.qt.nokia.com] elem deklarálásával felülírhatjuk az elem color tulajdonságát. A GradientStop [doc.qt.nokia.com] elemmel színeket is deklarálhatunk a gradiensünkön belül, melyet egy 0.0 és 1.0 közötti skálával adunk meg.
A menüsorunkon használjuk majd a gradienst egy színátmenet megjelenítésére. Az első szín 0.0-nál kezdődik, az utolsó pedig 1.0-nál végződik.
Innen hova
Ezzel befejeztük egy nagyon egyszerű szövegszerkesztő felhasználói felületét. Tovább haladva most már implementálhatjuk az alkalmazásunk logikáját a jól megszokott Qt és C++ segítségével. A QML szépen dolgozik, elválasztva előbbit az UI designtól.
QML kibővítése Qt C++ használatával
Már megvan a szövegszerkesztőnk váza, most implementálhatjuk a funkciókat C++ -ban. A QML-t és a C++ -t együtt használva lehetőségünk van Qt-ben létrehozni a program logikáját. Beilleszthetünk egy QML kotextust a C++ alkalmazásunkban a Qt’s Declarative [doc.qt.nokia.com] osztályok használatával és meg is jeleníthetjük a QML elemeket a Graphic Scene segítségével. Vagy exportálhatjuk a C++ kódunkat egy olyan pluginba, amit a qmlviewer olvasni tud. A programunk számára a mentés és betöltés funkciókat C++ -ban fogjuk implementálni és ezt exportáljuk egy pluginba. Így csak a QML fájlunkat kell betöltenünk, nem kell egy futtatható állományt elindítani.
C++ osztályok megismertetése a QML-el
Qt és C++ segítségével fogjuk implementálni a betöltés és mentés opciókat. A C++ osztályok és függvények használatához regisztrálni kell őket a QML-ben. Az osztály továbbá Qt pluginként kell fordítani és a QML fájlnak tudnia kell, hogy ez a plugin merre található.
Az alkalmazásunk számára a következő elemeket kell létrehoznunk:
- Directory osztály, mely a mappákhoz kötődő művelteket fogja végrehajtani
- File osztály, ami egy QObject [doc.qt.nokia.com], amely fájlok listáját szimulálja egy mappában
- plugin osztály mely a QML kontextushoz fogja regisztálni az osztályt
- Qt project fájl, mely majd lefordítja a plugin-t
- qmldir, mely átadja a plugin helyét a qmlviewer számára
Qt plugin létrehozása
A plugin létrehozásához a következőket kell beállítanunk a Qt project fájlunkban. Első körben a szükséges sources, headers, és a Qt modules szerepelnek a hozzáadandók listájában. Az összes C++ kód és project fájl a filedialog könyvtárban lesz.
A declarative modullal fordítjuk a Qt-t és plugin_ként konfiguráljuk, amihez egy _lib sablonra lesz szükségünk. A szülő plugins mappába kell tennünk a lefordított plugint.
Egy osztály regisztrálása QML-ben
A DialogPlugin osztályunk a QDeclarativeExtensionPlugin [doc.qt.nokia.com] egy alosztálya. Implementálnunk kell az örökölt függvényt, a registerTypes() [doc.qt.nokia.com] -t. A dialogPlugin.cpp a következőképpen néz ki:
A registerTypes() függvény regisztrálja a FILE és DIRECTORY osztályainkat QML-ben. Ennek a függvénynek meg kell adni a sablonja nevét, a fő- és az alverziószámot, valamint természetesen az osztályunk nevét.
Exportálnunk kell a plugint a Q_EXPORT_PLUGIN2 [doc.qt.nokia.com] makróval. Megjegyzendő, hogy a dialogPlugin.h fájlunkban ott van a Q_OBJECT [doc.qt.nokia.com] makró az osztályunk tetején. Majd futassuk a qmkae-t a project fájlunkon hogy legeneráljuk a szükséges meta-object kódot.
QML tulajdonságok létrehozása C++ osztályban
Létrehozhatunk QML elemeket és tulajdonságokat a C++ és a Qt’s Meta-Object System [doc.qt.nokia.com] segítségével. Implementálhatjuk ezeket a tulajdonságokat slot-ok és signal-ok használatával, átadva ezeket a Qt-nek.
A szövegszerkesztőnknek be kell tudnia tölteni, illetve elmenteni a fájlokat. Általában ezeket a funkciókat egy fájl dialogban valósítjuk meg. Szerencsére használhatjuk a QDir [doc.qt.nokia.com], QFile [doc.qt.nokia.com], QTextStream [doc.qt.nokia.com] függvényeket, hogy implementáljuk a mappaolvasásokat és az input/output folyamatokat.
A Directory class a Qt’s Meta-Object System-et használja, hogy regisztrálja a fájlkezelés megvalósításához szükséges tulajdonságokat. A Directory osztályt pluginként exportáltuk és QML-ben Directory elemként hivatkozhatunk rá. Az összes listázott tulajdonság a Q_PROPERTY makrót használja, amely egy QML tulajdonság.
A Q_PROPERTY [doc.qt.nokia.com] deklarál egy tulajdonságot, továbbá függvényeket olvas és ír a Qt’s Meta-Object System-ből/be. Például a QString [doc.qt.nokia.com] filename tulajdonságát a filename() függvénnyel tudjuk olvasni, illetve a setFilename() függvénnyel írni. Továbbá egy signál, a filenameChanged(), is rendelve van a filename tulajdonsághoz, amely minden esetben emittálásra kerül, ha a tulajdonság megváltozik. Az író és olvasó függvényeket public-ként deklaráljuk a header fájlban.
Hasonlóképpen deklaráljuk a többi tulajdonságot, természetesen a használatuknak megfelelően. A filesCount tulajdonság az adott mappában lévő fájlok számát adja jelzi. A filename tulajdonság mindig az éppen kijelölt fájl nevét tárolja, a fileContent tulajdonságban pedig a betöltött/elmentett fájl tartalma tárolódik el.
A files lista tulajdonság egy lista a mappában lévő fájlokról. A Directory osztály azért implementáltuk, hogy kiszűrje az érvénytelen szöveges fájlokat, csak a .txt kiterjesztésűek lesznek érvényesek. Továbbá a QList [doc.qt.nokia.com] QDeclarativeListProperty [doc.qt.nokia.com] -ként delarálva C++ -ban lesz használható QML-ben. A sablon objektumot a QObject [doc.qt.nokia.com] -től kell származtatni, így a File osztályt is. A Directory osztályban, a File objektumok listáját a QList_–ben tárolj _m_fileList néven.
Ez a tulajdonság ezután a Directory elem tulajdonságainak részeként használható QML-ben. Jegyezzük meg, hogy nem kell azonosító id tulajdonságot létrehoznunk a C++ kódunkban.
A sima C++ függvények is elérhetőek QML–ben. A betöltő és elmentő függvények C++ -ban kerültek implementálásra a Q_INVOKABLE [doc.qt.nokia.com] makró felhasználásával. De _slot_–ként is deklarálhatjuk a függvényeket, melyek ezután elérhetőek lesznek QML –ben.
A Directory osztálynak tudomást kell szereznie más objektumokról, ha megváltozik a mappa tartalma. Ezt a funkciót signal_–ok használatával oldjuk meg. Ahogy előzőleg említettük, a QML _signal_–oknak van egy hozzájuk tartozó végrehajtójuk, egy ún. _handler_–jük, amelyek neve megegyezik egy on prefixumot leszámítva. A signal neve _directoryChanged és ez mindig emittálásra kerül, ha a mappa frissül. A frissítés szimplán újra betölti a mappa tartalmát és frissíti a listában a mappa érvényes fájljait. Ezek a QML elemek észrevehetőek felhasználjuk az onDirectoryChanged handler-t.
Érdemes tovább vizsgálni a list tulajdonságokat, ugyanis ún. callback-eket, visszahívásokat alkalmaznak, hogy elérjék és módosítsák a lista tartalmát. A list tulajdonság QDeclarativeListProperty<File> típusú, így akárhányszor hozzáférünk a listához, a hozzáférőnek egy QDeclarativeListProperty<File>-al kell visszatérnie. A sablon típusnak, a File_–nak _QObject leszármaztatottnak kell lennie! Hogy létrehozzunk egy QDeclarativeListProperty [doc.qt.nokia.com] -t , a lista hozzáférőjét és módosítóját függvény mutatókként át kell adni konstruktornak! A listának, esetünkben a QList_–nek egy _File mutató listának kell lennie! A QDeclarativeProperrty konstruktor konstruktorának és a Directory implementálása:
A konstruktor átadja a mutatókat a függényekneknek, amik csatolják, megszámolják a elemeinek számát vagy kiürítik a listát, illetve visszanyerik az elemeit az indexek segítségével. Csak az append (csatoló) függvény megbízott. Megjegyzendő, hogy a függvény mutatóknak meg kell egyezniük az AppendFunction [doc.qt.nokia.com], a CountFunction [doc.qt.nokia.com], az AtFunction [doc.qt.nokia.com], és a ClearFunction [doc.qt.nokia.com] definícióival!
Hogy egyszerűbbé tegyük a dialógunkat, a Directory osztály kiszűr minden fájlt, amely nem .txt kiterjesztésű és csak azokat jeleníti meg, amelyek azok. Sőt, ez az implementáció arról is gondoskodik, hogy az elmentett fájljaink megfelelő (.txt) kiterjesztést kapjanak. A Directory a QTextStream [doc.qt.nokia.com] függvényt használja, hogy kiolvasson a fájlból, illetve hogy írjon bele.
A Directory elemünkkel tehát visszanyerhetjük a fájljaink listáját, azok nevét és tartalmát stringként, megtudhatjuk, hogy hány fájl van az adott mappában, és valahányszor megváltozik annak tartalma, arról értesítést kaphatunk.
Ahhoz hogy létrehozzuk a plugin_–t, futassuk a _qmake_–t a _cppPlugins.pro project fájlon, aztán futassuk a make parancsot hogy lefordítsuk és áthelyezzük a pluginunkkat a plugins könyvtára.
Plugin importálása QML-ben
A qmlviewer azokat a fájlokat importálja, amelyek az alkalmazásunkkal egy mappában van. De létrehozhatunk egy qmldir fájlt is, amely tartalmazza majd, hogy merre találhatóak a QML fájljaink, melyeket importálni szeretnénk. A qmldir fájl tovább tartalmazhatta más pluginok és ún. resources, eszközök helyét.
A plugin, melyet fentebb létrehoztunk FileDialog névvel rendelkezik, ahogy azt a TARGET mezőben is jeleztük a project fájlunkban. A lefordított plugin a plugins könyvtárban található.
Egy File Dialog integrálása a File Menu–be
A FileMenu_–ünknek egy _FileDialog_–ot kell elemet megjelenítenie, amely tartalmazza a könyvtár, .txt kiterjesztésű, fájljait és lehetővé teszi a felhasználó számára, hogy kiválassza a megnyitni kívánt fájlt. Továbbá el kell helyeznünk benne a mentés, a megnyitás és az új gombokat, hogy azok elvégezhessék a kívánt műveletet. A _FileMenu tartalmazni fog egy szerkeszthető szövegmezőt is, ahová a felhasználó begépelhet egy fájlnevet. A Directory elemet a FileMenu.qml_–ben használjuk fel, és ez majd értesít minket, ha megváltozott a könyvtár tartalma. Ezt az _signal-t az onDirectoryChanged handler fogja számunkra eljuttatni.
Alkalmazásunk egyszerűségét megőrizendő, a fájl dialógunk csak a szükséges fájlokat fogja megjeleníteni, amelyek .txt kiterjesztésűek.
Ahogy fentebb írtuk, a FileDialog elem meg fogja jeleníteni a mappa számunkra releváns tartalmát, amelyet a files tulajdonság kiolvasásával fogunk elérni. A fájlokat egy GridView [doc.qt.nokia.com] modellt használó elem fogja megjeleníteni rácsos elrendezésben egy delegate-nek megfelelően. A delegate fogja lekezelni a modellünk megjelenését és a fájl dialógunk létrehoz majd egy grid-et, egy rácsot, középre igazítva benne a szöveget. Egy fájlnévre kattintva egy rectangle jelenik meg, kijelölve a fájlnevet. Akárhányszor emittálásra kerül a notifyRefresh signal, a FileDialog újratölti majd a könyvtár tartalmát.
Most már a FileMenu-nk kapcsolódhat a megfelelő műveletekhez. A saveButton továbbítja majd a TextEdit-ből a szöveget a Directory filecontent tulajdonságában, majd átmásolja a fájl nevét a szerkeszthető szövegmezőből. Végül pedig a gomb meghívja a saveFile() függvényt, amely elmenti a fájlunkat. A loadButton hasonló végrehajtással rendelkezik. A New gomb megnyomására pedig kitörlődik a TextEdit tartalma. Továbbá a EditMenu gombjai kapcsolónak a TextEdit függvényeihez, hogy képesek legyenek a copy, paste funkció betöltésére, valamint hogy a kijelölhessük a szöveget.
A szövegszerkesztőnk befejezése
Összegezve, a kis alkalmazásunk képes az alapvető szövegszerkesztési funkciók ellátása, így képes elmenteni, megnyitni, illetve módosítani bármilyen .txt kiterjesztésű fájlt.
Köszönjük, hogy elolvasta eme ismertetőt, reméljük hasznosnak bizonyult és remek QML alkalmazások fognak születni az itt elolvasott tudás birtokában!
Have a nice day! :)