Tovább Vissza Tartalom

## 4. Fejlesztés a KDevelop-pal

Ebben a fejezetben általános áttekintést kapunk arról, hogy hogyan használhatjuk a KDevelop-ot és a beépített dialógus szerkesztőt saját alkalmazásaink létrehozására. Ennélfogva minden eszközt a fejlesztési folyamaton belüli használata alatt mutatunk be. Ha még kezdő vagy a C++/GUI tervezésben és programozásban, akkor olvasd el a A KDevelop Programozási Kézikönyvet, amely bemutat néhány programtervezési alapot és részletesebben bemutatja a KDevelop használatát néhány példaprojekttel amelyeket lépésről-lépésre követhetsz, hogy belerázódj az az alkalmazások létrehozásába a KDevelop használatával. Ezenkívűl elolvashatod a Programok részt, hogy jobban megértsd, hogy a Unix alkalmazásokhoz miért van szükség fejlesztőeszközökre; ezek jelentősen megkönnyítik a dolgunkat, nézzük meg például, hogy mik a Makefile-ok, stb.

## 4.1 Micsodák a KDevelop Projekt Alkalmazások ?

A KDeveloppal készített projektek nagyban megkönnyítik a GNU standard fejlesztőeszközök használatát. Ellentétben a Makefile-ok, saját írásával, melyeket mindenképp meg kell írni a project összetettsége miatt, ezek az eszközök nem csak jobb utat kínálnak a Makefile-ok létrehozására, hanem biztonságos módszert is biztosítanak a program különböző rendszerekre való átírásához az autoconf által létrehozot `configure` scriptekkel.

Az alkalmazásaid terjesztéséhez nincs szükség a felhasználónál másra, mint egy telepített C++ fordítóra és a fejlesztői könyvtárakra, amelyek legtöbb esetben rendelkezésre állnak; de ugyanúgy létre lehet hozni bináris csomagokat is. Bármelyik esetet vesszük, a terméked végfelhasználójánál nincs szükség arra, hogy a KDevelop fel legyen installálva. Ha kiadod a forráskódot, akkor azt tanácsoljuk, hogy hagyd benne a KDevelop project fált is, mert ez nagyon megkönnyíti azoknak a fejlesztőknek a munkáját akik a KDevelop-ot használják, és a te programod forrásával akarnak dolgozni. Néhány fejlesztős projekteknél, ahol a fejlesztők talán még különböző helyeken is dolgoznak, ezzel a módszerrel bizosíthatják a Makefile-ok következetességét, és azok különböző verziói nem fognak egymással ütközni. Különösen hasznos többnyelvű alkalmazásoknál, ahol a fordítók nem fognak a forráskódon dolgozni, kivéve ha azt módosítani kell a fordításhoz. Ők mindenképpen hálásak lesznek, mert a KDevelop leegyszerűsíti a munkájukat így már nem kell másra csak a fordításra koncentrálniuk.

Ha a KDevelop-ot saját projektek létrehozására használod, akkor a legjobb ha az új alkalmazás létrehozásához a KAppWizard-ot használod. Itt kiválaszthatod a projekt típusát a programod céljainak megfelelően. Ezután elkezdheted a felhasználói felület fejlesztését előre elkészített widgetek hozzáadásával, melyeket vagy "kézzel" hívsz meg a programodból, vagy pedig a dialógus szerkesztő írja meg a kódot, amely lefut a programinduláskor. A következő lépés a felhasználói felület kibővitése, a KDevelop által létrehozott elemek módosításával, bővítésével. Ilyenek a menük, eszköztárak, státuszsorok. Mivel az erőforrások egy erőforrásfájlba vannak gyűjtve ezért ezek könnyen kiegészíthetők új értékek hozzáadásával a már létezőkhöz; a megadott erőforrások akár irányadóként is használhatók a te egyedi erőforrásaidhoz. Miután kiegészítettük azokat a metódusokat, amelyeket a dialógus szerkesztő készített és üresek, vagy már van bennük kód a szokásos felhasználói műveletekre, jöhet a Felhasználói kézikönyv kiegészítése a ez előre elkészített SGML index fájl szerkesztésével. Utolsó lépésként létrehozhatunk fordítási fájlokat, majd eljuttatjuk a projektet a fordítókhoz, akik elvégzik a többi lépést, hogy az alkalmazás "még nemzetközibb" legyen.

Az IDE a nem GUI alkalmazások tervezőinek is könnyű utat kínál új projektek létrehozásához; a szerkesztő és az Osztályböngésző a KDevelop erőteljes projekt menedzsmentjével arra a minimumra csökkenti a fejlesztési időt amely a program rendeltetésének kifejtéséhez szükséges.

## 4.2 A KDevelop Eszközök rövid leírása

A KDeveloppal egy olyan csomagot választottál, amely más eszközökkel együttműködve tökéletes és rugalmas környezetet biztosít az objektumorientált alkalmazásfejlesztéshez Unix rendszerek alatt. Általánosságban a Kdevelop programozási környezet és a dialogus szerkesztő; mindemellett bele van ágyazva minden szükséges program amely segítségedre lehet az alkalmzás tervezéshez.

### Programozási környezet és a dialógus szerkesztő

### A programozási környezet

A programozási környezet a felhasználói felület amelyet a KDevelop biztosít projektek létrehozására és karbantartására, felhasználva sok más eszközt és leegyszerűsítve azok használatát. A beépített szerkesztője és Súgó böngészője csakúgy mint az Osztályböngésző lecsökkentik a munka mennyiségét, amelyek a fejlesztési folyamat alatt a programozót terhelik. Ez a könnyebbség élvezetté teszi a Unix alkalmazások írását, és valószínűleg rövidebb kibocsátási ciklusokat és jobb haladást fog eredményezni a fejlesztésben. Itt a projekted minden részletét kezelheted, áttekintheted az osztályokat, nincs szükség további konzolok használatára továbbá a felhasználói felületek integrációja révén csak egyetlen ablakkal kell dolgozni az X alatt, és nem kell többet figyelni, melyek szét vannak szórva a munkaasztalon.

### A dialógus szerkesztő

A KDevelop beépített dialógus szerkeszője könnyű módot biztosít a Qt és KDE könyvtárak által biztosított felhasználói felületek tervezéséhez. Ez lehetővé teszi, hogy szinte mindent az egérrel végezzünk, így biztosítja a párbeszédablakok (dialógusablakok), és főablakok gyors létrehozását és közvetlen átalakítását C++ kóddá, amely így bekerül a projektbe. Mivel a dialógus szerkesztő be van ágyazva a KDevelop felhasználói felületébe, ezért ennek használatakor is ugyanazok a parancsok használhatók mint a forráskód szerkesztő módban. Így pl. lehetséges a dialógus ablakok szerkesztése közben, kód kimenet létrehozása és annak közvetlen tesztelése a programon belül, mivel rendelkezésre állnak a make-parancsok és emellett ellenőrizheted a fordító kimenetét anélkül, hogy vissza kéne kapcsolni a forráskód szerkesztőre. Részletes leírás a Dialógus szerkesztő résznél található.

### A KAppWizard és az Osztályeszközök

A KAppWizard és és az Osztályeszközök a projekt készítés és automatikus kód készítés céljából lettek beépítve, hogy olyan könnyen és biztonságosan készítsenek alkalmazásokat amennyire csak lehet. Ezenkívül kiválóan megfelenek arra, hogy a Qt/KDE programozásában még kezdők is bele tudjanak fogni a GUI alkalmazástervezésbe, és gyorsan érjenek el eredményeket.

### KAppWizard

A KAppWizard célja működőképes alkalmazás projektek létrhozása, amelyek a szabványos GNU eszközökkel futásra készek, valamint -GUI programok részére- a Qt és KDE könyvtárak előnyeinek kihasználása. A legszükségesebb információk megadásával a felhasználók néhány másodperc alatt elkezdhetnek dolgozni egy új projekten. A KAppWizard futtatása az első lépés egy alkalmazás létrehozására a KDevelop-ban.

A KAppWizard egy ú.n. alkalmazás vázat biztosít minden szükséges C++ forráskóddal ahhoz, hogy az alkalmzás fusson. Miután megadtad a projektnevet és beállítottad szükséges tulajdonságokat, létrejön az új projekt, egy kész alkalmazás, mely már több funkciót is tartalmaz ( Qt és KDE projektek ) úgy, hogy egy sor C++ kódot sem kellett még írnod.

Ha készítő program összes információját megadtuk amit az kér, akkor az alkalmazásban már van:

- SDI-felület ( Egy dokumentum/alkalmazásablak ), a "Dokumentum-Nézet-Vezérlő" modellre alapozva
- menük és párbeszédablakok fájlok nyitásához és mentéséhez, továbbá nyomtatási párbeszédablakok
- egy eszköztár és egy státuszsor
- egy súgórendszer SGML-alapú kézikönyvekkel
- teljes HTML-alapú API (application programming interface) dokumentáció a projekt jelenlegi állapotához
- installáló rutinok ( make )

A KAppWizard a Projekt menüben, az "Új..." menüpont kiválasztásával érhető el.

### Osztályeszközök

Az "Osztályeszközök" fogalom egy sor lehetőséget jelöl, melyek a fejlesztő rendelkezésére állnak, hogy ne csak egy objektumoritentált nyelvvel dolgozzon, hanem a forráskódjait is objektumorientált módon használhassa. Osztályokkal dolgozni különálló fájlok helyett nagyon rugalmas utat kínál egy projekt bővítéséhez és lehetvé teszi, hogy a felhasználó a projektje objektumaira koncentráljon. A KDevelop ilyen eszközei az Osztálygenerátor és az Osztályböngésző, mindkettő jónéhány automatizált lehetőséget biztosít.

### Új osztály létrehozása az Osztálygenerátorral

A projekt létrehozása (KAppWizard-dal) után a fejlesztő dolga, hogy osztályokat adjon hozzá, melyek kielégítik az alkalmazás igényeit. A tipikus folyamat ekkor az lenne, -KDevelop nélkül- hogy létrehozunk egy fejléc és forrásfájlt, majd kézzel a megfelelő Makefile.am fájlt ezután elkezdhetjük írni az osztály deklarációt és az implementációt. Az egész folyamatot leegyszerüsíti az Osztálygenerátor: megadod az osztály nevét, a szülőosztályt, az öröklődés tulajdonságait, valamint néhány további információt mint például az osztály dokumentációja a projektben betöltött szerepe szerint. Ezenkívül megváltoztathatsz héhány alapértéket, mint például az osztálynévből létrehozott fájlnevet, vagy azt, hogy az osztályban már benne legyen -e a Qt-SIGNAL/SLOT támogatás. A munka fennmaradó része automatikusan végbemegy - nem kell törődni a Makefile.am-mel, és az osztállyal. Az új "make" használata elegendő, hogy az új osztály belekerüljön a fordítási folyamatba. Mivel az Osztályböngésző frissíti magát egy új osztály hozzáadása után, ezért a deklaráció és az implementáció rögtön rendelkezésre áll, így máris kezdheted a munkát az osztály kibővítésével. Az Osztály generátor a Projekt menü "Új osztály..." menüpontjával érhető el.

### Az Osztályböngésző

Az Osztályböngésző megjeleniti a projektben lévő összes objektumtípust és függvényt egy faszerkezetben, balra a szerkesztőablaktól. Egy osztály elemző végignézi az összes fájlt metódusokat és osztályokat keresve, majd grafikusan jeleníti meg őket. Ezekenfelül a helyi menük különleges funkcionalitást kínálnak arra, hogy úgy dolgozzunk a forrással, hogy az osztályokra és a függvényekre fókuszáljunk. Egy osztály kiválasztása azt eredményezi, hogy a szerkesztőben megnyílik az a fájl, ami az osztály deklarációját tartalmazza, metódusok és függvények esetén, pedig az implementációs rész lesz látható. Teljes leírást az Osztályböngésző résznél találsz.

## 4.3 A Fejlesztői folyamat

Egy új alkalmazás fejlesztése a KDeveloppal alapvetően két fő részre osztható: először létre kell hozni a program vázát a KAppWizarddal, a fejlesztés "többi" részét pedig a KDevelop eszközeivel kell végezni, amelyhez nincs másra szükség mint a te programozói képességeidre. A továbbiakban, hogy elmagyarázzuk a fejlesztői folyamatot, feltételezzük, hogy egy Qt/KDE alkalmazást akarsz létrehozni. Az ilyen projektekkel való munka folyamata magába foglalja a KDevelop legtöbb vonásának használatát, így bemutatása tulajdonképpen egy általános "HOGYAN".

### Programváz létrehozása

Alkalmazás létrehozásának első lépése a KAppWizard indítása, a projektnév megadása, és a létrehozás. Ezáltal a varázsló automatikusan létrehoz egy projekt fájlt az alkalmazásnak, és KDevelop részeket helyez el a Makefile.am-ekben, amelyek akkor lesznek használatosak amikor kibővítjük az alkalmazást. A projekt fájl az a fájl amit később betöltve megjelenik a teljes projekt a fejlesztői környezetben.

A KAppWizard-ot a "Projekt"-menü "Új..." menüpontjával érheted el. Amikor a varázsló megjelenik, az első oldalon meg kell határoznod a projekt típusát. A "Következő>>" gomb megnyomásával a második oldalra kerülsz, ahol meg kell adnod a projekt nevét, verzióját, a könyvtárát és személyes információkat. A 3. oldal még részletesebb lehetőségeket kínál (CVS verzió kontrol), a 4. és 5. oldalon pedig beállíthatjuk a projekt fejléc (.h) és implementációs fájljainak (.cpp) sablon fejlécét, amelyeket a KDevelop automatikusan ezeknek a fájloknak az elejére fűz. Ha már vannak sablon fájljaid (a Kdevelop is kínál ilyeneket), akkor azokat is meghatározhatod, mint sablonokat. Az utolsó ablak kimeneti ablakból, és hibaüzenet ablakból áll. Ha megnyomod a "Létrehoz" gombot, akkor elkezdődik az alkalmazás létrehozása, amely jónéhány lépésből áll, és a lépések nyomon követhetők a kimeneti ablakban. Amint a READY (KÉSZ) felirat megjelenik a kimeneti ablakban a KAppWizard végzett, és megnyomhatod a "Kilépés" gombot, hogy visszatérhess a programozói környezethez. Ha létre akarod hozni a bináris fájlt, akkor válaszd a "Make" menüpontot a "Build" menüből, vagy ugyanezt a gombot az eszköztárról. A már létező funkciókat ki is próbálhatod a "Build" menü "Végrehajtás" parancsának választásával.

### Alkalmazás fejlesztése

Ez a szakasz KDevelop-pal és a dialógus szerkesztővel való fejlesztési fázisokat ábrázolja - amely mind elvégezhető az IDE-n belül.

A lépések általában a forrásfájlok szerkesztéséből, a források fordításából állnak, amiket a Linkelési folyamat követ, amely az object (.o) fájlokat összefűzi a végleges futtatható binárissá. Ezután kell megkeresni a hibákat, amelyek vagy a fordítást vagy a linkelést akadályozzák meg, vagy pedig szemantikai hibák, amelyeket a hibakeresés során tárhatunk fel. Végezetül a dokumentációt kell kibővíteni, és el kell készíteni (ha van rá igény) ezek fordításait. Azonban ezek a lépések keveredhetnek egymással, nem ennyire egyszerű abrázolni általánosan, hogy hogyan fejleszd saját alkalmazásod. Tipikusan, a szokásos eljárás az, hogy először létrehozod a projekt látható részeit, mint a főablak, és a dialógus ablakok amelyekkel a különböző beállítások végezhetők el, ezután az ehhez tartozó forráskód létrehozása és a szükséges kapcsolatok (SIGNAL/SLOT) megírása, továbbá a menü és az eszköztár bővítése, a státuszsori súgók hozzáadása az új menüpontokhoz, és az új tagfüggvények objektumokkal való kitöltése, amelyek megjelenítik a dialógusablak(ok)at. Ezek után jöhet az alkalmazás fordítása, a tesztelése, majd a hibák javítása, azután újra tesztelés. A következő részek tárgyalják, hogy mindez hogyan lehetséges; a te egyedi alkalmazásodhoz választhatsz akár más módszert is - a KDevelop elég rugalmas ahhoz, hogy szabadon dönthess arról, hogy mikor, hol milyen módszert alkalmazol.

### Felhasználói felületek

Egy alkalmazás felhasználói felülete az amit a felhasználó valójában lát, és aminek segítségével ő és a program "egymásra hatnak". Ezért egy programnak általában van menüsora, eszköztára és státuszsora úgy mint fő nézete, ami például egy szövegszerkesztőnél egy szöveg beviteli mező lehet. A KAppWizard által készített alkalmazások, már egy sor ilyen grafikus felületű funkcióval rendelkeznek - a keretstruktúra gondoskodik az ilyen szokványos elemekről mint az eszköztár és ezek gombjai. Amikor az alkalmazásodat fejleszted, ki kell egészíteni a megadott struktrát azokkal az elemekkel, amiket szeretnél a felhasználónak biztosítani. A munka egy része a dialógusablakok megtervezése pl.: értékek megváltoztatásához, mint például az ecset vastagságának beállítása egy rajzolóprogramban. Ez könnyedén megtehető a dialógus szerkesztővel a KDevelop-on belül. Hogyan is csináljunk ilyen tetszetős ablakokat ? Mivel a Qt-könyvtár egy GUI készlet, ezért egy jónéhány alapvető ú.n. "widget"-et kínál. Ilyenek a cimkék, melyek szöveget, vagy képet jelenítenek meg, szövegbeviteli mezők -egy vagy többsorosak is akár- és gombok a navigáláshoz, vagy parancsok végrehajtásához. Ezek mellett az "alacsonyszintű" felületelemek mellett, vannak szabványos párbeszédablakok, mint például nyomtatási párbeszédablak. A KDE-könyvtárak amelyek a Qt-könyvtáron alapulnak helyettesítéseket tartalmaznak bizonyos párbeszédablakokra valamint jónéhány további widget-et, amelyek az alkalmazásokban használhatók. Tehát amikor elkezded a programod felületének tervezését, már ekkor kényelmesebbé teheted annak használatát a Qt és KDE widgetek-kel. A Qt online-dokumentációjában a legtöbb widget-ről vannak képek, így akár először meg is nézheted ott őket. Ezután azt tanácsoljuk, hogy ismerkedj meg közelebbről a KDE-UI könyvtárral, amely további widgeteket is kínál. További könyvtárak, mint a KHTML könyvtár spciális widgetek-et tartalmaz, melyeket számos program használ. Ez is leegyszerűsíti az alkalmazás tervezést, úgy mint az előre gyártott párbeszédablakok a Qt-ben. A te egyedi párbeszédablakaidhoz az alacsony-szintű widgetek-re lesz szükség. Egy párbeszédablakot a különböző widgetek egymással kombinált gyűjteménye alkotja, és technikailag egy C++ osztálynak felel meg, amely a `QWidget` vagy egy még speciálisabb dialógus osztály leszármazottja, amely szintén örökli a `QWidget`-et. A programnak amely egy widget-et használ ezért szüksége van egy objektumra az adott widget osztályából - ez majdnem minden amit meg kell értened, a párbeszédablakok és nézetek alkalmazásához. A KDevelop dialógus szerkesztője jó módszert kínál a párbeszédablakok készítéséhez: Vizuális szerkesztést tesz lehetővé dialógusok és C++ kód kombinációja helyett - ami a nehezebb út felhasználói felületek készítéséhez. Kapcsolj át a dialógus szerkesztőre "Nézet" menü megfelelő pontjának kiválasztásával (vagy az eszkőztár gombjával). Látni fogod, hogy a KDevelop külseje megváltozik, de a menü és az eszköztár nagyon hasonlók. Ez nagyon egyszerűvé teszi az oda-vissza kapcsolgatást a két mód között és egy idő múlva mindkettőben otthonosan fogod magad érezni. Itt létrehozhatod a nézeteket és párbeszédablakokat, és beállíthatsz minden rendelkezésre álló widget tulajdonságot. Új dialógust a következő módon hozhatunk létre: a bal oldalon található rész Dialógus ablakok fülre kattintunk, ahol megjelenik a már meglévő dialógus ablakok listája - új projekt esetén ez üres, a főablakot ne keressük itt, mert nincs a listában. Ezután az egér jobb gomjával a lista tetjére kattintva előjön egy helyi menü, benne az új dialógusablak menüponttal. Innetől a dolgok "maguktól mennek". Ha kész az ablak, válaszd ki a "Forráskód generálása..." menüpontot a "Build" menüből; a dialógus szerkesztő és a projekt kezelő elvégzi a többit. Ha a dialógust vagy nézetet most hoztad létre először, akkor a dialógus szerkesztő majd bekéri az osztály nevet és a szülő osztályt. Ezután megnézheted, hogy minden rendben van -e, a Make vagy Futtatás parancs használatával, ez újraépíti az alkalmazást -benne az új forrásokkal. De ekkor még ne várd, hogy az új ablakok már használhatók legyenek, ez az implementáció tárgya, a fejlesztő szokásos munkája. Ne aggódj, ez sem túl bonyolult. További információt a Dialógusszerkesztő résznél találhatsz, példák és irányelvek pedig a A KDevelop programozási kézikönyvben vannak.

### Új elemek projektbe integrálása

Miután létrehoztad a felhasználói felületeket, és a hozzájuk tartozó forrásokat, készen állsz arra, hogy az alkalmazásod használja őket objektumokon keresztül. Amint azt feljebb említettük egy szokásos GUI-alapú program vezérlőket és egy központi nézetet tartalmaz, ahol esetleg a főnézet is működteti a vezérlőket. Ezek mind az alkalmazás főosztályának részei, és a dokumentum objektum az amihez ez csatlakoztatva van. Az objektum orientált tervezés szerint a megadott architektúrát "Dokumentum-Nézet-Vezérlő" modellnek lehet nevezni. Ez a modell a programban betöltött szerepük szerint ábrázolja az objektumok alapvető funkcióit. A Vezérlő képviseli az alkalmazás koordinálását és biztosítja a felhasználói interakciót a menüvel továbbá az eszköztárral és a státuszsorral. A Dokumentum osztály feladata annak a dokumentumnak a képvislete amelyen a felhasználó éppen dolgozik. Ennélfogva a dokumentum osztályának hatáskörébe tartozik például a fájlok betöltése és mentése. A Nézet az alkalmazás ablakának központjában helyezkedik el, a dokumentumnak azt a részét mutatva, ami a felhasználót érdekli, és biztosítja azokat függvényeket amelyekkel a felhasználó az adatot manipulálhatja. Mivel a menük és eszköztárak már rendelkezésre állnak, a te feladatod a központi nézet és a többi párbeszédablak létrehozása, melyekkel a felhasználó megváltoztathatja a beállításokat, vagy további funkciókat érhet el. A központi nézet létrehozásához a generált forráskód már tartalmaz egy osztályt a <TeAlkalmazásod>View formában amely `QWidget` örökös osztály (ez az a minimális osztály ami képes a vizuális elemek kezelésére Qt-ben és így KDE-ben is). Általánosságban három különböző módszerrel lehet a megadott osztályt kibőviteni:

- szakítunk a Dokumentum-Nézet struktúrával és valamely előre definiált "nagy" widget-et használjuk, amely már számos funkcióval bír - Csak töröld a Nézet (View) osztályt és cseréld ki a nézet-objektumot egy másikkal
- változtasd meg a Nézet-osztály öröklődését. Változtasd meg a szülőosztályt például QMultiLineEdit-re és az alkalmazásod szinte máris egy egyszerű szövegszerkesztő.
- Ha a központi nézeted néhány különálló részből áll, hozd létre a widgeteket és az osztályaikat a dialógus szerkesztővel és a Nézet osztály konstruktorában hozz létre objektumokat ezekből az osztályokból, így a központi nézet ezek kombinációjából jön majd ki

A párbeszédablakoknál valamelyest más a helyzet. A szokásos módszer a meghívásukra a menün vagy az eszközsoron keresztül történik. Miután megalkottad a dialógust, és létrehoztad a forrásait, az osztály készen áll arra, hogy objektumot hozz belőle létre, ami ténylegesen a párbeszédablak lesz. Az első, hogy alkalmas helyet keress a menüben az új menüpont hozzáadásához, amelynek kiválasztásával aztán megjelenik a párbeszédablak. Ha a már kész menükben nem találsz megfelelőt, akkor csinálj egy új popup-menüt, csakúgy mint a többit, szúrd bele a menüsorba, helyezd el benne az új bejegyzést és készíts egy slot-ot amelyet akkor akarsz meghívni, ha a menüpontra kattintanak. Ezután a slot-hoz írd be kódot, amely létrehoz egy példányt a dialógus ablakból, majd hívd meg a dialógus ablakot valamely tag függvény-nyel az alaposztályból. Meg kell határoznod egy ID számot is az új menüponthoz. A keretalkalmazásoknak már megvannak a saját ID-ik, amelyek a resource.h fájlban vannak összegyűjtve, így csak hozzá kell adnod az ID-t és adni neki egy új számot. Ezzel készen is vagy - ezenkívül csinálhatsz egy újabb eszköztár ikont is és adhatsz hozzá státuszsor súgót is. Az alkalmazásod új funkciót kínál, melyet immár a felhasználó is lát. Ezután kell elkészíteni a dialógus metódusainak implementációját amelyekben az ablak és vezérlői az adatokat manipulálják. Végezetül indítsd el a make-et vagy futtasd a programot és a megváltozott fájlok újra fordításra kerülnek; az eredmény azonnal tesztelhető.

### A teljes fejlesztési folyamat

Feljebb megbeszéltük a szokásos módszert, hogy hogyan kezdjünk a KDevelop-pal új alkalmazás fejlesztésébe, és hogy hogyan bővitsük ki a felhasználói felületet. Nos, ezek a standard lépések, ahol az IDE segít neked, de a KDevelop több mint eszközök sora az alkalmazások létrehozásához és annak vizuális részeihez. A következőkben rövid leírást adunk arról, hogy milyen funkciókat kínál a KDevelop az alkalmazásfejlesztés kiteljesítéséhez.

### Forráskód karbantartás

A KDevelop IDE egy sor metódust biztosít a programozónak, hogy az a céljait a lehető legrövidebb idő alatt érje el. Amint azt fentebb tárgyaltuk a KAppWizard és a dialógus szerkesztő lerövidítik azt az időt amelyre általában szükséged lenne ahhoz, hogy ugyanazt az eredményt a forrás kézi gépelésével elérd. Ez azonban nem teljesíti azt a munkát amit egy programozónak általában tennie kell: kidolgozni az alkalmazása implementációs részét, hogy biztosítsa a program helyes futását a felhasználónál. Nos miért jó a KDevelop IDE programozási környezetnek, még akkor is ha nem GUI alkalmazásokat fejlesztesz ?

Az IDE általánosan karbantartja a projektedet; ez azt jelenti, hogy nem kell foglalkoznod a változások mentésével a Makefile létrehozásával, stb, - ezt biztosítja a teljes projektmenedzsment -, és a KDevelop itt mutatja meg ez erejét bármilyen C++ alkalmazásfejlesztéshez. Könnyen érthető, hogy ha ezeket a terheket leveszik a programozó válláról, akkor az sokkal jobban tud koncentrálni a forráskód kidolgozására. Másfelől a programkód általában szét van bontva több különböző fájlra a projektben, így lehet elkülöníteni bizonyos részeket egymástól. Ez azt jelenti, hogyha továbbra is a nehezebb utat választod - lévén te vagy a fejlesztő, neked kell küzdeni ezeknek a fájloknak a létrehozásával és megírni a szabványos tartalmát, mint például a fájlok fejlécei amelyek tartalmazzák a dátumot, a szerző nevét vagy például a liszensz feltételeket. Ráadásul így emlékezned kell, arra, hogy egy-egy függvény, osztály deklaráció és implementáció hol van a projektben. Ezért vannak a KDevelop-ban az Osztályeszközök - olyan funkciók, amellyel a fejlesztő áthelyezheti a figyelmét a fájlokról az objektumokra- osztályokra, struktúrákra és metódusokra. Az osztálygenerátorral könnyedén hozhatunk létre új osztályt, beleértve az öröklődést és a dokumentációt. Az Osztályböngésző elvezet az objektumaidhoz; töbé nem számít, hogy a kód valójában hol található. A böngésző automatikusan megvizsgálja az összes forrást, és újraépíti magát a kiegészítések után is, hogy lépést tartson a munkáddal, és lehetővé teszi, hogy az új kódot közvetlenül is elérd. A helyi menük használatával a böngésző még több funkciót kínál, mint a tagfüggvények implementációjára vagy deklarációjára ugrás. A tagok hozzáadása grafikusan történik párbeszédablakok segítségével- nem kell keresgélni a fájlt és benne a helyet, ahol hozzá lehetne adni az új bejegyzést. Végezetül egy még speciálisabb nézetét is kérheted a projekted osztályainak az Osztályböngésző segítségével, amely faszerkezetben mutatja annak használatát, tartalmát, öröklődését és az osztályból létrehozott objektumokat. Részletes információért nézd át az Osztályböngésző részt.

### Alkalmazások építése és futtatása

A KDevelop IDE speciálisan arra lett tervezve, hogy elvégezze azokat a lépéseket, amelyeket rendszeresen el kell végezned, mint az alkalmazások építése és futtatása vagy a hibák helyének azonosítása a forráskódban.

Az építési folyamatot a következőképpen kezdheted el:

- A "Build" vagy "Rebuild All"-ra kattintás az eszközsoron
- A "Build"/"Rebuild All" kiválasztása a Build menüben.

Az alkalmazásod futtatásához válaszd ki

- a "Futtatás" vagy "Nyomkövetés" (elindítja a KDbg-ot a programoddal együtt) gombot az eszköztárról
- a megfelelő menüpontokat a "Build" menüből
- vagy a "Végrehajtás argumentumokkal" menüpontot, hogy az alkalmazásodat további argumentumokkal indítsd el

További információt az építési folyamatról a Projektek résznél találsz.

### Programhibák keresése

Természetesen hibák előfordulhatnak mind az építési folyamat során (amelyeket a fordító detektál, és szintaktikai hibáknak nevezik őket, mert a hiba a forráskód rossz szintaxisából származik) mind pedig az alkalmazás futása közben is, amelyeket a programozónak kell megtalálni, és kijavítani (szemantikai hibák). A hibák feltárása érdekében a fejlesztőnek tudnia kell, hogy pontosan mi is okozta azt. Amint azt említettük a fordító képes felismerni a szintaktikai hibákat, aminek eredményeképpen nem lehet a futtatható állományt létrehozni (ez akkor is megtörténhet, ha a linker "feloldatlan hivatkozások"-at talál; lásd a Linker Beállítások részt). Lehetőség szerint ez olyan részletes leírást ad a hibáról, amilyet csak tud, így a hiba megtalálható és kijavítható. Az építési folyamat során látható a kimeneti ablak, amelyben a make és a fordító üzenetei láthatók. Hibák vagy figyelmeztetések esetén, csak kattints a hiba sorára, és a szerkesztő a megnyitja a hibás sort tartalmazó fájlt, és a hibát tartalmazó sorra ugrik. Ugyanezt megtehetjük a "Nézet" menü "Előző hiba" és "Következő hiba" pontjaival, vagy a megfelelő billentyű kombinációval. Ezt a funkciót nagyon hasznosnak fogod találni, ami rengeteg időt takarít meg a hibakeresésnél. A futásidejű hibákat, melyek a programfutás közben lépnek fel, és legtöbbször szegmentációs hibák, néha nagyon nehéz megtalálni. Ezért megkérheted a fordítót, hogy írjon a bináris fájlba hibakeresési információt, mellyel a forráskód futtatás közben is figyelhető. A hibakereső egy másik program, amellyel együtt indíthatod az alkalmazásodat, és amellyel töréspontokat állíthatsz be a kódban, ahol a futás megáll, így ellenőrzésed alá vonhatod az implementációs rész kritikus részeit, ezáltal felfedhető, hogy melyik a hibás sor. A hiba valódi okát megtalálni már egy másik feladat; ennek feltárása a programozón múlik. A gdb egy hibakereső amely a GNU fordítóhoz tartozik, és az olyan programok mint a ddd vagy a KDbg ehhez készült kezelőfelületek, melyek megkönnyítik használatát. A KDevelop a KDbg-t használja, a hibakereső folyamatot a "Debug" menü "Keres" parancsával, vagy az eszköztáron levő gombbal lehet segítségül hívni. Az alkalmazások hibakereséséről további információt a Projektek résznél és a KDevelop programozási kézikönyvben találhatsz.

## 4.4 További információk

Az ebben a fejezetben tárgyalt témák részletesebben ki vannak fejtve a KDevelop IDE által biztosított dokumentációban, és más dokumentációkban:

- A KDevelop programozási kézikönyv, benne teljes bevezetés a GUI alkalmazás tervezésbe, valamint a Qt és KDE könyvtárak használatába,
- ez a kézikönyv, az Áttekintéstől a Projektekig, a KDevelop minden funkcióját áttekinti,
- ez a kézikönyv, A Dialógus szerkesztő szakaszban részletesen kitér a dialógus szerkesztő használatára, bemutatva, hogy hogyan hozd létre a saját widget-eidet,
- a Qt-könyvtár Online-Referencia Dokumentációja, amely példaprogramokat tartalmaz a Qt GUI-eszközkészlet használatához, valamint benne van Qt osztályok referenciája, és képek a legfontosabb használatra kész widgetekről,
- A KDE Könyvtár Osztály-Referencia, amelyet a KDevelop hozott automatikusan létre a KDE könyvtárak forráskódjaiból, tartalmazza az osztályok és widgetek leírását, példaprogramokat használatukra,
- valamint az Interneten:
  - http://www.troll.no információ Qt és egyéb gyártók további widgeteiről,
  - http://www.kde.org információ a KDE projektről és a fejlesztői vezérelvekről,
  - http://developer.kde.org további referenciák a KDE alkalmazásfejlesztéshez
  - a KDevelop weboldalán http://www.kdevelop.org

Tovább Vissza Tartalom