]>

# 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&odblac;i Környezethez, 1.0 Verzió
Ralf
Nolden
KDevelop fejleszt&odblac;i csapat

    Ralf.Nolden@post.rwth-aachen.de

29/07/1999
2.02.00
KDE

Ez a kézikönyv része a KDevelop Integrált Fejleszt&odblac;i Környezetnek és ebb&odblac;l kifolyólag a GNU Általános Nyilvános Licensz vonatkozik a terjesztésére; további információkért lásd:Copyright.

## Bevezet&odblac;

Ahogy a világon mindennek megvan a maga divatja, a jelenkor számítógépes világában egyre inkább terjed a szabad szoftver használata, akár üzleti célokra is. A legnépszer&udblac;bb szabad szoftver projekt a Linux. Mostanára általánosan elfogadott, hogy a Linux - ahogy más projektek, mint például az Apache web szerver, a Perl nyelv és a GNU eszközök sora - bebizonyította, hogy a szabad szoftver min&odblac;sége állja a versenyt a kereskedelmi szoftverekével. De dacára a min&odblac;ségnek, a felhasználóknak még mindig a Unix Rendszerek titokzatos parancsaitól kell szenvednie. A Linux növekedéséhez alkalmazások kellenek, ingyenesek és kereskedelmiek, és könny&udblac; használhatóság.

A KDE
projekt ezt a szakadékot próbálja meg sz&udblac;kíteni azáltal, hogy könnyen használható munkafelületet nyújt egy csoport könyvtárral együtt, kiterjesztent&odblac; a rendelkezésre álló GUI
-alapú szoftverek választékát. De mivel a szabad szoftver leginkább a szerz&odblac;je szabad idejében készül, különösen fontos kérdés, hogy a programozó mennyire kedveli a jelenlegi kódfejleszt&odblac; környezetet. A KDevelop meg kívánja tenni a következ&odblac; nagy lépést: megkönnyíteni a programozó életét és hatékonyabbá tenni a munkáját; a KDevelop-pal létrehozott termékek azonos fejlesztési id&odblac; alatt magasabb min&odblac;ségi és megbízhatósági szintet érhetnek el.

E cél elérése érdekében a KDevelop Integrált Fejleszt&odblac;i Környezet sok, a fejleszt&odblac;k által igényelt szolgáltatást nyújt, magába ágyaz mások által írt programokat, mint például a `make` és a GNU C++ fordítóprogram
ok, láthatatlan, integrált részévé téve &odblac;ket a fejleszt&odblac;i folyamatnak. A KDevelop tartalmazza:

- A C++ programozáshoz szükséges minden fejleszt&odblac;eszközt, mint például a fordítóprogram
  , linker
  , automake
  és autoconf
  ,

- Alkalmazásvarázsló
  t, amely teljes futtatásra kész mintaalkalmazást generál,

- Osztálygenerátort, új osztály
  ok létrehozására és az aktuális projektbe való integrálására,

- Fájlkezelést a projektbe tartozó források, fejlécfájlok, dokumentáció stb. rendezgetésére,

- Felhasználói kézikönyvek létrehozását SGML
  -ben és KDE kinézet&udblac; HTML
  -kimenet
  automatikus generálását,

- Automatikus HTML
  -alapú API-dokumentációt
  a projekted osztály
  aihoz keresztreferenciákkal a felhasznált könyvtárakhoz,

- "Nemzetköziesítési" támogatást az alkalmazásodhoz, lehet&odblac;vé téve, hogy könnyen új támogatott nyelvet adhassunk a projekthez,

- WYSIWYG (Amit látsz, azt kapod) -felhasználói felület létrehozását, beépített dialógusszerkeszt&odblac;
  vel,

- A projekted CVS általi verziókarbantartását, könnyen használható felületet adva a legs&udblac;r&udblac;bben igényelt funkciókhoz,

- Az alkalmazásod nyomkövetését, a KDbg
  integrálása által,

- Projekt-specifikus pixmap
  -ok szerkesztését a KIconEdit
  -tel,

- Bármilyen más eszköz beágyazását az "Eszközök
  "-menün keresztül egyéni igényt&odblac;l függ&odblac;en.

A KDevelop használatát élvezetessé teszi, hogy minden program egy helyr&odblac;l érhet&odblac; el, id&odblac;t takaríthatunk meg a szokványos fejleszt&odblac;i folyamat automatizálásával, valamint, hogy közvetlen és átfogó módon érhetünk el minden szükséges információt. A beépített böngész&odblac; eljárások támogatják azon kereséseket a documentáció
ban, amelyeket a fejleszt&odblac;k a projektjükkel kapcsolatban elindíthatnak.

Az osztály nézet
és a hibakeres&odblac; egy egérgomb klikkentésre bárhová eljuttat a projekt forráson belül anélkül, hogy fájlokban kellene keresgélni; A fájl-fa nézet közvetlenül elérhet&odblac;vé teszi a projekt fájlok
at és a beépített segít&odblac; rendszer bárhonnan az IDE-n belül nagyszer&udblac; hozzáférést biztosít az online dokumentációhoz.

### Változások

A KDevelop 1.0-ás verziója a C/C++ fejlesztésekhez leginkább szükséges szolgáltatásokkal érkezik. A KDevelop kifejlesztésének során a projekt óriási fejl&odblac;désen ment keresztül a 0.1-es verzió óta, amelyet a 0.2, 0.3 és a 0.4 verziók követtek; mindegyiket teszteltük, és a talált hibákat kijavítottuk. Úgy gondoljuk, hogy a jelenlegi lesz a KDE 1.x sorozathoz szánt végs&odblac; verzió, amely olyan fejleszt&odblac;i környezetet nyújt, amilyet a programozók használni akarnak.

A következ&odblac; területeken értünk el javulást:

- gyors osztályelemz&odblac; és & ;böngész&odblac;, grafikus osztály-fa nézettel, osztályok és elemeik dialógusalapú szerkesztésével,

- CVS támogatás a leggyakrabban igényelt funkciókkal, mint például fájlok és könyvtárak hozzáadása, törlése, frissítése és jóváhagyása,

- a KDevelop-pal együtt szállított frissített és kiterjesztett dokumentáció, amely pillanatnyilag öt kötetet számlál,

- javított osztályelemz&odblac;, dialógusszerkeszt&odblac; és hibakeres&odblac;.

Az IDE-r&odblac;l, a dokumentációjáról vagy a szolgáltatásairól bármilyen észrevételt örömmel fogadunk.

### Err&odblac;l a kézikönyvr&odblac;l

Ez a felhasználói kézikönyv teljes áttekintést nyújt a KDevelop IDE-r&odblac;l és röviden leírja a fejleszt&odblac;i folyamat alapjait. Egyedi programozási kérdésekhez további információkért a KDevelop-pal szállított KDevelop Programozói Kézikönyv elolvasását ajánljuk, amely olyan témákkal foglalkozik, mint például a generált keretalkalmazás
ok megértése és telivér KDE
alkalmazások létrehozása példaprojektek felhasználásával.

Ez a kézikönyv a következ&odblac; részeket tartalmazza:

- A Telepítés fejezet ismerteti az ajánlott konfigurációt, a KDevelop IDE telepítését és üzembehelyezését.

- A Programok fejezet elmondja, hogyan hoznak létre programokat szabványos GNU fejleszt&odblac;eszközökkel, és hogyan lesznek lefordítva.

- A Fejlesztés a KDevelop-pal fejezet rövid kirándulásra visz, körülírva a környezet f&odblac;bb funkcióit.

- Az Áttekintés fejezet bemutatja a menüket, dialógusablakokat és a billenty&udblac;kombinációk
  at.

- A Súgó Rendszer megmutatja a beépített dokumentáció-böngész&odblac;
  használatát és a további súgó funkciókat.

- A Munkában a Szerkeszt&odblac; fejezet elmagyarázza a fájl-kezelés és szerkesztés szolgáltatásait.

- A Projektek fejezet leírja a szoftver projektek létrehozását és karbantartását.

- A Build beállítások fejezet referenciát tartalmaz a fordítóprogram
  és a linker, valamint a projekt beállításairól.

- Az Osztályböngész&odblac; fejezet elmondja, hogyan használhatjuk ki a KDevelop hatékony Osztályböngész&odblac;jének a szolgáltatásait.

- A Dialógus szerkeszt&odblac; fejezet felvázolja a beépített GUI
  épít&odblac;t, és az általa generált C++ kimenet
  et.

- Az Általános beállítások fejezet megmutatja, hogyan lehet a KDevelop-ban átlalánosan használt beállításokat megadni.

- A Kérdések és Válaszok fejezet a KDevelop különböz&odblac; Unix rendszerek alatti használatát, és általános problémákat érint&odblac; kérdéseket taglal.

Kezd&odblac; programozóknak és a KDevelop új felhasználóinak melegen ajánljuk ezen kézikönyv átolvasását, miel&odblac;tt az IDE-vel munkába kezdenének, mivel annak használatát mélységében taglalja. Annak megértése, hogyan lehet valamit a leggyorsabban elérni rengeteg, funkció és szolgáltatások utáni keresés idejét spórolhatja meg a számunkra, mivel még egyszer&udblac;bbé teszi az els&odblac;rangú fejleszt&odblac;eszközök használatát.

## Telepítés

### Hogyan szerezzük be a KDevelop-ot?

A KDevelop megtalálható egyrészt a KDE
Alkalmazások oldalon a \|\| címen, vagy a KDevelop honlapon: \|\|. A KDevelop része a Linux disztribúcióknak is, mint például a SuSE 6.1.

Azok számára, akik követni akarják a KDevelop fejlesztésének menetét a honlapunkon a KDevelop CVS raktárból napi levonatokat is felajánlunk. Általában ezek a levonatok nem ajánlottak programfejlesztésre, viszont ki lehet rajtuk próbálni a legújabb szolgáltatásokat és betekintést nyújtanak a KDevelop csapat fejleszt&odblac;i folyamatába. Különböz&odblac;, a KDevelop-hoz szükséges mások által írt szoftvert is ajánlunk, mint például a KDoc
és a KDbg
.

Ha a KDevelop fordítása vagy használata során problémákba ütközöl, kérjük olvasd el a Kérdések és Válaszok fejezetet ebben a kézikönyvben, vagy a GYIK (FAQ) fájlt a KDevelop csomagból. Ha a problémádra nem találsz választ, kérjük íratkozz fel a KDevelop levelezési listára itt: kdevelop@fara3.cs.uni-potsdam.de azáltal, hogy egy üres fejléc&udblac; levelet küldesz, és a levél tartalma csak egy szó: "subscribe" (felíratkozom). A kérdés lehet&odblac;leg a KDevelop IDE használatára vonatkozzon, és ne az általad írt alkalmazás kódolása során felmerül&odblac; megvalósítási
problémákra. Akárhogy is, minden a listára küldött levél nyelve lehet&odblac;leg angol legyen, hogy minden tag részt vehessen a probléma megvitatásában, és így jobban tudjunk segíteni. A levelez&odblac;lista azon felhasználók számára is készült, akik hozzá kívánnak járulni a fejlesztéshez, vagy megtalálták egy általuk ismert hibának a megoldását, így mi ki tudjuk küszöbölni a hibák
t és eltárolni ezt a tudást, hogy a kezd&odblac;knek még szakszer&udblac;bb segítséget nyújthassunk. A hibák bejelentésének egy bevált módszere ha elküldöd a kimenet
et a konzolból indított KDevelop után, vagy ha kimásolod és beilleszted a KDevelop bels&odblac; Üzenetek-ablak
ának tartalmát.

### Rendszer követelmények

Ahhoz hogy sikeresen lefordítsd és használd a KDevelop-ot, a következ&odblac; programokra és könyvtárakra lesz szükséged, melyek a legtöbb platformon elérhet&odblac;k disztribúciós csomagokként, és ilyen módon könnyedén telepíthet&odblac;k.

Szükséges:

- g++ 2.7.2/g++ 2.8.1/egcs 1.1 (vagy kompatibilis), letölthet&odblac;: \|\|

- GNU make (vagy kompatibilis), letölthet&odblac;: \|\|

- perl 5.004, letölthet&odblac;: \|\|

- autoconf
  2.12, letölthet&odblac;: \|\|

- automake
  1.2, letölthet&odblac;: \|\|

- flex 2.5.4,

- GNU gettext, letölthet&odblac;: \|\|

- Qt 1.42, letölthet&odblac;: \|\|

- KDE
  1.1.x, letölthet&odblac;: \|\|

Választható:

- a2ps
  vagy enscript
  a nyomtatás
  támogatására

- ghostview vagy kghostview a nyomtatás
  i el&odblac;nézethez

- glimpse
  4.0 a keresési index
  hez, letölthet&odblac;: \|\|

- sgmltools 1.0, letölthet&odblac;: \|\|

- KDE-SDK
  (KDE Szoftver Fejleszt&odblac; Készlet - Software Development Kit), amely tartalmazza a KDoc
  -ot, KSgml2Html
  -t, KTranslator
  -t (letölthet&odblac;: \|\|)

- KDbg
  , letölthet&odblac;: \|\|

- KIconEdit
  (letölthet&odblac;: \|\|)

A KDevelop SuSE Linux 5.2-es disztribúción lett tesztelve, hardver: AMD K6 200, 64MB RAM, továbbá FreeBSD 3.0-n és SuSE Linux 6.0-n, hardver: Intel 200 MMX, 128MB RAM.

A szerz&odblac;k tudomása szerint, a SuSE Linux és a FreeBSD minden szükséges csomagot tartalmaznak, beleértve az a2ps
-t és enscript
-et csomag vagy .rpm fájl formájában, így a szükséges más által írt szoftverek telepítésének nem kellene gondot okoznia.

Dokumentáció:

A KDE
könytár dokumentációjának létrehozásához szükség lesz a kdelibs csomagra forráskód formájában, elérhet&odblac; a rendszereden a disztribúcióban a KDE projekt részeként szállított forrás-csomagokban; és a KDoc
-ra (a KDE-SDK
-ban található).

A honlapunkról (\|\|) ajánlunk még egy C/C++ Referenciát
, amely telepítése után a dokumentáció böngész&odblac;be kerül integrálásra. Töltsd le a csomagot és másold be a forrás fájlt `root` felhasználóként a KDE
könyvtárba és csomagold ki a `tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz` paranccsal, ezután a referencia elérhet&odblac; lesz a dokumentációs fában; egyébként, ha a böngész&odblac;ben a referenciakönyvet választod, egy hibaüzenet jelenik meg a KDevelop honlap URL-lel, felajánlva a letöltést és leírva a telepítési eljárást.

### Fordítás és Telepítés

Ahhoz, hogy lefordítsd a KDevelop-ot és telepítsd a rendszeredre, a következ&odblac;ket gépeld be a KDevelop forrás disztribúció f&odblac;könyvtárában:

    	&&percnt;; ./configure
    	&&percnt;; make

    	(root-ként)

    	&&percnt;; make install

Miután a KDevelop az `autoconf
`-ot használja, a lefordításnak nem kellene problémát okoznia.

KDevelop CVS levonat fordításához a következ&odblac;ket gépeld be:

    	&&percnt;; make -f <idx/Makefile.cvs/
    	&&percnt;; ./configure
    	&&percnt;; make

    	menj át `root`-ba, és gépeld:

    	&&percnt;; make install

Ha a rendszered make-parancs
a a `gmake`, írj `gmake`-et a `make` helyett.

### A KDevelop elindítása

Ha ablakkezel&odblac;ként KDE
-t használsz, a KDevelop a "K"&->;"Fejlesztés"&->;"KDevelop 1.0" útvonalon érhet&odblac; el. Minthogy a KDevelop támogatja a KDE
-Mime-típusokat, egy KDevelop projekt fájlra ("*.kdevprj", a KDevelop projekt ikonnal jelezve) kattintva a KDE
Fájlkezel&odblac;ben is elindítható (az adott projekttel együtt). Más ablakkezel&odblac;k alatt nyiss meg egy konzolt és gépeld be:

    &&percnt;; kdevelop

Létez&odblac; projekttel a KDevelop-ot úgy indíthatjuk, hogy belépünk az adott projekt könyvtárába és begépeljük:

    &&percnt;; kdevelop  &<;aTeProjekted&>;.kdevprj

A KDevelop els&odblac; indításkor minden felhasználónál elindítja az automatikus telepítés programot, amely lehet&odblac;vé teszi a leggyakrabban használt választások gyors beállítását. Ha a telepítés el lett fuserálva, bármikor újrakonfigurálhatod a KDevelop-ot begépelve:

    &&percnt;; kdevelop  --setup

vagy, a KDE-t használva a "K"&->;"Fejlesztés"&->;"KDevelop Setup" menü kiválasztásával.

### A telepít&odblac;program

A KDevelop tartalmaz egy automatikus telepít&odblac; program modult, amely akkor kerül meghívásra, amikor a KDevelop-ot elindítják, de a kdeveloprc konfigurációs fájl nem létezik. Azt javasoljuk, kövesd a telepítés lépéseit a "Végrehajtás" kiválasztásával, hogy automatikusan ellen&odblac;rízze a rendszeredet és bel&odblac;je a KDevelop környezetet.

A telepít&odblac; dialógus nyomógombjai a következ&odblac; célokra szolgálnak:

Segítség: Megnyitja a KDEHelp programot.

Végrehajtás: Elindítja a telepítési folyamatot és a következ&odblac; lépéseket teszi:

1. Ellen&odblac;rzi a make/gmake, autoconf
   , autoheader, automake
   és perl meglétét a KDevelop által generált új alkalmazások létrehozásához és lefordításához. Ha a gmake van telepítve, a make-parancs
   automatikusan átállítódik ennek a használatára. A make programhoz további parancssori beállítások a "Projekt/Beállítások" menüben adhatók meg; a Unix rendszer alatti fejlesztésr&odblac;l rövid ismertet&odblac; a Programok fejezetben található.

2. Ellen&odblac;rzi a KDoc
   és a glimpse
   meglétét. Ezek teszik lehet&odblac;vé az új KDE-Könyvtár
   dokumentáció és a keres&odblac; index
   automatikus létrehozását a telepítés
   egy kés&odblac;bbi pontján, már ha megvannak.

3. Ellen&odblac;rzi az a2ps
   vagy az enscript
   jelenlétét, hogy biztosítsa a nyomtatás
   támogatottságát. A helyes nyomtatáshoz a két program valamelyikének rendelkezésre kell állnia. Ha egyik sincs telepítve, ezt bármikor a kés&odblac;bbiekben megteheted anélkül, hogy újra kellene futtatni a telepít&odblac;
   programot.

4. Ellen&odblac;rzi a KDbg
   , KIconEdit
   és KTranslator
   meglétét. Javasoljuk, hogy telepítsd ezeket a programokat, mivel kiváló segítséget nyújtanak komplett KDE
   -alkalmazások létrehozásánál. Megjegyzend&odblac;, hogy a KDbg
   közvetlenül elérhet&odblac; a KDevelop-on belül az aktuális projekt nyomkövetésére; a KIconEdit
   a fájl-nézeget&odblac; fában kijelölt pixmaps
   -ek kirajzolására és szerkesztésére használatos. A KDbg
   , KIconEdit
   és KTranslator
   programok -ha megvannak- úgy lesznek konfigurálva, hogy elérhet&odblac;ek legyenek az "Eszközök
   " menüb&odblac;l. Egyéb programok is hozzáadhatóak az Eszközök
   -menühöz kés&odblac;bb a "Beállítások" menüben az "Eszközök
   ..." menüpont kiválasztásával.

5. Summary of detected programs: the installer lists those programs it found and those it didn't. Additional hints are given, if a needed program is recommended.

6. Detection of your Qt-Documentation
   path: this checks for several standard paths in your system for the documentation and sets the path automatically. If your Qt-Documentation
   could not be found either because it is not installed or your system keeps it at a different location, a message will appear that asks you to set the correct path manually or to continue. Choosing the button to set the path will return to the main installation window and shows an editing field with a button on the right of it to choose the path. Usually this is in the qt/html directory. After doing so, the installation can continue with the selection of "Proceed" again.

7. If KDoc
   was detected, you are asked to create/update your KDE
   -library documentation. For that, you need to have the kde-libraries in source form. For Linux-Users who have installed KDE
   from a distribution, we suggest to copying and extracting the source of the kdelibs-package to your system; Free BSD users who installed the kdelibs as a package should look for their according distfile package of the ports-collection. If none of these cases match your situation, you should download the sources from \|\| and untar the sources on your system. If you wish to use the documentation package provided by \|\|, cancel the creation and continue with creating the search index
   . After the installer finished and KDevelop has been started, set the path to the extracted documentation package in the KDevelop Setup dialog and run the search index
   setup
   again, which can be found at the same setup
   page of the dialog.

   The "Update KDE
   -Library documentation" dialog is set up to use a default path for the location of the documentation in $(HOME)/.kde/share/apps/kdevelop/KDE-Documentation. The only thing you have to do is choosing the path to your library sources you extracted on the system with the selection button on top of the dialog and press OK. As an example, if you got the kdelibs.tar.gz package from \|\| and downloaded it to your home directory, you should open a console or terminal and enter "tar zxvf kdelibs.tar.gz". This will untar the sources into a directory $HOME/kdelibs, which then contains the sources for each library in a subdirectory, e.g. for kdecore, this would be in /home/rnolden/kdelibs/kdecore. Now, the path you have to enter in the KDE-Library documentation dialog would be the path to all libraries, in the example /home/rnolden/kdelibs. After pressing the OK button, a message in the installation window shows that the documentation generation is in progress and you should wait for the next message.

   NOTE: On a multi-user system
   or systems with disk-quotas
   for user accounts, the installation of a complete HTML
   documentation for each user would be a waste of disk space. In this case, ask your system administrator to run KDevelop under the root account to allow write access to the system's root directory. Then install the documentation within the KDE
   -directory, under $KDEDIR/share/apps/kdevelop/KDE-Documentation. The correct path can then be set up later in the KDevelop setup
   dialog, available in the "Options"-menu
   .

8. If the system check found the glimpse
   program on your system, you are offered to create a search database. The search database can be created with the options of including the KDE-Documentation
   and the Qt-Documentation
   (default). Additionally the KDevelop documentation is included and will be indexed. If you have other documentation that you want indexed you can select the directories and add them to the indexing process as well.

9. During the creation of the search index
   , the installation window will show a message that this is in progress.

10. If all installation steps were done correctly, a final message states that KDevelop will be started after pressing OK. Mind that you can set up additional options like auto saving in the KDevelop Setup dialog that can be accessed through the options menu.

Cancel: Will show a warning message that the installation process is going to be canceled. This warning message allows you to return to the installation ("Back") or to start KDevelop with the default values ("Continue"). Mind that in this case you will have to set all options yourself with the configuration dialog
s provided in the options-menu.

## Programok

Now that KDevelop installed successfully and the most commonly used options are set, you are probably wondering if it keeps what it promises. This Chapter gives you a guideline to how programs are created using the GNU tools in general and especially what part KDevelop plays in this game.

### A Fordító

The Compiler
is actually the program on your system that has to be installed as a minimum to create running programs; he is the one that compiles the source code into object files and creates the program.

Normally, you would start like this: Open an editor of your choice - don't use a word-processor. Type in something like this to create the source for your first program:

    #include <iostream.h>

    int main(){

    cout << "Hello World" << endl;

    }

Well, actually all the program will do is to print out the string "Hello World" to your standard output
. But this is just the source code for the program to be build, not the program itself. Therefore, we need a Compiler
, in this case a C++-Compiler
like g++. Then we can save the file with the source code, as, let's say, myprogram.cpp and invoke the Compiler
with the filename (on a console):

    g++ -o myprogram myprogram.cpp

Then we can start our program- just type `myprogram` on the console, and the program prints out the string; then exits.

### Make és Makefile
s

I have everything I need: an editor, a Compiler
and I can execute my own C++ program. But it isn't all that easy. What happens if you have more than one source file ? And, do you have to compile all sources over and over again only if you changed one file ? Compiling will become more and more complicated and time-consuming, because you have to type in all the commands and options yourself. Therefore, you could write a so-called "Makefile
". You could also call it some other name except the name of the program to build. Then, you should have the tool `make` or `gmake` installed, or any other tool that is capable of keeping track of a project's compilation. Insert all your Compiler
commands in a certain syntax into that Makefile
and save it; then you will only have to type `make` or `gmake` on the console in the directory where your Makefile
is located, and then make takes over, leading the Compiler
to create your application. The make utility has many other advantages and can be used to a lot of purposes. To get a complete overview, open a console and type:

`man make`

or search for "GNU Make" in KDEHelp, "System GNU Info contents". At least, you have an insight, why a developer needs the make utility for making it easier to compile his application. Now, writing Makefile
s is not only handwork until now, you also have to dig yourself into the whole syntax and options. But here is the good news about KDevelop and any Make-utility: You just have to set the Make-Command in the KDevelop Setup dialog, and then you're done. All projects generated with KDevelop will use that Make command to build the target application, and no typing at all. Just hit the buttons on the toolbar of KDevelop, beginning with the one after the second separator line, or choose the desired function for Make in the "Build" menu.

The toolbar and the build-menu then offer the most-common functions that you need to let make do the dirty work:

- Compile File
  : is only active if you're working on a source file. It invokes make with the correct command to compile only the current source.

- Make: just calls make and creates your target.

- Rebuild all: rebuilds the whole project

- Clean/Rebuild all: cleans the project directory first and then runs make again.

- Stop Build: cancels the current process- this is mostly used if you watch make working and staring at your sources. Then- ahh- I forgot about this line...and you have to correct your code. Just hit Stop, correct the error you found by yourself and run Make again.

But this is not the only way how KDevelop works together with make- for KDE
applications, there are some things that are special, like creating the message files for internationalization. These functions are also included, so no worry about these things anymore.

Until now, you know about sources, the Compiler
and why make is needed. In the next section, we'll discuss how it comes that projects created with KDevelop automatically can be compiled on most other Unix-platforms using the `configure-` script.

### Beállítás

The title of this section lets you probably question: Configure ? What has to be configured ? Or who ? Well, assume you have written a program including a Makefile
. Then you like to distribute it, but the binary compiled does only run on your system or on systems that are compatible with yours. To support other platforms like different Unix-systems or machines like Alpha's or RISC's, you have to recompile the program. The easiest way would be to copy the source package to the target machine and run `make` again. But what if the target machine uses another Compiler
command or has in some other way a problem to build your binary ? Not to mention more difficult issues like installation paths for your program and documentation- e.g. KDE
can be installed in ``opt/kde/ on one machine, while it is installed under ``usr/local/kde/ on another. In this case, you would have to rewrite the Makefile
each time to ensure a correct compilation and installation of your product.

Fortunately, GNU-tools have even more to provide than that mighty `make`- the commonly used automake
and autoconf
packages. It sounds good to hear something with "auto"- seems like something about application design can be done quick and easy, which exactly hits the point.

Automake's purpose is generally to create a so-called `Makefile.in
` from a file `Makefile.am
` which you have to write for your project. This Makefile.am
consists of macros which can be interpreted and reduce the complexity that make offers, so a Makefile.am
is written safer and quicker than the final Makefile
.

Having this said, who is finally creating me my Makefile
? Now, here comes autoconf
. Autoconf requires several macro files for the project. That are those Makefile.in
's generated by automake
and a file called `configure.in`, also containing macros. Hereby the Makefile.am
and .in's are containing macros that are responsible for the way how to build the software in terms of which sources have to be compiled, which files belong to the package and what name the final binary or library will have after a build. Configure.in on the other hand contains macros for what the final configure-shell script will check for on the system configure is executed. Those could be e.g. the Compiler
command, required libraries against which the final binary will be linked, include-files the project needs and their location.

For example you want to write a KDE
application. After writing your sources, you want to distribute the program to the user community, and each user has to compile the binary on his own. Then you would write a configure.in file that contains the macros for a KDE
-compliant application. That one macro finally expands to a check on the system whether the Qt-library is installed, checks for the Qt-header files, the KDE-libraries
and headers etc.

Summary: To create a GNU-compliant application that is portable to different Unix-OS's and machines other than yours, you will need to do the following:

1. write the sources of your project

2. write a Makefile.am
   for each subdirectory, including the main project directory of your project

3. write a configure.in file placed in the main project directory containing the macros for system requirements

4. run automake

5. run autoconf

Then the main work is done. Automake creates the Makefile.in
's, autoconf
processes the configure.in and generates an executable shell script called `configure`. All you then have to do is to execute it with `.`configure/ and the script will run the checks of your choice. Finally Makefile
s will be generated that allow a final execution of make (or gmake) that will process all Makefile
s and then you're done.

This seems to be a lot of stuff for writing a small application and much to learn especially how to write correct macros. But even the fact that you provide a compilation on almost all Unix-systems will be worth this work sooner or later. Finally, you only have to do this work once for your project and in case your project's files increase you only have to add the filenames to the macros.

Now, how far does KDevelop support this kind of application development and how complicated does it get for the programmer ? The good news is, that you don't even have to know anything about macros and scripts. All details are hidden behind an easy to use graphical interface doing the work for you. An application is therefore created with GNU tools in a very user-friendly way:

Just generate your application with KAppWizard
, by the choice of your application's needs- may it be a pure C++ terminal application or a kind of GUI
program using Qt or the Qt/KDE
libraries. All work is done automatically and your project already contains the Makefile
s that are created by an auto-execution of the GNU-tools and the configure-script.

This is it- you're ready to extend the source of your project, may it be by adding classes
, dialogs, translations or documentation, which is also completely automated. Just concentrate on the real work of the developer, which is providing functionality for the final application that you want to create. In most cases, you probably won't come in touch with Makefile
s at all when using KDevelop.

### Nyomkövetés

The following section covers a term that is widely used by developers: Debugging. It means, that, although your Compiler
produces the final application, your application may not run or crash during execution due to a so-called "bug" in the code. A program error described by the name of this insect comes from the history of computing; one of the first errors
that caused a machine to crash was not obviously a malfunction- bugs were inside the computer which were responsible for it. Therefore, an error not detectable on the first look is called a "bug", so "debugging
" means to throw out bugs where they shouldn't be. Now, you don't have to hunt them for real; assuming that today's computers are designed to keep them out by some kind of outer protection. They have to be found inside the code, mostly ending the execution of a program with the message "Segmentation fault". GNU provides another tool called `gdb`, the GNU debugger. This terminal program allows to watch the internal values of an application and the execution step by step with setting "breakpoints" in the code. Gdb stops the execution every time the program comes to a breakpoint while executing. But like most other tools, the debugger is handled by another program providing a frontend to it, allowing to easily watch values and the setting of breakpoints in the code.

For this purpose, your project's application is by default created with a Compiler
option for debugging
, thereby storing additional data in the executable to allow the localization of values and lines in the code. As a third-party frontend to gdb, KDevelop makes use of KDbg
, the KDebugger. To debug your program, you just have to select "Debug" in the Build-menu or press the according toolbar button displayed by a wheel having glasses over it, signaling that you want to watch the execution.

KDevelop then opens the Tools
-window and starts your application with KDbg
. The KDbg
interface appears inside the Tools
-window and allows the usage just like you started it from outside.

In general, the above steps are clearly showing the need of certain steps that a developer has to do when starting to write his own application, and cover issues that are common to all projects. Also, we explained what part KDevelop does for a developer and how it supports the idea of providing an easy way to Unix programming. To get further information about the role and purpose of GNU tools, you should read the documentation provided with them, commonly accessed via the `man` command or by the "System GNU Info contents" section in KDEHelp.

## 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&odblac;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&odblac; 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&odblac;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&udblac;l elolvashatod a Programok részt, hogy jobban megértsd, hogy a Unix alkalmazásokhoz miért van szükség fejleszt&odblac;eszközökre; ezek jelent&odblac;sen megkönnyítik a dolgunkat, nézzük meg például, hogy mik a Makefile
-ok, stb.

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

A KDeveloppal készített projektek nagyban megkönnyítik a GNU standard fejleszt&odblac;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&odblac; 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&odblac;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&odblac;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&odblac;s projekteknél, ahol a fejleszt&odblac;k talán még különböz&odblac; helyeken is dolgoznak, ezzel a módszerrel bizosíthatják a Makefile
-ok következetességét, és azok különböz&odblac; verziói nem fognak egymással ütközni. Különösen hasznos többnyelv&udblac; 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. &Odblac;k mindenképpen hálásak lesznek, mert a KDevelop leegyszer&udblac;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&odblac;en. Ezután elkezdheted a felhasználói felület fejlesztését el&odblac;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&odblac; írja meg a kódot, amely lefut a programinduláskor. A következ&odblac; lépés a felhasználói felület kib&odblac;vitése, a KDevelop által létrehozott elemek módosításával, b&odblac;vítésével. Ilyenek a menük, eszköztárak, státuszsorok. Mivel az er&odblac;források egy er&odblac;forrásfájlba vannak gy&udblac;jtve ezért ezek könnyen kiegészíthet&odblac;k új értékek hozzáadásával a már létez&odblac;khöz; a megadott er&odblac;források akár irányadóként is használhatók a te egyedi er&odblac;forrásaidhoz. Miután kiegészítettük azokat a metódusokat, amelyeket a dialógus szerkeszt&odblac;
készített és üresek, vagy már van bennük kód a szokásos felhasználói m&udblac;veletekre, jöhet a Felhasználói kézikönyv kiegészítése a ez el&odblac;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&odblac;inek is könny&udblac; utat kínál új projektek létrehozásához; a szerkeszt&odblac; és az Osztályböngész&odblac; a KDevelop er&odblac;teljes projekt menedzsmentjével arra a minimumra csökkenti a fejlesztési id&odblac;t amely a program rendeltetésének kifejtéséhez
szükséges.

### 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&udblac;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&odblac;
; 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&odblac;

##### 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&udblac;sítve azok használatát. A beépített szerkeszt&odblac;je és Súgó böngész&odblac;
je csakúgy mint az Osztályböngész&odblac; 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&udblac;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ályok
at, 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&odblac;

A KDevelop beépített dialógus szerkesz&odblac;
je könny&udblac; módot biztosít a Qt és KDE könyvtárak által biztosított felhasználói felületek tervezéséhez. Ez lehet&odblac;vé teszi, hogy szinte mindent az egérrel végezzünk, így biztosítja a párbeszédablakok (dialógusablakok), és f&odblac;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&odblac;
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&odblac; 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-parancs
ok és emellett ellen&odblac;rizheted a fordító
kimenet
ét anélkül, hogy vissza kéne kapcsolni a forráskód szerkeszt&odblac;re. Részletes leírás a Dialógus szerkeszt&odblac; 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&odblac;k is bele tudjanak fogni a GUI
alkalmazástervezésbe, és gyorsan érjenek el eredményeket.

##### KAppWizard

A KAppWizard
célja m&udblac;köd&odblac;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&odblac;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&odblac; 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&odblac; 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&odblac;" 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&odblac; el.

##### Osztályeszközök

Az "Osztályeszközök" fogalom egy sor lehet&odblac;séget jelöl, melyek a fejleszt&odblac; 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ályok
kal dolgozni különálló fájlok helyett nagyon rugalmas utat kínál egy projekt b&odblac;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&odblac;, mindkett&odblac; jónéhány automatizált lehet&odblac;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&odblac; dolga, hogy osztályok
at 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&odblac; 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&odblac;osztályt, az örökl&odblac;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&odblac;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&odblac;dni a Makefile.am
-mel, és az osztállyal. Az új "make" használata elegend&odblac;, hogy az új osztály belekerüljön a fordítási folyamatba. Mivel az Osztályböngész&odblac; 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&odblac;vítésével. Az Osztály generátor a Projekt menü "Új osztály
..." menüpontjával érhet&odblac; el.

###### Az Osztályböngész&odblac;

Az Osztályböngész&odblac; megjeleniti a projektben lév&odblac; összes objektumtípust és függvényt egy faszerkezetben, balra a szerkeszt&odblac;ablaktól. Egy osztály elemz&odblac; végignézi az összes fájlt metódusokat és osztályok
at keresve, majd grafikusan jeleníti meg &odblac;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ályok
ra és a függvényekre fókuszáljunk. Egy osztály kiválasztása azt eredményezi, hogy a szerkeszt&odblac;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&odblac; résznél találsz.

### A Fejleszt&odblac;i folyamat

Egy új alkalmazás fejlesztése a KDeveloppal alapvet&odblac;en két f&odblac; részre osztható: el&odblac;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&odblac;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&odblac; 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&odblac;vítjük az alkalmazást. A projekt fájl az a fájl amit kés&odblac;bb betöltve megjelenik a teljes projekt a fejleszt&odblac;i környezetben.

A KAppWizard
-ot a "Projekt"-menü "Új..." menüpontjával érheted el. Amikor a varázsló megjelenik, az els&odblac; oldalon meg kell határoznod a projekt típusát. A "Következ&odblac;>>" 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&odblac;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&udblac;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&odblac;dik az alkalmazás létrehozása, amely jónéhány lépésb&odblac;l áll, és a lépések nyomon követhet&odblac;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&odblac;l, vagy ugyanezt a gombot az eszköztárról. A már létez&odblac; 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&odblac;
vel való fejlesztési fázisokat ábrázolja - amely mind elvégezhet&odblac; az IDE-n belül.

A lépések általában a forrásfájlok szerkesztéséb&odblac;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&udblac;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&odblac;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&udblac; abrázolni általánosan, hogy hogyan fejleszd saját alkalmazásod. Tipikusan, a szokásos eljárás az, hogy el&odblac;ször létrehozod a projekt látható részeit, mint a f&odblac;ablak, és a dialógus ablakok amelyekkel a különböz&odblac; beállítások végezhet&odblac;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&odblac;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&odblac; 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 &odblac; és a program "egymásra hatnak". Ezért egy programnak általában van menüsora, eszköztára és státuszsora úgy mint f&odblac; nézete, ami például egy szövegszerkeszt&odblac;nél egy szöveg beviteli mez&odblac; lehet. A KAppWizard
által készített alkalmazások, már egy sor ilyen grafikus felület&udblac; funkcióval rendelkeznek - a keretstruktúra gondoskodik az ilyen szokványos elemekr&odblac;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&odblac; a dialógus szerkeszt&odblac;
vel a KDevelop-on belül. Hogyan is csináljunk ilyen tetszet&odblac;s ablakokat ? Mivel a Qt-könyvtár
egy GUI
készlet, ezért egy jónéhány alapvet&odblac; ú.n. "widget
"-et kínál. Ilyenek a cimkék, melyek szöveget, vagy képet jelenítenek meg, szövegbeviteli mez&odblac;k -egy vagy többsorosak is akár- és gombok a navigáláshoz, vagy parancsok végrehajtásához. Ezek mellett az "alacsonyszint&udblac;" 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&odblac;l vannak képek, így akár el&odblac;ször meg is nézheted ott &odblac;ket. Ezután azt tanácsoljuk, hogy ismerkedj meg közelebbr&odblac;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&udblac;síti az alkalmazás tervezést, úgy mint az el&odblac;re gyártott párbeszédablakok a Qt-ben. A te egyedi párbeszédablakaidhoz az alacsony-szint&udblac; widgetek
-re lesz szükség. Egy párbeszédablakot a különböz&odblac; widgetek
egymással kombinált gy&udblac;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&odblac;
je jó módszert kínál a párbeszédablakok készítéséhez: Vizuális szerkesztést tesz lehet&odblac;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&odblac;
re "Nézet" menü megfelel&odblac; pontjának kiválasztásával (vagy az eszk&odblac;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&udblac;vé teszi az oda-vissza kapcsolgatást a két mód között és egy id&odblac; múlva mindkett&odblac;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&odblac; 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&odblac; dialógus ablakok listája - új projekt esetén ez üres, a f&odblac;ablakot ne keressük itt, mert nincs a listában. Ezután az egér jobb gomjával a lista tetjére kattintva el&odblac;jön egy helyi menü, benne az új dialógusablak menüponttal. Innet&odblac;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&odblac;l; a dialógus szerkeszt&odblac;
és a projekt kezel&odblac; elvégzi a többit. Ha a dialógust vagy nézetet most hoztad létre el&odblac;ször, akkor a dialógus szerkeszt&odblac; majd bekéri az osztály nevet és a szül&odblac; 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&odblac; szokásos munkája. Ne aggódj, ez sem túl bonyolult. További információt a Dialógusszerkeszt&odblac; 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 &odblac;ket objektumokon keresztül. Amint azt feljebb említettük egy szokásos GUI
-alapú program vezérl&odblac;ket és egy központi nézetet tartalmaz, ahol esetleg a f&odblac;nézet is m&udblac;ködteti a vezérl&odblac;ket. Ezek mind az alkalmazás f&odblac;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&odblac;" modellnek lehet nevezni. Ez a modell a programban betöltött szerepük szerint ábrázolja az objektumok alapvet&odblac; funkcióit. A Vezérl&odblac; 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&odblac; módszerrel lehet a megadott osztályt kib&odblac;viteni:

- szakítunk a Dokumentum-Nézet struktúrával és valamely el&odblac;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&odblac;dését. Változtasd meg a szül&odblac;osztályt például QMultiLineEdit-re és az alkalmazásod szinte máris egy egyszer&udblac; szövegszerkeszt&odblac;.

- Ha a központi nézeted néhány különálló részb&odblac;l áll, hozd létre a widgetek
  et és az osztály
  aikat a dialógus szerkeszt&odblac;
  vel és a Nézet osztály konstruktorában hozz létre objektumokat ezekb&odblac;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&odblac;le létre, ami ténylegesen a párbeszédablak lesz. Az els&odblac;, 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&odblac;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&udblac;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&odblac;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&odblac;.

##### 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&odblac;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&odblac;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&odblac; legrövidebb id&odblac; alatt érje el. Amint azt fentebb tárgyaltuk a KAppWizard
és a dialógus szerkeszt&odblac;
lerövidítik azt az id&odblac;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&odblac;, 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&odblac;l a programkód általában szét van bontva több különböz&odblac; 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&odblac;, 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&odblac; 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&odblac; á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&odblac;dést és a dokumentációt. Az Osztályböngész&odblac; elvezet az objektumaidhoz; töbé nem számít, hogy a kód valójában hol található. A böngész&odblac; 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&odblac;vé teszi, hogy az új kódot közvetlenül is elérd. A helyi menük használatával a böngész&odblac; 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&odblac; segítségével, amely faszerkezetben mutatja annak használatát, tartalmát, örökl&odblac;dését és az osztályból létrehozott objektumokat. Részletes információért nézd át az Osztályböngész&odblac; 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&odblac;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&odblac; menüpontokat a "Build" menüb&odblac;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&odblac;fordulhatnak mind az építési folyamat során (amelyeket a fordító
detektál, és szintaktikai hibák
nak nevezik &odblac;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&odblac;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&odblac;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&odblac; a megnyitja a hibás sort tartalmazó fájlt, és a hibát tartalmazó sorra ugrik. Ugyanezt megtehetjük a "Nézet" menü "El&odblac;z&odblac; hiba" és "Következ&odblac; hiba" pontjaival, vagy a megfelel&odblac; billenty&udblac; kombináció
val. Ezt a funkciót nagyon hasznosnak fogod találni, ami rengeteg id&odblac;t takarít meg a hibakeresésnél. A futásidej&udblac; 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&odblac;. A hibakeres&odblac; 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&odblac;rzésed alá vonhatod az implementáció
s rész kritikus részeit, ezáltal felfedhet&odblac;, 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&odblac; amely a GNU fordító
hoz tartozik, és az olyan programok mint a ddd vagy a KDbg
ehhez készült kezel&odblac;felületek, melyek megkönnyítik használatát. A KDevelop a KDbg
-t használja, a hibakeres&odblac;
folyamatot a "Debug" menü "Keres" parancsával, vagy az eszköztáron lev&odblac; gombbal lehet segítségül hívni. Az alkalmazások hibakeresés
ér&odblac;l további információt a Projektek résznél és a KDevelop programozási kézikönyvben találhatsz.

### 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&odblac;l a Projektekig, a KDevelop minden funkcióját áttekinti,

- ez a kézikönyv, A Dialógus szerkeszt&odblac; szakaszban részletesen kitér a dialógus szerkeszt&odblac;
  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 widgetek
  r&odblac;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:

  - \|\| információ Qt és egyéb gyártók további widget
    eir&odblac;l,

  - \|\| információ a KDE projektr&odblac;l és a fejleszt&odblac;i vezérelvekr&odblac;l,

  - \|\| további referenciák a KDE alkalmazásfejlesztéshez

  - a KDevelop weboldalán \|\|

## Áttekintés

Looking at KDevelop, the user interface can be described by it's logical separation: the main window, the treeview and the output
window, surrounded by the menubar, toolbars and the statusbar. This section describes the purpose of each part of the interface, starting by the windows, followed by the bars and the functions they provide.

### A F&odblac; ablak

The main window consists of four tabulators for which the left two are for editing purpose. First comes the Header-/Resource window for headers and any other text files like the documentation SGML
's, then the C/C++ window for sourcecodes. These are followed by the Documentation window displaying in HTML
-format. At last is the Tools
window for external programs like KIconEdit
and KDbg
which are embedded into the IDE. Any Tool that is registered can be accessed via the Tools
-menu; whereas the registration of third-party programs can easily be done by a configuration dialog
(see General Configuration). For a description of the Editor windows functionality, see chapter Working with the Editor, and for the Helpbrowser
, you should look at section Using the Documentation Browser.

### Az Osztályböngész&odblac; és a fájlnézeget&odblac;k

#### The Class Viewer

The Class Viewer
(CV
) shows the classes
of your project as well as global functions and variable
s. Opening the tree will show all member functions
and members with symbols for attributes
(private, protected and public, signals and slots), so you can see the properties of members visually without switching to the header file. Selecting the class name will open the according headerfile containing the class and set the cursor to the class declaration
beginning. Selecting member functions
will open the implementation
file and place the cursor at the function header. For elements, KDevelop will look for the header file and place the cursor at the line the element is declarated. The classviewer
also provides popup-menus that offer more specified options, see The Class Browser for more detailed information.

#### The Logical File Viewer

The Logical File Viewer (LFV
) allows sorting files by filters in groups. Individual groups can be added by the properties entry of the project menu or by a right click on the tree items. This allows a more specialized search for files that you want to access quickly, in the first place only showing project-included files. According to their Mime-type, the files will be opened when selected. You will like the LFV
for things like selecting pixmaps
- this will start KIconEdit
(if installed on the system) in the Tools
-window and opens the chosen picture.

#### The Real File Viewer

The Real File Viewer (RFV
) shows the project directory tree with all files, so you can edit non-project files
or files hidden by the LFV
like configure.in and Makefile
s. Popup-menus also provide functions like adding or removing files to the current project.

#### The Documentation Tree

The Documentation Tree (DOC
) displays all available HTML
-based documentation that is configured as books. Selecting a book will open the first page in the Browser window. Also, a popup-menu provides personal configuration for additional HTML
-based documentation packages.

### A Kimeneti ablak

The Output window is separated as well into a messages window, a stdin/stdout window and a stderr window for the following necessities:

- messages window: displays all output
  of the Compiler
  . Clicking on error messages will change the edit widget to set the cursor to the line the Compiler
  found an error.

- stdout window: display for terminal based applications that send messages to the standard output
  of the computer. Note that Terminal applications are now started in an external console window.

- stderr window: displays all the error messages your program produces. This is useful for testing purposes. The Output window is programmed to show up each time an external process is called, such as make or a terminal application.

### Menubar
Commands

#### File Management and Printing

This section covers the functions that KDevelop provides about files; accessed via the File-menu in the menubar or by the according icons in the toolbar:

- New Ctrl+N Opens the "New File
  " dialog, allowing to create a new file. The file can be created using different templates and the filename has to be given as well as the path where the file will be created.

- Open Ctrl+O displays the "Open File..." dialog and lets you choose a file to be opened.

- Close Ctrl+W Closes the file in the top editing window

- Save Ctrl+S Saves the file opened in the top editing window. If the file has not been saved yet, the "Save File As..." dialog will be opened to let you choose a path and filename for the file to be saved.

- Save As... Opens the "Save File As..." dialog to let you save the current file under a new filename

- Save All Saves all changed files

- Print... Ctrl+P Opens the "Print File" dialog where you can set various options for printing
  either using enscript
  or lpr

- Quit Ctrl+Q Exits KDevelop. If files are changed, you will be asked if you want to save these files.

#### Editing Files

Here, the "Edit" menu and the according icons in the toolbar are covered which provide editing files. Also the editing functions are available via a context-menu in the editor
.

- Undo Ctrl+Z Reverts the last editing operation

- Redo Ctrl+Y lets you do the last undo step again

- Cut Ctrl+X cuts out a selection and copies it to the system clipboard.

- Copy Ctrl+C copies a selection to the system clipboard. This also counts for selections made in the documentation browser.

- Paste Ctrl+V inserts the clipboard contents at the current cursor position.

- Indent Ctrl+I Indent moves a selection to the right

- UnIndent Ctrl+U UnIndent moves a selection to the left

- Insert File...Ctrl+Insert Lets you select a file and inserts its contents at the current cursor position

- Search... Ctrl+FOpens the Search dialog that looks for an expression in the current file. For a search across several files, "Search in files..." should be used.

- Repeat Search F3 Repeats the last search for an expression. This also counts for searches that were made across the documentation, where more than one hit was found in the same page. The next hit will be displayed by choosing "Repeat Search" or F3 and signed as marked.

- Replace... Ctrl+R Opens the "Search and Replace" dialog that allows the search for an expression and replaces the found text with a new expression.

- Search in files... Ctrl+Alt+FDisplays the "Search in files..." dialog, that handles `grep
  ` on whole directories with wildcards. Search results are displayed with a list of the filenames, line and expression. Choosing an entry will open the file and the cursor is set to the line of the search result

- Select All Ctrl+A Selects the whole text of the file currently opened in the top editing window

- Deselect All Deselects the whole text of the current file. This is often used for multiple selections so you don't have to deselect each one separately

- Invert Selection Inverts the selection, meaning that a selection becomes deselected and text which is not selected becomes selected.

#### View Configuration

The View-Menu covers closing and opening functions for windows and commands to enable/disable the tool- and statusbar as well as to jump errors
in the code.

- Goto Line... Ctrl+GOpens a "Go to Line..." dialog that lets you insert a linenumber to show in the actual file. The last linenumber is remembered and marked, so you can either jump to that line again or just enter a new linenumber you want to see.

- Next Error F4Jumps to the next error KDevelop detects from the output
  . The output
  message of Make or other tools should give you a descriptive help what the problem is, so you can correct the error.

- Previous Error Shift+F4 Jumps to the previous error that was reported.

- Dialogeditor Ctrl+D Switches to the dialog editor

- Tree-View Ctrl+T en/disables the Tree window on the left side of the main view containing the Class Browser, LFV
  , RFV
  and DOC
  -tree.

- Output-View Ctrl+B en/disables the Output window on the bottom of the main view.

- Toolbar
  en/disables the toolbar.

- Browser-Toolbar
  en/disables the browser toolbar, containing the back, forward and search buttons for the browser

- Refresh rescans all files to rebuild the Class Browser. The scanning progress is shown in the statusbar progress display.

#### Creating and Maintaining Projects

This section describes functions that are available in the "Project"-menu and are supposed to cover the creation and maintaining of projects

- New... Starts the KAppWizard
  and allows you to create a new project by choosing application type, name, version and other options.

- Open Shows the Open Project dialog, where you can choose a KDevelop project file to be opened. After selection, the project will be loaded.

- Open recent project... contains a submenu with the last 5 opened projects. You can open a project more easily using the recent project menu.

- CloseCloses the current project. This is mostly done automatically when you quit KDevelop, invoke the KAppWizard
  or open another project.

- New Class
  ...Starts the class generator to create a new class that will be added to the current project. The class generator lets you specify classname, inheritance and filenames for the new class.

- Add existing File(s) Opens a selection dialog where you can choose the files that you want to add to the current project and the path where they will be copied to. If you choose a destination that was currently not included in the project, e.g. creating a new subdirectory, KDevelop will copy the files to add to the new subdirectory and create a new Makefile.am
  . After the copy process, your project will be rebuild by automake
  and autoconf
  to include the new subdirectory into the make-process.

- Add new translation file Opens a language selection dialog that lets you choose the translation file language that will be added to the project. This is mostly used by translators who can easily add their language to the project and work on the translation without having to care about the Makefile.am
  's

- File Properties Shift+F7 Opens the File Properties dialog showing a copy of the LFV
  and the project file options. Here, the properties for your files have to be set like installation path and file type.

- Make messages and merge This is intended to create the messages file for your project. The message file is the one containing all strings that are set up in the sources for internationalization and is used by translators to create the .po file for their target language.

- Make API
  -Doc Calls KDoc
  on your header files and generates a HTML
  output
  with the documentation of your project classes
  .

- Make User-Manual runs KSgml2Html
  on your manual SGML
  file, creating a HTML
  user manual. If KSgml2Html
  is not installed, sgml2html will be used to do this.

- Make Distribution:

  - tar.gz creates a distribution file of your current project in the project directory that is ready to ship to the end-users containing the sources of your project. The end-user has to `tar zxvf yourproject.tar.gz` to unpack it to a source directory and use the standard commands `./configure, make` and `make install`.

- Options F7 Opens the Project Options dialog that lets you change various settings for your project. This could be a new version number or the compiler options
  to set to -02 for a release with optimization.

#### Building Projects

This section describes the Build menu that covers all actions to be done with make or actions like rebuilding the project's online help or API
documentation.

- Compile file... Ctrl+F8Active, if the top editing window is the C++ Window. This only compiles the current implementation
  file and lets you save time in case you suspect errors
  .

- Make F8 Invokes the make-command
  to your project and builds the target.

- Rebuild All Rebuilds all object files and the target of you project.

- Clean Rebuild All Cleans the project directory from all make-created files and rebuilds the target.

- Stop Build F10 Stops the current process.

- Execute F9 Executes your target after building the program with make.

- Execute with Arguments Alt+F9 Executes your target with arguments. First, a dialog appears to let you specify the execution arguments (which are saved in the project for the next session), then your application uses the entered commandline. Mind that your application program is started from the project directory directly

- Debug... Opens KDbg
  in the Tools
  -Window to debug your application. In this case, KDbg
  automatically opens the file containing the main() function and executes your application.

- Distclean Removes all files that are generated by the project like object files etc. Distclean has to be done before distributing your project, so the distribution file doesn't contain any platform-specific files like those that were generated by your Compiler
  .

- Autoconf and automake
  Calls Make on the file Makefile.dist
  , located in your main project directory. Makefile.dist
  contains all commands for automake
  , autoconf
  etc. to build your project. If you added files manually or changed macros yourself, you should run Autoconf afterwards, followed by Configure to recreate all Makefile
  s.

- Configure Executes the configure-script generated by autoconf
  . If this command cannot be executed, run Autoconf and then Configure again.

#### Calling Tools

The Tools
-menu contains by default the entries for the following programs if installed: KDbg
, KIconEdit
and KTranslator
. These are checked by the KDevelop installation program and inserted in the given order into the menu. Invoking a tool will open the "Tools
"-window and start the selected program inside this window. The Tools
menu can be edited by the Tools
-entry in the Options-menu; see \|\|Tools
" Menu" name="Configuring the "Tools
" Menu">.

#### Changing KDevelop's settings

The Options-menu contains all entries for invoking configuration dialog
s with which you can change KDevelop's default settings. Major settings like those for the editor
or printing
have their own entries; general settings of KDevelop's behavior can be made with the KDevelop Setup dialog.

- Editor... Allows the configuration of the editor's behavior like word-breaking, selections etc.

- Editor Colors... Here, you can set the color-configuration of the editor
  like e.g. the background.

- Editor Defaults... This sets the default display like font and fontsize for the editor

- Syntax-Highlighting This dialog lets you configure the fonts and colors for the highlighting of several programming languages, including HTML
  .

- Documentation Browser In this tab-dialog, you can set the fonts, sizes and colors for the internal Helpbrowser

- Configure Printer... Contains the entries for the printer configuration dialog
  s.

  - enscript
    Configures the printer for use with enscript
    . See Printing for more information.

- Tools
  ... Opens the Configure Tools
  dialog. Here, you can configure the "Tools
  " menu by adding or removing programs that will be started in the Tools
  -window.

- KDevelop Setup Opens the KDevelop Setup dialog. The first tabulator configures general settings, followed by the key-configuration and the Documentation settings. The Documentation settings also include the generation of a new set of HTML
  -library documentation and the rebuilding of the search index
  for the Helpbrowser
  .

#### The Window Menu

The Window menu contains a list with all currently open files. This allows a quick switch to another file you're currently working on.

#### Managing Bookmarks

The Bookmarks menu is intended for adding and removing bookmarks
you want to set in the current editing file. As KDevelop uses two editing windows, each one configures it's bookmarks
separately.

- Set Bookmark Opens a context-menu with up to nine configurable bookmarks
  . This allows setting a bookmark to a certain entry in the bookmarks
  menu by logical reasons.

- Add Bookmark Ctrl+Alt+A Adds the line of the current cursor position to the bookmarks
  menu as a bookmark. Mind that this could overwrite a bookmark set with the Set Bookmark-option. If the browser is opened, a bookmark will be added to the Browser-Window bookmarks
  menu.

- Clear Bookmarks Ctrl+Alt+C Clears the bookmark-entries for the top editing window or the browser, e.g. if the Header-Window is visible and you call Clear Bookmarks, the entries for the Header-Window are deleted.

- Header-Window Contains the bookmark-list for the Header-Window. Selecting a bookmark will set the cursor to the selected bookmarks
  ' line. Mind that bookmarks
  are only assigned to the file they are set to, so if you change to another file, the bookmarks
  are not deleted but choosing a bookmark won't change to the file they are assigned to as well.

- C/C++-Window Contains the bookmark-list for the C/C++-Window. The preferences are the same as for the Header-Window.

- Browser Window Contains the browser bookmarks
  . Selecting a bookmark will open the browser with the selected page.

#### Online Help

The Help-menu contains entries for navigating in the Helpbrowser
as well as entries for library and online-documentation for the most recently used cases. Accessing additional online-documentation can be achieved with the DOC
-tree in the treeview automatically opened (if Autoswitch is enabled) when changing to the Documentation Browser window.

- Back
  Alt+ Left Arrow Opens the page opened before the actual one.

- Forward
  Alt+ Right Arrow Opens the next page of the browser-history, available after a "Back"-action.

- Search Marked Text
  F2 Scans the search-index for text currently marked in the editing windows or the browser-window. After the search, a result page is shown which lets you select the help-page to switch to. After choosing a page, the browser will highlight the found entry for the expression the search was invoked for. With the F3 key the next search result
  on the same page will be displayed if more than one hit was reported for the search on one page.

- Search for Help on...
  Opens the Search for Help on... dialog that lets you search for a specific expression you want help on.

- The User Manual to KDevelop
  F1
  Opens the User's Manual to KDevelop index page (this handbook).

- The KDevelop Programming Handbook
  Opens the KDevelop Programming Handbook index page. This handbook contains a complete programming guide to KDE development.

- KDE Application Tutorials
  Changes to the index page of the KDE Application Tutorials handbook. This handbook explains how to build the Qt tutorial applications and introduces you to KDE programming by developing an example application.

- The KDE Library Reference Guide
  Changes to the index page of the KDE Library Reference Guide. This handbook contains detailed information about using the KDE/Qt libraries separated on topics such as event handling.

- The KDE 2 Developer´s Guide
  Changes to the index page of the KDE 2 Developer´s Guide. This Handbook contains information about the most recent KDE development and how to prepare your application to be KDE 2-ready.

- C/C++ Reference
  Displays the language reference index page. If the reference is not installed, an error page shows you how to get the reference and how to install it correctly.

- Tip of the Day
  Opens the Tip of the Day dialog to inform you about KDevelop's features.

- KDevelop Homepage
  Opens the KDevelop Homepage in the browser window if Internet access is provided.

- Bug Report
  ... Opens the KDevelop Bug Report dialog, where you can send a bug-report directly to the KDevelop Team by email. See Bug Reporting

- Project-API-Doc
  Changes to the project's class-documentation index file.

- Project-User-Manual
  Opens the User manual's index file of your current project. This can be used to review the HTML
  -output
  generated by KSgml2Html

- About KDevelop... Shows the aboutbox of KDevelop containing the used version number and the authors' names and email-addresses as well as reference to the licensing of KDevelop.

### Toolbar
Items

KDevelop provides quick access to a various set of commands by it's toolbars. These are the standard and the browser toolbar; in dialog editor
mode only the standard toolbar is visible. Both can be en-/disabled by the according menu entries in the "View" menu; also dragged out of the main window and replaced on each side of the working area.

#### The Standard Toolbar

The standard toolbar provides quick access to the most recently used functions for file processing and editing as well as building your application. The buttons execute the following commands from left to right:

- Open Project - shows the open project dialog

- Open File - shows the open file dialog and contains a delayed popup to fast select the current project header and source files.

- Save File - saves the currently opened file to disk

- Print File - opens the printer dialog

- (separator)

- Undo - reverts the last action

- Redo - executes a reverted action again

- Cut - cuts out the current selection

- Copy - copies the current selection to the system clipboard

- Paste - pastes the current clipboard contents to the actual cursor position

- (separator)

- Compile File
  - compiles the file currently visible in the source file window. In Dialogeditor mode replaced by the Generate Files button.

- Make - invokes make on the project

- Rebuild All - rebuilds the project

- Debug - opens KDbg
  with the application binary for debugging
  in the Tools
  - window

- Execute - runs the application target binary

- Stop - cancels the current process

- (separator)

- Dialogeditor - switches to Dialogeditor mode. There, the button is replaced by a Sourcecode editor
  button

- Tree-View - en-/disables the treeview and works as a toggle button to display the current state

- Output-View - en-/disables the output
  view and works as a toggle button to display the current state

- (separator)

- What's this..? help button - changes the cursor to a question arrow and lets you get information about GUI
  components of KDevelop

#### The Browser Toolbar

The browser
toolbar is another toolbar that provides a lot of useful commands for browsing files and the documentation
. The toolbar contains:

- the Class combo box - lets you select a class of the current project to browse to

- the Method combo box - lets you select a method of the current class and browses to the implementation
  of the method

- the Class-assistant button - on a single click will bring you to the declaration
  of the method currently selected. Contains a delayed popup to access the Classtools for adding Classes, Methods and Attributes as well as the browsing commands.

- Back - browses back in the documentation browser
  history; contains a delayed popup to select a certain page of the back history.

- Forward - browses forward in the documentation browser
  history; contains a delayed popup to select a certain page of the forward history.

- Stop - stops the browser from loading a documentation file request

- Reload - reloads the currently displayed page

- Home - opens the KDevelop User Manual index page in the browser

- Search Marked Text - searches the documentation index for the selected text; works with the browser and the editor
  windows

- Search for Help on... - opens the the Search for Help on.. dialog to let you enter a keyword to search in the documentation

### Billenty&udblac;kombinációk

This section handles the predefined as well as the standard values for configurable keyboard commands used in the KDevelop IDE. You should see section Changing Keyboard Shortcuts for a detailed explanation how to change assigned values to commands.

#### Shortcuts for Text Processing

##### Cursor Movements

    one letter to the left                           Left Arrow
    one letter to the right                          Right Arrow
    one word to the left                             CTRL+Left Arrow
    one word to the right                            CTRL+Right Arrow
    one line upwards                                 Up Arrow
    one line downwards                               Down Arrow
    to the beginning of the line                     POS 1
    to the end of the line                           END
    one page up                                      PageUp
    one page down                                    PageDown
    to the beginning of the current file             CTRL+PageUp
    to the end of the current file                   CTRL+PageDown

##### Text Selections

    one letter to the left                           SHIFT+Left Arrow
    one letter to the right                          SHIFT+Right Arrow
    one word to the left                             CTRL+SHIFT+Left Arrow
    one word to the right                            CTRL+SHIFT+Right Arrow
    one line upwards                                 CTRL+Up
    one line downwards                               CTRL+Down
    to the beginning of the current line             CTRL+POS 1
    to the end of the current line                   CTRL+END
    one page up                                      SHIFT+PageUp
    one page down                                    SHIFT+PageDown
    to the beginning of the current file             CTRL+SHIFT+PageUp
    to the end of the current file                   CTRL+SHIFT+PageDown

##### Inserting and Copying Text, Tabulators

    en/disable insertmode                            INS
    copy selection to the clipboard                  CTRL+C, CTRL+INS
    insert text from the clipboard                   CTRL+V, SHIFT+INS
    delete current line                              CTRL+K
    insert line after current line                   END, then Enter
    insert line before current line                  POS 1, then Enter
    undo editing step                                CTRL+Z
    redo an undo step                                CTRL+Y
    tabulator                                        TAB

##### Deleting Text

    delete letter left of cursor position            Backspace
    delete letter right of cursor position           Delete
    delete selected text                             Select text, then Backspace or Delete

##### Searching Text within the Editor

    open Goto Line... dialog                         CTRL+G
    open Find Text dialog                            CTRL+F
    repeat last search                               F3
    open Search and Replace dialog                   CTRL+R

    open Search in Files dialog (grep)               CTRL+ALT+F
    search marked Text with Grep                     SHIFT+F2

    locate next error                                F4
    locate previous error                            SHIFT+F4

##### Searching Text with the Documentation Browser

    search selected editor text in documentation     F2
    search selected browser text in documentation    F2
    display next search hit on the same page         F3

    search selected browser text within project			 SHIFT+F2

##### Browser Shortcuts

    previous page                                    ALT+ Left Arrow
    next page                                        ALT+ Right Arrow

##### Managing Bookmarks

    add bookmark                                     CTRL+ALT+A
    clear bookmark list                              CTRL+ALT+C

#### Shortcuts for Toolbar
Symbols

    Symbol "Open File"                               CTRL+O
    Symbol "Save File"                               CTRL+S
    Symbol "Print File"                              CTRL+P
    Symbol "Undo"                                    CTRL+Z
    Symbol "Redo"                                    CTRL+Y
    Symbol "Cut"                                     CTRL+X
    Symbol "Copy"                                    CTRL+C
    Symbol "Paste"                                   CTRL+V
    Symbol "Compile File"                            CTRL+F8
    Symbol "Make"                                    F8
    Symbol "Execute"                                 F9
    Symbol "Execute with Arguments"                  ALT+F9
    Symbol "Dialog Editor"                           CTRL+D
    Symbol "Back"                                    ALT+Left Arrow, if browser opened
    Symbol "Forward"                                 ALT+Right Arrow, if browser opened
    Symbol "Search Marked Text"                      F2

#### Window Management

To switch to a certain window, press ALT plus the underlined letter in the window title, e.g. Tools
would be Alt+T

#### Shortcuts to Compilation Processes

    Compile current sourcefile                       CTRL+F8
    Build current project target                     F8
    Execute target after Build process               CTRL+F9
    Execute target with Arguments                    ALT+F9
    Stop the current process                         F10

## A Súgó Rendszer

Most of KDevelop's strength is accumulated in the Help System. It is also to be understood as an example of how to extend your own KDE application with a complete set of help functionality, and is, in part, already realized in the template applications, so KDE/Qt application framework
s generated with the KAppWizard
do already contain the basic functionality for statusbar help and documentation, that only has to be extended by the programmer. This section therefore introduces into the usage of the general help provided within the IDE as well as to show the usage of the Helpbrowser
, which, by intelligent use, will make it very easy to get the information you need for development.

### Az "Ez meg micsoda ?"-gomb és a Quickhelp
gyorssegítség

Looking at KDevelop's top toolbar, you will see the "What's this?" button on the right end. By selecting the button, the cursor will change to a pointer with a question mark on the right, as is the same as the button in the toolbar. Now, you can select any visible part of the KDevelop user interface and click on it. This will result in displaying a help-window giving you a short description of the function this part gives you or what it can do for you. Included are the main view, the tree-views and the toolbars, for which every button help is provided. After another mouse click or a keyboard input, the What's this? help window disappears and your cursor is set to the last active position. Mind, that, if you place the mouse pointer over a button, it gets raised and after a short time, you will get a Quick-Tip-window, describing the function the button represents in the menubar; this will disappear if you move the mouse pointer away.

For user interaction dialogs, Quickhelp
provides you help windows with a short description of the selected item you want help for. These are accessed by a right-button mouse click to the item, a context-menu pops up that allows the selection of "Quick-Help". Selecting this will pop up the help window. This is always useful for dialogs where you can't see the action's purpose for as long as you are not familiar with KDevelop. Mind that most dialogs offer a Help-button which will show you the detailed context-help for the dialog's options within the provided online-manual in the help-browser.

### The Statusbar
Help

The statusbar of KDevelop offers you many functions that inform you about the current activity state as well as "status messages" offering a short description for commands.

#### Statusbar
Entries

The Statusbar
contains:

1. a general message field, most left. This is used for help messages and displays the current activity.

2. the progressbar, indicating the progress for actions that require a comparably long time to be finished, such as saving files and the scan-progress of the Class Browser. The progressbar only appears during those processes are executed.

3. an Insert/Overwrite indicator. It shows the editor
   mode for insert actions by INS for Insert mode and OVR for Overwrite mode. The mode can be changed by the INS-key on the keyboard.

4. a line counter, displaying the current line the cursor is placed.

5. a column counter, indicating the current column position of the cursor in a line.

#### Help Messages

The statusbar informs you about the action of menu entries if you select a menu within the menubar and select an action without executing it. Further, if you press on a toolbar icon, but without releasing the mousebutton, the help message for the button is displayed in the same way as for the menu entries. You can prevent the execution of the selected icon by moving the mousepointer away from the icon, still holding the button pressed. If the cursor is away, release the mousebutton.

For actions that are currently executed, KDevelop displays the action. This counts for processes running in the background such as saving files as well as for dialogs. If the process has exited such as a make-invocation, the statusbar display changes back to "Ready" state.

Also, when using the documentation browser
, the statusbar displays link urls for as long as the cursor is placed over an URL link in the browser window. Therefore, you can easily find out if the file is a local or a remote file only accessed by network connection.

The caption of the KDevelop Project Editor shows you the currently opened filename in the top window. This would be a HTML
file for the documentation browser
or a text file for the editing windows. Further, the Project name is displayed, so you have constant control where you are and what you're currently working at.

### Configuring the HTML
Browser

The browser included in KDevelop is completely HTML
-based, therefore you can specify the usual options like background and the like. You can set all preferences by the "Documentation Browser"-entry of the "Options"-menu. The configuration dialog
shows you two tabulators; the first for setting the font preferences, the second for color selection.

#### Font Preferences

The first option for the font display is the size. Available are small, medium and large. The best display for normal use is set to small by default. For the font selection you have to specify a standard font for normal text as it appears in HTML
documents; the fixed font is the one used for displaying e.g. code within the HTML
file.

#### Color Preferences

The color preferences dialog allows configuration of background, normal text, URL Link and followed link color. The colored buttons on the right are displaying the current settings; selecting a button will result in opening the "Select Color" dialog. There, you can specify the color either by choosing a System Color, a custom color, select the color by the multi-colored window or by setting the values directly. The middle contains a preview for the color selected.

Further, you can specify if the browser should underline links to easier detect them visually and if you like to use your own colors always independent of the page's preset ones. "Apply" will execute all changes, while "OK" will apply changes and close the dialog. "Cancel" leaves all settings untouched and exits the configuration.

### Using the Documentation Browser

The documentation browser
allows quick and easy access to all manuals and documentations that are provided with KDevelop or generated automatically, including online-documentation for the KDE-libraries
and your project documentation. Plus, the Documentation Tree in the tree-view lets you customize a special "Others" folder that contains all individually added documentation.

#### Requirements

To make use of all features of the Helpbrowser
, you should have KDoc
and glimpse
installed. KDoc
will generate all kind of online class-documentation for the KDE-libraries
during the setup
process, but can also invoked by option in the KDevelop Setup. For the generation of an API
(Application Programming Interface) Documentation for your project's classes
, KDoc
is also used and called by the Project-menu, entry "Make API
-Doc". This will process all current header files of the project plus the addition of a cross-reference to the Qt and KDE-libraries
if those are available in the Helpbrowser
. For the generation of the project handbooks, you should have KSgml2Html
(provided with the KDE-SDK
) and, as a minimum, SGML
-tools installed on your system. To extend and change your project's online-documentation, you have to edit the documentation file for your project by selecting it in the RFV
. After saving your changes, call "Make User-Manual" from the Project-menu. In case SGML
tools detect formatting errors
, those will be displayed in the output
window allow you to find the error line directly. The program "glimpse
" is used to create a personal search-index for your documentation automatically. The index is generally build during the installation process, but can also be build with the KDevelop Setup dialog. For a description of the provided search functions see Using the Searchindex.

#### Provided Documentation

The KDevelop IDE comes with two sets of online-documentation, which can be accessed either via the Help-menu or by the Doc-tree in the Tree-View in the KDevelop folder. The first book provided is this online-handbook containing all information you need towards installation, configuration, available functionality and introduction to application development. The second book is The KDevelop Programming Handbook in it's first edition. The programming handbook covers most questions related to the creation and extension of projects that work with KDevelop. By tutorials the user gets an introduction to the rich facilities that applications created with the Qt- and/or KDE-libraries
have to offer as well as given a guideline for ensuring KDE
-compliance, which covers the same instructions given on the Internet site at \|\|. However, the programming handbook cannot replace any additional documentation available in printed or electronic form about the C++ programming language as well as about the usage of the Qt-library in certain terms.

The C/C++-Reference
used with KDevelop is currently only available on the KDevelop homepage at \|\|. On distributions the reference may be included, see your distribution installation program index for more information. It can be installed easily by downloading and copying the sourcefile to the main KDE-directory ($KDEDIR). There, you have to untar it as root with `tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz`, the reference will then be copied the documentation directory of KDevelop. For uninstalling the reference documentation you just have to delete the "reference" folder under ($KDEDIR)/share/doc/HTML/default/kdevelop/reference.

The Qt/KDE-libraries
documentation folder allows direct access to the HTML
-online documentation of your copy of the Qt-library. The path to the library documentation is usually automatically detected by the KDevelop installation program, but can be set manually in the KDevelop Setup dialog. Also, all available documentation for the KDE-libraries
are listed in order of the library name, so if you would use classes
of a certain library it is easy to determine the library type to be added to the Linker
settings in the project. Mind that the whole KDE-Library documentation is only accessible when generated by KDoc
- so this program, included in the KDE-SDK
, has to be installed before the documentation can be generated. As the installation program of KDevelop does this automatically, it should be installed before running the KDevelop Setup. If this is not the case and the documentation cannot be build, you are able to create it afterwards at any time with the KDevelop Setup dialog.

The documentation tree also contains the "Others" folder which is intended to contain all personally customized documentation as described below. Finally, the Doc-Tree allows access to the API
and the Manual for your current project.

#### Adding Documentation to the Helpbrowser

To customize your Helpbrowser
, open the Tree-View and select the "DOC
" Tabulator. You will see an opened tree containing four folders. The "Others" folder is, by default, empty. On a right mousebutton click over this folder, a context menu opens that has an entry "Add Entry". Select this to open the Add Entry dialog where you have to enter two values: the upper one for the name that will be displayed for the documentation within the Doc-tree, and, below that, a file-entry line. Here, you have to enter the path and filename to the start page that will be opened by the selection of the entry later. You can enter the path and filename directly or by selection of the pushbutton on the right to open a file-chooser dialog. This allows a quick browsing on your system to the path for your start page. Mind that only HTML
-documentation can be selected, so only HTML
files are allowed to choose. Selecting OK will add the entry to the Doc-tree and is available directly.

#### Using the Searchindex

KDevelop includes a set of functions to help you search information within HTML
documentation. To use these features, your system needs to have the program "glimpse
", a free database generator, installed, which creates the search index
and executes searches within the documentation. To set up the index, see KDevelop Setup. The index is also automatically generated during the installation program.

The search functions are available through several ways which you can choose from:

1. in the editor
   , select the text you want to have help on or place the cursor in the word that you want to look for. Then press the right mouse button and select look up: "expression" This can also be done by selecting "Search Marked Text" from the Help-menu, the shortcut key F2 or by selecting the Search icon from the toolbar.

2. in the Documentation browser select the text you want to look up and press the right mouse button, select look up:"expression" or select "Search Marked Text" or the search icon as above.

3. if you want to search for a specific keyword, select "Search for Help on..." in the Help-menu or select the "Search for Help on..." icon from the toolbar, opening a search dialog where you can enter the expression you want to get information for.

Direct access to specific documentation is given by selecting the according icon in the "DOC
" -tree-view or by the Help-menu entries.

The Helpbrowser
also offers support for grep
to search for a selection within your current project, e.g you've opened the documentation page for the `KTMainWindow` class (KDEUI library) and you want to know where in your code `KTMainWindow` appears. Mark `KTMainWindow` and either select "Grep: KTMainWindow" or press Shift+F2. The "Search in Files" dialog opens with the results about your grep
search directly. Then you can choose an result line to jump to the according sourcecode.

## Munkában a Szerkeszt&odblac;

An important part of the integrated development environment is the editor
. You're using it for:

- creating, opening and saving source and project files

- editing source and project files

- writing your SGML
  documentation

- printing
  your project files

Generally, the editor
itself doesn't do much difference in comparison to other editors; especially as it is a build-in version of the popular KWrite, also known as the "Extended Editor". If you're familiar with that, you won't have any problems using it for managing your projects. In addition to normal editors, KDevelop contains a new printing
system, that is far more extended for use with sourcecodes- and you can choose between the printing
program you want to use.

This section gives you more information about how to handle your project files
and to make you more familiar with the editor
's functionality. A lot of Unix-hardliners would prefer using Emacs or XEmacs- they're fine with that. But it isn't necessary for easy programming, and especially for beginners, to work themselves into powerful editors which shall, in the result, only allow you to enter your code.

### Managing Project Files

The following sections describe how to create, save, open and close your project files
you need to edit- mind that this doesn't include translation files or pixmaps
. Those are recognized automatically and the according editing program like KTranslator
opens those files for you.

To give you an easy access to your files, KDevelop contains two easy-to-handle tree-views, similar to a filemanager, that recognize if you selected a file, and opens it in the according editor
window. The main view contains two windows that are used independently, but connected via the Project Editor, so you can do all menubar actions the same way. The intention behind this is that it allows you to handle two windows at the same time, although only one is visible. The C/C++ window thereby takes another task, which allows you to easily compile your sources one by one, so you can check the implementations without having to run a complete build-process over your project.

This can be done when having the C/C++ window on top. Select "Compile File
" from the Build-menu or press the according button in the toolbar. Your file gets saved and compiled, and you can control any errors
by the Compiler
output
in the output
window.

Within the IDE you can open as many text files as you like. All opened files are listed in the Window-menu, so you can switch between them by selecting the according filename from the menu. Further, the actual opened file is displayed with its name in the window frame of KDevelop.

#### Creating and Saving Files

To create a new file, choose "New" from the File-menu. This opens the "New File
" dialog, where you can specify the filename and type. Additionally, you have to set the destination directory as well if the file is added to the project or not. Finally, you can also use your header template for the project in case you want to add a new sourcefile without generating a new class by the Class-Generator.

After the file has been created, you can edit the new file as usual; if you have to switch between different files, you can always turn back to the file either via the file-trees or by the Window-menu.

For saving any changes, KDevelop offers a whole variety of options. The standard way would be to save the file by selecting "Save" or "Save As" from the File-menu or by the Save-button on the toolbar. For saving all changed files at once, you could as well select "Save all" from the File-menu.

Now, when working on a project, it is very annoying if something critical happens while you have done a lot of changes on your files; sometimes you will bite yourself that you have forgotten to save the changes. KDevelop takes care of this by offering "Autosaving", which is by default enabled and set to save all files in intervals of 5 minutes. To select another saving period or to disable this, see KDevelop Setup, where the setup
options are described.

Additionally, KDevelop takes care for all changes if you open another project or exit KDevelop. You will be asked for saving the changed files, where you also have the option to specify which one to save and which you want to stay unsaved. Further, when invoking any build-processes, your files get saved automatically, so you won't ever wonder why your application doesn't run the way you expected it to do after your changes to the source files. The only exception is the "Compile File
" command, which only saves the currently opened source file visible in the source editor
window.

#### Opening and Closing Files

To open a source file, you have a lot of options as well. One way could be, as the standard for editors, to select "Open" from the File-menu. You will be presented an "Open File" dialog, which allows you to choose the file you want to edit. Another, probably more frequently used way is to select the file from the LFV
, the Logical File Viewer, or the RFV
, the Real File Viewer (see \|\|). The advantage of the file trees is that they provide a quick visual access to your files, especially the LFV
, which only displays your project files
by their type, collected into folders. You can as well configure the LFV
towards sorting your files in another manner by a right mouse click on the tree. Select "New Group" from the popup-menu, and you can configure a new group, or select "Edit Group" to install new file filters by specifying the group's file extensions, separated by commas.

The standard file groups for a project generated by KAppWizard
are the Headers, Sources, GNU and Others. Additionally, after adding a translation file, KDevelop adds a folder "Translations", containing your *.po files.

To close files, select the file to close from the Window-menu, which loads the opened file into the front editor
. Then select "Close" from the File-menu. If your file has been changed, you will be asked to save it. When closing a project, all currently opened files will be checked for changes and you will be asked for saving as well.

### Navigating within Files

The following gives you a general guideline how to locate certain positions within your files for a quicker access.

How to find a certain line in a file

1. Select "Goto Line" in the "View"-menu or press CTRL+G. The dialogfield "Goto Line" appears.

2. Insert the linenumber you want to go to.

3. Press OK.

How to set a bookmark

1. Set the cursor to the line you want to access via a bookmark

2. Select "Set Bookmark" from the "Bookmarks"-menu.

3. A popup-menu opens that allows you to select the bookmark number you want to set for the new bookmark.

4. Select the bookmark number.

Another way to set bookmarks
would be to select "Add Bookmark" from the "Bookmarks"-menu. This sets a bookmark to the current line and appends it to the bookmarks
-list. The documentation browser
also offers setting a bookmark to the current page by a context menu entry "Add Bookmark".

How to delete bookmarks

The bookmarks
are set for each editing window separately- mind that your bookmarks
aren't connected to a certain file you set the bookmark for. To delete all bookmarks, select "Delete Bookmarks" from the "Bookmarks"-menu. This deletes the bookmarks
for the window actually on top, either the Header window, the C++ window or the browser window.

How to go to a bookmarked line

1. Select the "Bookmarks"-menu and open the popup menu containing the bookmarks
   for the window containing the bookmark you want to view; either the C++-Window or the Header-Window entry.

2. Select the bookmarked line.

Selecting a bookmark for the browser window will open the browser and loads the page.

### Working with Keyboard Shortcuts

For using the editor
, you should make yourself comfortable with some keyboard shortcuts
that make it easier to position the cursor and edit the file. The complete shortcut reference is also listed in section Overview.

    one letter to the left                           Left Arrow
    one letter to the right                          Right Arrow
    one word to the left                             CTRL+Left Arrow
    one word to the right                            CTRL+Right Arrow
    one line upwards                                 Up Arrow
    one line downwards                               Down Arrow
    to the beginning of the line                     POS 1
    to the end of the line                           END
    one page up                                      PageUp
    one page down                                    PageDown
    to the beginning of the current file             CTRL+PageUp
    to the end of the current file                   CTRL+PageDown
    one letter to the left                           SHIFT+Left Arrow
    one letter to the right                          SHIFT+Right Arrow
    one word to the left                             CTRL+SHIFT+Left Arrow
    one word to the right                            CTRL+SHIFT+Right Arrow
    one line upwards                                 CTRL+Up
    one line downwards                               CTRL+Down
    to the beginning of the current line             CTRL+POS 1
    to the end of the current line                   CTRL+END
    one page up                                      SHIFT+PageUp
    one page down                                    SHIFT+PageDown
    to the beginning of the current file             CTRL+SHIFT+PageUp
    to the end of the current file                   CTRL+SHIFT+PageDown
    en/disable insertmode                            INS
    copy selection to the clipboard                  CTRL+C, CTRL+INS
    insert text from the clipboard                   CTRL+V, SHIFT+INS
    delete current line                              CTRL+K
    insert line after current line                   END, then Enter
    insert line before current line                  POS 1, then Enter
    undo editing step                                CTRL+Z
    redo an undo step                                CTRL+Y
    tabulator                                        TAB
    delete letter left of cursor position            Backspace
    delete letter right of cursor position           Delete
    delete selected text                             Select text, then Backspace

### Edit Windows Settings

The editor
inside KDevelop can be configured towards special editing needs with a global effect on all editing windows. Thereby you can set the color modes, highlighting colors (also configurable in reference to the programming language of the file) and automatic text settings like tab-with and selection modes. The following describes how to set these options by the configuration dialogs provided in the "Options"-menu.

#### General Settings

The editor
's general settings can be configured with the "Editor" entry in the "Options"-menu. Select the according values and press OK after you finished with your configuration.

##### Edit Options

Auto Indent:

  this sets the editor to place the cursor below the first literal when a new line is entered.

Backspace Indent:

  this option sets the cursor below the first literal of the line above when backspace is pressed.

Word Wrap:

  words are taken into the next line after the column set in "Wrap Words At:"

Replace Tabs:

  tabulators in the current text are replaced with tabulators of the "Tab Width:" value

Remove Trailing Spaces:

  removes trailing spaces

Wrap Cursor:

  sets the cursor to the end of the last line when backspace enters the beginning of a line

Auto Brackets:

  creates a closing bracket in front of the cursor when a bracket (any kind) is opened.

##### Select Options

Persistent Selections:

  selections made stay marked after setting the cursor to a different place

Multiple Selections:

  allows multiple independent selections within the text

Vertical Selections:

  allows vertical selections of text

Delete On Input:

  deletes a selection when writing in the selection.

Toggle Old:

  allows only one selection. A selection made gets deselected when another selection is made.

Wrap Words At:

  sets the maximum columns that a line can have. The word that contains a letter that reaches over this value will be automatically broken into the next line.

#### Colors

For changing the editor
's general appearance, you can define a set of colors that the editor uses by selecting "Editor Colors" from the "Options"-menu. You can configure colors for:

- background: the editor's background

- text background: the background of displayed text

- selected: the color of selected text

- found: the color of text found by a search via the menu "Edit"-"Search", "Repeat search" and "Replace".

- selected + found: the color of text selected to search for and found

#### Syntax Highlighting

The syntax-highlighting mode of KDevelop's editor
can be configured by two dialogs; first you can set default colors for syntax-highlighting by the "Editor Defaults" entry in the "Options"-menu. There, you can set colors and fonts as well as the fontsize for e.g. keywords. Select the default item and set all needed options.

The second configuration dialog
is accessed by the "Syntax-Highlighting" entry in the "Options"-menu. This allows you to set the file filters for the programming language, e.g. *.cpp, *.h for C++. Then select the item that you want to configure. If you wish to use the default values you've set in the "Editor Defaults" dialog, select the "default" checkboxes in the Item-style and Item-Font sections. This reads the default settings for the selected item. After pressing OK, your new values will be enabled and used by the editor
.

### Searching and Replacing

#### Single File Search

How to find one or more characters in the actual editing window

1. Select "Search" from the "Edit"-menu. This opens the search dialog.

2. Specify the expression to search for in the edit field. The drop-down menu offers selecting a previous search expression.

3. Select additional options like "Whole Words only"

4. Press OK.

To repeat searching for an expression entered in the search dialog, press F3.

#### Searching over Several Files

As the search function only is referencing searches over a single file that is currently visible, you're limited to this. But often you want to search for the same expression overall your project. Therefore, KDevelop contains a `grep
`-dialog, which lets you search over all files that you specify either by setting the directory to start the search from and/or by mime-type. Specifying the exact directory and the mime-type will therefore reduce the time that KDevelop needs to read your files and display the results. To start a search over several files, select "Search in files..." from the "Edit"-menu. The search dialog opens and lets you enter:

- The expression to search for (the pattern)

- The template used for the search

- The mime-type of files to search in

- The directory to start form

- If the search is recursive over all included subdirectories

By default, the grep
-dialog is set to start at your project directory and works recursively over implementation
and header files.

You can even extend your search pattern by using the following options:

1. . Match any character

2. &ˆ; Match the beginning of a line

3. $ Match the end of a line

4. \< Match the beginning of a word

5. \> Match the end of a word

For a repeating search, you can also use the available operators:

1. ? The preceding item matches less than once

2. * The preceding item is matched zero or more times

3. + The preceding item is matched once or more times

4. &&lcub;; n &&rcub;; The preceding item is matched exactly n times

5. &&lcub;; n,&&rcub;; The preceding item is matched n or more times

6. &&lcub;;,n &&rcub;; The preceding item matches less than n times

7. &&lcub;;n,m&&rcub;; The preceding item matches at least n times but less than m times

Backreferences to bracketed subexpressions are also available by the notation \n.

After specifying your search, press "Search". The results are then displayed in the result-window. To jump to a file and line number, select the resultline and press Enter or double click the result. The editor will automatically open the according file and place the cursor to the line of the result. This allows a complete specification for any search action and give out exact results.

KDevelop offers also some more specialized functionality to use grep
within the editor
s and the browser. Select the expression you want to search for in either of the windows and press SHIFT+F2 or select "grep
:&<;your&&lowbar;;expression&>;" from the right button popup menu. This will ask grep
to search for the selection in your project directory's files and will show the results immediately. Switching to the result works as described above. From within the editor window, it lasts to place the cursor over a word and start searching; the word under the cursor will be the search pattern.

#### Searching within Documentation

While working on a project, you often need to have information about the parameters of member functions
you want to use- most often you remember the function's name that matches your needs, but the parameters are a very hard thing to keep in mind. Therefore, and for other purposes that may occur, KDevelop contains a search functionality that combines searching expressions that appear in your files with the documentation browser
. To make use of this search functionality, you should have set up the documentation browser
correctly and created the search database. For invoking a search through the documentation, do the following:

1. place your cursor at the word you want to search or mark an expression

2. select "Search Marked Text" from the Help-menu
   or press the right mouse button to open the context menu; then select "Look Up: "expression".

3. after the search result
   page is displayed in the documentation browser
   , select the page that you think could contain the information you need.

4. the selected documentation page is displayed and your search result
   is marked. To display the next result within the same documentation page, press F3.

This allows you to easily find the information you need. For using the results, the documentation browser
allows marking a selection and copying it to the clipboard. Then return to the file you're editing and select "Paste" from the "Edit"-menu.

For a full description on how to use the Documentation, see Using the Searchindex.

#### Replacing Text

For replacing an expression, select "Search and Replace" from the "Edit"-menu. The "Search and Replace"-dialog lets you specify the expression to be replaced as well as the replacement expression. Then press OK. The first expression which is found will be marked, so you can see where the expression is and in which context. Then you can specify by a dialog if the expression shall be replaced or not. When the search is finished by reaching the end of the current file, you will be asked if you want to start the search again from the beginning. If you're finished, select "Cancel".

### Printing

As KDevelop is designed to give developers the best access to files and information to reduce development cycles, it also contains a new printing utility which makes use of enscript, a common printing program available for Unix-Systems. Besides, you can also print by directly using lpr (the lineprinter device). As using enscript offers the most options towards printing, you should install it on your system; it is usually shipped with distributions, so you shouldn't have any problem to get it. But before printing, you should have a look at the available configuration dialog to prepare the output according to your needs. The following section describes how to configure KDevelop for printing files.

#### Configuring the Printer

The printing
program can be configured by selecting "Print" from the "File"-menu
; on the printing
dialog, select the program by the drop-down-menu in the left upper corner. Then press the "Options" button on the right. This opens the configuration for the program. Another way to configure the program is selecting "Printer Configuration..." from the "Options"-menu; then select "enscript
".

##### The enscript
Configuration Options

###### Header

- Fancy Header: adds a fancy header

- Header Text: enables adding a header text

  - text: sets the text's contents

  - position: sets the text's position to left, center or right

- Login: add the UserID to the header

  - login: enables adding UserID

  - position: sets the position for the UserID

- Filename: add the filename to the header

  - Size of filename: add filename as full or short, meaning full path or filename only

  - Position: sets the position for the filename

- Hostname: add the hostname to the header

  - hostname: enables adding hostname

  - size of hostname: sets the size for hostname

  - Position: sets the position for hostname

###### Date & Time

- Current Date: include the current date

  - current date: enables current date adding

  - position: sets the position for the date entry

  - format: sets the date format

- Modification Date: include the last modification date

  - modification date: enables modification date adding

  - position: sets the position for modification date entry

  - format: sets the date format

- Current Time: include current time

  - current time: enables current time adding

  - AMPM:/ use AM/PM or 24h format

  - Position: sets the position for the time entry

  - Format: sets the time format

- Modification Time: include the last modification time

  - modification time: enables adding modification time

  - AMPM:/ use AM/PM or 24h format

  - Position: sets the position for the time entry

  - Format: sets the time format

###### Layout

- Numbering & Border:

  - numbering lines: adds line numbers to the document for printing

  - borders: adds a border to the pages for printing

  - numbering pages: numbers pages for printing

  - align files: appends files for page numbering

  - lines per page: the maximum value for lines per page

- Format and TAB:

  - set TAB size: sets the TAB size for interpreting TABs

  - font for header: sets the font used for the header text

  - font for body: sets the font for the body text (file contents)

- Textprinting
  :

  - cut lines: cuts the lines if too large. If unchecked, lines are broken

  - replace non-printing
    character by space: replaces characters that the printing
    charset doesn't support by space characters

- Other Options:

  - table of contents: adds a table of contents page that contains information about printed files, page numbers etc.

  - Highlight bars:

    - highlight bars: highlights rows for printing

    - cycle fo change: sets the number of rows to change highlight style

  - Wrapped line:

    - mark wrapped lines: lines that are broken get marked for printing

    - value for wrapped line: the preset value for the new line the line is broken into.

###### Underlay

- Text: sets the text to underlay

- Position: sets the position of underlay text

- Font: sets the font used for the underlay

- Angle: sets the angle for the underlay text

- Gray scaling: sets the grayscaling for the underlay text

- Style: sets the underlay text to be printed as outlined or filled

#### The Printing Dialog

##### Direct Printing Options

- Program: sets the printing
  program to be used for printing
  : enscript
  or lpr

- Printer: sets the printer to be used for printing

- Output location: for printing
  into a file, select the output
  location

- Orientation: sets the orientation for printing
  , either landscape or portrait

- Copy: sets the amount of copies to be made per page

- Paper Size: sets the paper size to be used

- Output Format: for using enscript
  as printing
  program, you can choose between postscript or html printing

- Default Printsettings: sets the default settings to use for printing

- Outprinting
  :

  - Page Printing: sets one or two pages on one sheet

  - Pages: select all,odd or even for using enscript

  - Pretty Print:

    - pretty-print: enables pretty-print mode for enscript

    - color: use color printing

    - Pretty Print Mode: sets the printing
      mode dependent on your file format

##### File Selection

The file selection dialog is accessed by the "Files" button on the printing
dialog. The file selection allows specifying which files to print out by certain criteria:

- File Selection:

  - current: the currently opened file visible in the editing window

  - all in project: all files included in the project currently opened

  - self chosen files: allows choosing the files to be printed by file-selection

  - all cpp files: prints out all source files of the project

  - all headers: prints out all header files of the project

  - changed files: allows specifying files that are changed in a timespan:

- Changed Files:

  - Between: specifies all files changed after:

    - Date: the date the files were changed

    - Time: the time the files were changed

  - And: specifies all files changed before:

    - Date: the date the files were changed

    - Time: the time the files were changed

- Self Chosen Files: available if self chosen files is selected (see above)

  - add: press this to add a file selected for printing
    in the lineedit field left

  - delete: deletes a selected file from the printing
    list

  - clear: clears the printing
    list

##### Print Preview

Print Preview is available for you to control how the output
will look like. Therefore, KDevelop uses the program ghostview or kghostview. When the preview-button was pressed on either printing
dialog, you will be presented a template output
that shows you the effect of the currently set options.

## Projektek

### Projecttypes

#### Programs

KDevelop creates a projectfile with the .kdevprj ending. This file contains all your project information, so be careful not to delete it. It is stored in the project's base directory and has to be opened to load the project. The projectfile keeps all information for your files like the file properties, install path, distribution status and compiler options
(CXXFLAGS). Setting file properties allows you to keep track of where the files should go.

With KAppWizard
, you can create a new application project according to your choice of application type. For now, KAppWizard
generates four kinds of frame applications, as:

- a single document interface (SDI) KDE
  -application including a menubar, a toolbar and a statusbar. It contains basic control resource management to allow extending the frame application into a unique KDE
  application. The application frame also contains statusbar help messages as known from commercial products just like KDevelop itself. From the programmer's point of view, it is based on three application-specific classes
  leaning on the MVC-concept (Model-View-Controller). Technically, the base classes
  may not be viewed that way, but it's construction is at least created most logical to create applications with a GUI
  .

- a KDE
  -based application frame window. This application type offers most flexibility to those wanting to develop their program from scratch, but can also be used as a basis for developing wizard applications or modules.

- a Qt-only based program framework. For those programmers who want to use the Qt-library
  as the GUI
  interface alone, we tried to offer you a smart framework to support your application development. As Qt programming is fully supported, you should have no problems to create a full-functional application by using Qt only.

- a C++ program framework. This application type is intended for those wanting to write a terminal based C++ program. Just remove the "Hello World" line in main() and construct your classes
  the same way with KDevelop as for KDE
  applications.

- a C program framework for C programmers. This is as well a terminal based application but only uses the C compiler.

Additionally, KDevelop enables you to work with already existing projects. Those can have any options set by the programmer himself by configure and Makefiles. As far as the execution and the build-process is concerned, the current state only allows the same structure as for the other baseclasses. Create a custom project with the application wizard and add your files to the project to allow scanning by the classbrowser.

To ensure the build process, your custom project has to have all sources in a subdirectory matching the lowercase name of your project; the execution of the binary is also restricted to this lowercase project name.

Mind that KDevelop does not write any information into Makefiles or configuration files. You are responsible for any project behavior and build settings yourself.

#### Libraries

A general project-type to create libraries is not available at the moment. Anyway, building libraries is not impossible with KDevelop. Here are a few guidelines and workarounds:

- Whenever your project subdirectory gets another subdirectory that contains source files, KDevelop will build a static library of these. That means static libraries are already supported by automatic creation in order to sort project sourcefiles. Mind that the static library is part of the binary later and won't get installed.

- to create a shared library, you have the option to create another project subdirectory. The sourcefiles that are created in this subdirectory are included in the project and are therefore available in the classviewer as root classes. To create the shared library, the KDevelop Programming Handbook offers a Makefile.am template. If the subdirectory's Makefile is added to the configure.in script, you only have to run "Autoconf and automake" and "Configure" to create the Makefiles. The build instead is only possible from a make-command within the subdirectory, as KDevelop invokes the build from within the original project subdirectory. Another possibility to create shared libraries is changing the Makefile.am of the original project-subdirectory according to the template in the Programming Handbook by hand following the rules for project modifications explained in chapter Project Hacking.

- for installing a shared library, you have to watch the KDE-File-system Standard as explained in The KDevelop Programming Handbook

#### Multiple Targets

For some projects, the facilities of KDevelop at it's current state will not last. Those are projects that include multiple targets like packages containing several applications. As commands like "Execute" require that only one target is build by the developer, those types of projects are only supported in the way that you have to write your own entries to the Makefile.am
's and creating your directories for the additional libraries or binaries to build. Nevertheless, a build-process always invokes your make-program independent from what actually the targets are; so these functions still can be used (with the restriction that the build is invoked from the main project subdirectory).

Another way to still work with this type and to still have access to the binaries themselves are creating empty projects and move their subdirectories in conjunction with the project files
to the directory containing all sources later. Then you could load each target independently by its project file; this also allows executing and debugging
the target.

Multiple binaries or libraries within the main project subdirectory are possible with following the rules explained in section Project Hacking and the following guidelines for editing the main project's subdirectory Makefile.am (all modifications outside the KDevelop write area):

- add your target to the bin&&lowbar;;PROGRAMS if it is an executable

- add your library declaration line if it is a shared library

- add the same declarations like the original project binary is build:

  - newtarget&&lowbar;;METASOURCES

  - newtarget&&lowbar;;LD&&lowbar;;FLAGS

  - DISTCLEANFILES

  - copy the messages: entry for the original binary and replace target&&lowbar;;SOURCES with newtarget&&lowbar;;SOURCES, target.pot with newtarget.pot

- add your sources like the KDevelop write area contains outside the write area for your binary or library

- for installing static libraries, create the library with KDevelop's auto-creation inside subdirectories. Then modify the Makefile.am outside the write area according to the needed settings

### New Project
s

The KDevelop Application Wizard allows the creation of thirteen different types of projects, constructing a framework for each. All projects use the GNU standard development tools as described in the requirements section of this handbook.

For KDE
applications there are six different frameworks:

- Mini: Creates a KDE-application with an empty main widget.

- Normal: Creates a KDE-application with session-management, menubar, toolbar, statusbar and support for a document-view codeframe model.

- Normal-OpenGL: Creates a KDE-application with session-management, menubar, toolbar, statusbar and support for a document-view codeframe model. OpenGL(tm) (Mesa3D) support is added.

- KDE 2 Normal: Creates a KDE-2 application with session-management, menubar, toolbar, statusbar and support for a document-view codeframe model.

- KDE 2 Mini: Creates a KDE-2 application with an empty main widget.

- KDE 2 MDI: Creates a KDE-2 MDI (Multiple Document Interface) application with menubar, toolbar, statusbar and support for a document-view codeframe model.

If you wish no dependencies towards the KDE-libraries
for end-users, you can choose from four Qt-only types:

- Normal: Creates a Qt-Application with a main window containing a menubar, toolbar and statusbar, including support for a generic document-view model.

- QT 2.x SDI: Creates a Qt-2.x Application with a main window containing a menubar, toolbar and statusbar, including support for a single document-view interface (SDI) model.

- QT 2.1 MDI: Creates a Qt-2.1 Application with a main window containing a menubar, toolbar and statusbar, including support for a multiple document interface (MDI) model.

- QextMDI: Creates an MDI framework based on the QextMDI library and Qt2.0x. Allows to switch between both modes, Toplevel and Childframe. Requires QextMDI!!! (www.geocities.com/gigafalk/qextmdi.htm).

The two C and C++ -Application types offer a framework for creating commandline applications.

And last but not least you can create an empty projekt, e.g. to work with existing projects.

The wizard asks for your project name, version and the location where the project directory will be build. Further, your Name and Email address are asked for inserting them in header and cpp templates on top of your source files as well as for entries in the *.lsm file.

### Opening and Closing of Projects

KDevelop is by default configured to open the last project loaded when starting. This allows a fast start, but you may want to change that to just start the IDE without any project. To prevent the default behavior, disable the "Load last project" option in the KDevelop Setup dialog.

To open another project, select "Open" from the "Project" menu or press the "Open Project" button on the toolbar. In case you've got another project currently open, this will be closed. If your current project then contains files that aren't saved, you are asked to save all changed files. Thereby, you can select which file to save and which you want to close without saving, or to save all at once.

Then you get an "Open Project" dialog, where you can change to the directory containing the project file to be loaded. KDevelop project files
have the *.kdevprj mime-type which is also displayed by a project icon. Select the project file and press "Open". When loading a project, the Class Browser scans all files and builds the initial classtree, so you can start working on the project by using the Class Browser directly.

Another comfortable way to open a project is to select the project file in the KFM, the KDE
File Manager. This will start KDevelop with loading the selected project file. You could as well open a project by commandline, entering `kdevelop projectname.kdevprj`.

When closing KDevelop, your project file will be saved automatically and the IDE detects if you have changed any project files. Then you will be asked to save any changes before exiting. The available options for closing are the same than for closing a project before loading another.

### Editing a Project

After you created a new project with the KAppWizard
, the usual task is to extend the project by editing the already created sources and adding classes
, pixmaps
, pictures and whatelse you project needs. Now, editing a project means that you can change the default project after its generation by menus and dialogs according to your needs. The next section therefore describes how you can add existing files and classes
as well as creating new files. This is needed for building your project, but this won't help you for the installation process by the end-user. Therefore, section Setting Project File Options describes how to set File Properties especially for additional files that you want make to install, like documentation or pixmaps
. Another part in project maintaining is adding translations for applications that support internationalization, which is described in Adding Translations.

Extending the Project Documentation covers questions on how to create a good set of documentation for online help enabling the end-user to help himself in case of troubles as well as how to use your product.

Finally, Project Hacking describes how you can eventually work around the KDevelop project management in special cases.

#### Adding and Removing Files and Classes

Adding a new file is often used when you think that you should separate your class implementation
file into several ones. Then you need to create an new file which will contain the part of the class implementation
you want to move. You can do this by choosing "New" from the "File"-menu
, opening the "New File
" dialog. This enables you to specify the file-type, name and the location. When entering the filename, KDevelop automatically enters the extension for you, but you can as well change the extensions towards your own preferences. Further, you can include the header template for sourcefiles, so you don't have to copy this into your new file yourself. Also, you can decide, if the file is included in the project or not. Mind that this doesn't cover the installation destination; this has to be configured later by setting the file preferences.

After the new file has been created, the project file will be updated as well as the according Makefile.am
's. To add a complete class to your project, you can construct a new class with the Classgenerator which is invoked by "New Class
" from the Project-menu.

In case you have an existing project and you want to add certain classes
that you want to re-use in your project, select "Add File(s) to Project..." from the "Project"-menu
. Select "Add existing files", which will open a dialog to let you specify which files will be added to the project and the destination directory. Mind that the files will be copied into the specified directory and added to the project. You should call "Make" after adding sources; then your added files will be included in the build-process. In case you want to add e.g. pixmaps
that have to be installed by the end-user, you should update the File Properties for the added file and specify the installation path (see Setting Project File Options

To add a file to the project that is already in the project directory, go to the RFV
, where all project-included files are displayed by their project status by a red ! over the file icon. Select the file you want to add to the project (which has a normal file icon) and press the right mouse button to get the popup-menu. Then select "Add".

Files can also be removed from your project. This could be needed in cases where you don't want to use pre-generated files that are already given by the KAppWizard
. To remove a file, you have additionally the option between removing a file from the project or delete it completely. To remove a file from the project, select the file in the LFV
or the RFV
, press the right mouse button and select "remove". To delete a file, select "delete physically".

#### Setting Project File Options

The file properties dialog can be accessed via the project menu or within the LFV
by a right mouseclick. It shows the project files in groups as they are sorted in the LFV
and displays the file properties like file size, file type and if the file is included in the project as well as the installation path if the file is going to be installed by the end-user's make install command. It is important for documentation files as well as pixmaps
to specify the location where the files should go when the project is build and installed by end users, so you have to set up those locations. For standard KDE
location macros you should look in your Makefile.am
where the location macros are specified.

#### Adding Translations

As KDE
allows configuring your desktop and the behavior of your applications, you also have the option to choose the language that your application uses, in regards of the use of online-documentation as well as the application's look. For documentation files, this seems a trivial task. You would add a subdirectory labeled by the desired language, e.g. `de` for German, to the `docs` directory of your project and copy the english documentation into that directory. Then you would generate the documentation and set all project file options for the installation directories. Then you could start translating the SGML
file to your desired language and regenerate the documentation; then you're done. For the application, this seems a bit more difficult for the programmer. Now, we want to explain how to enable internationalization support for your application and how to add the languages you want to support.

First, you have to enclose all visible strings of your application that appear in bars or dialogs with the `i18n
()` macro. This macro is a replacement for the function `klocale->translate()` of the KLocale class and much easier to use. As this macro is declared in the `kapp.h` include file, you have to add `&&num;;include &<;kapp.h&>;` to the source file or the class declaration
file of the class that makes use of the macro. Also it should be mentioned, that although `i18n
()` is a macro and therefore you could think about using the original function, this won't work because the strings that are set up for translation have to be read out of the sources and get stored in the application's translation file (&<;YourApp&>;.pot in the /po subdirectory). This task is done by the program xgettext, and to do this, you would enter `make messages
` in your project directory containing the sources. As xgettext depends on the `i18n
()` macro, the original function won't do the job.

For translations themselves, you first have to create the message file containing all strings that are used in your sources with the `i18n
()` macro. This can be done by choosing "Make messages
and merge" from the Build-menu. Then you have to add the languages that your application wants to support. Therefore, select "Add Translation File" from the Project-menu. This opens a language selection dialog. Select the language and press OK. This will build the ASCII file containing entries for the filename of the string and the line where the original string is placed. Then you will see a `msgid` line containing the string to translate, followed by `msgstr`. The msgstr line is mostly empty except for the translations already provided by the KDE-libraries
. Those have to be filled with the according translations of your language.

You could think about writing the translations by hand, which can also be done. But the KDE-SDK
offers the use of the program KTranslator
, which ready the already existing files from other applications installed on the system, so you can reuse already translated strings to support your language.

To access KTranslator
, the easiest way is selecting a &<;language&>;.po file in the /po directory either in the LFV
or in the RFV
. This opens KTranslator
and lets you do the translating easily. Mind that you have to set up KTranslator
's properties yourself to include the author name and the language as well as the destination file. KTranslator
by default only opens your translation file.

For all translation files, `make
` uses the program `msgfmt` to format your message files to use with the binary, but you don't have to take care for that, as well as specifying the destination directory for installing the translation files; this is all done by KDevelop automatically.

For more information about internationalization support, see \|\|; a lot of people are doing translations for you to support their language. You will find a list of email-addresses of the translators you could write to and who will help you with this. Also read The Dialog Editor and The KDevelop Programming Handbook where questions about internationalization are covered again.

#### Extending the Project Documentation

All projects created with KDevelop contain a pre-configured documentation, which already contains standard chapters for installation, project name and version as well as the author name and email-address. As KDevelop uses SGML
-templates, it's very easy to extend the documentation to a full descriptive helpsystem. The only thing you have to do is editing the SGML
file, placed in docs/en as index.sgml. The reference documentation included with your sgml-tools package can be added to the Helpbrowser
and allow you direct access to special tags as well as a short description of how to extend the documentation. SGML
has a lot of advantages, whereas KDE
makes wide use by this documentation type with the additional KSgml2Html
tool. This creates the typical KDE
-style documentation and makes it look nicer. Anyway, the sgmltools alone are enough to produce a html output
that is already included in your application. To create the documents using KSgml2Html
, install the tool and run "Make User-Manual" from the Build-menu. The Documentation Browser allows a direct controlling of the output
by selecting "Project User-Manual" from the Help-menu or the according icon in the DOC
-tree. Then you can browse the documentation online in KDevelop and have a better overview by the output
over errors
that result in missing tags.

Now, while extending the documentation, you can't avoid that additional files are produced that have to be included into the project as each `sect`-tag creates a new HTML
file. The output
generated by the KAppWizard
is already included in the project, so you don't have to care for their installation path. What you have to watch out for is any index-xx.html file, where xx is higher than 6 (as the first six pages are already included in the project). After generating the documentation, switch to the RFV
and browse to your documentation directory. Press the right mouse button over the files to add and select "Add". Further, KSgml2Html
adds the KDE
logo to the documentation directory. This file, `logotp3.gif`, has to be added to the project as well. Then you have to select the "File Properties" either from the Project menu or by the popup menu in the file-viewers. The easiest way to set the installation path is to select a documentation file already set up for installation such as `index.html`. You see that `Install` is checked and the Installdir+filename already contains the destination. Mark the Installdir and enter CTRL+C to copy the installation path to the clipboard. Then select the file you want to specify for installation. Enable `Install`, this will enable the installdir-entry field, already containing the filename. Place the cursor in front of the filename and enter CTRL+V to insert the clipboard contents (which was the installation path copied before). This is the fastest way to specify the installation path. For more options about specifying installation destinations, see The KDevelop Programming Handbook.

#### Project Hacking

When working with a project, you should never edit the project file by hand. This will prevent KDevelop from loading your project correctly under certain circumstances, as well as changes will not result in updating the Makefile
s. To change any settings for your project, you have to use the given menu entries like e.g. for adding files or setting file properties. For experts that are not comfortable with certain options for e.g. the Linker
or need additional project configuration, you should work yourself into the Makefile.am
macros and add all changes in the Makefile.am
's after the section separated with the entry "KDevelop write area". As the GNU-tools are using the commands at the end of all macro files, you can overwrite KDevelop's settings with this. Mind that this will prevent using KDevelop for any changes related to project configuration.

### Compiler and Linker
Flags for Projects

Each new project contains all needed options for the Compiler
and Linker
as well as general settings. By default, your project is set to use debugging
by the -g flag, and warnings
are set to the standard, -Wall. This ensures you can debug your application and detect constructions that may cause program errors
. For some applications, you would need additional Compiler
or Linker
flags, especially if you're using libraries that are not currently included by the Linker
. Then you need to update the project by configuring the correct settings with the Project Options dialog. See Build Settings for more information how and where to set Compiler Options, Warnings and Linker
Options.

### External Projects

Existing projects can be converted to KDevelop projects by selecting "New" from the project menu. The following dialog creates an empty project file with your project name, version and type information as well as your name and email address. Then copy all your compilation and construction files to the new project directory and choose "Add Files" from the project menu. The files selected will be copied into your project directory and the Makefile.am
's are updated. Please change all Makefile.am
entries existing before the conversion towards the now created entries done by KDevelop in the KDevelop area. Test, if your program can still be compiled and installed after the conversion to ensure the project's consistency.

## Build beállítások

The Project Options dialog, accessed by the project menu, lets you specify all needed parameters for your project. Those will be used for the Makefile.am
's and the configure
.in script (e.g. version number change or compiler warnings
) and thereby set the compilation preferences as well.. After changing the project options, you should invoke "make
clean" or "rebuild all" to compile your project with the new options. Please mind that debugging
is only available if the project options are set to create debugging
information, the amount can be set with the debug level (0-3). If you add functions that belong to a library that is not included in the Linker
flags, your program will not link correctly if those are not updated, so keep track of your library linking.

For a release build of your application or for distributing the sourcecode package, you should watch the following standard settings:

- disable debugging

- enable optimization and set optimization level to -02

- set the compiler warnings
  to -Wall

- for each new release, increase the version number and update the project.lsm file for version and requirements.

### General Options

The first page of the Project Options dialog sets the general options for your project. These are project name and number, the handbook sgml file which is used for generating a set of HTML
files that are included in the project and specific information about the author. The short description field is for additional information that you want to include like the program's purpose and the like.

### Compiler Options

The compiler options
page sets the compiler flags towards your target, debugging
and additional.

#### Target

The target box contains two options that can be set:

Target Machine: You have the choice to set the target machine option here by choosing between your machine (default) and i386v, which is the option if you configure
d your Compiler
as a cross-compiler for an Intel 386-compatible machine running System V. This option sets the -b flag to the Compiler
. Usually you would leave this to the default.

Optimize: You can enable optimization for your build process by this option, meaning to set the -O flag. If not checked, the flag is set to -O0, so no optimization will be used. If you enable optimization by checking this option, you can as well specify the optimization level below from 1 to 3.

For a release version of your application, enable optimization and set the level to 2.

#### Debugging

Right of the Target box, you can see the debugging
-section. This means that you can set your Compiler
to include information for debuggers within the final binary, so the programmer can follow the execution of the application with the debugger in direct context to the sourcecode.

Enable debugging
therefore sets the -g flag; the debugging
level specifies the amount of information to be included in the binary. Available are level 1 to 3 to choose from. Mind that the binary execution will be slower by setting any debugging
option and that the binary size will increase by the debugging
level.

Generate extra information for gprof: sets the -pg flag, resulting that the Compiler
will include information for the gprof program that displays caller graphs of your program's function.

Store temporary intermediate files: sets the -save-temps flag. This will result in storing the usually temporary files produced by the preprocessor and the assembler. A compilation of a sourcefile will therefore produce three output
files: an *.o file which is the final output
of the Compiler
, an *.i file produced by the preprocessor and an *.s file as the output
of the assembler.

For a release of your project, disable any debugging
.

#### Additional Options

The text entry field on the bottom is intended for you to manually set any flags for the Compiler
by setting the CXXFLAGS environment variable
in the Makefile
s, so make sets the flags before the build process and reset them afterwards. For a complete description of all available Compiler
flags you should see your Compiler
documentation; for gcc and egcs this can be done by man gcc; man g++ will show you information about the c++ script that is used to lead the Compiler
.

### Compiler Warnings

The following gives a description about the Compiler
warning options that can be set on page 3 of the project options dialog. The explanations are taken from the man page for GCC, egcs version 1.1.1. The warnings
themselves are diagnostic messages that indicate that constructions may cause errors
.

-Wall

  Standard `-W' options combined.

-W

  Compile with -W. This option sets options not included in -Wall which are very specific. Please read GCC-Info for more information.

-Wtraditional

  Warn about certain constructs that behave differently in traditional and ANSI C.

-Wundef

  Warn if an undefined identifier is evaluated in an `&&num;;if' directive.

-Wshadow

  Warn whenever a local variable
  shadows another local variable
  .

-Wid-clash-LEN

  Warn whenever two distinct identifiers match in the first len characters. This may help you prepare a program that will compile with certain obsolete, brain-damaged Compiler
  s.

-Wlarger-then-LEN

  Warn whenever an object of larger than LEN bytes is defined.

-Wpointer-arith

  Warn about anything that depends on the «size of» a function type or of void. GNU C assigns these types a size of 1, for convenience in calculations with void * pointers and pointers to functions.

-Wbad-function-cast

  Warn whenever a function call is cast to a non-matching type. For example, warn if `int malloc()` is cast to `anything *.`

-Wcast-equal

  Warn whenever a pointer is cast so as to remove a type qualifier from the target type. For example, warn if a const char * is cast to an ordinary char *.

-Wcast-align

  Warn whenever a pointer is cast such that the required alignment of the target is increased. For example, warn if a char * is cast to an int * on machines where integers can only be accessed at two- or four-byte boundaries.

-Wwrite-strings

  Give string constants the type const char&&lsqb;;length] so that copying the address of one into a non-const char * pointer will get a warning. These warnings
  will help you find at compile time code that can try to write into a string constant, but only if you have been very careful about using const in declaration
  s and prototypes. Otherwise, it will just be a nuisance; this is why we did not make `-Wall' request these warnings
  .

-Wconversion

  Warn if a prototype causes a type conversion that is different from what would happen to the same argument in the absence of a prototype. This includes conversions of fixed point to floating and vice versa, and conversions changing the width or signedness of a fixed point argument except when the same as the default promotion.

-Wsign-compare

  Warn when a comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned.

-Waggregate-return

  Warn if any functions that return structures or unions are defined or called. (In languages where you can return an array, this also elicits a warning.)

-Wmissing-prototypes

  Warn if a global function is defined without a previous prototype declaration
  . This warning is issued even if the definition itself provides a prototype. The aim is to detect global functions that fail to be declared in header files.

-Wmissing-declaration
s

  Warn if a global function is defined without a previous declaration
  . Do so even if the definition itself provides a prototype. Use this option to detect global functions that are not declared in header files. -Wredundant-decls Warn if anything is declared more than once in the same scope, even in cases where multiple declaration
  is valid and changes nothing.

-Wredundant-decls

  Warn if anything is declared more than once in the same scope even in cases where multiple declaration
  is valid and changes nothing.

-Wnested-externs

  Warn if an extern declaration
  is encountered within an function.

-Winline

  Warn if a function can not be inlined, and either it was declared as inline, or else the -fin*line-functions option was given.

-Wold-style-cast

  Warn if an old-style (C-style) cast is used within a program

-Woverloaded-virtual

  (C++ only.) In a derived class, the definitions of virtual functions must match the type signature of a virtual function declared in the base class. Use this option to request warnings
  when a derived class declares a function that may be an erroneous attempt to define a virtual function: that is, warn when a function with the same name as a virtual function in the base class, but with a type signature that doesn't match any virtual functions from the base class.

-Wsynth

  Warn when g++'s synthesis behavior does not match that of cfront.

make all warnings
into errors

  (-Werror) Treat warnings
  as errors
  ; abort compilation after any warning.

For a release of your project, it is recommended to enable -Wall.

### Linker
Options

The Linker
Options for your current project can be set by the last page of the project options dialog. You have to enable those libraries that your application uses to link them to your binary with the Linker
, e.g. your application uses the class
KFileDialog. As the class
KFileDialog is part of the KFile library, you have to enable kfile. For classes
or functions that are not listed as checkboxes, use the "additional libraries" field.

#### Linker
Flags

remove all symbol table and relocation information from the executable:

  This means that all redundant information will be removed from the object files and the binary, resulting that debugging
  will not be possible. For as long as your application is in a development stage and not released as final, you should leave this option disabled.

prevent using shared libraries:

  This option disables the use of shared libraries on systems that support this. On systems using no shared libraries, this option will have no effect.

additional flags:

  Here, you can enter additional flags for the Linker
  , setting the LDFLAGS environment variable
  by make
  . The available options can be taken from the man page for ld or your Compiler
  manpage.

#### Libraries

The libraries section contains checkboxes for the most needed libraries in conjuction with Qt/KDE
application development. You have to enable those libraries that your application uses, otherwise the Linker
will complain about unresolved symbol tables.

X11

  The X11 library. Recommended for all X-Window programs.

Xext

  The X11 extension library. Also most X-Window programs depend on Xext.

qt

  The Qt-library
  . Recommended for Qt and KDE
  applications.

kdecore

  The KDE Core library; contains the classes
  for KDE Application frameworks.

kdeui

  The KDE User Interface library; contains KDE-specific widgets
  .

khtmlw

  The KHTML Widget library.

kfm

  The KFM library containing classes
  for KFM functions.

kfile

  The KFile library. Contains file dialogs etc.

kspell

  The KSpell library. Contains an interface for programs to use Ispell for spell-checking.

kab

  The KAdressBook library. Needed for access to the addressbook as well as providing addressbook widgets

additional libraries: Here you can enter additional libraries that your application needs, e.g. the KOM library. Set the libraries with the -l option; for the example -lkom.

### Make
Options

As GNU make
supports some useful options, the Project Options dialog contains a page called "Make-Options", where those can be en/disabled. The available settings are:

Print debug information

  prints out all information about the project files
  and what make
  determines for rebuilding them.

Continue after errors

  tries to continue with the compilation after an error occurred (e.g. a file couldn't be compiled due to an error)

Print the data base

  prints out the make
  -database for the current process which contains the changes from the last build-run.

Environment variables

  give the current environment variables a higher priority than the currently used variables in the Makefile
  s.

No built-in rules

  doesn't use built-in rules for make
  .

Touch files

  don't run the Compiler
  on changed files; instead only touches them. This sets them as already processed by make
  .

Ignore all errors

  Ignores all errors
  that occur

Silent operation

  doesn't print out any information about the build-process

Print working directory

  prints the current directory during the make
  -process.

job number

  sets the amount of parallel processes for make
  . For a single-CPU system we recommend setting this to one or two.

set modified

  sets the selected file modified. Choose the file by clicking the folder button on the right. Setting a file modified means that the file will be processed by make
  and compiled if it is a source file.

additional options

  set additional options to make
  ; those can be found in your local man page for "GNU Make".

Rebuild behaviour on run

  Sets the actions taken when you choose run. There are three options you can choose from:

  - always rebuild: Always rebuild without checking for modified files.

  - Warning on modification: Warn if source files have been modified and ask if the project should be rebuilt.

  - Only on modification: Check if sources have changed and rebuild if so.

  The default is to rebuild always.

## Az Osztályböngész&odblac;

### The Classviewer

The KDevelop Classviewer is one of the most useful and important tools that the IDE provides a developer for managing his project sources. When a project is loaded, a class parser reads all project sources for functions, classes
etc., then displays the results in the CV
treeview. This chapter shows you how to use the Classviewer and the provided functionality and how it can improve your work.

Classes and their methods can also be accessed by the browser toolbar. There, the left combo selects the class; the right lets you choose the methods of the selected class. When you select a method, the classbrowser will automatically bring you to the implementation
file and sets the cursor to the method. Finally, the class-assistant button on the right of the method combo will bring you to the declaration
of the method on a click; on another click to the definition. The delayed popup menu, displayed by the down-arrow on the button, offers additional functionality that is also available in the classviewer's context menus, such as:

- Goto Declaration: browses to the declaration
  of the method

- Goto Definition: browses to the definition of the method

- Goto Class Declaration: browses to the class declaration

- New Class
  : opens the New Class
  dialog to construct a new class

- Add Method: adds a method to the selected class

- Add Attribute: adds an attribute to the selected class

- Show graphical classview: Opens the graphical inheritance tree

#### Available Objects

By available objects, we describe a term that means that C++ code can be seen as a collection of objects- classes
, their members, global functions and the like. The classtree displays these objects logically and orders them by character, so they are easy to locate in the tree as well by their according icon. Therefore the classtree contains a "Classes" and a "Globals" folder. Thereby the "Classes" folder generally contains the project's classes
; if your project contains subfolders to manage your sourcefiles, these are also displayed by their original folder name and contain all classes
that are stored in the files located in the subfolder.

Further, when popping up a class, the classtree displays the class contents by separating methods and attributes
. As these can have attributes
as well like public, private and protected, these are displayed by modified icons as well. You see that a class displayed in the Class Browser contains all the objects that are present in the class declaration
.

Now, classes
are a very common thing when programming in C++ and will contain most of the code. But applications also contain objects that have a "Global" appearance to the program. These would be structs, functions etc. Especially the `main()` function appears in every application and you need to modify it in one or the other way sometimes. To access these objects, the Classviewer provides the "Globals" folder, containing subfolders for the following object types:

- Structs

- Functions

- Variables

As the icons displaying these items are similar to those used in the class-viewer, their meaning is easy to guess and to remember by the programmer.

Finally, it can be stated that the classviewer
displays your project graphically by their objects related to their appearance in the code. In the following section you will learn how to use the classviewer
and it's tools in conjunction with your code.

#### Browsing Object Declarations and Implementations

The Classviewer's best strength is providing a fast and good access to his code by the code's contents independent of the location within files. Therefore, selections by a mouse click will result in the following actions:

- On a classname: Switches to the class declaration

- On a class method: Switches to the method implementation

- On a class attribute: Switches to the attribute's declaration
  in the class declaration

- On a struct: Switches to the struct's declaration

- On a global function: Switches to the function's implementation

Now, this provides you the most needed access towards code objects. Apparently, it may be needed to change a method's header, resulting that you have to change it's declaration
in the class as well as the implementation
. The classviewer
supports this by providing right-button context menus over items. On a method or function, this means that you can select where to go:

- Go to definition: Switches to the implementation
  - this is the default for a left click as described above

- Go to declaration
  : Switches to the declaration
  of the method or function.

By this behavior, the Class Browser offers you access to every place you have to go for coding your C++ application.

The following sections give you a description of the other tools that the Class Browser offers- you will find them very useful when working with large projects as they enhance working object-orientated on C++ programs.

### The Classtools

The classtools are dialogs that makes it even more easier for the developer to get more information about his project's classes
. The classviewer
displays all objects by their occurrence in the code, but you sometimes want to get more information about classes
without having to look inside the code. Therefore, the classtool dialogs are specialized on displaying specific class attributes
.

The classtool dialog is invoked by the popup menu over a class in the classviewer
. Select "Classtool", and the dialog will appear. To get informed about a class, select the class in the combo box on top. Then the buttons in the toolbar provide functions that give you specific trees for your class. These are:

Parents:

  The parents of the selected class, which means the class it inherits. This is useful for multiple inheritance as well as to see why a class behaves in one or the other way, e.g. for dialogs your parent class could be `
  QWidget` or `
  QDialog`.

Children:

  Displays the children classes
  that inherit the current class.

Clients:

  Classes that make use of the selected class by an attribute in their class declaration

Suppliers:

  The suppliers that give attributes
  to the selected class.

Attributes:

  The attributes
  of the class by their name

Methods:

  The Methods of the selected class

Further, the selection of the attribute public, protected, private or all shows Attributes, Methods and Virtual Methods by their attribute value.

### Managing Classes

The Class Browser additionally allows adding methods and attributes
directly by dialogs. This means you don't have to type the classdeclaration
and the implementation
header yourself. After adding a method, you only have to set the formal parameters to the implementation
header and, if the method requires an attribute, to the declaration
.

How to add a method to a class

1. select the class you want to add a method

2. press the right mouse button; the popup menu appears

3. select "Add member function".

4. the "Add member function" dialog appears.

5. insert the type, declaration
   and documentation for the method

6. specify the access and the modifiers for the method

7. press OK to exit the dialog

For adding a variable
, this is the same action, just with selecting "Add member variable
" in the popup menu.

The difference between the actions of these dialogs is that the adding of a variable
will add the variable
to the classdeclaration
, the adding of a method will add the method's declaration
and the method's implementation
header to the sources. As the classviewer
directly updates himself, you have a direct access to the new method implementation
, so you only have to fill out the code for the actual purpose of the method.

## A Dialógusszerkeszt&odblac;

The KDevelop integrated dialog editor
allows the easy construction of widgets
and dialogs your application uses all by graphical means. You see the direct appearance of your dialog as it will be presented to the user. Using the dialog editor
is usually the first step you would take after creating a new project with the KAppWizard
to create your main view, the user interaction dialogs and, after finishing the graphical work, the code generation. This way, your project will contain all the usually considered "difficult" parts that normally would take a long time to implement. Then, the "rest" of your work is implementing the functionality in the generated code. This chapter deals with how to use the dialog editor
to create your project widgets
as well as what to do in case you see your widgets
need corrections or additions during the further development process.

You can switch to the dialog editor
either by selecting "Dialog Editor" from the "View
"-menu or by the according toolbar icon. To switch back to the Project Editor, select "KDevelop" from the dialog editor
's "View
"-menu or by the icon in the toolbar.

What else does the dialog editor
's interface offer you ? Mainly, that its appearance is almost the same as the project editor in term of the main view separation as well as the menu- and toolbars. This allows you to make yourself accustomed with the dialog editor
very quickly and, as he completely interacts with the project management, stay in the dialog editor
if you want to control your build-process. Actions that require to switch back to KDevelop will do that automatically for you, like accessing the documentation browser. Just select the menu commands, and KDevelop reacts to your will.

The following chapters give you an overview of the dialog editor
interface, how to create a new dialog initially and how set up the properties of the child widgets
that your dialog contains.

### The Dialog Editor View

#### The Mainview

The dialog editor
's view is logically separated by:

- The Widgets Tabulator, containing the "Widgets", "Dialogs" and "Items" tabs. These are described in Adding Widgets.

- The Widget-Editor, representing the editing view for creating your dialog. See The Widget Editor

- The Properties window, containing a list of properties and their values, dependent on the currently selected widget in the widget editor. See Setting Properties for information how to specialize the widget's behavior and look.

#### Menubar
, Toolbar
and Statusbar
differences to KDevelop

In Dialogeditor mode, KDevelop changes the menubar, toolbar and statusbar slightly to provide the functionality you need for creating widgets
. These are:

##### Menubar

"File"-menu
: replaces "New" with "New Dialog". "Open" allows to open a dialog definition file.

"View"-menu
: replaces "Tree-View" with "Widgets-View", en/disabling the Widgets-View tabulators; adds "Properties-View" to en/disable the Properties-View and "Grid Size" to let you specify the grid size in pixels for horizontal and vertical values.

"Build"-menu
: replaces "Compile File
" with "Generate Sources". This lets you actually generate the sources for your dialog.

##### Toolbar

The toolbar contains a new icon for "New Dialog" as well as a replacement for "Compile File
" by "Generate Sources".

##### Statusbar

The statusbar is providing you information about the currently selected widget, especially displaying the values for X and Y size in the coordinate system. For Statusbar
help, you are provided the same functionality than in Project-editing mode.

While changing widget size, the statusbar shows the current values for width and height of the selected widget.

### Creating a New Dialog

After creating your project skeleton, you are provided a ready-to-run application, according to your preferences. As KDevelop provides the project types KDE and Qt application, the dialog editor
recognizes this and offers widget construction by the widgets
that are provided by the used libraries. To save time, you already should have a design in mind that will do the intended actions. For information about widget design, see The KDevelop Programming Handbook.

To create a new dialog, select "New" from the "File"-menu
or select "New" from the context menu in the "Dialogs" tab. The New File Dialog appears where you can select the item Qt/KDE Dialog(*.kdevdlg). Enter the file name for your dialog to save the layout to. Then press OK and a new dialog will appear. When finished with the new dialog, select "Generate Complete Sources" from the Build-Menu. The dialog to generate the widget´s source file will appear. There you have to give KDevelop the dialog-specific information about the baseclass, the source file names and destination.

#### Dialog Class

The dialog class you can select, is the class that is inherited by your new widget, which is technically represented by a class itself. Therefore, you have the following options:

1. QWidget: the base class for all user interaction widgets
   provided by Qt. Used for main views and top-level widgets
   .

2. QFrame: inherits `
   QWidget` and is used by numerous widgets
   as a base class. This is useful for widgets
   that already want to have a `
   QFrame` functionality in addition to `
   QWidget` methods.

3. Custom: inherits a custom class that has to be set in the "Custom Properties". This could be an already designed class provided by your project or the libraries.

4. QDialog: the base class for dialogs that you would inherit for user interaction like setting properties or changing values.

5. QTabDialog: inherits
   QDialog and provides a dialog with predefined buttons and a set of tabs, which you will provide by the widgets
   that you create.

Custom Properties

For the inheritance of a custom class as selected in the dialog class field, you have to specify the classname, which goes to "Custom Class". The dialog editor
uses this for the code-generation; therefore, you also have to insert the "Custom Header", where the header filename of the custom class has to be set.

#### Files

In the "Files" section, you have to enter the widget's specific information. This is the classname (which would be e.g. KColorSelectDlg for a dialog that allows selecting the color of a pen), the header, C++ and Data filenames. When inserting the Classname, the filenames are given by the dialog editor
, but you can as well change the filenames.

Now, what about the files ? When you are ready with constructing the widget visually, you will have to generate the files that contain the implementation
for your widget. As this will be a class, the dialog will exist by the header file containing the classdeclaration
, a C++ file containing the method implementation
for your widget's methods and slots. The Data file is the file that will contain a function that is called by the constructor of your widget, the initDialog() method. The file itself shouldn't be changed as it will contain the generated code from the dialog editor
to create the widget on the screen. If you ever have to change values, you should do this by the constructor or be sure that you won't change the dialog during the development process, as the Data file will be overwritten each time the code is generated for your widget. The header and C++ file contain sections, where the dialog editor
writes; these are marked by comments. After file generation, you can change any values and settings outside these sections; otherwise your changes will get lost by the next code-creation.

#### Location

For generating the widget's sources, the dialog editor
needs to know the location where these will go. The default value for the output
directory is the current project subdirectory containing the sources already present.

After pressing "OK", your default values are generated and an empty Widget constructor is opened. Then you are ready to go for creating your own widget. Mind that the dialog editor
currently only supports static widgets
without geometry management. If you're about to use geometry management for your widgets
, you should make yourself accustomed with the classes
that Qt provides for this, create a new class with the classgenerator and write your widget by hand. For more information, see The KDevelop Programming Handbook.

### Adding Widgets

After specifying the dialogs or widgets
class and filenames, you are ready to start creating the widget and filling it with contents. Adding low-level widgets
to your dialog is a very easy task. Just select the widget you want to add from the "Widgets" tabulator on the left by a single click over the according widget icon. The widget will then be laid on the left upper corner of the currently opened main widget. An added widget then gets the default size of 100x30 pixels on the editor
view. To move a widget, click over it to activate the drawing frame, which is displayed in dark grey with hot spots on the corners and on the center of the top, bottom, left and right sides of the widget. A cross-cursor indicates that the widget can be moved. To move it, press the left mouse button and keep it pressed. then move the widget with your mouse to the place you want to have it displayed later.

To resize a widget, move your mouse cursor over one of the hot spots of the already activated item. The mouse cursor then changes to a double-arrow indicating the directions, in which resizing can be done. Press the left mouse button and hold it pressed. The widget item will change it's size when the mouse is moved to the direction indicated by the cursor.

Further, the widget editor contains a lot of context menus to help you coordinate your work. Those are available over all items in the widgets
tabulator and give you a quick help message window that shows the class name of the selected widget with a short description. Over a selected widget, the context menu shows the class name of the selected item and offers:

- Raise

- Lower

- Raise to top

- Lower to bottom

- Cut

- Delete

- Copy

- Paste

- Help

After setting the size and position, you can edit the preferences for the selected item on the Preferences window.

#### The Widgets Tabulator

The widgets
tab represents the available widgets
you can place on the dialog. If you want information about a certain widget, press the right mouse button over a widget icon and select "Quick-Help" from the popup-menu. Mind that the dialog editor
automatically determines, if your project type is Qt-only or KDE. This prevents you from using KDE-widgets
in a Qt application.

After you selected a widget item, it is placed with default sizes and values on the editing window and marked selected by a frame and darkened corners. To resize a widget, move your mouse over one of the dark spots and your cursor will change to display which resizing directions are possible. Then press the mousebutton and move the mouse while holding it. When you're finished with resizing the widget, release the mouse. While resizing, the statusbar displays the current position of the item by X and Y values and the current size by W(Width) and H(Height) values.

#### The Dialogs Tabulator

The dialogs tabulator is intended to let you open your project's dialogs by a mouseclick. As the dialog's structure is saved in a *.kdevdlg file within the directory that contains the generated files, only those dialog definition files are shown. Also mind that you don't delete these definition files.

On selecting a dialog, it will be shown as by the state it was saved in the last editing step in the Widget-Editor view.

#### The Items Tabulator

The Items tabulator lets you have an overview over the currently present widget items of the dialog hierarchically. This means, that, as your background represents the parent of all widgets
within the dialog, it is shown on top of the tree. The children of the main dialog are then listed in the next tree-level.

On selecting an item, it gets marked in the editor view, as well as the properties are shown in the properties window. Using the items view is sometimes important if your widgets
behavior depends on the parent-child relationship.

### The Widget Editor

The Widget Editor is the main view that is placed in the middle and where you are constructing your widget. After adding items, those can be selected and resized, as well as moved to the place you need them. Over all items, popup menus provide a quick access to functions like cut, copy and insert.

### Setting Properties

The properties window on the right is the place where you set the default behavior for the widget and its items. It displays the pre-set values for each selected item right away; changing values will result in direct changes on the Widget Editor view, e.g. naming labels or buttons.

To separate certain property values by their effect, the properties window contains four folders; selecting a folder will pop up all values for the properties group. All possible values are described below. Mind that the properties are dependent on the widget, e.g. a label and button will have a property for their on-screen name, while lineedits will have properties for methods like setText().

For a complete list of the available values per item, you should see the class-reference of the widget which explains the used methods and all possible values. Note that most values are implemented in `
QWidget` and are used for all widgets
that inherit
QWidget. Also mind that the final code does not contain any method calls that are unchanged by the user and therefore use the default values as given in the widget's constructors.

A complete list of the supported properties that can be set in the properties window for each widget item.

### Generating Files

After creating a widget, you have to generate the sourcecode to make it available in your project. This can be done either with the "Generate Sources" from the "Build"-menu or by the according icon in the dialog editor
toolbar. Your Makefile
s will be updated automatically to include the new widget in the compiling process; therefore, after calling "Generate Sources", you can build your project again within the dialog editor
. The output
window pops up below the Widget-Editor window as in Project Editor mode.

Now that your project contains a new widget, your work as a programmer is to implement functionality to the used slots and eventually add other methods you may need. See The KDevelop Programming Handbook, The Dialogeditor for more information about widget properties and sourcecode generation.

## A bels&odblac; nyomkövet&odblac;

### Setup

The default setup for KDevelop is to use the internal debugger. You can change this under Options select the "KDevelop setup" menu item, and then the Debugger tab.

Click on "Use external debugger" if you wish to use a different debugger and enter the name of the debugger to use. See your debuggers documentation on how to run it.

Selecting the internal debugger enables an additional set of options you can choose from:

- Display static members: Displaying static members makes gdb slower in producing data within kde and qt. It may change the "signature" of the data which QString and friends rely on. But if you need to debug into these values then check this option.

- Display mangled names: When displaying the disassembled code you can select to see the methods mangled names. However, non-mangled names are easier to read.

- Try setting BPs on lib load: This will try to set pending breakpoints on loading a library. If GDB hasn't seen a library that will be loaded via "dlopen" then it will refuse to set a breakpoint in that code. We can get gdb to stop on a library load and hence try to set the pending breakpoints. See Shared libraries and breakpoints for more details and a "gotcha" relating to this behaviour. If you are not "dlopen"ing libs, leave this off.

- Enable floating toolbar: This will allow you to use the floating toolbar to control the debugger in addition to the menu and buttons. The toolbar is most useful for debugging GUI applications. For details see The floating toolbar.

### Using the internal debugger

#### Changes made in the tree and output view window

If you choose the internal debugger, four tabs are added to your tree and output view windows.

##### On the tree view window

- VAR tab : A tree view of the local variables at the current place in the program you have stopped at. You can also see local variables in the function that called this functions. The VAR tab also contains a watch window. This allows you to see the value of global variables, or perhaps you may want to see only one local variable rather than the variable in a large list of local variables.

##### On the output view window

- breakpoint : A list of breakpoints set and their current state.

- framestack : The calling stack.

- disassemble : A machine instruction view of the code showing the current instruction to be executed.

#### Changes made in the Debug menu and on the panel

##### On the panel

Two normal and two dropdown buttons to control the debugger functions will be accessible as soon as you start the debugger.

##### In the Debug menu

When you start debugging, ten items to control the debugger will be enabled.

Available functions:

- Run: Continue the program from the current point.

- Run to cursor: Execute the program up to the current cursor position

- Step over: Execute one line of code stopping on the next line of code in the same surce file. This will run any functions encountered until the above condition is met.

- Step over i(nstruction): Execute one machine instruction as above.

- Step in: Execute exactly one source line of code. This means you will "step into" the current function, if necessary

- Step in i(nstruction): Execute one machine instruction as above.

- Step out: Run to the end of the current stack frame (function)

- Viewers: Allows a variety of views into the data. Currently implemented views are:

  1. Memory address

  2. Disassemble code

  3. Current registers

  4. Current libraries

- Interrupt: Stop the application executing.

- Stop: Stop the application executing and exit the debugger.

#### Details

##### Breakpoints

Breakpoints can be set against source lines in a file (referred to as breakpoints) or on variables in the source (referred to as watchpoints). Both types of breakpoints can be set at anytime, however watchpoints on local variables only have meaning in the variables local scope. Watchpoints have more meaning when you are dealing with global variables.

##### Set/Unset breakpoints

Simple one click set/unset. Click on the "icon" border to the left of the text in the editor at the line you want the breakpoint. Click again on this line to unset the breakpoint.

##### Alternative beakpoint manipulating via menus

By right clicking on a breakpoint in the breakpoint list or on a breakpoint in the editors icon border you will get a menu of breakpoint options. This allows you to remove this breakpoint, clear all breakpoints, or edit the breakpoint.

##### Editing breakpoints

Use the above menu to display the edit breakpoint dialog. This contains the following fields :

1. Conditional: Enter the condition that must be met before gdb will interrupt the program execution.

2. Ignore count: How many times you want the code to past through this breakpoint before gdb interrupts the program execution.

3. Enable: When enabled gdb will break at this breakpoint. When disabled gdb will not break here.

##### Clear all breakpoints

Removes all the breakpoints for this program.

##### Set/Unset watchpoints

In the VAR view click with the Right Mouse button on a variable. A popup menu will be displayed allowing you to set a watchpoint on the local variable. This functionality is limited to the scope that the local variable is in. As the variable goes out of scope the program breaks and the watchpoint is deleted.

WARNING: This is known to be problematic, so use caution when setting watchpoints on local variables.

The watchpoint can also be set by a right mouse click on a previously entered watch variable, and selecting "toggle watchpoint"

##### Set/Unset Watch variables

At the bottom of the VAR view there is the "Watch" field where you can enter the variable name you wish to see display in the watch list. Enter the variable name and type "enter" or click on the "Add" button alongside the field. Right Mouse clicking on the watch variable in the treeview will bring up a menu so that you can remove the variable from the list.

You can also enter a watch variable by right mouse clicking on a variable name in the editor window. This displays a popup menu with "watch: variable name" on it.

##### Changing variable values

This is done via the watch variable. If you have a variable "test" then to set "test" to 5 type "test=5" in the watch field and add it to the list. Note that "test" will be set to "5" EVERY time the program stops at a breakpoint, so once you have set the variable, usually you should remove the item from the watch view.

### The floating toolbar

The floating toolbar is a feature of the internal debugger, which greatly improves your comfort in debugging GUI applications. The toolbar is either on top of all windows displayed, or docked into the panel. When docked you can run your code by clicking on the docked icon. The function this performs is the "step over" function. Right clicking on the docked item allows you to restore the toolbar and optionally place focus on kdevelop.

Besides the functions available from the Debug Menu, the floating toolbar offers two additional functions:

- Set focus on kdevelop : Set the focus on kdevelop

- Set focus on app : This sets the focus on the window that had focus when you pressed the "set focus on kdevelop" button. This is a compromise, it should set the focus on the application being debugged but this is difficult to do. If anyone has a better solution than the current functionality then please let us know.

When gdb interrupts the program, probably because a breakpoint has been triggered, we highlight the "Set focus on kdevelop". We do not automatically switch focus to kdevelop so that you can view the application window at this point. Click on the "set focus" button to switch to kdevelop or press a button on the toolbar to perform your selected function.

### Shared libraries and breakpoints

Shared libraries and breakpoints have a problem that has a reasonable solution. The problem is that gdb will not accept breakpoints in source that is in a shared library which has not yet been opened but will be opened via a dlopen.

The solution is to get gdb to tell us when a shared library has been opened. We do so by setting "stop-on 1". This means that when the user sets a breakpoint, we flag this breakpoint as pending, try to set the breakpoint and if gdb says it succeeded then flag it as active. If gdb is not successful then we leave the breakpoint as pending. The next instruction will always be "continue" .

This is known as "lazy breakpoints"

However, this can lead to a problem when you use the "step over" command and step over code that will load a library. This will trigger a break on the library load, and, normally the debugger would do a "continue" (ie run to the next breakpoint or the end of the code). The user, however, is expecting the program to stop at the next line, so in this situation we do not continue, but leave it at that point (which will be somewhere inside a dlopen command). This is disconcerting but cannot be helped.

## Beépített CVS

KDevelop also takes care of managing your project via CVS repositories. The goal behind CVS (concurrent version control) is to enable groups of developers to work on the same source-tree independently and to merge changes into the repository. Usually, the repository is located at a server. The initial repository contains the base set of files that the project includes; directories and files are then added or removed to the CVS by the developers.

Locally, the developer works on his copy of the CVS tree. He writes his changes into his files and tests, if his project still works, at least to a certain extend where incomplete sources don't prevent other developers from still working on the CVS repository if they receive the changes.

### Enabling CVS Support

As CVS support is most often only needed by professionals or companies as well as by KDE developers maintaining their project over the KDE CVS server, using the CVS commands of KDevelop is optional. To enable the CVS commands, open the Project-Options dialog and change the option for Version Control to "CVS".

### Using CVS Commands

Then the following commands are available in the LFV and RFV by context menus:

Over a file not included in the repository:

- Add to Repository: adds the file to the repository. The file is set up to be added and will be introduced to the repository on the next `commit` command that includes the directory where the added file is located locally.

Over a file included in the repository:

- Update: update the selected file with the CVS version

- Commit: commit the selected file to the CVS repository

- Remove from Repository: remove the file from the repository

Over a folder:

- Add: adds the folder to the repository

- Remove: removes the folder from the repository

- Update: update the folder recursively to be in sync with the repository

- Commit: commit any changes recursively to the repository

The CVS commands all require a working network connection to the CVS server. When invoking a command, you will be shown a dialog with the command sent to the CVS server and the retrieved output. Thereby you can control what actually happens and if the command was successful or not.

As the CVS commands of KDevelop only work with the `cvs` system command and its commandline options, you should have no trouble to use the cvs features.

## Általános beállítások

This chapter describes how you can set your individual preferences about how KDevelop works. All settings addressed below can be found by the according entry in the Options-menu.

### Configuring the "Tools
" MenuTools
" Menu">

As KDevelop supports the use of third-party programs within it's user interface, you are able to configure
any program that suits your needs towards application development. This can be done by adding programs to the already pre-defined ones in the "Tools"-menu
. To change the tools-menu, select "Tools
" from the "Options" menu. This dialog allows to specify the entry name, program and additional command line options you want to pass to the execution. To remove a program from the menu, select the entry name and choose "Delete". To add a program, specify the menuentry, where a & is used as a menu-accelerator; you may compare the already configured entries with the entry list. Select the binary and pass your commandline options. Then hit "Add" and the entry is added to the list. After leaving the configuration dialog
, the tools-menu updates itself, so the new configuration is already usable without restarting KDevelop.

### File Viewer Options

The Logical File Viewer can be configured by context menus completely. As it's intention is to separate files logically to keep a better overview over complex projects, one of the most used configurations is to create file groups. Those can be set by opening the context menu with a right mouse button click over the project icon displayed at the root of the tree. The menu offers:

- New File
  : Opens the New File
  dialog. Equals to the menubar command "File"-"New"

- New Class
  : Opens the Classgenerator to create a new class. Equals to the menubar command "Project"-"New Class
  "

- New Group: Opens a dialog to create a new group. There, set the group name and the file filter for the project files
  that will be displayed in this group.

- Show relative path: displays the files with their path name starting from the main project directory if checked; otherwise only the filename is shown.

Over a group folder, the according context menu offers:

- New Group: Opens the New Group dialog as in the context menu described above.

- Remove group: removes the group from the LFV
  .

- Properties: Opens the properties of the group. There, you can edit the file filters by a list of wildcards separated by commas.

### KDevelop Setup

Make-command
: The General Options dialog lets you configure KDevelop's general settings. First, you should set the make-command
available on your system. If the selected program does not exist, KDevelop will warn you the next time you're invoking a make command.

Autosave
:

If Autosave is checked, KDevelop will save all changed files periodically. The autosaving time range can be set to 3, 5, 15 or 30 minutes.

Autoswitch
:

If Autoswitch is enabled, the KDevelop windows will switch on and off according to the usage context, e.g. if you switch to a documentation in the Help-menu, the Documentation browser will be opened, together with the documentation tree and the output
window turned off.

Startup
:

For starting KDevelop, you have the option to enable/disable the start-logo
to be shown during the time KDevelop loads. Further, if you don't like the last project to be opened on startup, you can disable the default behavior.

### Changing Keyboard Shortcuts

The Configure Keys dialog lets you configure the KDevelop key bindings. Note that global keys can be configured in the KDE Control Center, such as open file and print. A key function can be configured by choosing the menu entry. Then the configuration can be changed by checking values like the Alt / Ctrl key etc.

### Documentation

#### Directories

For setting up the documentation browser
to work correctly, KDevelop needs some information about where the HTML
-documentation is placed on the system. Therefore, the Documentation Path properties dialog needs the path of the Qt- online documentation in HTML
as well as the path to the KDE-Library documentation.

Usually, the Qt-Documentation
is placed in the same directory where Qt is installed; e.g. if Qt resides in /usr/local/qt, the path you have to enter is /usr/local/qt/html. For the KDE- Documentation, you have to set the directory to the root of the documentation, assumed all KDE-Libs documentation resides in the same directory. Both path's can be selected by pressing the according buttons, displaying a path-selection. If your system doesn't contain the documentation for the KDE-libs, you should first enter the next configuration dialog
, Update KDE-Documentation
. This will create the documentation to a path of your choice, also setting the KDE Library Doc path automatically.

#### Options

##### Update KDE-Documentation

For those users who don't have a recent documentation of the KDE-libraries
, especially the documentation for the files installed on the system, the Update KDE-Documentation
dialog creates a new one or updates existing documentations. This function requires your system to have KDoc
and qt2KDoc
installed, included in the KDE-SDK
package. First of, you have to set up the path to your recent kdelibs sources, which is not the include-path for KDE ! Just enter the path to the sources, like: /home/rnolden/kdelibs-1.1/.

Then, you can choose three different installation modes, as:

- Delete old Documentation and install to recent Documentation-path: this assumes that you already have a documentation installed and is placed in the path the Documentation Path-dialog was entered. This will delete all documentation and install the newly generated documentation into the recent path.

- Delete old Documentation and install to new Documentation-path: this will result in deleting the old documentation as well as above, but gives you the choice to set up a new documentation place.

- Leave old Documentation untouched and install to new Documentation path: This is recommended for a new generation of the kdelibs documentation for users who didn't have one before and for those who want to keep the last documentation for an older kdelibs version.

The "new KDE Libs Documentation path" is to be set for option 2 and 3 of the installation mode. This is also recommended for users who generate a new documentation from scratch.

After pressing the OK button, KDevelop will create a subdirectory "KDoc
-reference" in the documentation path containing the KDoc
reference files. First, the qt library documentation classes
will be indexed to connect the Qt documentation with the documentation to be generated for the kdelibs. So it is important that you have set up the Qt documentation path first to ensure that it can be found by `
qt2kdoc`. Finally, the KDE libs will be indexed and the documentation will be build with cross-references to give browsing the most functionality.

##### Create Search Database

The Create Search Database dialog, accessed via the create-button, allows the programmer to create a database to search for a keyword interactively. To create and use the documentation search function, you must have the program glimpse
4.0 or ht://Dig installed. Preset are the options to index the given KDE-Library documentation as well as the Qt-Documentation
, assuming the path to the documentation files were set in the "Documentation Path" dialog of the options- menu. Additionally, the index can include directories the user can set up himself by the "additional directories to index"-field. After setting a path to an additional directory, the "Add" - button must be pushed to set the path. A path once set can be removed from the index by selecting the path in the path field and pushing "Remove". Furthermore, the user is offered three different modes for the index size: tiny, small and medium. The higher the index size, the more the index files will grow. On the other hand, a search in a bigger search-database will be faster and more successful, so we suggest choosing a "medium" size. For using the search function, see section Using the Documentation Browser.

### Debugger

The default setup for KDevelop is to use the internal debugger. Click on "Use external debugger" if you wish to use a different debugger and enter the name of the debugger to use. See your debuggers documentation on how to run it.

Selecting the internal debugger enables an additional set of options you can choose from:

- Display static members: Displaying static members makes gdb slower in producing data within kde and qt. It may change the "signature" of the data which QString and friends rely on. But if you need to debug into these values then check this option.

- Display mangled names: When displaying the disassembled code you can select to see the methods mangled names. However, non-mangled names are easier to read.

- Try setting BPs on lib load: This will try to set pending breakpoints on loading a library. If GDB hasn't seen a library that will be loaded via "dlopen" then it will refuse to set a breakpoint in that code. We can get gdb to stop on a library load and hence try to set the pending breakpoints. See Shared libraries and breakpoints for more details and a "gotcha" relating to this behaviour. If you are not "dlopen"ing libs, leave this off.

- Enable floating toolbar: This will allow you to use the floating toolbar to control the debugger in addition to the menu and buttons. The toolbar is most useful for debugging GUI applications. For details see The floating toolbar.

### Setting Paths

On the paths tab you can enter the paths to your Qt 2.x and KDE 2 installations as well as where to create new projects. To learn more about installing Qt 2.x / KDE 2 and configuring KDevelop for Qt 2.x and KDE 2 read the KDE Application Tutorials.

The default location for KDevelop to create new projects is in the user's home directory. If you want to change this behaviour you can enter the desired location into the default project path field.

## Kérdések és Válaszok

This section addresses questions by users that were answered by the KDevelop Team or by their supporters on the KDevelop mailing list during experiences with the current versions of KDevelop as well as bug reporting in general.

### Bug Reporting

Another improvement of KDevelop is the integrated bug-reporting system via email. If you experience a bug, you have the option to send the KDevelop development team a bug report either by your email-client or by the bug-report dialog. All bug-reports are collected on the KDevelop web site and can be reviewed on http://bugs.kde.org//db/pa/lkdevelop.html.

To send bug reports, please use the email address submit@bugs.kde.org. If you want to use KDevelop for direct bug-reporting, choose "Bug Report" from the Help-menu
. You are presented the report dialog that lets you enter all necessary information about the bug you found. After pressing "OK", the dialog's contents is sent there automatically.

### Where to get Information

Q: I have a question which is not addressed in the FAQ file, nor in the manuals of KDevelop. Where should I turn to ?

A: In any case send all requests that are regarding KDevelop by subscribing to the KDevelop mailing list at kdevelop-request@barney.cs.uni-potsdam.de. Send a mail with an empty header and "subscribe youremailaddres" as contents; then you can participate on the discussions. All questions should go there and will be addressed there as well. If you stick to that, you will get the most help by the developers and all users having the same problems, as well as helping to keep the FAQ up to date.

The KDevelop Homepage
at \|\| also contains a mailing-list
archive that allows you to browse the mails already send by the subscribers, so you should look there first as most problems should have been addressed already by the team or other users.

### Library and System Problems

Q: Wrong JPEG library version: library is 61, caller expects 62

A: There are 2 ways.

1. When the kdelibs are installed it installs header files for the jpeg libraries, these are version 61, however most distributions (Redhat) use version 62 libraries. To fix this just remove jpeglib.h from /opt/kde/include. The pukka include file for version 62 should then be picked up. However looking at the error message above it may be the other way round, in any case ensure you only have on version of the header file, the library and that they are consistent.

   It is useful to use the locate command to verify that I have the correct version of a library and header files e.g. updatedb locate libjpeg locate jpeglib

2. You must recompiled kdesupport without jpeg library (./configure
   --with-libjpeg --with-libgif).

Q:

    make[2]: Entering directory `/usr/local/src/kdevelop-0.3/po'
    cd .. && automake --gnu --include-deps po/Makefile
    aclocal.m4: 2709: `AM_PROG_INSTALL' is obsolete; use `AC_PROG_INSTALL'
    make[2]: *** [Makefile.in] Error 1

A: Workaround for automake-1.4/automake-2.13 users: Just run "aclocal" manually, then it will compile.

Q: What must i do, if configure
said ,that i need giflib23.

A: Try a newer snap of kdesupport, or maybe you have another giflib installed?

Q: How can I convert a KDevelop 0.2 project to a 0.3 one?

A: Please change the AC&&lowbar;;OUTPUT in the configure
.in to a oneline version

for example: old version:

    AC_OUTPUT(Makefile \
    kdevelop/kwrite/Makefile \
    kdevelop/templates/Makefile
    )

new version:

    AC_OUTPUT(Makefile kdevelop/kwrite/Makefile kdevelop/templates/Makefile)

Q: I get the following Linker
errors
when using SuSE Linux with KDE 1.1, what do I have to do to get KDevelop linked ?

    /usr/lib/libqt.so:
    warning: multiple common of `QArrayT&<;char&>; type_info node'
    ckdevelop.o: warning: previous common is here
    ckdevelop.o: In function `CKDevelop::slotFileSaveAll(void)':
    ckdevelop.o(.text+0x784): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o(.text+0x839): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o(.text+0x89d): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o: In function `CKDevelop::slotFileSaveAs(void)':
    ckdevelop.o(.text+0xd28): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o: In function `CKDevelop::slotFileClose(void)':
    ckdevelop.o(.text+0x1216): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o(.text+0x1263): more undefined references to `kdebug(unsigned
    short, unsigned short, char const     *,...)' follow  collect2: ld returned 1
    exit status  make[2]: ***
    [kdevelop] Error 1  make[2]: Leaving directory
    '/home/LinuXDaten/Programme_Updates_Packete/KDE_Updates/Kdevelop_actual_snapshot/kdevelop-0.3/kdevelop'
    make[1]: *** [all-recursive] Error 1  make[1]: Leaving directory
    `/home/LinuXDaten/Programme_Updates_Packete/KDE_Updates/Kdevelop_actual_snapshot/kdevelop-0.3'
    make: *** [all-recursive-am] Error 2

A: If you have the SuSE rpm´s of KDE-1.1, you must recompile the kdelibs without the patch commited by SuSE and reinstall them or get an updated rpm of the kdelibs from \|\|

### Usage Questions

Q: I see the KDevelop does not allow for usage of the delete key (or backspace deleting when text is marked).

A: go to "Options"->"Editor" and make sure that "Delete on Input" is enabled, then backspace and delete works.

Q: If I add files to my project, will they be automatically included and compiled ?

A: Yes, they are included in the Makefile.am
's then and if you make a "Rebuild All" (./configure
updates the Makefile
s), your new added files will be included as well.

Q: If I removed a file, I get some weird Linker
messages. What is wrong with my project ?

A: If the removed file is a header file, that is automatically processed by automoc (running the Qt-Meta-Object-Compiler automatically on all headers), your removed header is still present as a moc-generated *.moc.cpp file and compiled. Remove the according *.moc.cpp file and rebuild the project.

## Szerz&odblac;k

Main Developers:

Sandy Meier <smeier@rz.uni-potsdam.de> (maintainer, development coordinator and homepage provider) Main development of: frame structure, IDE look'n feel, project management.

Stefan Heidrich <sheidric@rz.uni-potsdam.de> Main development of: KAppWizard
, printing
functionality

Ralf Nolden <Ralf.Nolden@post.rwth-aachen.de> Main development of: KDevelop<->Dialog Editor interface, configuration functionality, online-help and handbooks

Jonas Nordin <jonas.nordin@cenacle.se> Main development of: Classviewer and -parser

Pascal Krahmer <pascal@beast.de> Main development of: Dialog Editor

Bernd Gehrmann <bernd@physik.hu-berlin.de> Main development of: Grep Dialog, CVS integration, new DOC tree

Jörgen Olsson <jorgen@cenacle.net> Main development of: Visual Classtree

Stefan Bartel <bartel@rz.uni-potsdam.de> Main development of: Real-File-Viewer

Walter Tasin <tasin@e-technik.fh-muenchen.de> Main development of: Enhancements and Bug fixing

John Birch <jbb@ihug.co.nz> Main development of: Integrated Debugger

Translation coordination:

Martin Piskernig <martin.piskernig@stuwo.at>

Program and Documentation Translations:

- Martin Spirk <spirk@kla.pvt.cz> -Czech

- Steen Rabol <rabol@get2net.dk> -Danish

- Peeter Russak <pezz@tkwcy.ee> - Estonian

- Sami Kuhmonen <sami@iqs.fi> -Finnish

- Herve Lefebvre <hlefebvre@easynet.fr> -French

- Martin Piskernig <martin.piskernig@stuwo.at> -German

- Ralf Funken <funken.ruk@netcologne.de> -German ( Debugger work )

- Pahan Szabolcs <szabczy@bigfoot.com> -Hungarian

- Massimo Morin <mmorin@schedsys.com> -Italian

- Taiki Komoda <kom@kde.gr.jp> - Japanese

- Jacek Wojdel <wojdel@kbs.twi.tudelft.nl> -Polish

- Duarte Loreto <dnloreto@esoterica.pt> -Portuguese

- Guilherme Ceschiatti B.M.<guiga@cpdee.ufmg.br> -Portuguese/Brazil

- Ilmar Habibulin <ilmar@ints.ru> -Russian

- Jan Prokop <jprokop@ibl.sk> -Slovak

- Salvador Gimeno <salgiza@eui.upv.es> -Spanish

- Patrik Adolfsson <patrik.adolfsson@iname.com> -Swedish

- Kaðan Kongar <kongar@doruk.net.tr> - Turkish

- Sunchange Lee <leesongchen@263.net> - Simpl. Chinese (GB2312)

Startlogo:

- KDevelop 1.0: Jacek Wojdel <wojdel@kbs.twi.tudelft.nl>

- KDevelop 1.1: Ralph Kocher <RKocher@t-online.de>

Additions, patches and bugfixes:

- Pau Estalella Fernandez <pef@upcnet.upc.es>

- Jost Schenk <Jost@Schenk.de>

- David Barth <dbarth@videotron.ca>

- Matthias Hipp <Matthias.Hipp@gmx.de>

- Martin Piskernig <martin.piskernig@stuwo.at>

- Jochen Wilhelmy <digisnap@cs.tu-berlin.de>

- Matthias Hoelzer-Kluepfel <mh@caldera.de>

- Matt Koss <koss@napri.sk>

- Torsten Uhlmann <TUhlmann@debis.com>

- Stefan Mars <mars@lysator.liu.se>

- Nikolay Liber <nikolay_liber@mail.ru>

- Gordon Tyler <gtyler@iafrica.com>

- Huy Cuong Nguyen <huyc@iquebec.com>

- John R. Zedlewski <zedlwski@princeton.edu>

- Stephan Uhlmann <suhlmann@gmx.de>

- Charles Egan <cega@oklahoma.net>

- Andrew Morton <morton@nortelnetworks.com>

- p&&lowbar;;george <p_george@club-internet.fr>

- Lubos Lunak <l.lunak@sh.cvut.cz>

- Armin L. Schneider <armin@uumail.de.uu.net>

- Martin Spirk <spirk@kla.pvt.cz>

- Ralf Palsa <rpalsa@eso.org>

- Richard Dale <Richard_Dale@tipitina.demon.co.uk>

- Holger Schurig <holger@holger.om.org>

- Dag Andersen <dandersen@c2i.net>

- Alexis Mikhailov <alexis@abc.cap.ru>

- Ulltveit-Moe <Nils.Ulltveit-Moe@hia.no>

- Nich Hudson <nick@nthcliff.demon.co.uk>

- R. Imura <imura@cs.titech.ac.jp>

- Falk Brettschneider <gigafalk@yahoo.com>

KDevelop contains sourcecode from the following applications:

KWrite 0.98 &©; by Jochen Wilhelmy <digisnap@cs.tu-berlin.de>

KDE Help &©; by Martin R. Jones <mjones@kde.org>

KSwallow &©; by Matthias Hoelzer <hoelzer@physik.uni-wuerzburg.de>

kcmlocale &©; 1998 by Matthias Hoelzer <hoelzer@physik.uni-wuerzburg.de>

## Köszönet

We like to express special thanks to all of our family members and friends who supported us in several ways to let us construct and improve KDevelop.

Further, we thank Jochen Wilhelmy for offering his program kwrite and his help on integrating it into KDevelop.

Thanks also to the KDE team and Stephan Kulow, who gave us the possibility to work on KDevelop via CVS

We hope that our free work on this product will lead to a better acceptance of Free Software and its development. Without the help and idealism of many, the KDevelop IDE would never have been realized in such a short period of time and we're proud that so many users already have reported good experience and brought KDevelop to it's destiny: helping free software programmers to build a better world where users have the freedom of choice.

## Copyright

    KDevelop Copyright 1998,1999 The KDevelop Team.

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.