KDevelop Felhasználói Kézikönyv -Fordítás alatt: Referencia Kézikönyv a Unix operációs rendszer alatt futó KDevelop Integrált Fejlesztői Környezethez, 1.0 Verzió
Vissza | Fejezet 4. Fejlesztés a KDevelop-pal | Tovább

# 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 KAppWizard dal, 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".

## 4.3.1. 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 kimenet i 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 kimenet i ablakban. Amint a READY (KÉSZ) felirat megjelenik a kimenet i 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.

## 4.3.2. 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és i folyamat követ, amely az object (.o) fájlokat összefűzi a végleges futtatható binárissá. Ezután kell megkeresni a hibák at, 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.

### 4.3.2.1. 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 widgetek et 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.

### 4.3.2.2. Ú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 widgetek et és az osztály aikat 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ő.

### 4.3.2.3. 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.

#### 4.3.2.3.1. 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ályok ra, 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ály ainak 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.

#### 4.3.2.3.2. 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.

#### 4.3.2.3.3. 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ák nak 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ák at, 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 kimenet i 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.

Vissza | Tartalom | Tovább
A KDevelop Eszközök rövid leírása | Fel | További információk