<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook V3.1-Based Variant V1.0//EN" [
 <!ENTITY kdevelop "<application>kdevelop</application>">
 <!ENTITY % addindex "IGNORE">
 <![ %addindex; [ <!ENTITY docindex SYSTEM "docindex.docbook"> ]]>
]>
<book lang="en">
<bookinfo>
<title>KDevelop Felhasználói Kézikönyv -Fordítás alatt
</title>
<subtitle>Referencia Kézikönyv a Unix operációs rendszer alatt futó KDevelop Integrált Fejlesztői Környezethez, 1.0 Verzió</subtitle>
<authorgroup>
<author>
<surname>Ralf Nolden </surname>
<affiliation>
	  <orgname>KDevelop fejlesztői csapat</orgname>
<address><email><ulink url="mailto:Ralf.Nolden@post.rwth-aachen.de">&lt;Ralf.Nolden@post.rwth-aachen.de&gt;</ulink></email></address>
</affiliation>
</author>
</authorgroup>
<date>2.2 verzió, 1999. Július 29</date>
<releaseinfo><!-- information about this particular version --></releaseinfo>
<abstract>
<para>Ez a kézikönyv része a KDevelop Integrált Fejlesztői Környezetnek és ebből kifolyólag a GNU Általános Nyilvános Licensz vonatkozik
 a terjesztésére; további információkért lásd:<link linkend="Copyright">Copyright</link>.</para>
<para>KDE</para><!-- Merge this with the previous paragraph; it comes from <META NAME="description" CONTENT="..."> --></abstract>

</bookinfo>

<chapter id="bevezet">
<title>Bevezető</title>

<para>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ű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ősége állja a versenyt a
kereskedelmi szoftverekével. De dacára a minő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ű használhatóság.</para>

<para>A KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> projekt ezt a szakadékot próbálja meg szűkíteni azáltal, hogy könnyen használható munkafelületet nyújt egy csoport könyvtárral
együtt, kiterjesztentő a rendelkezésre álló GUI <indexterm remap="idx"><primary>GUI</primary></indexterm>-alapú szoftverek választékát. De mivel a szabad szoftver leginkább a szerzője
szabad idejében készül, különösen fontos kérdés, hogy a programozó mennyire kedveli a jelenlegi kódfejlesztő környezetet.
A KDevelop meg kívánja tenni a következő 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ő alatt magasabb minőségi és megbízhatósági szintet érhetnek el.</para>

<para>E cél elérése érdekében a KDevelop Integrált Fejlesztői Környezet sok, a fejlesztők által igényelt szolgáltatást nyújt,
magába ágyaz mások által írt programokat, mint például a <literal remap="tt">make</literal> és a GNU C++ fordítóprogram <indexterm remap="idx"><primary>fordítóprogram</primary></indexterm>ok, láthatatlan, integrált
részévé téve őket a fejlesztői folyamatnak. A KDevelop tartalmazza:</para>

<para><itemizedlist>
<listitem>
<para> A C++ programozáshoz szükséges minden fejlesztőeszközt, mint például a fordítóprogram <indexterm remap="idx"><primary>fordítóprogram</primary></indexterm>, linker <indexterm remap="idx"><primary>linker</primary></indexterm>, automake <indexterm remap="idx"><primary>automake</primary></indexterm> és
autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm>,</para>
</listitem>
<listitem>
<para> Alkalmazásvarázsló <indexterm remap="idx"><primary>Alkalmazásvarázsló</primary></indexterm>t, amely teljes futtatásra kész mintaalkalmazást generál,</para>
</listitem>
<listitem>
<para> Osztálygenerátort, új osztály <indexterm remap="idx"><primary>osztály</primary></indexterm>ok létrehozására és az aktuális projektbe való integrálására,</para>
</listitem>
<listitem>
<para> Fájlkezelést a projektbe tartozó források, fejlécfájlok, dokumentáció stb. rendezgetésére,</para>
</listitem>
<listitem>
<para> Felhasználói kézikönyvek létrehozását SGML <indexterm remap="idx"><primary>SGML</primary></indexterm>-ben és KDE kinézetű HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-kimenet <indexterm remap="idx"><primary>kimenet</primary></indexterm> automatikus generálását,</para>
</listitem>
<listitem>
<para> Automatikus HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-alapú API-dokumentációt <indexterm remap="idx"><primary>API-dokumentációt</primary></indexterm> a projekted osztály <indexterm remap="idx"><primary>osztály</primary></indexterm>aihoz keresztreferenciákkal a felhasznált könyvtárakhoz,</para>
</listitem>
<listitem>
<para> "Nemzetköziesítési" támogatást az alkalmazásodhoz, lehetővé téve, hogy könnyen új támogatott nyelvet adhassunk a projekthez,</para>
</listitem>
<listitem>
<para> WYSIWYG (Amit látsz, azt kapod) -felhasználói felület létrehozását, beépített dialógusszerkesztő <indexterm remap="idx"><primary>dialógusszerkesztő</primary></indexterm>vel,</para>
</listitem>
<listitem>
<para> A projekted CVS általi verziókarbantartását, könnyen használható felületet adva a legsűrűbben igényelt funkciókhoz,</para>
</listitem>
<listitem>
<para> Az alkalmazásod nyomkövetését, a KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm> integrálása által,</para>
</listitem>
<listitem>
<para> Projekt-specifikus pixmap <indexterm remap="idx"><primary>pixmap</primary></indexterm>-ok szerkesztését a KIconEdit <indexterm remap="idx"><primary>KIconEdit</primary></indexterm>-tel,</para>
</listitem>
<listitem>
<para> Bármilyen más eszköz beágyazását az "Eszközök <indexterm remap="idx"><primary>Eszközök</primary></indexterm>"-menün keresztül egyéni igénytől függően.</para>
</listitem>
</itemizedlist>
</para>

<para>A KDevelop használatát élvezetessé teszi, hogy minden program egy helyről érhető el, időt takaríthatunk meg a szokványos fejlesztő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ő eljárások támogatják azon kereséseket a documentáció <indexterm remap="idx"><primary>documentáció</primary></indexterm>ban, amelyeket a fejlesztők a projektjükkel kapcsolatban
elindíthatnak.</para>

<para>Az osztály nézet <indexterm remap="idx"><primary>osztály nézet</primary></indexterm> és a hibakereső 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ővé teszi a projekt fájlok <indexterm remap="idx"><primary>projekt fájlok</primary></indexterm>at és a beépített segítő rendszer bárhonnan az IDE-n belül
nagyszerű hozzáférést biztosít az online dokumentációhoz.</para>

<sect1 id="vltozsok">
<title>Változások</title>

<para>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ő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ő verzió, amely olyan fejlesztői
környezetet nyújt, amilyet a programozók használni akarnak.</para>

<para>A következő területeken értünk el javulást:</para>

<para><itemizedlist>
<listitem>
<para>gyors osztályelemző és &&nbsp;;böngésző, grafikus osztály-fa nézettel, osztályok és elemeik dialógusalapú szerkesztésével,</para>
</listitem>
<listitem>
<para>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,</para>
</listitem>
<listitem>
<para>a KDevelop-pal együtt szállított frissített és kiterjesztett dokumentáció, amely pillanatnyilag öt kötetet számlál,</para>
</listitem>
<listitem>
<para>javított osztályelemző, dialógusszerkesztő és hibakereső.</para>
</listitem>
</itemizedlist>
</para>

<para>Az IDE-ről, a dokumentációjáról vagy a szolgáltatásairól bármilyen észrevételt örömmel fogadunk.</para>
</sect1>

<sect1 id="errl-a-kziknyvrl">
<title>Erről a kézikönyvről</title>

<para>Ez a felhasználói kézikönyv teljes áttekintést nyújt a KDevelop IDE-ről és röviden leírja a fejlesztői folyamat alapjait. Egyedi
programozási kérdésekhez további információkért a KDevelop-pal szállított <ulink url="../../default/kdevelop/programming/index.html">KDevelop Programozói Kézikönyv</ulink> elolvasását ajánljuk, amely olyan témákkal foglalkozik, mint például a generált keretalkalmazás <indexterm remap="idx"><primary>keretalkalmazás</primary></indexterm>ok
megértése és telivér KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> alkalmazások létrehozása példaprojektek felhasználásával.</para>

<para>Ez a kézikönyv a következő részeket tartalmazza:
<itemizedlist>
<listitem>
<para>A <link linkend="Installation">Telepítés</link> fejezet ismerteti az ajánlott konfigurációt, a KDevelop IDE telepítését és üzembehelyezését.</para>
</listitem>
<listitem>
<para>A <link linkend="Programs">Programok</link> fejezet elmondja, hogyan hoznak létre programokat szabványos GNU fejlesztőeszközökkel, és hogyan
lesznek lefordítva.</para>
</listitem>
<listitem>
<para>A <link linkend="Development-with-KDevelop">Fejlesztés a KDevelop-pal</link> fejezet rövid kirándulásra visz, körülírva a környezet főbb funkcióit.</para>
</listitem>
<listitem>
<para>Az <link linkend="Overview">Áttekintés</link> fejezet bemutatja a menüket, dialógusablakokat és a billentyűkombinációk <indexterm remap="idx"><primary>billentyűkombinációk</primary></indexterm>at.</para>
</listitem>
<listitem>
<para><link linkend="The-Help-System">A Súgó Rendszer</link> megmutatja a beépített dokumentáció-böngésző <indexterm remap="idx"><primary>dokumentáció-böngésző</primary></indexterm> használatát és a további súgó funkciókat.</para>
</listitem>
<listitem>
<para>A <link linkend="Working-with-the-Editor">Munkában a Szerkesztő</link> fejezet elmagyarázza a fájl-kezelés és szerkesztés szolgáltatásait.</para>
</listitem>
<listitem>
<para>A <link linkend="Projects">Projektek</link> fejezet leírja a szoftver projektek létrehozását és karbantartását.</para>
</listitem>
<listitem>
<para>A <link linkend="Build-Settings">Build beállítások</link> fejezet referenciát tartalmaz a fordítóprogram <indexterm remap="idx"><primary>fordítóprogram</primary></indexterm> és a linker, valamint a projekt beállításairól.</para>
</listitem>
<listitem>
<para><link linkend="The-Class-Browser">Az Osztályböngésző</link> fejezet elmondja, hogyan használhatjuk ki a KDevelop hatékony Osztályböngészőjének a szolgáltatásait.</para>
</listitem>
<listitem>
<para><link linkend="The-Dialog-Editor">A Dialógus szerkesztő</link> fejezet felvázolja a beépített GUI <indexterm remap="idx"><primary>GUI</primary></indexterm> építőt, és az általa generált C++ kimenet <indexterm remap="idx"><primary>kimenet</primary></indexterm>et.</para>
</listitem>
<listitem>
<para>Az <link linkend="General-Configuration">Általános beállítások</link> fejezet megmutatja, hogyan lehet a KDevelop-ban átlalánosan használt beállításokat megadni.</para>
</listitem>
<listitem>
<para>A <link linkend="Questions-and-Answers">Kérdések és Válaszok</link> fejezet a KDevelop különböző Unix rendszerek alatti használatát, és általános problémákat
érintő kérdéseket taglal.</para>
</listitem>
</itemizedlist>
</para>

<para>Kezdő programozóknak és a KDevelop új felhasználóinak melegen ajánljuk ezen kézikönyv átolvasását, mielő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űbbé teszi az elsőrangú fejlesztőeszközök
használatát.</para>
</sect1>
</chapter>

<chapter id="installation">
<title>Telepítés <indexterm remap="idx"><primary>Telepítés</primary></indexterm></title>

<sect1 id="hogyan-szerezzk-be-a-kdevelop-ot">
<title>Hogyan szerezzük be a KDevelop-ot?</title>

<para>A KDevelop megtalálható egyrészt a KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Alkalmazások oldalon a <ulink url="http://www.kde.org/current.html">\|\|</ulink> címen, vagy a KDevelop
honlapon: <ulink url="http://www.kdevelop.org">\|\|</ulink>. A KDevelop része a Linux disztribúcióknak is, mint például a SuSE 6.1.</para>

<para>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ői folyamatába. Különböző, a KDevelop-hoz szükséges mások által írt szoftvert is
ajánlunk, mint például a KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> és a KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm>.</para>

<para>Ha a KDevelop fordítása vagy használata során problémákba ütközöl, kérjük olvasd el a <link linkend="Questions-and-Answers">Kérdések és Válaszok</link>
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: <ulink url="mailto:kdevelop@fara3.cs.uni-potsdam.de">kdevelop@fara3.cs.uni-potsdam.de</ulink>
azáltal, hogy egy üres fejlécű levelet küldesz, és a levél tartalma csak egy szó: "subscribe" (felíratkozom). A kérdés lehetőleg a
KDevelop IDE használatára vonatkozzon, és ne az általad írt alkalmazás kódolása során felmerülő megvalósítási <indexterm remap="idx"><primary>megvalósítási</primary></indexterm> problémákra.
Akárhogy is, minden a listára küldött levél nyelve lehetőleg angol legyen, hogy minden tag részt vehessen a probléma megvitatásában,
és így jobban tudjunk segíteni. A levelező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 <indexterm remap="idx"><primary>hibák</primary></indexterm>t és eltárolni ezt a tudást, hogy
a kezdőknek még szakszerűbb segítséget nyújthassunk.
A hibák bejelentésének egy bevált módszere ha elküldöd a kimenet <indexterm remap="idx"><primary>kimenet</primary></indexterm>et a konzolból indított KDevelop után, vagy ha kimásolod és beilleszted
a KDevelop belső Üzenetek-ablak <indexterm remap="idx"><primary>Üzenetek-ablak</primary></indexterm>ának tartalmát.</para>
</sect1>

<sect1 id="rendszer-kvetelmnyek-rendszer-kvetelmnyek">
<title>Rendszer követelmények <indexterm remap="idx"><primary>Rendszer követelmények</primary></indexterm></title>

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

<para><emphasis remap="bf">Szükséges:</emphasis>
<itemizedlist>
<listitem>
<para>g++ 2.7.2/g++ 2.8.1/egcs 1.1 (vagy kompatibilis), letölthető: <ulink url="http://www.gnu.org">\|\|</ulink></para>
</listitem>
<listitem>
<para>GNU make (vagy kompatibilis), letölthető: <ulink url="http://www.gnu.org">\|\|</ulink></para>
</listitem>
<listitem>
<para>perl 5.004, letölthető: <ulink url="http://www.perl.com">\|\|</ulink></para>
</listitem>
<listitem>
<para>autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm> 2.12, letölthető: <ulink url="http://www.gnu.org">\|\|</ulink></para>
</listitem>
<listitem>
<para>automake <indexterm remap="idx"><primary>automake</primary></indexterm> 1.2, letölthető: <ulink url="http://www.gnu.org">\|\|</ulink></para>
</listitem>
<listitem>
<para>flex 2.5.4,</para>
</listitem>
<listitem>
<para>GNU gettext, letölthető: <ulink url="http://www.gnu.org">\|\|</ulink></para>
</listitem>
<listitem>
<para>Qt 1.42, letölthető: <ulink url="http://www.troll.no">\|\|</ulink></para>
</listitem>
<listitem>
<para>KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 1.1.x, letölthető: <ulink url="http://www.kde.org">\|\|</ulink></para>
</listitem>
</itemizedlist>
</para>

<para><emphasis remap="bf">Választható:</emphasis>
<itemizedlist>
<listitem>
<para>a2ps <indexterm remap="idx"><primary>a2ps</primary></indexterm> vagy enscript <indexterm remap="idx"><primary>enscript</primary></indexterm> a nyomtatás <indexterm remap="idx"><primary>nyomtatás</primary></indexterm> támogatására</para>
</listitem>
<listitem>
<para>ghostview vagy kghostview a nyomtatás <indexterm remap="idx"><primary>nyomtatás</primary></indexterm>i előnézethez</para>
</listitem>
<listitem>
<para>glimpse <indexterm remap="idx"><primary>glimpse</primary></indexterm> 4.0 a keresési index <indexterm remap="idx"><primary>keresési index</primary></indexterm>hez, letölthető: <ulink url="http://glimpse.cs.arizona.edu">\|\|</ulink></para>
</listitem>
<listitem>
<para>sgmltools 1.0, letölthető: <ulink url="http://www.sgmltools.org">\|\|</ulink></para>
</listitem>
<listitem>
<para>KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm> (<emphasis remap="bf">KDE Szoftver Fejlesztő Készlet - S</emphasis>oftware <emphasis remap="bf">D</emphasis>evelopment <emphasis remap="bf">K</emphasis>it), amely tartalmazza a
KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm>-ot, KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm>-t, KTranslator <indexterm remap="idx"><primary>KTranslator</primary></indexterm>-t
(letölthető: <ulink url="http://developer.kde.org">\|\|</ulink>)</para>
</listitem>
<listitem>
<para>KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm>, letölthető: <ulink url="http://members.telecom.at/~johsixt/kdbg.html">\|\|</ulink></para>
</listitem>
<listitem>
<para>KIconEdit <indexterm remap="idx"><primary>KIconEdit</primary></indexterm> (letölthető: <ulink url="http://www.kde.org">\|\|</ulink>)</para>
</listitem>
</itemizedlist>
</para>

<para>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.</para>

<para>A szerzők tudomása szerint, a SuSE Linux és a FreeBSD minden szükséges csomagot tartalmaznak, beleértve az a2ps <indexterm remap="idx"><primary>a2ps</primary></indexterm>-t és enscript <indexterm remap="idx"><primary>enscript</primary></indexterm>-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.</para>

<para><emphasis remap="bf">Dokumentáció:</emphasis>	</para>

<para>A KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 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ő a rendszereden a disztribúcióban a KDE projekt részeként szállított forrás-csomagokban;
és a <emphasis remap="bf">KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm></emphasis>-ra (a KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm>-ban található).</para>

<para>A honlapunkról (<ulink url="http://www.kdevelop.org">\|\|</ulink>) ajánlunk még egy C/C++ Referenciát <indexterm remap="idx"><primary>Referenciát</primary></indexterm>, amely telepítése után a
dokumentáció böngészőbe kerül integrálásra. Töltsd le a csomagot és másold be a forrás fájlt <literal remap="tt">root</literal> felhasználóként
a KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> könyvtárba és csomagold ki a <literal remap="tt">tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz</literal> paranccsal, ezután a referencia elérhető lesz
a dokumentációs fában; egyébként, ha a böngésző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.</para>
</sect1>

<sect1 id="fordts-s-telepts">
<title>Fordítás és Telepítés</title>

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

<para><screen>	&&percnt;; ./configure
	&&percnt;; make

	(root-ként)
	
	&&percnt;; make install
</screen>
</para>

<para>Miután a KDevelop az <literal remap="tt">autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm></literal>-ot használja, a lefordításnak nem kellene problémát okoznia.</para>

<para>KDevelop CVS levonat fordításához a következőket gépeld be:
<screen>	&&percnt;; make -f &lt;idx/Makefile.cvs/
	&&percnt;; ./configure
	&&percnt;; make

	menj át `root`-ba, és gépeld:
	
	&&percnt;; make install
</screen>
</para>

<para>Ha a rendszered make-parancs <indexterm remap="idx"><primary>make-parancs</primary></indexterm>a a <literal remap="tt">gmake</literal>, írj <literal remap="tt">gmake</literal>-et a <literal remap="tt">make</literal> helyett.</para>
</sect1>

<sect1 id="a-kdevelop-elindtsa">
<title>A KDevelop elindítása</title>

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

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

<para><screen> 	
&&percnt;; kdevelop  &&lt;;aTeProjekted&&gt;;.kdevprj
</screen>
</para>

<para>A KDevelop első indításkor minden felhasználónál elindítja az <link linkend="The-Installation-Program">automatikus telepítés</link> programot,
amely lehető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:</para>

<para><screen> 	
&&percnt;; kdevelop  --setup
</screen>
</para>

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

<sect1 id="the-installation-program">
<title>A telepítőprogram</title>

<para>A KDevelop tartalmaz egy automatikus telepítő 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őrízze a rendszeredet és belője a KDevelop környezetet.</para>

<para>A telepítő dialógus nyomógombjai a következő célokra szolgálnak:</para>

<para><emphasis remap="bf">Segítség:</emphasis>  Megnyitja a KDEHelp programot.</para>

<para><emphasis remap="bf">Végrehajtás:</emphasis> Elindítja a telepítési folyamatot és a következő lépéseket teszi:</para>

<para><orderedlist><listitem>
<para> Ellenőrzi a make/gmake, autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm>, autoheader, automake <indexterm remap="idx"><primary>automake</primary></indexterm> é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 <indexterm remap="idx"><primary>make-parancs</primary></indexterm> 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ől
rövid ismertető a <link linkend="Programs">Programok</link> fejezetben található.
</para>
</listitem>
<listitem>
<para> Ellenőrzi a KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> és a glimpse <indexterm remap="idx"><primary>glimpse</primary></indexterm> meglétét. Ezek teszik lehetővé az új KDE-Könyvtár <indexterm remap="idx"><primary>KDE-Könyvtár</primary></indexterm> dokumentáció és a kereső index <indexterm remap="idx"><primary>kereső index</primary></indexterm>
automatikus létrehozását a telepítés <indexterm remap="idx"><primary>telepítés</primary></indexterm> egy későbbi pontján, már ha megvannak.
</para>
</listitem>
<listitem>
<para> Ellenőrzi az a2ps <indexterm remap="idx"><primary>a2ps</primary></indexterm> vagy az enscript <indexterm remap="idx"><primary>enscript</primary></indexterm> jelenlétét, hogy biztosítsa a nyomtatás <indexterm remap="idx"><primary>nyomtatás</primary></indexterm> 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őbbiekben megteheted anélkül, hogy
újra kellene futtatni a telepítő <indexterm remap="idx"><primary>telepítő</primary></indexterm> programot.
</para>
</listitem>
<listitem>
<para> Ellenőrzi a KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm>, KIconEdit <indexterm remap="idx"><primary>KIconEdit</primary></indexterm> és KTranslator <indexterm remap="idx"><primary>KTranslator</primary></indexterm> meglétét. Javasoljuk, hogy telepítsd ezeket a programokat, mivel
kiváló segítséget nyújtanak komplett KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-alkalmazások létrehozásánál. Megjegyzendő, hogy a KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm> közvetlenül elérhető a
KDevelop-on belül az aktuális projekt nyomkövetésére; a KIconEdit <indexterm remap="idx"><primary>KIconEdit</primary></indexterm> a fájl-nézegető fában kijelölt pixmaps <indexterm remap="idx"><primary>pixmaps</primary></indexterm>-ek kirajzolására és
szerkesztésére használatos. A KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm>, KIconEdit <indexterm remap="idx"><primary>KIconEdit</primary></indexterm> és KTranslator <indexterm remap="idx"><primary>KTranslator</primary></indexterm> programok -ha megvannak- úgy lesznek konfigurálva, hogy
elérhetőek legyenek az "Eszközök <indexterm remap="idx"><primary>Eszközök</primary></indexterm>" menüből.
Egyéb programok is hozzáadhatóak az Eszközök <indexterm remap="idx"><primary>Eszközök</primary></indexterm>-menühöz később a "Beállítások" menüben az "Eszközök <indexterm remap="idx"><primary>Eszközök</primary></indexterm>..." menüpont kiválasztásával.
</para>
</listitem>
<listitem>
<para> 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.
</para>
</listitem>
<listitem>
<para>Detection of your Qt-Documentation <indexterm remap="idx"><primary>Qt-Documentation</primary></indexterm> path: this checks for several standard paths in your system for the documentation and
sets the path automatically. If your Qt-Documentation <indexterm remap="idx"><primary>Qt-Documentation</primary></indexterm> 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.
</para>
</listitem>
<listitem>
<para> If KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> was detected, you are asked to create/update your KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-library documentation.  For that, you need to have the
kde-libraries in source form. For Linux-Users who have installed KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 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 <ulink url="http://www.kde.org">\|\|</ulink> and untar the sources on your system. If you wish to use the documentation package provided by <ulink url="http://developer.kde.org">\|\|</ulink>, cancel the creation and continue with creating the search index <indexterm remap="idx"><primary>search index</primary></indexterm>. 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 <indexterm remap="idx"><primary>search
index</primary></indexterm> setup <indexterm remap="idx"><primary>setup</primary></indexterm> again, which can be found at the same setup <indexterm remap="idx"><primary>setup</primary></indexterm> page of the dialog.

The "Update KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-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 <ulink url="http://www.kde.org">\|\|</ulink> 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.</para>

<para><emphasis remap="bf">NOTE:</emphasis> On a multi-user system <indexterm remap="idx"><primary>multi-user system</primary></indexterm> or systems with disk-quotas <indexterm remap="idx"><primary>disk-quotas</primary></indexterm> for user accounts, the installation of a complete
HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> 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 <indexterm remap="idx"><primary>KDE</primary></indexterm>-directory, under $KDEDIR/share/apps/kdevelop/KDE-Documentation. The correct path can then be set up later in the KDevelop
setup <indexterm remap="idx"><primary>setup</primary></indexterm> dialog, available in the "Options"-menu <indexterm remap="idx"><primary>"Options"-menu</primary></indexterm>.</para>

</listitem>
<listitem>
<para> If the system check found the glimpse <indexterm remap="idx"><primary>glimpse</primary></indexterm> 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 <indexterm remap="idx"><primary>KDE-Documentation</primary></indexterm> and the Qt-Documentation <indexterm remap="idx"><primary>Qt-Documentation</primary></indexterm> (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.
</para>
</listitem>
<listitem>
<para> During the creation of the search index <indexterm remap="idx"><primary>search index</primary></indexterm>, the installation window will show a message that this is in progress.
</para>
</listitem>
<listitem>
<para> 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
<link linkend="General-Configuration">KDevelop Setup</link> dialog that can be accessed through the options menu.</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf">Cancel:</emphasis>  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 <indexterm remap="idx"><primary>configuration dialog</primary></indexterm>s provided in the options-menu.</para>
</sect1>
</chapter>

<chapter id="programs">
<title>Programok</title>

<para>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.</para>

<sect1 id="the-compiler">
<title>A Fordító</title>

<para>The Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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.</para>

<para>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:</para>

<para><screen>#include &lt;iostream.h&gt;

int main(){

cout &lt;&lt; "Hello World" &lt;&lt; endl;

}
</screen>

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

<para><screen>g++ -o myprogram myprogram.cpp
</screen>

Then we can start our program- just type <literal remap="tt">myprogram</literal>  on the console, and the program prints out the string; then exits.</para>
</sect1>

<sect1 id="make">
<title>Make és Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm>s</title>

<para>I have everything I need: an editor, a Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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 <indexterm remap="idx"><primary>Makefile</primary></indexterm>". You could also call it some other name except the name of the program
to build. Then, you should have the tool <literal remap="tt">make</literal> or <literal remap="tt">gmake</literal> installed, or any other tool that is capable of keeping track of
a project's compilation. Insert all your Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> commands in a certain syntax into that Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm> and save it; then you will only
have to type <literal remap="tt">make</literal> or <literal remap="tt">gmake</literal> on the console in the directory where your Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm> is located, and then make takes over,
leading the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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:</para>

<para><literal remap="tt">man make</literal></para>

<para>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 <indexterm remap="idx"><primary>Makefile</primary></indexterm>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 <link linkend="General-Configuration">KDevelop Setup</link> 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.</para>

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

<para><itemizedlist>
<listitem>
<para> Compile File <indexterm remap="idx"><primary>Compile File</primary></indexterm>: is only active if you're working on a source file. It invokes make with the correct command to compile only
the current source.</para>
</listitem>
<listitem>
<para> Make: just calls make and creates your target.</para>
</listitem>
<listitem>
<para> Rebuild all: rebuilds the whole project</para>
</listitem>
<listitem>
<para> Clean/Rebuild all: cleans the project directory first and then runs make again.</para>
</listitem>
<listitem>
<para> 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.</para>
</listitem>
</itemizedlist>
</para>

<para>But this is not the only way how KDevelop works together with make- for KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 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.</para>

<para>Until now, you know about sources, the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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 <literal remap="tt">configure-</literal> script.</para>
</sect1>

<sect1 id="configure">
<title>Beállítás</title>

<para>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 <indexterm remap="idx"><primary>Makefile</primary></indexterm>. 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 <literal remap="tt">make</literal> again. But what if the target machine uses another Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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 <indexterm remap="idx"><primary>KDE</primary></indexterm> can be installed in <literal remap="tt"></literal>opt/kde/ on one machine, while it is installed under <literal remap="tt"></literal>usr/local/kde/ on another. In this
case, you would have to rewrite the Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm> each time to ensure a correct compilation and installation of your product.</para>

<para>Fortunately, GNU-tools have even more to provide than that mighty <literal remap="tt">make</literal>- the commonly used automake <indexterm remap="idx"><primary>automake</primary></indexterm> and autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm>
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.</para>

<para>Automake's purpose is generally to create a so-called <literal remap="tt">Makefile.in <indexterm remap="idx"><primary>Makefile.in</primary></indexterm></literal> from a file <literal remap="tt">Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm></literal> which you have to write for
your project. This Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> consists of macros which can be interpreted and reduce the complexity that make offers, so a
Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> is written safer and quicker than the final Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm>.</para>

<para>Having this said, who is finally creating me my Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm> ? Now, here comes autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm>. Autoconf requires several macro files
for the project. That are those Makefile.in <indexterm remap="idx"><primary>Makefile.in</primary></indexterm>'s generated by automake <indexterm remap="idx"><primary>automake</primary></indexterm> and a file called <literal remap="tt">configure.in</literal>, also containing macros.
Hereby the Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> 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 <indexterm remap="idx"><primary>Compiler</primary></indexterm> command, required libraries against which the final binary will be linked,
include-files the project needs and their location.</para>

<para>For example you want to write a KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 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 <indexterm remap="idx"><primary>KDE</primary></indexterm>-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 <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> and headers etc.</para>

<para><emphasis remap="bf">Summary:</emphasis>  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:</para>

<para><orderedlist><listitem>
<para> write the sources of your project</para>
</listitem>
<listitem>
<para> write a Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> for each subdirectory, including the main project directory of your project</para>
</listitem>
<listitem>
<para> write a configure.in file placed in the main project directory containing the macros for system requirements</para>
</listitem>
<listitem>
<para> run automake <indexterm remap="idx"><primary>automake</primary></indexterm></para>
</listitem>
<listitem>
<para> run autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm></para>
</listitem>
</orderedlist>
</para>

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

<para>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.</para>

<para>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:</para>

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

<para>This is it- you're ready to extend the source of your project, may it be by adding classes <indexterm remap="idx"><primary>classes</primary></indexterm>, 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 <indexterm remap="idx"><primary>Makefile</primary></indexterm>s at
all when using KDevelop.</para>
</sect1>

<sect1 id="debugging">
<title>Nyomkövetés</title>

<para>The following section covers a term that is widely used by developers: Debugging.  It means, that, although your Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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 <indexterm remap="idx"><primary>errors</primary></indexterm> 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 <indexterm remap="idx"><primary>debugging</primary></indexterm>" 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 <literal remap="tt">gdb</literal>, 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.</para>

<para>For this purpose, your project's application is by default created with a Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> option for debugging <indexterm remap="idx"><primary>debugging</primary></indexterm>, 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 <indexterm remap="idx"><primary>KDbg</primary></indexterm>, 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.</para>

<para>KDevelop then opens the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>-window and starts your application with KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm>. The KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm> interface appears inside the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>-window and
allows the usage just like you started it from outside.</para>

<para>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 <literal remap="tt">man</literal> command or by the "System GNU
Info contents" section in KDEHelp.</para>
</sect1>
</chapter>

<chapter id="development-with-kdevelop">
<title>Fejlesztés a KDevelop-pal</title>

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

<sect1 id="micsodk-a-kdevelop-projekt-alkalmazsok">
<title>Micsodák a KDevelop Projekt Alkalmazások ?</title>

<para>A KDeveloppal készített projektek nagyban megkönnyítik a GNU standard fejlesztőeszközök használatát. Ellentétben a Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm>-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 <indexterm remap="idx"><primary>Makefile</primary></indexterm>-ok létrehozására, hanem
biztonságos módszert is biztosítanak a program különböző rendszerekre való átírásához az autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm> által létrehozot <literal remap="tt">configure</literal> scriptekkel.</para>

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

<para>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 <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>-ot használod. 
Itt kiválaszthatod a projekt típusát a programod céljainak megfelelően. Ezután elkezdheted a felhasználói felület fejlesztését előre elkészített 
widgetek <indexterm remap="idx"><primary>widgetek</primary></indexterm> hozzáadásával, melyeket vagy "kézzel" hívsz meg a programodból, vagy pedig a dialógus szerkesztő írja meg a kódot, 
amely lefut a programinduláskor. A következő lépés a felhasználói felület kibővitése, a KDevelop által létrehozott elemek módosításával, 
bővítésével. Ilyenek a menük, eszköztárak, státuszsorok. Mivel az erőforrások egy erőforrásfájlba vannak gyűjtve ezért ezek könnyen 
kiegészíthetők új értékek hozzáadásával a már létezőkhöz; a megadott erőforrások akár irányadóként is használhatók a te egyedi 
erőforrásaidhoz. Miután kiegészítettük azokat a metódusokat, amelyeket a dialógus szerkesztő <indexterm remap="idx"><primary>dialógus szerkesztő</primary></indexterm> készített és üresek, vagy már van bennük 
kód a szokásos felhasználói műveletekre, jöhet a Felhasználói kézikönyv kiegészítése a ez előre elkészített SGML <indexterm remap="idx"><primary>SGML</primary></indexterm> 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.</para>

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

<sect1 id="a-kdevelop-eszkzk-eszkzk-rvid-lersa">
<title>A KDevelop Eszközök <indexterm remap="idx"><primary>Eszközök</primary></indexterm> rövid leírása</title>

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

<sect2 id="programozsi-krnyezet-s-a-dialgus-szerkeszt">
<title>Programozási környezet és a dialógus szerkesztő</title>

<sect3 id="a-programozsi-krnyezet">
<title>A programozási környezet</title>

<para>A programozási környezet a felhasználói felület amelyet a KDevelop biztosít projektek létrehozására és karbantartására, felhasználva sok
más eszközt és leegyszerűsítve azok használatát. A beépített szerkesztője és Súgó böngésző <indexterm remap="idx"><primary>Súgó böngésző</primary></indexterm>je csakúgy mint az Osztályböngésző 
lecsökkentik a munka mennyiségét, amelyek a fejlesztési folyamat alatt a programozót terhelik. Ez a könnyebbség élvezetté teszi a Unix
alkalmazások írását, és valószínűleg rövidebb kibocsátási ciklusokat és jobb haladást fog eredményezni a fejlesztésben. Itt a projekted 
minden részletét kezelheted, áttekintheted az osztályok <indexterm remap="idx"><primary>osztályok</primary></indexterm>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.</para>
</sect3>

<sect3 id="a-dialgus-szerkeszt">
<title>A dialógus szerkesztő</title>

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

<sect2 id="a-kappwizard-kappwizard-s-az-osztlyeszkzk">
<title>A KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> és az Osztályeszközök</title>

<para>A KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> é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 <indexterm remap="idx"><primary>KDE</primary></indexterm> 
programozásában még kezdők is bele tudjanak fogni a GUI <indexterm remap="idx"><primary>GUI</primary></indexterm> alkalmazástervezésbe, és gyorsan érjenek el eredményeket.</para>

<sect3 id="kappwizard-kappwizard">
<title>KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm></title>

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

<para>A KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> 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.</para>

<para>Ha készítő program összes információját megadtuk amit az kér, akkor az alkalmazásban már van:
<itemizedlist>
<listitem>
<para> SDI-felület ( Egy dokumentum/alkalmazásablak ), a "Dokumentum-Nézet-Vezérlő" modellre alapozva </para>
</listitem>
<listitem>
<para>menük és párbeszédablakok fájlok nyitásához és mentéséhez, továbbá nyomtatási <indexterm remap="idx"><primary>nyomtatási</primary></indexterm> párbeszédablakok </para>
</listitem>
<listitem>
<para>egy eszköztár és egy státuszsor </para>
</listitem>
<listitem>
<para>egy súgórendszer SGML <indexterm remap="idx"><primary>SGML</primary></indexterm>-alapú kézikönyvekkel </para>
</listitem>
<listitem>
<para>teljes HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-alapú API <indexterm remap="idx"><primary>API</primary></indexterm> (application programming interface) dokumentáció a projekt jelenlegi állapotához</para>
</listitem>
<listitem>
<para>installáló rutinok ( make )</para>
</listitem>
</itemizedlist>
</para>

<para>A KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> a Projekt menüben, az "Új..." menüpont kiválasztásával érhető el.</para>
</sect3>

<sect3 id="osztlyeszkzk">
<title>Osztályeszközök</title>

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

<sect4 id="j-osztly-ltrehozsa-az-osztlygenertorral">
<title>Új osztály létrehozása az Osztálygenerátorral</title>

<para>A projekt létrehozása (KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>-dal) után a fejlesztő dolga, hogy osztályok <indexterm remap="idx"><primary>osztályok</primary></indexterm>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ő Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> fájlt ezután elkezdhetjük írni az osztály <indexterm remap="idx"><primary>osztály</primary></indexterm> deklarációt <indexterm remap="idx"><primary>deklarációt</primary></indexterm> és az implementációt <indexterm remap="idx"><primary>implementációt</primary></indexterm>. Az egész 
folyamatot leegyszerüsíti az Osztálygenerátor: megadod az osztály nevét, a szülőosztályt, az öröklődés tulajdonságait, valamint
néhány további információt mint például az osztály dokumentációja a projektben betöltött szerepe szerint. Ezenkívül
megváltoztathatsz héhány alapértéket, mint például az osztálynévből létrehozott fájlnevet, vagy azt, hogy az osztályban már benne
legyen -e a Qt-SIGNAL/SLOT támogatás. A munka fennmaradó része automatikusan végbemegy - nem kell törődni a Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>-mel,
és az osztállyal. Az új "make" használata elegendő, hogy az új osztály belekerüljön a fordítási folyamatba. Mivel az Osztályböngésző
frissíti magát egy új osztály hozzáadása után, ezért a deklaráció <indexterm remap="idx"><primary>deklaráció</primary></indexterm> és az implementáció <indexterm remap="idx"><primary>implementáció</primary></indexterm> rögtön rendelkezésre áll, így
máris kezdheted a munkát az osztály kibővítésével. Az Osztály generátor a Projekt menü "Új osztály <indexterm remap="idx"><primary>Új osztály</primary></indexterm>..." menüpontjával érhető
el.</para>
</sect4>

<sect4 id="az-osztlybngsz">
<title>Az Osztályböngésző</title>

<para>Az Osztályböngésző megjeleniti a projektben lévő összes objektumtípust és függvényt egy faszerkezetben, balra a szerkesztőablaktól.
Egy osztály elemző végignézi az összes fájlt metódusokat és osztályok <indexterm remap="idx"><primary>osztályok</primary></indexterm>at keresve, majd grafikusan jeleníti meg őket.
Ezekenfelül a helyi menük különleges funkcionalitást kínálnak arra, hogy úgy dolgozzunk a forrással, hogy az osztályok <indexterm remap="idx"><primary>osztályok</primary></indexterm>ra és a
függvényekre fókuszáljunk. Egy osztály kiválasztása azt eredményezi, hogy a szerkesztőben megnyílik az a fájl, ami az osztály
deklaráció <indexterm remap="idx"><primary>deklaráció</primary></indexterm>ját tartalmazza, metódusok és függvények esetén, pedig az implementáció <indexterm remap="idx"><primary>implementáció</primary></indexterm>s rész lesz látható. Teljes leírást
<link linkend="The-Class-Browser">az Osztályböngésző</link> résznél találsz.</para>
</sect4>
</sect3>
</sect2>
</sect1>

<sect1 id="a-fejleszti-folyamat">
<title>A Fejlesztői folyamat</title>

<para>Egy új alkalmazás fejlesztése a KDeveloppal alapvetően két fő részre osztható: először létre kell hozni a program vázát a
KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>dal, a fejlesztés "többi" részét pedig a KDevelop eszközeivel kell végezni, amelyhez nincs másra szükség mint a te
programozói képességeidre.
A továbbiakban, hogy elmagyarázzuk a fejlesztői folyamatot, feltételezzük, hogy egy Qt/KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 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".</para>

<sect2 id="programvz-ltrehozsa">
<title>Programváz létrehozása</title>

<para>Alkalmazás létrehozásának első lépése a KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> 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 <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>-ekben, amelyek akkor
lesznek használatosak amikor kibővítjük az alkalmazást. A projekt fájl az a fájl amit később betöltve megjelenik a teljes projekt a
fejlesztői környezetben.</para>

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

<sect2 id="alkalmazs-fejlesztse">
<title>Alkalmazás fejlesztése</title>

<para>Ez a szakasz KDevelop-pal és a dialógus szerkesztő <indexterm remap="idx"><primary>dialógus szerkesztő</primary></indexterm>vel való fejlesztési fázisokat ábrázolja - amely mind elvégezhető az IDE-n
belül.</para>

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

<sect3 id="felhasznli-felletek">
<title>Felhasználói felületek</title>

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

<sect3 id="j-elemek-projektbe-integrlsa">
<title>Új elemek projektbe integrálása</title>

<para>Miután létrehoztad a felhasználói felületeket, és a hozzájuk tartozó forrásokat, készen állsz arra, hogy az alkalmazásod használja 
őket objektumokon keresztül. Amint azt feljebb említettük egy szokásos GUI <indexterm remap="idx"><primary>GUI</primary></indexterm>-alapú program vezérlőket és egy központi nézetet 
tartalmaz, ahol esetleg a főnézet is működteti a vezérlőket. Ezek mind az alkalmazás főosztályának részei, és a dokumentum objektum 
az amihez ez csatlakoztatva van. Az objektum orientált tervezés szerint a megadott architektúrát "Dokumentum-Nézet-Vezérlő" 
modellnek lehet nevezni. Ez a modell a programban betöltött szerepük szerint ábrázolja az objektumok alapvető funkcióit. 
A Vezérlő képviseli az alkalmazás koordinálását és biztosítja a felhasználói interakciót a menüvel továbbá az eszköztárral és a 
státuszsorral.
A Dokumentum osztály feladata annak a dokumentumnak a képvislete amelyen a felhasználó éppen dolgozik. Ennélfogva a dokumentum 
osztályának hatáskörébe tartozik például a fájlok betöltése és mentése.
A Nézet az alkalmazás ablakának központjában helyezkedik el, a dokumentumnak azt a részét mutatva, ami a felhasználót érdekli, és 
biztosítja azokat függvényeket amelyekkel a felhasználó az adatot manipulálhatja. Mivel a menük és eszköztárak már rendelkezésre 
állnak, a te feladatod a központi nézet és a többi párbeszédablak létrehozása, melyekkel a felhasználó megváltoztathatja a 
beállításokat, vagy további funkciókat érhet el. A központi nézet létrehozásához a generált forráskód már tartalmaz egy osztályt a 
&&lt;;TeAlkalmazásod&&gt;;View formában amely <literal remap="tt"><indexterm remap="cdx"><primary><literal>QWidget</literal></primary></indexterm>QWidget</literal> ö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 <indexterm remap="idx"><primary>KDE</primary></indexterm>-ben is). Általánosságban három különböző módszerrel lehet a megadott osztályt kibőviteni:
<itemizedlist>
<listitem>
<para>szakítunk a Dokumentum-Nézet struktúrával és valamely előre definiált "nagy" widget <indexterm remap="idx"><primary>widget</primary></indexterm>-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</para>
</listitem>
<listitem>
<para>változtasd meg a Nézet-osztály öröklődését. Változtasd meg a szülőosztályt például QMultiLineEdit-re és az alkalmazásod 
szinte máris egy egyszerű szövegszerkesztő.</para>
</listitem>
<listitem>
<para>Ha a központi nézeted néhány különálló részből áll, hozd létre a widgetek <indexterm remap="idx"><primary>widgetek</primary></indexterm>et és az osztály <indexterm remap="idx"><primary>osztály</primary></indexterm>aikat a dialógus 
szerkesztő <indexterm remap="idx"><primary>dialógus 
szerkesztő</primary></indexterm>vel és a Nézet osztály konstruktorában hozz létre objektumokat ezekből az osztályokból, így a központi nézet ezek 
kombinációjából jön majd ki</para>
</listitem>
</itemizedlist>
</para>

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

<sect3 id="a-teljes-fejlesztsi-folyamat">
<title>A teljes fejlesztési folyamat</title>

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

<sect4 id="forrskd-karbantarts">
<title>Forráskód karbantartás</title>

<para>A KDevelop IDE egy sor metódust biztosít a programozónak, hogy az a céljait a lehető legrövidebb idő alatt érje el. Amint azt 
fentebb tárgyaltuk a KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> és a dialógus szerkesztő <indexterm remap="idx"><primary>dialógus szerkesztő</primary></indexterm> lerövidítik azt az időt amelyre általában szükséged lenne 
ahhoz, hogy ugyanazt az eredményt a forrás kézi gépelésével elérd. Ez azonban nem teljesíti azt a munkát amit egy programozónak 
általában tennie kell: kidolgozni az alkalmazása implementációs részét <indexterm remap="idx"><primary>implementációs részét</primary></indexterm>, 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 <indexterm remap="idx"><primary>GUI</primary></indexterm> alkalmazásokat fejlesztesz ?</para>

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

<sect4 id="alkalmazsok-ptse-s-futtatsa">
<title>Alkalmazások építése és futtatása</title>

<para>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 <indexterm remap="idx"><primary>hibák</primary></indexterm> helyének azonosítása a forráskódban.</para>

<para>Az építési folyamatot a következőképpen kezdheted el:
<itemizedlist>
<listitem>
<para>A "Build" vagy "Rebuild All"-ra kattintás az eszközsoron</para>
</listitem>
<listitem>
<para>A "Build"/"Rebuild All" kiválasztása a Build menüben.</para>
</listitem>
</itemizedlist>
</para>

<para>Az alkalmazásod futtatásához válaszd ki
<itemizedlist>
<listitem>
<para>a "Futtatás" vagy "Nyomkövetés" (elindítja a KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm>-ot a programoddal együtt) gombot az eszköztárról</para>
</listitem>
<listitem>
<para>a megfelelő menüpontokat a "Build" menüből</para>
</listitem>
<listitem>
<para>vagy a "Végrehajtás argumentumokkal" menüpontot, hogy az alkalmazásodat további argumentumokkal indítsd el</para>
</listitem>
</itemizedlist>
</para>

<para>További információt az építési folyamatról a <link linkend="Projects">Projektek</link> résznél találsz.  </para>
</sect4>

<sect4 id="programhibk-keresse">
<title>Programhibák keresése</title>

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

<sect1 id="tovbbi-informcik">
<title>További információk</title>

<para>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:</para>

<para><itemizedlist>
<listitem>
<para><ulink url="../../default/kdevelop/programming/index.html">A KDevelop programozási kézikönyv</ulink>, benne teljes bevezetés
a GUI <indexterm remap="idx"><primary>GUI</primary></indexterm> alkalmazás tervezésbe, valamint a Qt és KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> könyvtárak használatába,</para>
</listitem>
<listitem>
<para>ez a kézikönyv, az <link linkend="Overview">Áttekintés</link>től a <link linkend="Projects">Projektek</link>ig, a KDevelop minden funkcióját áttekinti,</para>
</listitem>
<listitem>
<para>ez a kézikönyv, <link linkend="The-Dialog-Editor">A Dialógus szerkesztő</link> szakaszban részletesen kitér a
dialógus szerkesztő <indexterm remap="idx"><primary>dialógus szerkesztő</primary></indexterm> használatára, bemutatva, hogy hogyan hozd létre a saját widget <indexterm remap="idx"><primary>widget</primary></indexterm>-eidet,</para>
</listitem>
<listitem>
<para>a Qt-könyvtár <indexterm remap="idx"><primary>Qt-könyvtár</primary></indexterm> <emphasis>Online-Referencia <indexterm remap="idx"><primary>Referencia</primary></indexterm> Dokumentáció</emphasis>ja, amely példaprogramokat tartalmaz a Qt GUI <indexterm remap="idx"><primary>GUI</primary></indexterm>-eszközkészlet
használatához, valamint benne van Qt osztályok referenciája, és képek a legfontosabb használatra kész widgetek <indexterm remap="idx"><primary>widgetek</primary></indexterm>ről,</para>
</listitem>
<listitem>
<para>A <emphasis>KDE Könyvtár Osztály-Referencia <indexterm remap="idx"><primary>Referencia</primary></indexterm></emphasis>, amelyet a KDevelop hozott automatikusan létre a KDE könyvtárak forráskódjaiból,
tartalmazza az osztályok <indexterm remap="idx"><primary>osztályok</primary></indexterm> és widgetek <indexterm remap="idx"><primary>widgetek</primary></indexterm> leírását, példaprogramokat használatukra,</para>
</listitem>
<listitem>
<para>valamint az Interneten:
<itemizedlist>
<listitem>
<para><ulink url="http://www.troll.no">\|\|</ulink> információ Qt és egyéb gyártók további widget <indexterm remap="idx"><primary>widget</primary></indexterm>eiről,</para>
</listitem>
<listitem>
<para><ulink url="http://www.kde.org">\|\|</ulink> információ a KDE projektről és a fejlesztői vezérelvekről,</para>
</listitem>
<listitem>
<para><ulink url="http://developer.kde.org">\|\|</ulink> további referenciák a KDE alkalmazásfejlesztéshez</para>
</listitem>
<listitem>
<para>a KDevelop weboldalán <ulink url="http://www.kdevelop.org">\|\|</ulink></para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect1>
</chapter>

<chapter id="overview">
<title>Áttekintés</title>

<para>Looking at KDevelop, the user interface can be described by it's logical separation: the main window, the treeview and the output <indexterm remap="idx"><primary>output</primary></indexterm>
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.</para>

<sect1 id="a-f-ablak">
<title>A Fő ablak</title>

<para>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 <indexterm remap="idx"><primary>SGML</primary></indexterm>'s, then the C/C++ window for sourcecodes. These are
followed by the Documentation window displaying in HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-format. At last is the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm> window for external programs like KIconEdit <indexterm remap="idx"><primary>KIconEdit</primary></indexterm>
and KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm> which are embedded into the IDE. Any Tool that is registered can be accessed via the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>-menu; whereas the registration
of third-party programs can easily be done by a configuration dialog <indexterm remap="idx"><primary>configuration dialog</primary></indexterm> (see <link linkend="General-Configuration">General Configuration</link>). For a description of the Editor windows functionality, see chapter <link linkend="Working-with-the-Editor">Working with the Editor</link>, and for the Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm>, you should look at section <link linkend="Using-the-Documentation-Browser">Using the Documentation Browser</link>.</para>
</sect1>

<sect1 id="az-osztlybngsz-s-a-fjlnzegetk">
<title>Az Osztályböngésző és a fájlnézegetők</title>

<sect2 id="the-class-viewer-class-viewer">
<title>The Class Viewer <indexterm remap="idx"><primary>Class Viewer</primary></indexterm></title>

<para>The Class Viewer <indexterm remap="idx"><primary>Class Viewer</primary></indexterm> (CV <indexterm remap="idx"><primary>CV</primary></indexterm>) shows the classes <indexterm remap="idx"><primary>classes</primary></indexterm> of your project as well as global functions and variable <indexterm remap="idx"><primary>variable</primary></indexterm>s.  Opening the tree will show
all member functions <indexterm remap="idx"><primary>member functions</primary></indexterm> and members with symbols for attributes <indexterm remap="idx"><primary>attributes</primary></indexterm> (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 <indexterm remap="idx"><primary>declaration</primary></indexterm> beginning. Selecting member functions <indexterm remap="idx"><primary>member functions</primary></indexterm> will open the
implementation <indexterm remap="idx"><primary>implementation</primary></indexterm> 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 <indexterm remap="idx"><primary>classviewer</primary></indexterm> also provides popup-menus that offer more specified options,
see <link linkend="The-Class-Browser">The Class Browser</link> for more detailed information.</para>
</sect2>

<sect2 id="the-logical-file-viewer">
<title>The Logical File Viewer</title>

<para>The Logical File Viewer (LFV <indexterm remap="idx"><primary>LFV</primary></indexterm>) 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 <indexterm remap="idx"><primary>LFV</primary></indexterm> for things like selecting pixmaps <indexterm remap="idx"><primary>pixmaps</primary></indexterm>- this will start KIconEdit <indexterm remap="idx"><primary>KIconEdit</primary></indexterm> (if installed on the system) in
the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>-window and opens the chosen picture.</para>
</sect2>

<sect2 id="the-real-file-viewer">
<title>The Real File Viewer</title>

<para>The Real File Viewer (RFV <indexterm remap="idx"><primary>RFV</primary></indexterm>) shows the project directory tree with all files, so you can edit non-project files <indexterm remap="idx"><primary>project files</primary></indexterm> or files hidden by
the LFV <indexterm remap="idx"><primary>LFV</primary></indexterm> like configure.in and Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm>s.
Popup-menus also provide functions like adding or removing files to the current project.</para>
</sect2>

<sect2 id="the-documentation-tree">
<title>The Documentation Tree</title>

<para>The Documentation Tree (DOC <indexterm remap="idx"><primary>DOC</primary></indexterm>) displays all available HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-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 <indexterm remap="idx"><primary>HTML</primary></indexterm>-based
documentation packages.</para>
</sect2>
</sect1>

<sect1 id="a-kimeneti-ablak">
<title>A Kimeneti ablak</title>

<para>The Output window is separated as well into a messages window, a stdin/stdout
window and a stderr window for the following necessities:
<itemizedlist>
<listitem>
<para> messages window:	displays all output <indexterm remap="idx"><primary>output</primary></indexterm> of the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm>. Clicking on error messages will change the edit widget to set the
cursor to the line the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> found an error.</para>
</listitem>
<listitem>
<para> stdout window: display for terminal based applications that send messages to the standard output <indexterm remap="idx"><primary>output</primary></indexterm> of the computer. Note that
Terminal applications are now started in an external console window.</para>
</listitem>
<listitem>
<para> 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.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="menubar-menubar-commands">
<title>Menubar <indexterm remap="idx"><primary>Menubar</primary></indexterm> Commands</title>

<sect2 id="file-management-and-printing">
<title>File Management and Printing</title>

<para>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:
<indexterm><primary>"File"-menu</primary></indexterm>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">New			Ctrl+N</emphasis> Opens the "New File <indexterm remap="idx"><primary>New File</primary></indexterm>" 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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Open			Ctrl+O</emphasis> displays the "Open File..." dialog and lets you choose a file to be opened.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Close		Ctrl+W</emphasis> Closes the file in the top editing window</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Save			Ctrl+S</emphasis>	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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Save As...</emphasis> Opens the "Save File As..." dialog to let you save the current file under a new filename</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Save All</emphasis> Saves all changed files</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Print...	Ctrl+P</emphasis> Opens the "Print File" dialog where you can set various options for printing <indexterm remap="idx"><primary>printing</primary></indexterm> either using enscript <indexterm remap="idx"><primary>enscript</primary></indexterm> or
lpr</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Quit			Ctrl+Q</emphasis> Exits KDevelop. If files are changed, you will be asked if you want to save these files.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="editing-files">
<title>Editing Files</title>

<para><indexterm><primary>"Edit"-menu"</primary></indexterm>
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 <indexterm remap="idx"><primary>editor</primary></indexterm>.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Undo			Ctrl+Z</emphasis> Reverts the last editing operation</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Redo	Ctrl+Y</emphasis> lets you do the last undo step again</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Cut			Ctrl+X</emphasis> cuts out a selection and copies it to the system clipboard.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Copy			Ctrl+C</emphasis> copies a selection to the system clipboard. This also counts for selections made in the documentation
browser.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Paste		Ctrl+V</emphasis> inserts the clipboard contents at the current cursor position.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Indent		Ctrl+I</emphasis> Indent moves a selection to the right</para>
</listitem>
<listitem>
<para><emphasis remap="bf">UnIndent	Ctrl+U</emphasis> UnIndent moves a selection to the left</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Insert File...Ctrl+Insert</emphasis> Lets you select a file and inserts its contents at the current cursor position</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Search...		Ctrl+F</emphasis>Opens the Search dialog that looks for an expression in the current file. For a search across several
files, "Search in files..." should be used.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Repeat Search	F3</emphasis> 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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Replace...		Ctrl+R</emphasis> Opens the "Search and Replace" dialog that allows the search for an expression and replaces the found
text with a new expression.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Search in files...		Ctrl+Alt+F</emphasis>Displays the "Search in files..." dialog, that handles <literal remap="tt">grep <indexterm remap="idx"><primary>grep</primary></indexterm></literal> 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 <indexterm remap="idx"><primary>search result</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Select All  Ctrl+A</emphasis> Selects the whole text of the file currently opened in the top editing window</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Deselect All</emphasis> 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</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Invert Selection</emphasis> Inverts the selection, meaning that a selection becomes deselected and text which is not selected
becomes selected.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="view-configuration">
<title>View Configuration</title>

<para><indexterm><primary>"View"-menu"</primary></indexterm>
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 <indexterm remap="idx"><primary>errors</primary></indexterm> in the code.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Goto Line...	Ctrl+G</emphasis>Opens 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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Next Error		F4</emphasis>Jumps to the next error KDevelop detects from the output <indexterm remap="idx"><primary>output</primary></indexterm>. The output <indexterm remap="idx"><primary>output</primary></indexterm> message of Make or other tools should
give you a descriptive help what the problem is, so you can correct the error.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Previous Error		Shift+F4</emphasis> Jumps to the previous error that was reported.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Dialogeditor   Ctrl+D</emphasis> Switches to the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm> </para>
</listitem>
<listitem>
<para><emphasis remap="bf">Tree-View	Ctrl+T</emphasis> en/disables the Tree window on the left side of the main view containing the Class Browser, LFV <indexterm remap="idx"><primary>LFV</primary></indexterm>,
RFV <indexterm remap="idx"><primary>RFV</primary></indexterm> and DOC <indexterm remap="idx"><primary>DOC</primary></indexterm>-tree.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Output-View	Ctrl+B</emphasis> en/disables the Output window on the bottom of the main view.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm></emphasis> en/disables the toolbar.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Browser-Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm></emphasis> en/disables the browser toolbar, containing the back, forward and search buttons for the browser</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Refresh</emphasis> rescans all files to rebuild the Class Browser. The scanning progress is shown in the statusbar progress display.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="creating-and-maintaining-projects">
<title>Creating and Maintaining Projects</title>

<para><indexterm><primary>"Project"-menu</primary></indexterm>
This section describes functions that are available in the "Project"-menu and are supposed to cover the creation and maintaining
of projects
<itemizedlist>
<listitem>
<para><emphasis remap="bf">New...</emphasis> Starts the KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> and allows you to create a new project by choosing application type, name,
version and other options.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Open</emphasis> Shows the Open Project dialog, where you can choose a KDevelop project file to be opened. After selection, the
project will be loaded.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Open recent project...</emphasis> contains a submenu with the last 5 opened projects. You can open a project more easily using the
recent project menu.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Close</emphasis>Closes the current project. This is mostly done automatically when you quit KDevelop, invoke the
KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> or open another project.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">New Class <indexterm remap="idx"><primary>New Class</primary></indexterm>...</emphasis>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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Add existing File(s)</emphasis> 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 <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>. After the copy process,
your project will be rebuild by automake <indexterm remap="idx"><primary>automake</primary></indexterm> and autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm> to include the new subdirectory into the make-process.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Add new translation file</emphasis> 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 <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>'s</para>
</listitem>
<listitem>
<para><emphasis remap="bf">File Properties Shift+F7</emphasis> Opens the File Properties dialog showing a copy of the LFV <indexterm remap="idx"><primary>LFV</primary></indexterm> and the project file options. Here, the
properties for your files have to be set like installation path and file type.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Make messages and merge</emphasis> 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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Make API <indexterm remap="idx"><primary>API</primary></indexterm>-Doc</emphasis> Calls KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> on your header files and generates a HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> output <indexterm remap="idx"><primary>output</primary></indexterm> with the documentation of your project
classes <indexterm remap="idx"><primary>classes</primary></indexterm>.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Make User-Manual</emphasis> runs KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm> on your manual SGML <indexterm remap="idx"><primary>SGML</primary></indexterm> file, creating a HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> user manual. If KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm> is not installed,
sgml2html will be used to do this.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Make Distribution:</emphasis></para>
<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">tar.gz </emphasis> 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 <literal remap="tt">tar zxvf yourproject.tar.gz </literal> to unpack it to a source directory and
use the standard commands <literal remap="tt">./configure, make </literal>and <literal remap="tt">make install</literal>.</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Options  F7</emphasis> 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 <indexterm remap="idx"><primary>compiler options</primary></indexterm> to set to -02 for a
release with optimization.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="building-projects">
<title>Building Projects</title>

<para><indexterm><primary>"Build"-menu</primary></indexterm>
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 <indexterm remap="idx"><primary>API</primary></indexterm> documentation.</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Compile file... Ctrl+F8</emphasis>Active, if the top editing window is the C++ Window. This only compiles the current implementation <indexterm remap="idx"><primary>implementation</primary></indexterm>
file and lets you save time in case you suspect errors <indexterm remap="idx"><primary>errors</primary></indexterm>.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Make  F8</emphasis> Invokes the make-command <indexterm remap="idx"><primary>make-command</primary></indexterm> to your project and builds the target.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Rebuild All</emphasis> Rebuilds all object files and the target of you project.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Clean Rebuild All</emphasis> Cleans the project directory from all make-created files and rebuilds the target.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Stop Build  F10</emphasis> Stops the current process.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Execute F9</emphasis> Executes your target after building the program with make.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Execute with Arguments Alt+F9</emphasis> 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</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Debug...</emphasis> Opens KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm> in the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>-Window to debug your
application. In this case, KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm> automatically opens the file containing the main() function and executes your application.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Distclean</emphasis> 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 <indexterm remap="idx"><primary>Compiler</primary></indexterm>.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Autoconf and automake <indexterm remap="idx"><primary>automake</primary></indexterm></emphasis> Calls Make on the file Makefile.dist <indexterm remap="idx"><primary>Makefile.dist</primary></indexterm>, located in your main project directory. Makefile.dist <indexterm remap="idx"><primary>Makefile.dist</primary></indexterm> contains
all commands for automake <indexterm remap="idx"><primary>automake</primary></indexterm>, autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm> 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 <indexterm remap="idx"><primary>Makefile</primary></indexterm>s.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Configure</emphasis> Executes the configure-script generated by autoconf <indexterm remap="idx"><primary>autoconf</primary></indexterm>. If this command cannot be executed, run Autoconf and then
Configure again.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="calling-tools-tools">
<title>Calling Tools <indexterm remap="idx"><primary>Tools</primary></indexterm></title>

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

<sect2 id="changing-kdevelops-settings">
<title>Changing KDevelop's settings</title>

<para><indexterm><primary>"Options"-menu</primary></indexterm>
The Options-menu contains all entries for invoking configuration dialog <indexterm remap="idx"><primary>configuration dialog</primary></indexterm>s with which you can change KDevelop's default settings.
Major settings like those for the editor <indexterm remap="idx"><primary>editor</primary></indexterm> or printing <indexterm remap="idx"><primary>printing</primary></indexterm> have their own entries; general settings of KDevelop's behavior can be made
with the <link linkend="KDevelop-Setup">KDevelop Setup</link> dialog.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Editor...</emphasis> Allows the configuration of the editor's behavior like word-breaking, selections etc.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Editor Colors...</emphasis> Here, you can set the color-configuration of the editor <indexterm remap="idx"><primary>editor</primary></indexterm> like e.g. the background.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Editor Defaults...</emphasis> This sets the default display like font and fontsize for the editor <indexterm remap="idx"><primary>editor</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Syntax-Highlighting </emphasis> This dialog lets you configure the fonts and colors for the highlighting of several programming
languages, including HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Documentation Browser</emphasis> In this tab-dialog, you can set the fonts, sizes and colors for the internal Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Configure Printer...</emphasis> Contains the entries for the printer configuration dialog <indexterm remap="idx"><primary>configuration dialog</primary></indexterm>s.

<itemizedlist>
<listitem>
<para><emphasis remap="bf">enscript <indexterm remap="idx"><primary>enscript</primary></indexterm></emphasis> Configures the printer for use with enscript <indexterm remap="idx"><primary>enscript</primary></indexterm>. See Printing for more information.</para>
</listitem>
</itemizedlist>

</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>...</emphasis> Opens the Configure Tools <indexterm remap="idx"><primary>Tools</primary></indexterm> dialog. Here, you can configure the "Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>" menu by adding or removing programs that will
be started in the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>-window.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">KDevelop Setup</emphasis> 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 <indexterm remap="idx"><primary>HTML</primary></indexterm>-library documentation and the rebuilding of the search index <indexterm remap="idx"><primary>search index</primary></indexterm> for the Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm>.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="the-window-menu">
<title>The Window Menu</title>

<para><indexterm><primary>"Window"-menu</primary></indexterm>
The Window menu contains a list with all currently open files. This allows a quick switch to another file you're currently working
on.</para>
</sect2>

<sect2 id="managing-bookmarks">
<title>Managing Bookmarks</title>

<para><indexterm><primary>"Bookmarks"-menu</primary></indexterm>
The Bookmarks menu is intended for adding and removing bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> you want to set in the current editing file. As KDevelop uses two
editing windows, each one configures it's bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> separately.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Set Bookmark</emphasis> Opens a context-menu with up to nine configurable bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm>. This allows setting a bookmark to a certain entry
in the bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> menu by logical reasons.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Add Bookmark  Ctrl+Alt+A</emphasis> Adds the line of the current cursor position to the bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> 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 <indexterm remap="idx"><primary>bookmarks</primary></indexterm> menu.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Clear Bookmarks Ctrl+Alt+C</emphasis> 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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Header-Window</emphasis> Contains the bookmark-list for the Header-Window. Selecting a bookmark will set the cursor to the selected
bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm>' line. Mind that bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> are only assigned to the file they are set to, so if you change to another file, the
bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> are not deleted but choosing a bookmark won't change to the file they are assigned to as well.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">C/C++-Window</emphasis> Contains the bookmark-list for the C/C++-Window. The preferences are the same as for the
Header-Window.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Browser Window</emphasis> Contains the browser bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm>. Selecting a bookmark will open the browser with the selected page.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="online-help-online-help">
<title>Online Help <indexterm remap="idx"><primary>Online Help</primary></indexterm></title>

<para><indexterm><primary>Help-menu</primary></indexterm>
The Help-menu contains entries for navigating in the Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm> 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 <indexterm remap="idx"><primary>DOC</primary></indexterm>-tree in the treeview
automatically opened (if Autoswitch is enabled) when changing to the Documentation Browser window.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Back <indexterm remap="idx"><primary>Back</primary></indexterm>  Alt+ Left Arrow</emphasis> Opens the page opened before the actual one.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Forward <indexterm remap="idx"><primary>Forward</primary></indexterm> Alt+ Right Arrow</emphasis> Opens the next page of the browser-history, available after a "Back"-action.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Search Marked Text <indexterm remap="idx"><primary>Search Marked Text</primary></indexterm>		F2</emphasis> 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 <indexterm remap="idx"><primary>search result</primary></indexterm> on the same page
will be displayed if more than one hit was reported for the search on one page.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Search for Help on... <indexterm remap="idx"><primary>Search for Help on...</primary></indexterm></emphasis>Opens the Search for Help on... dialog that lets you search for a specific expression you want
help on.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">The User Manual to KDevelop <indexterm remap="idx"><primary>The User Manual to KDevelop</primary></indexterm>		F1 <indexterm remap="idx"><primary>F1</primary></indexterm></emphasis> Opens the User's Manual to KDevelop index page (this handbook).
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">The KDevelop Programming Handbook <indexterm remap="idx"><primary>The KDevelop Programming Handbook</primary></indexterm></emphasis>
Opens the <ulink url="programming/index.html">KDevelop Programming Handbook</ulink>
index page. This handbook contains a complete programming guide to KDE development.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">KDE Application Tutorials <indexterm remap="idx"><primary>KDE Application Tutorials</primary></indexterm></emphasis>
Changes to the index page of the <ulink url="tutorial/index.html">KDE Application Tutorials</ulink> handbook.
This handbook explains how to build the Qt tutorial applications and introduces you to KDE programming by developing
an example application.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">The KDE Library Reference Guide <indexterm remap="idx"><primary>The KDE Library Reference Guide</primary></indexterm></emphasis>
Changes to the index page of the <ulink url="kde_libref/index.html">KDE Library Reference Guide</ulink>. This handbook contains
detailed information about using the KDE/Qt libraries separated on topics such as event handling. </para>
</listitem>
<listitem>
<para><emphasis remap="bf">The KDE 2 Developer´s Guide <indexterm remap="idx"><primary>The KDE 2 Developer´s Guide</primary></indexterm></emphasis>
Changes to the index page of the <ulink url="addendum/index.html">KDE 2 Developer´s Guide</ulink>. This Handbook contains
information about the most recent KDE development and how to prepare your application to be KDE 2-ready.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">C/C++ Reference <indexterm remap="idx"><primary>Reference</primary></indexterm></emphasis> 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.

</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Tip of the Day <indexterm remap="idx"><primary>Tip of the Day</primary></indexterm></emphasis> Opens the Tip of the Day dialog to inform you about KDevelop's
features.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">KDevelop Homepage <indexterm remap="idx"><primary>KDevelop Homepage</primary></indexterm></emphasis> Opens the KDevelop Homepage in the browser window if Internet access is provided.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Bug Report <indexterm remap="idx"><primary>Bug Report</primary></indexterm>...</emphasis> Opens the KDevelop Bug Report dialog, where you can send a bug-report directly to the KDevelop Team by
email. See <link linkend="Bug-Reporting">Bug Reporting</link>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Project-API-Doc <indexterm remap="idx"><primary>Project-API-Doc</primary></indexterm></emphasis> Changes to the project's class-documentation index file.<indexterm><primary>KDoc</primary></indexterm><indexterm><primary>API</primary></indexterm>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Project-User-Manual <indexterm remap="idx"><primary>Project-User-Manual</primary></indexterm></emphasis> Opens the User manual's index file of your current project. This can be used to review the
HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-output <indexterm remap="idx"><primary>output</primary></indexterm> generated by KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">About KDevelop...</emphasis> 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.</para>
</listitem>
</itemizedlist>
</para>
</sect2>
</sect1>

<sect1 id="toolbar-toolbar-items">
<title>Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm> Items</title>

<para>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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> 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.</para>

<sect2 id="the-standard-toolbar-toolbar">
<title>The Standard Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm></title>

<para>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:
<indexterm><primary>"File"-menu</primary></indexterm><indexterm><primary>"Edit"-menu</primary></indexterm><indexterm><primary>"Project"-menu"</primary></indexterm><indexterm><primary>"Build"-menu</primary></indexterm><indexterm><primary>debugging</primary></indexterm><indexterm><primary>Tree-View</primary></indexterm><indexterm><primary>Output-View</primary></indexterm><indexterm><primary>execute target</primary></indexterm></para>

<para><itemizedlist>
<listitem>
<para>Open Project - shows the open project dialog</para>
</listitem>
<listitem>
<para>Open File - shows the open file dialog and contains a delayed popup to fast select the current project header and source files.</para>
</listitem>
<listitem>
<para>Save File - saves the currently opened file to disk</para>
</listitem>
<listitem>
<para>Print File - opens the printer dialog</para>
</listitem>
<listitem>
<para>(separator)</para>
</listitem>
<listitem>
<para>Undo - reverts the last action</para>
</listitem>
<listitem>
<para>Redo - executes a reverted action again</para>
</listitem>
<listitem>
<para>Cut - cuts out the current selection</para>
</listitem>
<listitem>
<para>Copy - copies the current selection to the system clipboard</para>
</listitem>
<listitem>
<para>Paste - pastes the current clipboard contents to the actual cursor position</para>
</listitem>
<listitem>
<para>(separator)</para>
</listitem>
<listitem>
<para>Compile File <indexterm remap="idx"><primary>Compile File</primary></indexterm> - compiles the file currently visible in the source file window. In Dialogeditor mode replaced by the Generate Files
button.</para>
</listitem>
<listitem>
<para>Make - invokes make on the project</para>
</listitem>
<listitem>
<para>Rebuild All - rebuilds the project</para>
</listitem>
<listitem>
<para>Debug - opens KDbg <indexterm remap="idx"><primary>KDbg</primary></indexterm> with the application binary for debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> in the Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>- window</para>
</listitem>
<listitem>
<para>Execute - runs the application target binary</para>
</listitem>
<listitem>
<para>Stop - cancels the current process</para>
</listitem>
<listitem>
<para>(separator)</para>
</listitem>
<listitem>
<para>Dialogeditor - switches to Dialogeditor mode. There, the button is replaced by a Sourcecode editor <indexterm remap="idx"><primary>editor</primary></indexterm> button</para>
</listitem>
<listitem>
<para>Tree-View - en-/disables the treeview and works as a toggle button to display the current state</para>
</listitem>
<listitem>
<para>Output-View - en-/disables the output <indexterm remap="idx"><primary>output</primary></indexterm> view and works as a toggle button to display the current state</para>
</listitem>
<listitem>
<para>(separator)</para>
</listitem>
<listitem>
<para>What's this..? help button - changes the cursor to a question arrow and lets you get information about GUI <indexterm remap="idx"><primary>GUI</primary></indexterm> components of KDevelop</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="the-browser-toolbar-toolbar">
<title>The Browser Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm></title>

<para>The browser <indexterm remap="idx"><primary>browser</primary></indexterm> toolbar is another toolbar that provides a lot of useful commands for browsing files and the documentation <indexterm remap="idx"><primary>documentation</primary></indexterm>. The
toolbar contains:
<indexterm><primary>documentation browser</primary></indexterm><indexterm><primary>Help-menu"</primary></indexterm>
<itemizedlist>
<listitem>
<para>the Class combo box - lets you select a class of the current project to browse to</para>
</listitem>
<listitem>
<para>the Method combo box - lets you select a method of the current class and browses to the implementation <indexterm remap="idx"><primary>implementation</primary></indexterm> of the method</para>
</listitem>
<listitem>
<para>the Class-assistant button - on a single click will bring you to the declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> 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.</para>
</listitem>
<listitem>
<para>Back - browses back in the documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm> history; contains a delayed popup to select a certain page of the back history.</para>
</listitem>
<listitem>
<para>Forward - browses forward in the documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm> history; contains a delayed popup to select a certain page of the forward
history.</para>
</listitem>
<listitem>
<para>Stop - stops the browser from loading a documentation file request</para>
</listitem>
<listitem>
<para>Reload - reloads the currently displayed page</para>
</listitem>
<listitem>
<para>Home - opens the KDevelop User Manual index page in the browser</para>
</listitem>
<listitem>
<para>Search Marked Text - searches the documentation index for the selected text; works with the browser and the editor <indexterm remap="idx"><primary>editor</primary></indexterm> windows</para>
</listitem>
<listitem>
<para>Search for Help on... - opens the the Search for Help on.. dialog to let you enter a keyword to search in the documentation</para>
</listitem>
</itemizedlist>
</para>
</sect2>
</sect1>

<sect1 id="billentykombincik">
<title>Billentyűkombinációk</title>

<para>This section handles the predefined as well as the standard values for configurable keyboard commands used in the KDevelop IDE.
You should see section <link linkend="Changing-Keyboard-Shortcuts">Changing Keyboard Shortcuts</link> for a detailed explanation how
to change assigned values to commands.</para>

<sect2 id="shortcuts-for-text-processing">
<title>Shortcuts for Text Processing</title>

<para><indexterm><primary>Keyboard Shortcuts</primary></indexterm><indexterm><primary>Shortcuts</primary></indexterm></para>

<sect3 id="cursor-movements">
<title>Cursor Movements</title>

<para><programlisting>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</programlisting>
</para>
</sect3>

<sect3 id="text-selections">
<title>Text Selections</title>

<para><programlisting>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</programlisting>
</para>
</sect3>

<sect3 id="inserting-and-copying-text-tabulators">
<title>Inserting and Copying Text, Tabulators</title>

<para><programlisting>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</programlisting>
</para>
</sect3>

<sect3 id="deleting-text">
<title>Deleting Text</title>

<para><programlisting>delete letter left of cursor position            Backspace
delete letter right of cursor position           Delete
delete selected text                             Select text, then Backspace or Delete
</programlisting>
</para>
</sect3>

<sect3 id="searching-text-within-the-editor-editor">
<title>Searching Text within the Editor <indexterm remap="idx"><primary>Editor</primary></indexterm></title>

<para><programlisting>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
</programlisting>
</para>
</sect3>

<sect3 id="searching-text-with-the-documentation-browse">
<title>Searching Text with the Documentation Browser</title>

<para><programlisting>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</programlisting>
</para>
</sect3>

<sect3 id="browser-shortcuts">
<title>Browser Shortcuts</title>

<para><programlisting>previous page                                    ALT+ Left Arrow
next page                                        ALT+ Right Arrow</programlisting>
</para>
</sect3>

<sect3 id="managing-bookmarks-0">
<title>Managing Bookmarks</title>

<para><programlisting>add bookmark                                     CTRL+ALT+A
clear bookmark list                              CTRL+ALT+C</programlisting>
</para>
</sect3>
</sect2>

<sect2 id="shortcuts-for-toolbar-toolbar-symbols">
<title>Shortcuts for Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm> Symbols</title>

<para><programlisting>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</programlisting>
</para>
</sect2>

<sect2 id="window-management">
<title>Window Management</title>

<para>To switch to a certain window, press ALT plus the underlined letter in the window title, e.g. Tools <indexterm remap="idx"><primary>Tools</primary></indexterm> would be Alt+T</para>
</sect2>

<sect2 id="shortcuts-to-compilation-processes">
<title>Shortcuts to Compilation Processes</title>

<para><programlisting>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</programlisting>
</para>
</sect2>
</sect1>
</chapter>

<chapter id="the-help-system">
<title>A Súgó Rendszer</title>

<para>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 <indexterm remap="idx"><primary>application framework</primary></indexterm>s generated with the KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> 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 <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm>, which, by intelligent use, will make it very easy to
get the information you need for development.</para>

<sect1 id="az-ez-meg-micsoda-gomb-s-a-quickhelp-quickhe">
<title>Az "Ez meg micsoda ?"-gomb és a Quickhelp <indexterm remap="idx"><primary>Quickhelp</primary></indexterm> gyorssegítség</title>

<para>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.</para>

<para>For user interaction dialogs, Quickhelp <indexterm remap="idx"><primary>Quickhelp</primary></indexterm> 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.</para>
</sect1>

<sect1 id="the-statusbar-statusbar-help">
<title>The Statusbar <indexterm remap="idx"><primary>Statusbar</primary></indexterm> Help</title>

<para>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.</para>

<sect2 id="statusbar-statusbar-entries">
<title>Statusbar <indexterm remap="idx"><primary>Statusbar</primary></indexterm> Entries</title>

<para>The Statusbar <indexterm remap="idx"><primary>Statusbar</primary></indexterm> contains:
<orderedlist><listitem>
<para> a general message field, most left. This is used for help messages and displays the current activity.</para>
</listitem>
<listitem>
<para> 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.</para>
</listitem>
<listitem>
<para> an Insert/Overwrite indicator. It shows the editor <indexterm remap="idx"><primary>editor</primary></indexterm> 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.</para>
</listitem>
<listitem>
<para> a line counter, displaying the current line the cursor is placed.</para>
</listitem>
<listitem>
<para> a column counter, indicating the current column position of the cursor in a line.</para>
</listitem>
</orderedlist>
</para>
</sect2>

<sect2 id="help-messages">
<title>Help Messages</title>

<para>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.</para>

<para>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.</para>

<para>Also, when using the documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm>, 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.</para>

<para>The caption of the KDevelop Project Editor shows you the currently opened filename in the top window. This would be a HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> file
for the documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm> 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.</para>
</sect2>
</sect1>

<sect1 id="configuring-the-html-html-browser">
<title>Configuring the HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> Browser</title>

<para>The browser included in KDevelop is completely HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-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 <indexterm remap="idx"><primary>configuration dialog</primary></indexterm> shows you two tabulators; the first for setting the font preferences, the second for color selection.</para>

<sect2 id="font-preferences">
<title>Font Preferences</title>

<para>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 <indexterm remap="idx"><primary>HTML</primary></indexterm> documents; the fixed font is the
one used for displaying e.g. code within the HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> file.</para>
</sect2>

<sect2 id="color-preferences">
<title>Color Preferences</title>

<para>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.</para>

<para>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.</para>
</sect2>
</sect1>

<sect1 id="using-the-documentation-browser">
<title>Using the Documentation Browser</title>

<para>The documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm> 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 <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> 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.</para>

<sect2 id="requirements">
<title>Requirements</title>

<para>To make use of all features of the Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm>, you should have KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> and glimpse <indexterm remap="idx"><primary>glimpse</primary></indexterm> installed. KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> will generate all kind of online
class-documentation for the KDE-libraries <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> during the setup <indexterm remap="idx"><primary>setup</primary></indexterm> process, but can also invoked by option in the <link linkend="General-Configuration">KDevelop Setup</link>. For the generation of an API <indexterm remap="idx"><primary>API</primary></indexterm> (Application Programming Interface) Documentation for your
project's classes <indexterm remap="idx"><primary>classes</primary></indexterm>, KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> is also used and called by the Project-menu, entry "Make API <indexterm remap="idx"><primary>API</primary></indexterm>-Doc". This will process all current header files
of the project plus the addition of a cross-reference to the Qt and KDE-libraries <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> if those are available in the Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm>. For
the generation of the project handbooks, you should have KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm> (provided with the KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm>) and, as a minimum, SGML <indexterm remap="idx"><primary>SGML</primary></indexterm>-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 <indexterm remap="idx"><primary>RFV</primary></indexterm>. After saving your changes, call "Make User-Manual" from the Project-menu. In case SGML <indexterm remap="idx"><primary>SGML</primary></indexterm>tools detect
formatting errors <indexterm remap="idx"><primary>errors</primary></indexterm>, those will be displayed in the output <indexterm remap="idx"><primary>output</primary></indexterm> window allow you to find the error line directly. The program "glimpse <indexterm remap="idx"><primary>glimpse</primary></indexterm>"
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 <link linkend="General-Configuration">KDevelop Setup</link> dialog. For a description of
the provided search functions see <link linkend="Using-the-Searchindex">Using the Searchindex</link>.</para>
</sect2>

<sect2 id="provided-documentation">
<title>Provided Documentation</title>

<para>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 <ulink url="../../default/kdevelop/programming/index.html">The KDevelop Programming Handbook</ulink> 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 <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> have to offer as well as given a guideline for
ensuring KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-compliance, which covers the same instructions given on the Internet site at <ulink url="http://developer.kde.org">\|\|</ulink>.
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.</para>

<para>The C/C++-Reference <indexterm remap="idx"><primary>Reference</primary></indexterm> used with KDevelop is currently only available on the KDevelop homepage at <ulink url="http://www.kdevelop.org">\|\|</ulink>. 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 <literal remap="tt">tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz</literal>, 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.</para>

<para>The Qt/KDE-libraries <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> documentation folder allows direct access to the HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-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 <link linkend="General-Configuration">KDevelop Setup</link> dialog. Also, all available documentation for the
KDE-libraries <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> are listed in order of the library name, so if you would use classes <indexterm remap="idx"><primary>classes</primary></indexterm> of a certain library it is easy to
determine the library type to be added to the Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> settings in the project. Mind that the whole KDE-Library documentation is
only accessible when generated by KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm>- so this program, included in the KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm>, 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 <link linkend="General-Configuration">KDevelop Setup</link> dialog.</para>

<para>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 <indexterm remap="idx"><primary>API</primary></indexterm> and the Manual for your current
project.</para>
</sect2>

<sect2 id="adding-documentation-to-the-helpbrowser-help">
<title>Adding Documentation to the Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm></title>

<para>To customize your Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm>, open the Tree-View and select the "DOC <indexterm remap="idx"><primary>DOC</primary></indexterm>" 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 <indexterm remap="idx"><primary>HTML</primary></indexterm>-documentation can be selected, so only HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> files are allowed to choose. Selecting OK will add the entry to the Doc-tree
and is available directly.</para>
</sect2>

<sect2 id="using-the-searchindex">
<title>Using the Searchindex</title>

<para>KDevelop includes a set of functions to help you search information within HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> documentation. To use these features, your system
needs to have the program "glimpse <indexterm remap="idx"><primary>glimpse</primary></indexterm>", a free database generator, installed, which creates the search index <indexterm remap="idx"><primary>search index</primary></indexterm> and executes searches
within the documentation. To set up the index, see <link linkend="General-Configuration">KDevelop Setup</link>. The index is also
automatically generated during the installation program.</para>

<para>The search functions are available through several ways which you can choose from:
<orderedlist><listitem>
<para>in the editor <indexterm remap="idx"><primary>editor</primary></indexterm>, 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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</orderedlist>

Direct access to specific documentation is given by selecting the according icon in the "DOC <indexterm remap="idx"><primary>DOC</primary></indexterm>" -tree-view or by the Help-menu
entries.</para>

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

<chapter id="working-with-the-editor">
<title>Munkában a Szerkesztő</title>

<para>An important part of the integrated development environment is the editor <indexterm remap="idx"><primary>editor</primary></indexterm>. You're using it for:
<itemizedlist>
<listitem>
<para>creating, opening and saving source and project files <indexterm remap="idx"><primary>project files</primary></indexterm></para>
</listitem>
<listitem>
<para>editing source and project files <indexterm remap="idx"><primary>project files</primary></indexterm></para>
</listitem>
<listitem>
<para>writing your SGML <indexterm remap="idx"><primary>SGML</primary></indexterm> documentation</para>
</listitem>
<listitem>
<para>printing <indexterm remap="idx"><primary>printing</primary></indexterm> your project files <indexterm remap="idx"><primary>project files</primary></indexterm></para>
</listitem>
</itemizedlist>

Generally, the editor <indexterm remap="idx"><primary>editor</primary></indexterm> 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 <indexterm remap="idx"><primary>printing</primary></indexterm> system, that is far more extended for use
with sourcecodes- and you can choose between the printing <indexterm remap="idx"><primary>printing</primary></indexterm> program you want to use.</para>

<para>This section gives you more information about how to handle your project files <indexterm remap="idx"><primary>project files</primary></indexterm> and to make you more familiar with the editor <indexterm remap="idx"><primary>editor</primary></indexterm>'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.</para>

<sect1 id="managing-project-files">
<title>Managing Project Files</title>

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

<para>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 <indexterm remap="idx"><primary>editor</primary></indexterm> 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.</para>

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

<para>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.</para>

<sect2 id="creating-and-saving-files">
<title>Creating and Saving Files</title>

<para>To create a new file, choose "New" from the File-menu. This opens the "New File <indexterm remap="idx"><primary>New File</primary></indexterm>" 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.</para>

<para>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.</para>

<para>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.</para>

<para>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 <link linkend="KDevelop-Setup">KDevelop Setup</link>, where the setup <indexterm remap="idx"><primary>setup</primary></indexterm> options are described.</para>

<para>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 <indexterm remap="idx"><primary>Compile File</primary></indexterm>" command, which only
saves the currently opened source file visible in the source editor <indexterm remap="idx"><primary>editor</primary></indexterm> window.</para>
</sect2>

<sect2 id="opening-and-closing-files">
<title>Opening and Closing Files</title>

<para>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 <indexterm remap="idx"><primary>LFV</primary></indexterm>, the Logical File Viewer, or the RFV <indexterm remap="idx"><primary>RFV</primary></indexterm>, the Real File Viewer (see <link linkend="Overview">\|\|</link>). The advantage of the file trees is that they provide a quick visual access to your files, especially the LFV <indexterm remap="idx"><primary>LFV</primary></indexterm>,
which only displays your project files <indexterm remap="idx"><primary>project files</primary></indexterm> by their type, collected into folders. You can as well configure the LFV <indexterm remap="idx"><primary>LFV</primary></indexterm> 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.</para>

<para>The standard file groups for a project generated by KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> are the Headers, Sources, GNU and Others. Additionally, after
adding a translation file, KDevelop adds a folder "Translations", containing your *.po files.</para>

<para>To close files, select the file to close from the Window-menu, which loads the opened file into the front editor <indexterm remap="idx"><primary>editor</primary></indexterm>. 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.</para>
</sect2>
</sect1>

<sect1 id="navigating-within-files">
<title>Navigating within Files</title>

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

<para><emphasis remap="bf"> How to find a certain line in a file</emphasis></para>

<para><orderedlist><listitem>
<para>Select "Goto Line" in the "View"-menu or press CTRL+G. The dialogfield "Goto Line" appears.</para>
</listitem>
<listitem>
<para>Insert the linenumber you want to go to.</para>
</listitem>
<listitem>
<para>Press OK.</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf"> How to set a bookmark</emphasis></para>

<para><orderedlist><listitem>
<para>Set the cursor to the line you want to access via a bookmark</para>
</listitem>
<listitem>
<para>Select "Set Bookmark" from the "Bookmarks"-menu.</para>
</listitem>
<listitem>
<para>A popup-menu opens that allows you to select the bookmark number you want to set for the new bookmark.</para>
</listitem>
<listitem>
<para>Select the bookmark number.</para>
</listitem>
</orderedlist>
</para>

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

<para><emphasis remap="bf"> How to delete bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm></emphasis></para>

<para>The bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> are set for each editing window separately- mind that your bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> 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 <indexterm remap="idx"><primary>bookmarks</primary></indexterm> for the
window actually on top, either the Header window, the C++ window or the browser window.</para>

<para><emphasis remap="bf"> How to go to a bookmarked line</emphasis></para>

<para><orderedlist><listitem>
<para>Select the "Bookmarks"-menu and open the popup menu containing the bookmarks <indexterm remap="idx"><primary>bookmarks</primary></indexterm> for the window containing the bookmark you want
to view; either the C++-Window or the Header-Window entry.</para>
</listitem>
<listitem>
<para>Select the bookmarked line.</para>
</listitem>
</orderedlist>
</para>

<para>Selecting a bookmark for the browser window will open the browser and loads the page.</para>
</sect1>

<sect1 id="working-with-keyboard-shortcuts">
<title>Working with Keyboard Shortcuts</title>

<para>For using the editor <indexterm remap="idx"><primary>editor</primary></indexterm>, you should make yourself comfortable with some keyboard shortcuts <indexterm remap="idx"><primary>shortcuts</primary></indexterm> that make it easier to position the cursor
and edit the file. The complete shortcut reference is also listed in section <link linkend="Overview">Overview</link>.</para>

<para><programlisting>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</programlisting>
</para>
</sect1>

<sect1 id="edit-windows-settings">
<title>Edit Windows Settings</title>

<para>The editor <indexterm remap="idx"><primary>editor</primary></indexterm> 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.</para>

<sect2 id="general-settings">
<title>General Settings</title>

<para>The editor <indexterm remap="idx"><primary>editor</primary></indexterm>'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.</para>

<sect3 id="edit-options">
<title>Edit Options</title>

<para><variablelist>
<varlistentry>
<term>Auto Indent:</term>
<listitem>
<para>this sets the editor to place the cursor below the first literal when a new line is entered.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Backspace Indent:</term>
<listitem>
<para>this option sets the cursor below the first literal of the line above when backspace is pressed.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Word Wrap:</term>
<listitem>
<para>words are taken into the next line after the column set in "Wrap Words At:"</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Replace Tabs:</term>
<listitem>
<para>tabulators in the current text are replaced with tabulators of the "Tab Width:" value</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Remove Trailing Spaces:</term>
<listitem>
<para>removes trailing spaces</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Wrap Cursor:</term>
<listitem>
<para>sets the cursor to the end of the last line when backspace enters the beginning of a line</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Auto Brackets:</term>
<listitem>
<para>creates a closing bracket in front of the cursor when a bracket (any kind) is opened.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect3>

<sect3 id="select-options">
<title>Select Options</title>

<para><variablelist>
<varlistentry>
<term>Persistent Selections:</term>
<listitem>
<para>selections made stay marked after setting the cursor to a different place</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Multiple Selections:</term>
<listitem>
<para>allows multiple independent selections within the text</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Vertical Selections:</term>
<listitem>
<para>allows vertical selections of text</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Delete On Input:</term>
<listitem>
<para>deletes a selection when writing in the selection.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Toggle Old:</term>
<listitem>
<para>allows only one selection. A selection made gets deselected when another selection is made.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Wrap Words At:</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect3>
</sect2>

<sect2 id="colors">
<title>Colors</title>

<para>For changing the editor <indexterm remap="idx"><primary>editor</primary></indexterm>'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:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">background:      </emphasis>        the editor's background</para>
</listitem>
<listitem>
<para><emphasis remap="bf">text background:  </emphasis>     	the background of displayed text</para>
</listitem>
<listitem>
<para><emphasis remap="bf">selected:         </emphasis>       the color of selected text</para>
</listitem>
<listitem>
<para><emphasis remap="bf">found:            </emphasis>       the color of text found by a search via the menu "Edit"-"Search", "Repeat search" and "Replace".</para>
</listitem>
<listitem>
<para><emphasis remap="bf">selected + found: </emphasis>       the color of text selected to search for and found</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="syntax-highlighting">
<title>Syntax Highlighting</title>

<para>The syntax-highlighting mode of KDevelop's editor <indexterm remap="idx"><primary>editor</primary></indexterm> 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.</para>

<para>The second configuration dialog <indexterm remap="idx"><primary>configuration dialog</primary></indexterm> 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 <indexterm remap="idx"><primary>editor</primary></indexterm>.</para>
</sect2>
</sect1>

<sect1 id="searching-and-replacing">
<title>Searching and Replacing</title>

<sect2 id="single-file-search">
<title>Single File Search</title>

<para><emphasis remap="bf"> How to find one or more characters in the actual editing window</emphasis>
<orderedlist><listitem>
<para>Select "Search" from the "Edit"-menu. This opens the search dialog.</para>
</listitem>
<listitem>
<para>Specify the expression to search for in the edit field. The drop-down menu offers selecting a previous search expression.</para>
</listitem>
<listitem>
<para>Select additional options like "Whole Words only"</para>
</listitem>
<listitem>
<para>Press OK.</para>
</listitem>
</orderedlist>
</para>

<para>To repeat searching for an expression entered in the search dialog, press F3.</para>
</sect2>

<sect2 id="searching-over-several-files">
<title>Searching over Several Files</title>

<para>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 <literal remap="tt">grep <indexterm remap="idx"><primary>grep</primary></indexterm></literal>-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:</para>

<para><itemizedlist>
<listitem>
<para>The expression to search for (the pattern)</para>
</listitem>
<listitem>
<para>The template used for the search</para>
</listitem>
<listitem>
<para>The mime-type of files to search in</para>
</listitem>
<listitem>
<para>The directory to start form</para>
</listitem>
<listitem>
<para>If the search is recursive over all included subdirectories</para>
</listitem>
</itemizedlist>
</para>

<para>By default, the grep <indexterm remap="idx"><primary>grep</primary></indexterm>-dialog is set to start at your project directory and works recursively over implementation <indexterm remap="idx"><primary>implementation</primary></indexterm> and header files.</para>

<para>You can even extend your search pattern by using the following options:</para>

<para><orderedlist><listitem>
<para><emphasis remap="bf">.</emphasis> Match any character</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&circ;;</emphasis> Match the beginning of a line</para>
</listitem>
<listitem>
<para><emphasis remap="bf">$</emphasis> Match the end of a line</para>
</listitem>
<listitem>
<para><emphasis remap="bf">\&lt; </emphasis> Match the beginning of a word</para>
</listitem>
<listitem>
<para><emphasis remap="bf">\&gt; </emphasis> Match the end of a word</para>
</listitem>
</orderedlist>
</para>

<para>For a repeating search, you can also use the available operators:
<orderedlist><listitem>
<para><emphasis remap="bf">?</emphasis> The preceding item matches less than once</para>
</listitem>
<listitem>
<para><emphasis remap="bf">*</emphasis> The preceding item is matched zero or more times</para>
</listitem>
<listitem>
<para><emphasis remap="bf">+</emphasis> The preceding item is matched once or more times</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;; n &&rcub;;</emphasis> The preceding item is matched exactly <emphasis>n</emphasis> times</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;; n,&&rcub;;</emphasis> The preceding item is matched <emphasis>n</emphasis> or more times</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;;,n &&rcub;;</emphasis> The preceding item matches less than <emphasis>n</emphasis> times</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;;n,m&&rcub;;</emphasis> The preceding item matches at least <emphasis>n</emphasis> times but less than <emphasis>m</emphasis> times</para>
</listitem>
</orderedlist>
</para>

<para>Backreferences to bracketed subexpressions are also available by the notation <emphasis>\n</emphasis>.</para>

<para>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.</para>

<para>KDevelop offers also some more specialized functionality to use grep <indexterm remap="idx"><primary>grep</primary></indexterm> within the editor <indexterm remap="idx"><primary>editor</primary></indexterm>s and the browser. Select the expression you want
to search for in either of the windows and press SHIFT+F2 or select "grep <indexterm remap="idx"><primary>grep</primary></indexterm>:&&lt;;your&&lowbar;;expression&&gt;;" from the right button popup menu.
This will ask grep <indexterm remap="idx"><primary>grep</primary></indexterm> 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.</para>
</sect2>

<sect2 id="searching-within-documentation">
<title>Searching within Documentation</title>

<para>While working on a project, you often need to have information about the parameters of member functions <indexterm remap="idx"><primary>member functions</primary></indexterm> 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 <indexterm remap="idx"><primary>documentation browser</primary></indexterm>. To make use of this search functionality, you should have set up the
documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm> correctly and created the search database. For invoking a search through the documentation, do the
following:</para>

<para><orderedlist><listitem>
<para>place your cursor at the word you want to search or mark an expression</para>
</listitem>
<listitem>
<para>select "Search Marked Text" from the Help-menu <indexterm remap="idx"><primary>Help-menu</primary></indexterm> or press the right mouse button to open the context menu; then select
"Look Up: "expression".</para>
</listitem>
<listitem>
<para>after the search result <indexterm remap="idx"><primary>search result</primary></indexterm> page is displayed in the documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm>, select the page that you think could contain the
information you need.</para>
</listitem>
<listitem>
<para>the selected documentation page is displayed and your search result <indexterm remap="idx"><primary>search result</primary></indexterm> is marked. To display the next result within the same
documentation page, press F3.</para>
</listitem>
</orderedlist>
</para>

<para>This allows you to easily find the information you need. For using the results, the documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm> 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.</para>

<para>For a full description on how to use the Documentation, see <link linkend="Using-the-Searchindex">Using the Searchindex</link>.</para>
</sect2>

<sect2 id="replacing-text">
<title>Replacing Text</title>

<para>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".</para>
</sect2>
</sect1>

<sect1 id="printing">
<title>Printing</title>

<para>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 <emphasis>enscript</emphasis>, 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.</para>

<sect2 id="configuring-the-printer">
<title>Configuring the Printer</title>

<para>The printing <indexterm remap="idx"><primary>printing</primary></indexterm> program can be configured by selecting "Print" from the "File"-menu <indexterm remap="idx"><primary>"File"-menu</primary></indexterm>; on the printing <indexterm remap="idx"><primary>printing</primary></indexterm> 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 <indexterm remap="idx"><primary>enscript</primary></indexterm>".</para>

<sect3 id="the-enscript-enscript-configuration-options">
<title>The enscript <indexterm remap="idx"><primary>enscript</primary></indexterm> Configuration Options</title>

<sect4 id="header">
<title>Header</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Fancy Header:</emphasis> adds a fancy header</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Header Text:</emphasis> enables adding a header text
<itemizedlist>
<listitem>
<para><emphasis remap="bf">text:</emphasis> sets the text's contents</para>
</listitem>
<listitem>
<para><emphasis remap="bf">position:</emphasis> sets the text's position to left, center or right</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Login:</emphasis> add the UserID to the header
<itemizedlist>
<listitem>
<para><emphasis remap="bf">login:</emphasis> enables adding UserID</para>
</listitem>
<listitem>
<para><emphasis remap="bf">position:</emphasis> sets the position for the UserID</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Filename:</emphasis> add the filename to the header
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Size of filename:</emphasis> add filename as full or short, meaning full path or filename only</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> sets the position for the filename</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Hostname:</emphasis> add the hostname to the header
<itemizedlist>
<listitem>
<para><emphasis remap="bf">hostname:</emphasis> enables adding hostname</para>
</listitem>
<listitem>
<para><emphasis remap="bf">size of hostname:</emphasis> sets the size for hostname</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> sets the position for hostname</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect4>

<sect4 id="date-time">
<title>Date & Time</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Current Date:</emphasis> include the current date
<itemizedlist>
<listitem>
<para><emphasis remap="bf">current date:</emphasis> enables current date adding</para>
</listitem>
<listitem>
<para><emphasis remap="bf">position:</emphasis> sets the position for the date entry</para>
</listitem>
<listitem>
<para><emphasis remap="bf">format:</emphasis> sets the date format</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Modification Date:</emphasis> include the last modification date
<itemizedlist>
<listitem>
<para><emphasis remap="bf">modification date:</emphasis> enables modification date adding</para>
</listitem>
<listitem>
<para><emphasis remap="bf">position:</emphasis> sets the position for modification date entry</para>
</listitem>
<listitem>
<para><emphasis remap="bf">format:</emphasis> sets the date format</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Current Time:</emphasis> include current time
<itemizedlist>
<listitem>
<para><emphasis remap="bf">current time:</emphasis> enables current time adding</para>
</listitem>
<listitem>
<para><emphasis remap="bf">AM</emphasis>PM:/ use AM/PM or 24h format</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> sets the position for the time entry</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Format:</emphasis> sets the time format</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Modification Time:</emphasis> include the last modification time
<itemizedlist>
<listitem>
<para><emphasis remap="bf">modification time:</emphasis> enables adding modification time</para>
</listitem>
<listitem>
<para><emphasis remap="bf">AM</emphasis>PM:/ use AM/PM or 24h format</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> sets the position for the time entry</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Format:</emphasis> sets the time format</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect4>

<sect4 id="layout">
<title>Layout</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Numbering & Border:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">numbering lines:</emphasis> adds line numbers to the document for printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">borders:</emphasis> adds a border to the pages for printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">numbering pages:</emphasis> numbers pages for printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">align files:</emphasis> appends files for page numbering</para>
</listitem>
<listitem>
<para><emphasis remap="bf">lines per page:</emphasis> the maximum value for lines per page</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Format and TAB:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">set TAB size:</emphasis> sets the TAB size for interpreting TABs</para>
</listitem>
<listitem>
<para><emphasis remap="bf">font for header:</emphasis> sets the font used for the header text</para>
</listitem>
<listitem>
<para><emphasis remap="bf">font for body:</emphasis> sets the font for the body text (file contents)</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Textprinting <indexterm remap="idx"><primary>printing</primary></indexterm>:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">cut lines:</emphasis> cuts the lines if too large. If unchecked, lines are broken</para>
</listitem>
<listitem>
<para><emphasis remap="bf">replace non-printing <indexterm remap="idx"><primary>printing</primary></indexterm> character by space:</emphasis> replaces characters that the printing <indexterm remap="idx"><primary>printing</primary></indexterm> charset doesn't support by space characters</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Other Options:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">table of contents:</emphasis> adds a table of contents page that contains information about printed files, page numbers etc.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Highlight bars:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">highlight bars:</emphasis> highlights rows for printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">cycle fo change:</emphasis> sets the number of rows to change highlight style</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Wrapped line:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">mark wrapped lines:</emphasis> lines that are broken get marked for printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">value for wrapped line:</emphasis> the preset value for the new line the line is broken into.</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect4>

<sect4 id="underlay">
<title>Underlay</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Text:</emphasis> sets the text to underlay</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> sets the position of underlay text</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Font:</emphasis> sets the font used for the underlay</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Angle:</emphasis> sets the angle for the underlay text</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Gray scaling:</emphasis> sets the grayscaling for the underlay text</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Style:</emphasis> sets the underlay text to be printed as outlined or filled</para>
</listitem>
</itemizedlist>
</para>
</sect4>
</sect3>
</sect2>

<sect2 id="the-printing-dialog">
<title>The Printing Dialog</title>

<sect3 id="direct-printing-options">
<title>Direct Printing Options</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Program:</emphasis> sets the printing <indexterm remap="idx"><primary>printing</primary></indexterm> program to be used for printing <indexterm remap="idx"><primary>printing</primary></indexterm>: enscript <indexterm remap="idx"><primary>enscript</primary></indexterm> or lpr</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Printer:</emphasis> sets the printer to be used for printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Output location:</emphasis> for printing <indexterm remap="idx"><primary>printing</primary></indexterm> into a file, select the output <indexterm remap="idx"><primary>output</primary></indexterm> location</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Orientation:</emphasis> sets the orientation for printing <indexterm remap="idx"><primary>printing</primary></indexterm>, either landscape or portrait</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Copy:</emphasis> sets the amount of copies to be made per page</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Paper Size:</emphasis> sets the paper size to be used</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Output Format:</emphasis> for using enscript <indexterm remap="idx"><primary>enscript</primary></indexterm> as printing <indexterm remap="idx"><primary>printing</primary></indexterm> program, you can choose between postscript or html printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Default Printsettings:</emphasis> sets the default settings to use for printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Outprinting <indexterm remap="idx"><primary>printing</primary></indexterm>:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Page Printing:</emphasis> sets one or two pages on one sheet</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Pages:</emphasis> select all,odd or even for using enscript <indexterm remap="idx"><primary>enscript</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Pretty Print:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">pretty-print:</emphasis> enables pretty-print mode for enscript <indexterm remap="idx"><primary>enscript</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">color:</emphasis> use color printing <indexterm remap="idx"><primary>printing</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">Pretty Print Mode:</emphasis> sets the printing <indexterm remap="idx"><primary>printing</primary></indexterm> mode dependent on your file format</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect3>

<sect3 id="file-selection">
<title>File Selection</title>

<para>The file selection dialog is accessed by the "Files" button on the printing <indexterm remap="idx"><primary>printing</primary></indexterm> dialog. The file selection allows specifying which files to
print out by certain criteria:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">File Selection:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">current:</emphasis> the currently opened file visible in the editing window</para>
</listitem>
<listitem>
<para><emphasis remap="bf">all in project:</emphasis> all files included in the project currently opened</para>
</listitem>
<listitem>
<para><emphasis remap="bf">self chosen files:</emphasis> allows choosing the files to be printed by file-selection</para>
</listitem>
<listitem>
<para><emphasis remap="bf">all cpp files:</emphasis> prints out all source files of the project</para>
</listitem>
<listitem>
<para><emphasis remap="bf">all headers:</emphasis> prints out all header files of the project</para>
</listitem>
<listitem>
<para><emphasis remap="bf">changed files:</emphasis> allows specifying files that are changed in a timespan:</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Changed Files:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Between:</emphasis> specifies all files changed after:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Date:</emphasis> the date the files were changed</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Time:</emphasis> the time the files were changed</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">And:</emphasis> specifies all files changed before:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Date:</emphasis> the date the files were changed</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Time:</emphasis> the time the files were changed</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Self Chosen Files:</emphasis> available if self chosen files is selected (see above)
<itemizedlist>
<listitem>
<para><emphasis remap="bf">add:</emphasis> press this to add a file selected for printing <indexterm remap="idx"><primary>printing</primary></indexterm> in the lineedit field left</para>
</listitem>
<listitem>
<para><emphasis remap="bf">delete:</emphasis> deletes a selected file from the printing <indexterm remap="idx"><primary>printing</primary></indexterm> list</para>
</listitem>
<listitem>
<para><emphasis remap="bf">clear:</emphasis> clears the printing <indexterm remap="idx"><primary>printing</primary></indexterm> list</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect3>

<sect3 id="print-preview">
<title>Print Preview</title>

<para>Print Preview is available for you to control how the output <indexterm remap="idx"><primary>output</primary></indexterm> will look like. Therefore, KDevelop uses the program <emphasis>ghostview</emphasis> or
<emphasis>kghostview</emphasis>. When the preview-button was pressed on either printing <indexterm remap="idx"><primary>printing</primary></indexterm> dialog, you will be presented a template output <indexterm remap="idx"><primary>output</primary></indexterm> that shows you
the effect of the currently set options.</para>
</sect3>
</sect2>
</sect1>
</chapter>

<chapter id="projects">
<title>Projektek</title>

<sect1 id="projecttypes">
<title>Projecttypes</title>

<sect2 id="programs-0">
<title>Programs</title>

<para>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 <indexterm remap="idx"><primary>compiler options</primary></indexterm> (CXXFLAGS). Setting
file properties allows you to keep track of where the files should go.</para>

<para>With KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>, you can create a new application project according to your choice of application type. For now, KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>
generates four kinds of frame applications, as:</para>

<para><itemizedlist>
<listitem>
<para>a single document interface (SDI) KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-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 <indexterm remap="idx"><primary>KDE</primary></indexterm> 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 <indexterm remap="idx"><primary>classes</primary></indexterm> leaning on the MVC-concept (Model-View-Controller). Technically, the base
classes <indexterm remap="idx"><primary>classes</primary></indexterm> may not be viewed that way, but it's construction is at least created most logical to create applications with a GUI <indexterm remap="idx"><primary>GUI</primary></indexterm>.
</para>
</listitem>
<listitem>
<para>a KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-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.
</para>
</listitem>
<listitem>
<para>a Qt-only based program framework. For those programmers who want to use the Qt-library <indexterm remap="idx"><primary>Qt-library</primary></indexterm> as the GUI <indexterm remap="idx"><primary>GUI</primary></indexterm> 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.
</para>
</listitem>
<listitem>
<para>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 <indexterm remap="idx"><primary>classes</primary></indexterm> the same way with KDevelop as for KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> applications.</para>
</listitem>
<listitem>
<para>a C program framework for C programmers. This is as well a terminal based application but only uses the C compiler.</para>
</listitem>
</itemizedlist>
</para>

<para>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.</para>

<para>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.</para>

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

<sect2 id="libraries">
<title>Libraries</title>

<para>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:</para>

<para><itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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 <ulink url="../../default/kdevelop/programming/index-19.html">KDevelop Programming Handbook</ulink> 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 <link linkend="Project-Hacking">Project Hacking</link>.</para>
</listitem>
<listitem>
<para>for installing a shared library, you have to watch the KDE-File-system Standard as explained in <ulink url="../../default/kdevelop/programming/index-13.html">The KDevelop Programming Handbook</ulink></para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="multiple-targets">
<title>Multiple Targets</title>

<para>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 <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>'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).</para>

<para>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 <indexterm remap="idx"><primary>project files</primary></indexterm> to the directory containing all sources later. Then you could load each
target independently by its project file; this also allows executing and debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> the target.</para>

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

<para><itemizedlist>
<listitem>
<para>add your target to the bin&&lowbar;;PROGRAMS if it is an executable</para>
</listitem>
<listitem>
<para>add your library declaration line if it is a shared library</para>
</listitem>
<listitem>
<para>add the same declarations like the original project binary is build:
<itemizedlist>
<listitem>
<para>newtarget&&lowbar;;METASOURCES</para>
</listitem>
<listitem>
<para>newtarget&&lowbar;;LD&&lowbar;;FLAGS</para>
</listitem>
<listitem>
<para>DISTCLEANFILES</para>
</listitem>
<listitem>
<para>copy the messages: entry for the original binary and replace target&&lowbar;;SOURCES with newtarget&&lowbar;;SOURCES, target.pot with
newtarget.pot</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para>add your sources like the KDevelop write area contains outside the write area for your binary or library</para>
</listitem>
<listitem>
<para>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</para>
</listitem>
</itemizedlist>
</para>
</sect2>
</sect1>

<sect1 id="new-project-new-projects">
<title>New Project <indexterm remap="idx"><primary>New Project</primary></indexterm>s</title>

<para>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.</para>

<para>For KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> applications there are six different frameworks:
<itemizedlist>
<listitem>
<para>Mini: Creates a KDE-application with an empty main widget.</para>
</listitem>
<listitem>
<para>Normal: Creates a KDE-application with session-management, menubar, toolbar, statusbar and support for a document-view codeframe model.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>KDE 2 Normal: Creates a KDE-2 application with session-management, menubar, toolbar, statusbar and support for a document-view codeframe 
model.</para>
</listitem>
<listitem>
<para>KDE 2 Mini: Creates a KDE-2 application with an empty main widget.</para>
</listitem>
<listitem>
<para>KDE 2 MDI: Creates a KDE-2 MDI (Multiple Document Interface) application with menubar, toolbar, statusbar and support for a document-view 
codeframe model.</para>
</listitem>
</itemizedlist>
</para>

<para>If you wish no dependencies towards the KDE-libraries <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm> for end-users, you can choose from four Qt-only types:
<itemizedlist>
<listitem>
<para>Normal: Creates a Qt-Application with a main window containing a menubar, toolbar and statusbar, including support for a generic 
document-view model.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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).</para>
</listitem>
</itemizedlist>
</para>

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

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

<para>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.</para>
</sect1>

<sect1 id="opening-and-closing-of-projects">
<title>Opening and Closing of Projects</title>

<para>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 <link linkend="KDevelop-Setup">KDevelop Setup</link> dialog.</para>

<para>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.</para>

<para>Then you get an "Open Project" dialog, where you can change to the directory containing the project file to be loaded. KDevelop
project files <indexterm remap="idx"><primary>project files</primary></indexterm> have the <emphasis>*.kdevprj</emphasis> 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.</para>

<para>Another comfortable way to open a project is to select the project file in the KFM, the KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> File Manager. This will start
KDevelop with loading the selected project file. You could as well open a project by commandline, entering <literal remap="tt">kdevelop
projectname.kdevprj</literal>.</para>

<para>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.</para>
</sect1>

<sect1 id="editing-a-project">
<title>Editing a Project</title>

<para>After you created a new project with the KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>, the usual task is to extend the project by editing the already created
sources and adding classes <indexterm remap="idx"><primary>classes</primary></indexterm>, pixmaps <indexterm remap="idx"><primary>pixmaps</primary></indexterm>, 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 <indexterm remap="idx"><primary>classes</primary></indexterm> 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 <link linkend="Setting-Project-File-Options">Setting Project File Options</link> describes how to set File Properties especially for additional files that you want make to install, like documentation or
pixmaps <indexterm remap="idx"><primary>pixmaps</primary></indexterm>.
Another part in project maintaining is adding translations for applications that support internationalization, which is described
in <link linkend="Adding-Translations">Adding Translations</link>.</para>

<para><link linkend="Extending-the-Project-Documentation">Extending the Project Documentation</link> 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.</para>

<para>Finally, <link linkend="Project-Hacking">Project Hacking</link> describes how you can eventually work around the KDevelop project
management in special cases.</para>

<sect2 id="adding-files-and-classes">
<title>Adding and Removing Files and Classes</title>

<para>Adding a new file is often used when you think that you should separate your class implementation <indexterm remap="idx"><primary>implementation</primary></indexterm> file into several ones. Then you
need to create an new file which will contain the part of the class implementation <indexterm remap="idx"><primary>implementation</primary></indexterm> you want to move. You can do this by choosing
"New" from the "File"-menu <indexterm remap="idx"><primary>"File"-menu</primary></indexterm>, opening the "New File <indexterm remap="idx"><primary>New File</primary></indexterm>" 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.</para>

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

<para>In case you have an existing project and you want to add certain classes <indexterm remap="idx"><primary>classes</primary></indexterm> that you want to re-use in your project, select "Add
File(s) to Project..." from the "Project"-menu <indexterm remap="idx"><primary>"Project"-menu</primary></indexterm>. 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 <indexterm remap="idx"><primary>pixmaps</primary></indexterm> 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 <link linkend="Setting-Project-File-Options">Setting Project File Options</link></para>

<para>To add a file to the project that is already in the project directory, go to the RFV <indexterm remap="idx"><primary>RFV</primary></indexterm>, 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".</para>

<para>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 <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>. 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 <indexterm remap="idx"><primary>LFV</primary></indexterm> or the RFV <indexterm remap="idx"><primary>RFV</primary></indexterm>, press the right mouse button
and select "remove". To delete a file, select "delete physically".</para>
</sect2>

<sect2 id="setting-project-file-options">
<title>Setting Project File Options</title>

<para>The file properties dialog can be accessed via the project menu or within the LFV <indexterm remap="idx"><primary>LFV</primary></indexterm> by a right mouseclick.  It shows the project
files in groups as they are sorted in the LFV <indexterm remap="idx"><primary>LFV</primary></indexterm> 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 <indexterm remap="idx"><primary>pixmaps</primary></indexterm> 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 <indexterm remap="idx"><primary>KDE</primary></indexterm> location macros you should
look in your Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> where the location macros are specified.</para>
</sect2>

<sect2 id="adding-translations">
<title>Adding Translations</title>

<para>As KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 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. <literal remap="tt">de</literal> for German, to the
<literal remap="tt">docs</literal> 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 <indexterm remap="idx"><primary>SGML</primary></indexterm> 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.</para>

<para>First, you have to enclose all visible strings of your application that appear in bars or dialogs with the <literal remap="tt">i18n <indexterm remap="idx"><primary>i18n</primary></indexterm>()</literal> macro.
This macro is a replacement for the function <literal remap="tt">klocale-&gt;translate()</literal> of the KLocale class and much easier to use. As this macro
is declared in the <literal remap="tt">kapp.h</literal> include file, you have to add <literal remap="tt">&&num;;include &&lt;;kapp.h&&gt;;</literal> to the source file or the class
declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> file of the class that makes use of the macro. Also it should be mentioned, that although <literal remap="tt">i18n <indexterm remap="idx"><primary>i18n</primary></indexterm>()</literal> 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 (&&lt;;YourApp&&gt;;.pot in the /po
subdirectory). This task is done by the program xgettext, and to do this, you would enter <literal remap="tt">make messages <indexterm remap="idx"><primary>messages</primary></indexterm></literal> in your project
directory containing the sources. As xgettext depends on the <literal remap="tt">i18n <indexterm remap="idx"><primary>i18n</primary></indexterm>()</literal> macro, the original function won't do the job.</para>

<para>For translations themselves, you first have to create the message file containing all strings that are used in your sources with
the <literal remap="tt">i18n <indexterm remap="idx"><primary>i18n</primary></indexterm>()</literal> macro. This can be done by choosing "Make messages <indexterm remap="idx"><primary>messages</primary></indexterm> 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 <literal remap="tt">msgid</literal> line
containing the string to translate, followed by <literal remap="tt">msgstr</literal>. The msgstr line is mostly empty except for the translations already
provided by the KDE-libraries <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm>. Those have to be filled with the according translations of your language.</para>

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

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

<para>For all translation files, <literal remap="tt">make <indexterm remap="idx"><primary>make</primary></indexterm></literal> uses the program <literal remap="tt">msgfmt</literal> 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.</para>

<para>For more information about internationalization support, see <ulink url="http://www.kde.org">\|\|</ulink>; 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 <link linkend="The-Dialog-Editor">The Dialog Editor</link> and <ulink url="../../default/kdevelop/programming/index-11.html">The KDevelop Programming Handbook</ulink> where questions about internationalization are covered again.</para>
</sect2>

<sect2 id="extending-the-project-documentation">
<title>Extending the Project Documentation</title>

<para>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 <indexterm remap="idx"><primary>SGML</primary></indexterm>-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 <indexterm remap="idx"><primary>SGML</primary></indexterm> file, placed
in docs/en as index.sgml. The reference documentation included with your sgml-tools package can be added to the Helpbrowser <indexterm remap="idx"><primary>Helpbrowser</primary></indexterm> and
allow you direct access to special tags as well as a short description of how to extend the documentation. SGML <indexterm remap="idx"><primary>SGML</primary></indexterm> has a lot of
advantages, whereas KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> makes wide use by this documentation type with the additional KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm> tool. This creates the typical
KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-style documentation and makes it look nicer. Anyway, the sgmltools alone are enough to produce a html output <indexterm remap="idx"><primary>output</primary></indexterm> that is already
included in your application. To create the documents using KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm>, install the tool and run "Make User-Manual" from the
Build-menu. The Documentation Browser allows a direct controlling of the output <indexterm remap="idx"><primary>output</primary></indexterm> by selecting "Project User-Manual" from the
Help-menu or the according icon in the DOC <indexterm remap="idx"><primary>DOC</primary></indexterm>-tree. Then you can browse the documentation online in KDevelop and have a better
overview by the output <indexterm remap="idx"><primary>output</primary></indexterm> over errors <indexterm remap="idx"><primary>errors</primary></indexterm> that result in missing tags.</para>

<para>Now, while extending the documentation, you can't avoid that additional files are produced that have to be included into the
project as each <literal remap="tt">sect</literal>-tag creates a new HTML <indexterm remap="idx"><primary>HTML</primary></indexterm> file. The output <indexterm remap="idx"><primary>output</primary></indexterm> generated by the KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> 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 <indexterm remap="idx"><primary>RFV</primary></indexterm>
and browse to your documentation directory. Press the right mouse button over the files to add and select "Add". Further,
KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm> adds the KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> logo to the documentation directory. This file, <literal remap="tt">logotp3.gif</literal>, 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 <literal remap="tt">index.html</literal>. You
see that <literal remap="tt">Install</literal> 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
<literal remap="tt">Install</literal>, 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 <ulink url="../../default/kdevelop/programming/index-14.html">The KDevelop Programming Handbook</ulink>.</para>
</sect2>

<sect2 id="project-hacking">
<title>Project Hacking</title>

<para>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 <indexterm remap="idx"><primary>Makefile</primary></indexterm>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 <indexterm remap="idx"><primary>Linker</primary></indexterm> or need additional project configuration, you should work yourself into
the Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> macros and add all changes in the Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>'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.</para>
</sect2>
</sect1>

<sect1 id="compiler-and-linker-linker-flags-for-project">
<title>Compiler and Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> Flags for Projects</title>

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

<sect1 id="external-projects">
<title>External Projects</title>

<para>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 <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>'s are updated.   Please change all Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm> 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.</para>
</sect1>
</chapter>

<chapter id="build-settings">
<title>Build beállítások</title>

<para>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 <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>'s and the configure <indexterm remap="idx"><primary>configure</primary></indexterm>.in script (e.g. version number change or compiler warnings <indexterm remap="idx"><primary>compiler warnings</primary></indexterm> ) and thereby set the
compilation preferences as well.. After changing the project options, you should invoke "make <indexterm remap="idx"><primary>make</primary></indexterm> clean" or "rebuild all" to compile
your project with the new options. Please mind that debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> is only available if the project options are set to create debugging <indexterm remap="idx"><primary>debugging</primary></indexterm>
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 <indexterm remap="idx"><primary>Linker</primary></indexterm> flags, your program will not link correctly if those are not updated, so keep track of your library linking.</para>

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

<para><itemizedlist>
<listitem>
<para>disable debugging <indexterm remap="idx"><primary>debugging</primary></indexterm></para>
</listitem>
<listitem>
<para>enable optimization and set optimization level to <emphasis remap="bf">-02</emphasis></para>
</listitem>
<listitem>
<para>set the compiler warnings <indexterm remap="idx"><primary>compiler warnings</primary></indexterm> to <emphasis remap="bf">-Wall</emphasis></para>
</listitem>
<listitem>
<para>for each new release, increase the version number and update the project.lsm file for version and requirements.</para>
</listitem>
</itemizedlist>
</para>

<sect1 id="general-options">
<title>General Options</title>

<para>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 <indexterm remap="idx"><primary>HTML</primary></indexterm> 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.</para>
</sect1>

<sect1 id="compiler-options">
<title>Compiler Options</title>

<para>The compiler options <indexterm remap="idx"><primary>compiler options</primary></indexterm> page sets the compiler flags towards your target, debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> and additional.</para>

<sect2 id="target">
<title>Target</title>

<para>The target box contains two options that can be set:</para>

<para>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 <indexterm remap="idx"><primary>configure</primary></indexterm>d your Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> as a cross-compiler for an Intel 386-compatible machine running System V. This
option sets the -b flag to the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm>. Usually you would leave this to the default.</para>

<para>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.</para>

<para>For a release version of your application, enable optimization and set the level to 2.</para>
</sect2>

<sect2 id="debugging-0">
<title>Debugging</title>

<para>Right of the Target box, you can see the debugging <indexterm remap="idx"><primary>debugging</primary></indexterm>-section. This means that you can set your Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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.</para>

<para>Enable debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> therefore sets the -g flag; the debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> 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 <indexterm remap="idx"><primary>debugging</primary></indexterm> option and that
the binary size will increase by the debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> level.</para>

<para>Generate extra information for gprof: sets the -pg flag, resulting that the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> will include information for the gprof
program that displays caller graphs of your program's function.</para>

<para>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 <indexterm remap="idx"><primary>output</primary></indexterm> files: an *.o file which is
the final output <indexterm remap="idx"><primary>output</primary></indexterm> of the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm>, an *.i file produced by the preprocessor and an *.s file as the output <indexterm remap="idx"><primary>output</primary></indexterm> of the assembler.</para>

<para>For a release of your project, disable any debugging <indexterm remap="idx"><primary>debugging</primary></indexterm>.</para>
</sect2>

<sect2 id="additional-options">
<title>Additional Options</title>

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

<sect1 id="compiler-warnings">
<title>Compiler Warnings</title>

<para>The following gives a description about the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> 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 <indexterm remap="idx"><primary>warnings</primary></indexterm> themselves are diagnostic messages that indicate that constructions may cause errors <indexterm remap="idx"><primary>errors</primary></indexterm>.</para>

<para><variablelist>
<varlistentry>
<term>-Wall</term>
<listitem>
<para>Standard `-W' options combined.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-W</term>
<listitem>
<para>Compile with -W. This option sets options not included in -Wall which are very specific. Please read GCC-Info for more
information.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wtraditional</term>
<listitem>
<para>Warn about certain constructs that behave differently in traditional and ANSI C.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wundef</term>
<listitem>
<para>Warn if an undefined identifier is evaluated in an `&&num;;if' directive.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wshadow</term>
<listitem>
<para>Warn whenever a local variable <indexterm remap="idx"><primary>variable</primary></indexterm> shadows another local variable <indexterm remap="idx"><primary>variable</primary></indexterm>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wid-clash-LEN</term>
<listitem>
<para>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 <indexterm remap="idx"><primary>Compiler</primary></indexterm>s.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wlarger-then-LEN</term>
<listitem>
<para>Warn whenever an object of larger than LEN bytes is defined.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wpointer-arith</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wbad-function-cast</term>
<listitem>
<para>Warn whenever a function call is cast to a non-matching type. For example, warn if <literal remap="tt">int malloc()</literal> is
cast to <literal remap="tt">anything *.</literal></para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wcast-equal</term>
<listitem>
<para>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 *.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wcast-align</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wwrite-strings</term>
<listitem>
<para>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 <indexterm remap="idx"><primary>warnings</primary></indexterm> 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 <indexterm remap="idx"><primary>declaration</primary></indexterm>s and prototypes. Otherwise, it will just be a nuisance;
this is why we did not make `-Wall' request these warnings <indexterm remap="idx"><primary>warnings</primary></indexterm>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wconversion</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wsign-compare</term>
<listitem>
<para>Warn when a comparison between signed and unsigned values could produce an incorrect result when the signed
value is converted to unsigned.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Waggregate-return</term>
<listitem>
<para>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.)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wmissing-prototypes</term>
<listitem>
<para>Warn if a global function is defined without a previous prototype declaration <indexterm remap="idx"><primary>declaration</primary></indexterm>. 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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wmissing-declaration <indexterm remap="idx"><primary>declaration</primary></indexterm>s</term>
<listitem>
<para>Warn if a global function is defined without a previous declaration <indexterm remap="idx"><primary>declaration</primary></indexterm>. 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 <indexterm remap="idx"><primary>declaration</primary></indexterm> is valid and changes nothing.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wredundant-decls</term>
<listitem>
<para>Warn if anything is declared more than once in the same scope even in cases where multiple declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> is
valid and changes nothing.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wnested-externs</term>
<listitem>
<para>Warn if an extern declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> is encountered within an function.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Winline</term>
<listitem>
<para>Warn if a function can not be inlined, and either it was declared as inline, or else the -fin*line-functions option was given.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wold-style-cast</term>
<listitem>
<para>Warn if an old-style (C-style) cast is used within a program</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Woverloaded-virtual</term>
<listitem>
<para>(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 <indexterm remap="idx"><primary>warnings</primary></indexterm> 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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wsynth</term>
<listitem>
<para>Warn when g++'s synthesis behavior does not match that of cfront.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>make all warnings <indexterm remap="idx"><primary>warnings</primary></indexterm> into errors <indexterm remap="idx"><primary>errors</primary></indexterm></term>
<listitem>
<para>(-Werror) Treat warnings <indexterm remap="idx"><primary>warnings</primary></indexterm> as errors <indexterm remap="idx"><primary>errors</primary></indexterm>; abort compilation after any warning.</para>
</listitem>
</varlistentry>
</variablelist>
</para>

<para>For a release of your project, it is recommended to enable <emphasis remap="bf">-Wall</emphasis>.</para>
</sect1>

<sect1 id="linker-options">
<title>Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> Options</title>

<para><indexterm><primary>linker options</primary></indexterm>
The Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> 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 <indexterm remap="idx"><primary>Linker</primary></indexterm>, e.g. your application uses the class
<indexterm remap="cdx"><primary><literal>KFileDialog</literal></primary></indexterm>KFileDialog. As the class <indexterm remap="cdx"><primary><literal>KFileDialog</literal></primary></indexterm>KFileDialog is part of the KFile library, you have to enable kfile. For classes <indexterm remap="idx"><primary>classes</primary></indexterm>
or functions that are not listed as checkboxes, use the <emphasis remap="bf">"additional libraries"</emphasis> field.</para>

<sect2 id="linker-linker-flags">
<title>Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> Flags</title>

<para><indexterm><primary>linker flags</primary></indexterm>
<variablelist>
<varlistentry>
<term>remove all symbol table and relocation information from the executable:</term>
<listitem>
<para>This means that all redundant information will be
removed from the object files and the binary, resulting that debugging <indexterm remap="idx"><primary>debugging</primary></indexterm> 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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>prevent using shared libraries:</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>additional flags:</term>
<listitem>
<para>Here, you can enter additional flags for the Linker <indexterm remap="idx"><primary>Linker</primary></indexterm>, setting the LDFLAGS environment variable <indexterm remap="idx"><primary>variable</primary></indexterm> by make <indexterm remap="idx"><primary>make</primary></indexterm>. The
available options can be taken from the man page for <emphasis remap="bf">ld</emphasis> or your Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> manpage.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect2>

<sect2 id="libraries-0">
<title>Libraries</title>

<para>The libraries section contains checkboxes for the most needed libraries in conjuction with Qt/KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> application
development. You have to enable those libraries that your application uses, otherwise the Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> will complain about unresolved
symbol tables.
<variablelist>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>X11</literal></primary></indexterm>X11</term>
<listitem>
<para>The X11 library. Recommended for all X-Window programs.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>Xext</literal></primary></indexterm>Xext</term>
<listitem>
<para>The X11 extension library. Also most X-Window programs depend on Xext.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>qt</literal></primary></indexterm>qt</term>
<listitem>
<para>The Qt-library <indexterm remap="idx"><primary>Qt-library</primary></indexterm>. Recommended for Qt and KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> applications.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>kdecore</literal></primary></indexterm>kdecore</term>
<listitem>
<para>The KDE Core library; contains the classes <indexterm remap="idx"><primary>classes</primary></indexterm> for KDE Application frameworks.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>kdeui</literal></primary></indexterm>kdeui</term>
<listitem>
<para>The KDE User Interface library; contains KDE-specific widgets <indexterm remap="idx"><primary>widgets</primary></indexterm>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>khtmlw</literal></primary></indexterm>khtmlw</term>
<listitem>
<para>The KHTML Widget library.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>kfm</literal></primary></indexterm>kfm</term>
<listitem>
<para>The KFM library containing classes <indexterm remap="idx"><primary>classes</primary></indexterm> for KFM functions.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>kfile</literal></primary></indexterm>kfile</term>
<listitem>
<para>The KFile library. Contains file dialogs etc.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>kspell</literal></primary></indexterm>kspell</term>
<listitem>
<para>The KSpell library. Contains an interface for programs to use Ispell for spell-checking.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><indexterm remap="cdx"><primary><literal>kab</literal></primary></indexterm>kab</term>
<listitem>
<para>The KAdressBook library. Needed for access to the addressbook as well as providing addressbook widgets <indexterm remap="idx"><primary>widgets</primary></indexterm></para>
</listitem>
</varlistentry>
</variablelist>

<emphasis remap="bf">additional libraries:</emphasis> 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.</para>
</sect2>
</sect1>

<sect1 id="make-options">
<title>Make <indexterm remap="idx"><primary>Make</primary></indexterm> Options</title>

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

<para><variablelist>
<varlistentry>
<term>Print debug information</term>
<listitem>
<para>prints out all information about the project files <indexterm remap="idx"><primary>project files</primary></indexterm> and what make <indexterm remap="idx"><primary>make</primary></indexterm> determines for rebuilding them.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Continue after errors <indexterm remap="idx"><primary>errors</primary></indexterm></term>
<listitem>
<para>tries to continue with the compilation after an error occurred (e.g. a file couldn't be compiled due to an
error)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Print the data base</term>
<listitem>
<para>prints out the make <indexterm remap="idx"><primary>make</primary></indexterm>-database for the current process which contains the changes from the last
build-run.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Environment variables</term>
<listitem>
<para>give the current environment variables a higher priority than the currently used variables in
the Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm>s.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>No built-in rules</term>
<listitem>
<para>doesn't use built-in rules for make <indexterm remap="idx"><primary>make</primary></indexterm>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Touch files</term>
<listitem>
<para>don't run the Compiler <indexterm remap="idx"><primary>Compiler</primary></indexterm> on changed files; instead only touches them. This sets them as already processed by make <indexterm remap="idx"><primary>make</primary></indexterm>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Ignore all errors <indexterm remap="idx"><primary>errors</primary></indexterm></term>
<listitem>
<para>Ignores all errors <indexterm remap="idx"><primary>errors</primary></indexterm> that occur</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Silent operation</term>
<listitem>
<para>doesn't print out any information about the build-process</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Print working directory</term>
<listitem>
<para>prints the current directory during the make <indexterm remap="idx"><primary>make</primary></indexterm>-process.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>job number</term>
<listitem>
<para>sets the amount of parallel processes for make <indexterm remap="idx"><primary>make</primary></indexterm>. For a single-CPU system we recommend setting this to one or two.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>set modified</term>
<listitem>
<para>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 <indexterm remap="idx"><primary>make</primary></indexterm> and compiled if it is a source file.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>additional options</term>
<listitem>
<para>set additional options to make <indexterm remap="idx"><primary>make</primary></indexterm>; those can be found in your local man page for "GNU Make".</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Rebuild behaviour on run</term>
<listitem>
<para>Sets the actions taken when you choose run. There are three options you can choose from:
<itemizedlist>
<listitem>
<para>always rebuild: Always rebuild without checking for modified files.</para>
</listitem>
<listitem>
<para>Warning on modification: Warn if source files have been modified and ask if the project should be rebuilt.</para>
</listitem>
<listitem>
<para>Only on modification: Check if sources have changed and rebuild if so.</para>
</listitem>
</itemizedlist>

The default is to rebuild always.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>
</chapter>

<chapter id="the-class-browser">
<title>Az Osztályböngésző</title>

<sect1 id="the-classviewer">
<title>The Classviewer</title>

<para><indexterm><primary>classbrowser</primary></indexterm>
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 <indexterm remap="idx"><primary>classes</primary></indexterm> etc., then displays the results in
the CV <indexterm remap="idx"><primary>CV</primary></indexterm> treeview. This chapter shows you how to use the Classviewer and the provided functionality and how it can improve your work.</para>

<para>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 <indexterm remap="idx"><primary>implementation</primary></indexterm> 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 <indexterm remap="idx"><primary>declaration</primary></indexterm> 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:</para>

<para><itemizedlist>
<listitem>
<para>Goto Declaration: browses to the declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> of the method</para>
</listitem>
<listitem>
<para>Goto Definition: browses to the definition of the method</para>
</listitem>
<listitem>
<para>Goto Class Declaration: browses to the class declaration <indexterm remap="idx"><primary>declaration</primary></indexterm></para>
</listitem>
<listitem>
<para>New Class <indexterm remap="idx"><primary>New Class</primary></indexterm>: opens the New Class <indexterm remap="idx"><primary>New Class</primary></indexterm> dialog to construct a new class</para>
</listitem>
<listitem>
<para>Add Method: adds a method to the selected class</para>
</listitem>
<listitem>
<para>Add Attribute: adds an attribute to the selected class</para>
</listitem>
<listitem>
<para>Show graphical classview: Opens the graphical inheritance tree</para>
</listitem>
</itemizedlist>
</para>

<sect2 id="available-objects">
<title>Available Objects</title>

<para>By available objects, we describe a term that means that C++ code can be seen as a collection of objects- classes <indexterm remap="idx"><primary>classes</primary></indexterm>, 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 <indexterm remap="idx"><primary>classes</primary></indexterm>; if your project contains subfolders to manage your sourcefiles, these are also
displayed by their original folder name and contain all classes <indexterm remap="idx"><primary>classes</primary></indexterm> that are stored in the files located in the subfolder.</para>

<para>Further, when popping up a class, the classtree displays the class contents by separating methods and attributes <indexterm remap="idx"><primary>attributes</primary></indexterm>. As these can have
attributes <indexterm remap="idx"><primary>attributes</primary></indexterm> 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 <indexterm remap="idx"><primary>declaration</primary></indexterm>.</para>

<para>Now, classes <indexterm remap="idx"><primary>classes</primary></indexterm> 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 <literal remap="tt">main()</literal> 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:
<itemizedlist>
<listitem>
<para>Structs</para>
</listitem>
<listitem>
<para>Functions</para>
</listitem>
<listitem>
<para>Variables</para>
</listitem>
</itemizedlist>
</para>

<para>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.</para>

<para>Finally, it can be stated that the classviewer <indexterm remap="idx"><primary>classviewer</primary></indexterm> 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 <indexterm remap="idx"><primary>classviewer</primary></indexterm> and it's tools in conjunction with your code.</para>
</sect2>

<sect2 id="browsing-object-declarations-and-implementat">
<title>Browsing Object Declarations and Implementations</title>

<para>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:</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">On a classname:</emphasis>  Switches to the class declaration <indexterm remap="idx"><primary>declaration</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">On a class method:</emphasis> Switches to the method implementation <indexterm remap="idx"><primary>implementation</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">On a class attribute:</emphasis> Switches to the attribute's declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> in the class declaration <indexterm remap="idx"><primary>declaration</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">On a struct:</emphasis> Switches to the struct's declaration <indexterm remap="idx"><primary>declaration</primary></indexterm></para>
</listitem>
<listitem>
<para><emphasis remap="bf">On a global function:</emphasis> Switches to the function's implementation <indexterm remap="idx"><primary>implementation</primary></indexterm></para>
</listitem>
</itemizedlist>
</para>

<para>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 <indexterm remap="idx"><primary>declaration</primary></indexterm> in the class as well as the implementation <indexterm remap="idx"><primary>implementation</primary></indexterm>. The classviewer <indexterm remap="idx"><primary>classviewer</primary></indexterm> supports this by providing
right-button context menus over items. On a method or function, this means that you can select where to go:</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Go to definition:</emphasis> Switches to the implementation <indexterm remap="idx"><primary>implementation</primary></indexterm>- this is the default for a left click as described above</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Go to declaration <indexterm remap="idx"><primary>declaration</primary></indexterm>:</emphasis> Switches to the declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> of the method or function.</para>
</listitem>
</itemizedlist>
</para>

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

<para>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.</para>
</sect2>
</sect1>

<sect1 id="the-classtools">
<title>The Classtools</title>

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

<para>The classtool dialog is invoked by the popup menu over a class in the classviewer <indexterm remap="idx"><primary>classviewer</primary></indexterm>. 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:</para>

<para><variablelist>
<varlistentry>
<term> Parents:</term>
<listitem>
<para>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 <literal remap="tt"><indexterm remap="cdx"><primary><literal>QWidget</literal></primary></indexterm>QWidget</literal> or <literal remap="tt"><indexterm remap="cdx"><primary><literal>QDialog</literal></primary></indexterm>QDialog</literal>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Children:</term>
<listitem>
<para>Displays the children classes <indexterm remap="idx"><primary>classes</primary></indexterm> that inherit the current class.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Clients:</term>
<listitem>
<para>Classes that make use of the selected class by an attribute in their class declaration <indexterm remap="idx"><primary>declaration</primary></indexterm></para>
</listitem>
</varlistentry>
<varlistentry>
<term>Suppliers:</term>
<listitem>
<para>The suppliers that give attributes <indexterm remap="idx"><primary>attributes</primary></indexterm> to the selected class.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Attributes:</term>
<listitem>
<para>The attributes <indexterm remap="idx"><primary>attributes</primary></indexterm> of the class by their name</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Methods:</term>
<listitem>
<para>The Methods of the selected class</para>
</listitem>
</varlistentry>
</variablelist>

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

<sect1 id="managing-classes">
<title>Managing Classes</title>

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

<para><emphasis remap="bf"> How to add a method to a class</emphasis></para>

<para><orderedlist><listitem>
<para>select the class you want to add a method</para>
</listitem>
<listitem>
<para>press the right mouse button; the popup menu appears</para>
</listitem>
<listitem>
<para>select "Add member function".</para>
</listitem>
<listitem>
<para>the "Add member function" dialog appears.</para>
</listitem>
<listitem>
<para>insert the type, declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> and documentation for the method</para>
</listitem>
<listitem>
<para>specify the access and the modifiers for the method</para>
</listitem>
<listitem>
<para>press OK to exit the dialog</para>
</listitem>
</orderedlist>
</para>

<para>For adding a variable <indexterm remap="idx"><primary>variable</primary></indexterm>, this is the same action, just with selecting "Add member variable <indexterm remap="idx"><primary>variable</primary></indexterm>" in the popup menu.</para>

<para>The difference between the actions of these dialogs is that the adding of a variable <indexterm remap="idx"><primary>variable</primary></indexterm> will add the variable <indexterm remap="idx"><primary>variable</primary></indexterm> to the classdeclaration <indexterm remap="idx"><primary>classdeclaration</primary></indexterm>,
the adding of a method will add the method's declaration <indexterm remap="idx"><primary>declaration</primary></indexterm> and the method's implementation <indexterm remap="idx"><primary>implementation</primary></indexterm> header to the sources. As the classviewer <indexterm remap="idx"><primary>classviewer</primary></indexterm>
directly updates himself, you have a direct access to the new method implementation <indexterm remap="idx"><primary>implementation</primary></indexterm>, so you only have to fill out the code for the
actual purpose of the method.</para>
</sect1>
</chapter>

<chapter id="the-dialog-editor">
<title>A Dialógusszerkesztő</title>

<para>The KDevelop integrated dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm> allows the easy construction of widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> 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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> is usually the first step you
would take after creating a new project with the KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm> 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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> to create your project widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> as well as what to do in case you see your widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> need
corrections or additions during the further development process.</para>

<para>You can switch to the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm> either by selecting "Dialog Editor" from the "View <indexterm remap="idx"><primary>View</primary></indexterm>"-menu or by the according toolbar icon.
To switch back to the Project Editor, select "KDevelop" from the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm>'s "View <indexterm remap="idx"><primary>View</primary></indexterm>"-menu or by the icon in the toolbar.</para>

<para>What else does the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm>'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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> very
quickly and, as he completely interacts with the project management, stay in the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm> 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.</para>

<para>The following chapters give you an overview of the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm> interface, how to create a new dialog initially and how set up the
properties of the child widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> that your dialog contains.</para>

<sect1 id="the-dialog-editor-view">
<title>The Dialog Editor View</title>

<sect2 id="the-mainview">
<title>The Mainview</title>

<para>The dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm>'s view is logically separated by:
<itemizedlist>
<listitem>
<para>The Widgets Tabulator, containing the "Widgets", "Dialogs" and "Items" tabs. These are described in <link linkend="Adding-Widgets">Adding Widgets</link>.</para>
</listitem>
<listitem>
<para>The Widget-Editor, representing the editing view for creating your dialog. See <link linkend="The-Widget-Editor">The Widget Editor</link></para>
</listitem>
<listitem>
<para>The Properties window, containing a list of properties and their values, dependent on the currently selected widget in the widget
editor. See <link linkend="Setting-Properties">Setting Properties</link> for information how to specialize the widget's behavior and look.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="menubar-menubar-toolbar-toolbar-and-statusba">
<title>Menubar <indexterm remap="idx"><primary>Menubar</primary></indexterm>, Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm> and Statusbar <indexterm remap="idx"><primary>Statusbar</primary></indexterm> differences to KDevelop</title>

<para>In Dialogeditor mode, KDevelop changes the menubar, toolbar and statusbar slightly to provide the functionality you need for creating
widgets <indexterm remap="idx"><primary>widgets</primary></indexterm>. These are:</para>

<sect3 id="menubar-menubar">
<title>Menubar <indexterm remap="idx"><primary>Menubar</primary></indexterm></title>

<para><emphasis remap="bf">"File"-menu <indexterm remap="idx"><primary>"File"-menu</primary></indexterm>:</emphasis> replaces "New" with "New Dialog". "Open" allows to open a dialog definition file.</para>

<para><emphasis remap="bf">"View"-menu <indexterm remap="idx"><primary>"View"-menu</primary></indexterm>:</emphasis> 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.</para>

<para><emphasis remap="bf">"Build"-menu <indexterm remap="idx"><primary>"Build"-menu</primary></indexterm>:</emphasis> replaces "Compile File <indexterm remap="idx"><primary>Compile File</primary></indexterm>" with "Generate Sources". This lets you actually generate the sources for your
dialog.</para>
</sect3>

<sect3 id="toolbar-toolbar">
<title>Toolbar <indexterm remap="idx"><primary>Toolbar</primary></indexterm></title>

<para>The toolbar contains a new icon for "New Dialog" as well as a replacement for "Compile File <indexterm remap="idx"><primary>Compile File</primary></indexterm>" by "Generate Sources".</para>
</sect3>

<sect3 id="statusbar-statusbar">
<title>Statusbar <indexterm remap="idx"><primary>Statusbar</primary></indexterm></title>

<para>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 <indexterm remap="idx"><primary>Statusbar</primary></indexterm> help, you are provided the same functionality than in Project-editing mode.</para>

<para>While changing widget size, the statusbar shows the current values for width and height of the selected widget.</para>
</sect3>
</sect2>
</sect1>

<sect1 id="creating-a-new-dialog">
<title>Creating a New Dialog</title>

<para>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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> recognizes this and offers widget construction by the widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> 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 <ulink url="../../default/kdevelop/programming/index-6.html">The KDevelop Programming Handbook</ulink>.</para>

<para>To create a new dialog, select "New" from the "File"-menu <indexterm remap="idx"><primary>"File"-menu</primary></indexterm> 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.</para>

<sect2 id="dialog-class">
<title>Dialog Class</title>

<para>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:
<orderedlist><listitem>
<para><emphasis remap="bf"><indexterm remap="cdx"><primary><literal>QWidget</literal></primary></indexterm>QWidget:</emphasis> the base class for all user interaction widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> provided by Qt. Used for main views and top-level widgets <indexterm remap="idx"><primary>widgets</primary></indexterm>.</para>
</listitem>
<listitem>
<para><emphasis remap="bf"><indexterm remap="cdx"><primary><literal>QFrame</literal></primary></indexterm>QFrame:</emphasis> inherits <literal remap="tt"><indexterm remap="cdx"><primary><literal>QWidget</literal></primary></indexterm>QWidget</literal> and is used by numerous widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> as a base class. This is useful for
widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> that already want to have a <literal remap="tt"><indexterm remap="cdx"><primary><literal>QFrame</literal></primary></indexterm>QFrame</literal> functionality in addition to <literal remap="tt"><indexterm remap="cdx"><primary><literal>QWidget</literal></primary></indexterm>QWidget</literal> methods.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Custom:</emphasis> 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.</para>
</listitem>
<listitem>
<para><emphasis remap="bf"><indexterm remap="cdx"><primary><literal>QDialog</literal></primary></indexterm>QDialog:</emphasis> the base class for dialogs that you would inherit for user interaction like setting properties or changing values.</para>
</listitem>
<listitem>
<para><emphasis remap="bf"><indexterm remap="cdx"><primary><literal>QTabDialog</literal></primary></indexterm>QTabDialog:</emphasis> inherits <indexterm remap="cdx"><primary><literal>QDialog</literal></primary></indexterm>QDialog and provides a dialog with predefined buttons and a set of tabs, which you will provide by the
widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> that you create.</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf">Custom Properties</emphasis></para>

<para>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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> 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.</para>
</sect2>

<sect2 id="files">
<title>Files</title>

<para>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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm>, but you can as well change the filenames.</para>

<para>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 <indexterm remap="idx"><primary>implementation</primary></indexterm> for your widget. As this will be a class, the dialog will exist by the header file containing the classdeclaration <indexterm remap="idx"><primary>classdeclaration</primary></indexterm>,
a C++ file containing the method implementation <indexterm remap="idx"><primary>implementation</primary></indexterm> 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 <emphasis>initDialog()</emphasis> method. The file itself shouldn't be changed as it
will contain the generated code from the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm> 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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> 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.</para>
</sect2>

<sect2 id="location">
<title>Location</title>

<para>For generating the widget's sources, the dialog editor <indexterm remap="idx"><primary>dialog editor</primary></indexterm> needs to know the location where these will go. The default value for the
output <indexterm remap="idx"><primary>output</primary></indexterm> directory is the current project subdirectory containing the sources already present.</para>

<para>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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> currently only supports static widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> without geometry management. If you're about to use
geometry management for your widgets <indexterm remap="idx"><primary>widgets</primary></indexterm>, you should make yourself accustomed with the classes <indexterm remap="idx"><primary>classes</primary></indexterm> that Qt provides for this, create a new
class with the classgenerator and write your widget by hand. For more information, see <ulink url="../../default/kdevelop/programming/index.html">The KDevelop Programming Handbook</ulink>.</para>
</sect2>
</sect1>

<sect1 id="adding-widgets">
<title>Adding Widgets</title>

<para>After specifying the dialogs or widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> class and filenames, you are ready to start creating the widget and filling it with contents.
Adding low-level widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> 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 <indexterm remap="idx"><primary>editor</primary></indexterm> 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.</para>

<para>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.</para>

<para>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 <indexterm remap="idx"><primary>widgets</primary></indexterm> 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:</para>

<para><itemizedlist>
<listitem>
<para>Raise</para>
</listitem>
<listitem>
<para>Lower</para>
</listitem>
<listitem>
<para>Raise to top</para>
</listitem>
<listitem>
<para>Lower to bottom</para>
</listitem>
<listitem>
<para>Cut</para>
</listitem>
<listitem>
<para>Delete</para>
</listitem>
<listitem>
<para>Copy</para>
</listitem>
<listitem>
<para>Paste</para>
</listitem>
<listitem>
<para>Help</para>
</listitem>
</itemizedlist>
</para>

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

<sect2 id="the-widgets-tabulator">
<title>The Widgets Tabulator</title>

<para><indexterm><primary>dialog editor widgets</primary></indexterm>
The widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> tab represents the available widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> 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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> automatically determines,
if your project type is Qt-only or KDE. This prevents you from using KDE-widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> in a Qt application.</para>

<para>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.</para>
</sect2>

<sect2 id="the-dialogs-tabulator">
<title>The Dialogs Tabulator</title>

<para><indexterm><primary>project dialogs</primary></indexterm>
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.</para>

<para>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.</para>
</sect2>

<sect2 id="the-items-tabulator">
<title>The Items Tabulator</title>

<para><indexterm><primary>dialog items</primary></indexterm>
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 <indexterm remap="idx"><primary>widgets</primary></indexterm> 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.</para>

<para>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 <indexterm remap="idx"><primary>widgets</primary></indexterm> behavior depends on the parent-child relationship.</para>
</sect2>
</sect1>

<sect1 id="the-widget-editor">
<title>The Widget Editor</title>

<para>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.</para>
</sect1>

<sect1 id="setting-properties">
<title>Setting Properties</title>

<para><indexterm><primary>setting widget properties</primary></indexterm>
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.</para>

<para>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 <emphasis>setText()</emphasis>.</para>

<para>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 <literal remap="tt"><indexterm remap="cdx"><primary><literal>QWidget</literal></primary></indexterm>QWidget</literal> and are used for all widgets <indexterm remap="idx"><primary>widgets</primary></indexterm> that inherit
<indexterm remap="cdx"><primary><literal>QWidget</literal></primary></indexterm>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.</para>

<para>A complete list of the supported properties that can be set in the properties window for each widget item.</para>
</sect1>

<sect1 id="generating-files">
<title>Generating Files</title>

<para><indexterm><primary>dialog sourcecode generation</primary></indexterm></para>

<para>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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm> toolbar. Your Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm>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 <indexterm remap="idx"><primary>dialog editor</primary></indexterm>. The output <indexterm remap="idx"><primary>output</primary></indexterm> window pops up below the Widget-Editor window as in Project Editor mode.</para>

<para>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. 
<footnote>
<para>See <ulink url="../../default/kdevelop/programming/index-6.html">The KDevelop Programming Handbook, The Dialogeditor</ulink> for more information about widget properties and sourcecode generation.</para>
</footnote>
</para>
</sect1>
</chapter>

<chapter id="the-internal-debugger">
<title>A belső nyomkövető</title>

<sect1 id="setup">
<title>Setup</title>

<para>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.</para>

<para>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.</para>

<para>Selecting the internal debugger enables an additional set of options you can choose from:</para>

<para><itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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 <link linkend="Shared-libraries-and-breakpoints">Shared libraries and breakpoints</link> for more details 
and a "gotcha" relating to this behaviour. If you are not "dlopen"ing libs, leave this off.</para>
</listitem>
<listitem>
<para>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 <link linkend="The-floating-toolbar">The floating toolbar</link>.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="using-the-internal-debugger">
<title>Using the internal debugger</title>

<sect2 id="changes-made-in-the-tree-and-output-view-win">
<title>Changes made in the tree and output view window</title>

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

<sect3 id="on-the-tree-view-window">
<title>On the tree view window</title>

<para><itemizedlist>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</para>
</sect3>

<sect3 id="on-the-output-view-window">
<title>On the output view window</title>

<para><itemizedlist>
<listitem>
<para>breakpoint : A list of breakpoints set and their current state.</para>
</listitem>
<listitem>
<para>framestack : The calling stack.</para>
</listitem>
<listitem>
<para>disassemble : A machine instruction view of the code showing the current instruction to be executed.</para>
</listitem>
</itemizedlist>
</para>
</sect3>
</sect2>

<sect2 id="changes-made-in-the-debug-menu-and-on-the-pa">
<title>Changes made in the Debug menu and on the panel</title>

<sect3 id="on-the-panel">
<title>On the panel</title>

<para>Two normal and two dropdown buttons to control the debugger functions will be accessible as soon as you start the debugger.</para>
</sect3>

<sect3 id="available-functions">
<title>In the Debug menu</title>

<para>When you start debugging, ten items to control the debugger will be enabled.</para>

<para>Available functions: 
<itemizedlist>
<listitem>
<para>Run: Continue the program from the current point.</para>
</listitem>
<listitem>
<para>Run to cursor: Execute the program up to the current cursor position</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>Step over i(nstruction): Execute one machine instruction as above.</para>
</listitem>
<listitem>
<para>Step in: Execute exactly one source line of code. This
means you will "step into" the current function, if necessary</para>
</listitem>
<listitem>
<para>Step in i(nstruction): Execute one machine instruction as above.</para>
</listitem>
<listitem>
<para>Step out: Run to the end of the current stack frame (function)</para>
</listitem>
<listitem>
<para>Viewers: Allows a variety of views into the data.
Currently implemented views are:
<orderedlist><listitem>
<para> Memory address</para>
</listitem>
<listitem>
<para> Disassemble code</para>
</listitem>
<listitem>
<para> Current registers</para>
</listitem>
<listitem>
<para> Current libraries</para>
</listitem>
</orderedlist>
</para>
</listitem>
<listitem>
<para>Interrupt: Stop the application executing.</para>
</listitem>
<listitem>
<para>Stop: Stop the application executing and exit the debugger.</para>
</listitem>
</itemizedlist>
</para>
</sect3>
</sect2>

<sect2 id="details">
<title>Details</title>

<sect3 id="breakpoints">
<title>Breakpoints</title>

<para>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.</para>
</sect3>

<sect3 id="setunset-breakpoints">
<title>Set/Unset breakpoints</title>

<para>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.</para>
</sect3>

<sect3 id="alternative-beakpoint-manipulating-via-menus">
<title>Alternative beakpoint manipulating via menus</title>

<para>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.</para>
</sect3>

<sect3 id="editing-breakpoints">
<title>Editing breakpoints</title>

<para>Use the above menu to display the edit breakpoint dialog. This contains the following fields :
<orderedlist><listitem>
<para>Conditional: Enter the condition that must be met before gdb will interrupt the program execution.</para>
</listitem>
<listitem>
<para>Ignore count: How many times you want the code to past through this breakpoint before gdb interrupts the program execution.</para>
</listitem>
<listitem>
<para>Enable: When enabled gdb will break at this breakpoint. When disabled gdb will not break here.</para>
</listitem>
</orderedlist>
</para>
</sect3>

<sect3 id="clear-all-breakpoints">
<title>Clear all breakpoints</title>

<para>Removes all the breakpoints for this program.</para>
</sect3>

<sect3 id="setunset-watchpoints">
<title>Set/Unset watchpoints</title>

<para>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.</para>

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

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

<sect3 id="setunset-watch-variables">
<title>Set/Unset Watch variables</title>

<para>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.</para>

<para>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.</para>
</sect3>

<sect3 id="changing-variable-values">
<title>Changing variable values</title>

<para>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.</para>
</sect3>
</sect2>
</sect1>

<sect1 id="the-floating-toolbar">
<title>The floating toolbar </title>

<para>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.</para>

<para>Besides the <link linkend="Available-functions">functions available from the Debug Menu</link>, the floating toolbar offers two additional 
functions:
<itemizedlist>
<listitem>
<para>Set focus on kdevelop : Set the focus on kdevelop</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</para>

<para>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.</para>
</sect1>

<sect1 id="shared-libraries-and-breakpoints">
<title>Shared libraries and breakpoints </title>

<para>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.</para>

<para>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" .</para>

<para>This is known as "lazy breakpoints"</para>

<para>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.</para>
</sect1>
</chapter>

<chapter id="beptett-cvs">
<title>Beépített CVS</title>

<para>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.</para>

<para>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.</para>

<sect1 id="enabling-cvs-support">
<title>Enabling CVS Support</title>

<para>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".</para>
</sect1>

<sect1 id="using-cvs-commands">
<title>Using CVS Commands</title>

<para>Then the following commands are available in the LFV and RFV by context menus:</para>

<para>Over a file not included in the repository:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Add to Repository</emphasis>: adds the file to the repository. The file is set up to be added and will be introduced to the repository
on the next <literal remap="tt">commit</literal> command that includes the directory where the added file is located locally.</para>
</listitem>
</itemizedlist>
</para>

<para>Over a file included in the repository:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Update</emphasis>: update the selected file with the CVS version</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Commit</emphasis>: commit the selected file to the CVS repository</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Remove from Repository</emphasis>: remove the file from the repository</para>
</listitem>
</itemizedlist>
</para>

<para>Over a folder:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Add</emphasis>: adds the folder to the repository</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Remove</emphasis>: removes the folder from the repository</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Update</emphasis>: update the folder recursively to be in sync with the repository</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Commit</emphasis>: commit any changes recursively to the repository</para>
</listitem>
</itemizedlist>
</para>

<para>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.</para>

<para>As the CVS commands of KDevelop only work with the <literal remap="tt">cvs</literal> system command and its commandline options, you should have no trouble to
use the cvs features.</para>
</sect1>
</chapter>

<chapter id="general-configuration">
<title>Általános beállítások</title>

<para>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.</para>

<sect1 id="configuring-the-">
<title>Configuring the "Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>" MenuTools <indexterm remap="idx"><primary>Tools</primary></indexterm>" Menu"&gt;</title>

<para><indexterm><primary>configuring the Tools-menu</primary></indexterm><indexterm><primary>"Options"-menu</primary></indexterm></para>

<para>As KDevelop supports the use of third-party programs within it's user interface, you are able to configure <indexterm remap="idx"><primary>configure</primary></indexterm> 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 <indexterm remap="idx"><primary>"Tools"-menu</primary></indexterm>. To change the tools-menu, select "Tools <indexterm remap="idx"><primary>Tools</primary></indexterm>" 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 <indexterm remap="idx"><primary>configuration dialog</primary></indexterm>, the tools-menu updates itself, so the new configuration is already
usable without restarting KDevelop.</para>
</sect1>

<sect1 id="file-viewer-options">
<title>File Viewer Options</title>

<para><indexterm><primary>file viewers</primary></indexterm></para>

<para>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:
<itemizedlist>
<listitem>
<para>New File <indexterm remap="idx"><primary>New File</primary></indexterm>: Opens the New File <indexterm remap="idx"><primary>New File</primary></indexterm> dialog. Equals to the menubar command "File"-"New"</para>
</listitem>
<listitem>
<para>New Class <indexterm remap="idx"><primary>New Class</primary></indexterm>: Opens the Classgenerator to create a new class. Equals to the menubar command "Project"-"New
Class <indexterm remap="idx"><primary>New
Class</primary></indexterm>"<indexterm><primary>"Project"-menu</primary></indexterm></para>
</listitem>
<listitem>
<para>New Group: Opens a dialog to create a new group. There, set the group name and the file filter for
the project files <indexterm remap="idx"><primary>project files</primary></indexterm> that will be displayed in this group.</para>
</listitem>
<listitem>
<para>Show relative path: displays the files with their path name starting from the main project directory if checked; otherwise only
the filename is shown.</para>
</listitem>
</itemizedlist>
</para>

<para>Over a group folder, the according context menu offers:
<itemizedlist>
<listitem>
<para>New Group: Opens the New Group dialog as in the context menu described above.</para>
</listitem>
<listitem>
<para>Remove group: removes the group from the LFV <indexterm remap="idx"><primary>LFV</primary></indexterm>.</para>
</listitem>
<listitem>
<para>Properties: Opens the properties of the group. There, you can edit the file filters by a list of wildcards separated by commas.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="kdevelop-setup">
<title>KDevelop Setup <indexterm remap="idx"><primary>KDevelop Setup</primary></indexterm></title>

<para><emphasis remap="bf">Make-command <indexterm remap="idx"><primary>Make-command</primary></indexterm>:</emphasis>
The General Options dialog lets you configure KDevelop's general settings.
First, you should set the make-command <indexterm remap="idx"><primary>make-command</primary></indexterm> available on your system. If the selected program does not exist,
KDevelop will warn you the next time you're invoking a make command.</para>

<para><emphasis remap="bf">Autosave <indexterm remap="idx"><primary>Autosave</primary></indexterm>:</emphasis></para>

<para>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.</para>

<para><emphasis remap="bf">Autoswitch <indexterm remap="idx"><primary>Autoswitch</primary></indexterm>:</emphasis></para>

<para>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 <indexterm remap="idx"><primary>output</primary></indexterm>
window turned off.</para>

<para><emphasis remap="bf">Startup <indexterm remap="idx"><primary>Startup</primary></indexterm>:</emphasis></para>

<para>For starting KDevelop, you have the option to enable/disable the start-logo <indexterm remap="idx"><primary>start-logo</primary></indexterm> 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.</para>
</sect1>

<sect1 id="changing-keyboard-shortcuts">
<title>Changing Keyboard Shortcuts <indexterm remap="idx"><primary>Keyboard Shortcuts</primary></indexterm></title>

<para>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.</para>
</sect1>

<sect1 id="documentation">
<title>Documentation</title>

<sect2 id="directoriesdocumentation-path">
<title>Directories<indexterm><primary>documentation path</primary></indexterm></title>

<para>For setting up the documentation browser <indexterm remap="idx"><primary>documentation browser</primary></indexterm> to work correctly, KDevelop needs some information about where the HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-documentation
is placed on the system. Therefore, the Documentation Path properties dialog needs the path of the Qt- online documentation in HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>
as well as the path to the KDE-Library documentation.</para>

<para>Usually, the Qt-Documentation <indexterm remap="idx"><primary>Qt-Documentation</primary></indexterm> 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 <indexterm remap="idx"><primary>configuration dialog</primary></indexterm>, Update KDE-Documentation <indexterm remap="idx"><primary>KDE-Documentation</primary></indexterm>. This will create the documentation to a path of your choice,
also setting the KDE Library Doc path automatically.</para>
</sect2>

<sect2 id="options">
<title>Options</title>

<sect3 id="update-kde-documentation-kde-documentation">
<title>Update KDE-Documentation <indexterm remap="idx"><primary>KDE-Documentation</primary></indexterm></title>

<para>For those users who don't have a recent documentation of the KDE-libraries <indexterm remap="idx"><primary>KDE-libraries</primary></indexterm>, especially the documentation for the files
installed on the system, the Update KDE-Documentation <indexterm remap="idx"><primary>KDE-Documentation</primary></indexterm> dialog creates a new one or updates existing documentations. This
function requires your system to have KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> and qt2KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm> installed, included in the KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm> 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/.</para>

<para>Then, you can choose three different installation modes, as:</para>

<para><itemizedlist>
<listitem>
<para> 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.</para>
</listitem>
<listitem>
<para> 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.</para>
</listitem>
<listitem>
<para> 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.</para>
</listitem>
</itemizedlist>
</para>

<para>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.</para>

<para>After pressing the OK button, KDevelop will create a subdirectory "KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm>-reference" in the documentation path containing the KDoc <indexterm remap="idx"><primary>KDoc</primary></indexterm>
reference files.  First, the qt library documentation classes <indexterm remap="idx"><primary>classes</primary></indexterm> 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 <literal remap="tt"><indexterm remap="cdx"><primary><literal>qt2kdoc</literal></primary></indexterm>qt2kdoc</literal>. Finally, the KDE libs will be indexed and the documentation will be build with
cross-references to give browsing the most functionality.</para>
</sect3>

<sect3 id="create-search-database">
<title>Create Search Database</title>

<para>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 <indexterm remap="idx"><primary>glimpse</primary></indexterm> 4.0 or ht://Dig 
installed.
Preset are the options to index the given KDE-Library documentation as well as the Qt-Documentation <indexterm remap="idx"><primary>Qt-Documentation</primary></indexterm>, 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
<link linkend="Using-the-Documentation-Browser">Using the Documentation Browser</link>.</para>
</sect3>
</sect2>
</sect1>

<sect1 id="debugger">
<title>Debugger </title>

<para>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.</para>

<para>Selecting the internal debugger enables an additional set of options you can choose from:</para>

<para><itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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 <link linkend="Shared-libraries-and-breakpoints">Shared libraries and breakpoints</link> for more details
and a "gotcha" relating to this behaviour. If you are not "dlopen"ing libs, leave this off.</para>
</listitem>
<listitem>
<para>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 <link linkend="The-floating-toolbar">The floating toolbar</link>.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="setting-paths">
<title>Setting Paths </title>

<para>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
<ulink url="tutorial/index.html">KDE Application Tutorials</ulink>.</para>

<para>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.</para>
</sect1>
</chapter>

<chapter id="questions-and-answers">
<title>Kérdések és Válaszok</title>

<para>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.</para>

<sect1 id="bug-reporting">
<title>Bug Reporting <indexterm remap="idx"><primary>Bug Reporting</primary></indexterm> </title>

<para>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 <ulink url="http://bugs.kde.org//db/pa/lkdevelop.html">http://bugs.kde.org//db/pa/lkdevelop.html</ulink>. </para>

<para>To send bug reports, please use the email address <ulink url="mailto:submit@bugs.kde.org">submit@bugs.kde.org</ulink>. If you want to use KDevelop for direct bug-reporting, choose
"Bug Report" from the Help-menu <indexterm remap="idx"><primary>Help-menu</primary></indexterm>. 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.</para>
</sect1>

<sect1 id="where-to-get-information">
<title>Where to get Information</title>

<para><emphasis remap="bf">Q:</emphasis> I have a question which is not addressed in the FAQ file, nor in the manuals of KDevelop. Where should I turn to ?</para>

<para><emphasis remap="bf">A:</emphasis>  In any case send all requests that are regarding KDevelop by subscribing to the KDevelop mailing list at <ulink url="mailto:kdevelop-request@barney.cs.uni-potsdam.de">kdevelop-request@barney.cs.uni-potsdam.de</ulink>. 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.</para>

<para>The KDevelop Homepage <indexterm remap="idx"><primary>KDevelop Homepage</primary></indexterm> at <ulink url="http://www.kdevelop.org">\|\|</ulink> also contains a mailing-list <indexterm remap="idx"><primary>mailing-list</primary></indexterm> 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.</para>
</sect1>

<sect1 id="library-and-system-problems">
<title>Library and System Problems</title>

<para><emphasis remap="bf">Q:</emphasis> Wrong JPEG library version: library is 61, caller expects 62</para>

<para><emphasis remap="bf">A:</emphasis>  There are 2 ways.
<orderedlist><listitem>
<para> 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
</para>
</listitem>
<listitem>
<para> You must recompiled kdesupport without jpeg
library (./configure <indexterm remap="idx"><primary>configure</primary></indexterm> --with-libjpeg --with-libgif).</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf">Q:</emphasis>
<screen>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
</screen>

<emphasis remap="bf">A:</emphasis>  Workaround for automake-1.4/automake-2.13 users: Just run
"aclocal" manually, then it will compile.</para>

<para><emphasis remap="bf">Q:</emphasis>  What must i do, if configure <indexterm remap="idx"><primary>configure</primary></indexterm> said ,that i need giflib23.</para>

<para><emphasis remap="bf">A:</emphasis>  Try a newer snap of kdesupport, or maybe you have another giflib installed?</para>

<para><emphasis remap="bf">Q:</emphasis> How can I convert a KDevelop 0.2 project to a 0.3 one?</para>

<para><emphasis remap="bf">A:</emphasis> Please change the AC&&lowbar;;OUTPUT in the configure <indexterm remap="idx"><primary>configure</primary></indexterm>.in to a oneline version</para>

<para>for example:
old version:
<screen>AC_OUTPUT(Makefile \
kdevelop/kwrite/Makefile \
kdevelop/templates/Makefile
)
</screen>

new version:
<screen>AC_OUTPUT(Makefile kdevelop/kwrite/Makefile kdevelop/templates/Makefile)
</screen>
</para>

<para><emphasis remap="bf">Q:</emphasis>  I  get the following Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> errors <indexterm remap="idx"><primary>errors</primary></indexterm> when using SuSE Linux with KDE 1.1, what do I have to do to get KDevelop linked ?
<screen>/usr/lib/libqt.so:
warning: multiple common of `QArrayT&&lt;;char&&gt;; 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
</screen>

<emphasis remap="bf">A:</emphasis> 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 <ulink url="ftp://ftp.suse.com">\|\|</ulink></para>
</sect1>

<sect1 id="usage-questions">
<title>Usage Questions</title>

<para><emphasis remap="bf">Q:</emphasis> I see the KDevelop does not allow for usage of the delete key (or backspace deleting when text is marked).</para>

<para><emphasis remap="bf">A:</emphasis>  go to "Options"-&gt;"Editor" and make sure that "Delete on Input" is enabled, then backspace and delete works.</para>

<para><emphasis remap="bf">Q:</emphasis> If I add files to my project, will they be automatically included and compiled ?</para>

<para><emphasis remap="bf">A:</emphasis> Yes, they are included in the Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>'s then and if you make a "Rebuild All" (./configure <indexterm remap="idx"><primary>configure</primary></indexterm> updates the Makefile <indexterm remap="idx"><primary>Makefile</primary></indexterm>s), your new
added files will be included as well.</para>

<para><emphasis remap="bf">Q:</emphasis> If I removed a file, I get some weird Linker <indexterm remap="idx"><primary>Linker</primary></indexterm> messages. What is wrong with my project ?</para>

<para><emphasis remap="bf">A:</emphasis> 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.</para>
</sect1>
</chapter>

<chapter id="szerzk">
<title>Szerzők</title>

<para><emphasis remap="bf">Main Developers:</emphasis></para>

<para>Sandy Meier 			<ulink url="mailto:smeier@rz.uni-potsdam.de">&lt;smeier@rz.uni-potsdam.de&gt;</ulink>
(maintainer, development coordinator and homepage provider)
<quote>Main development of: frame structure, IDE look'n feel, project management.</quote></para>

<para>Stefan Heidrich			<ulink url="mailto:sheidric@rz.uni-potsdam.de">&lt;sheidric@rz.uni-potsdam.de&gt;</ulink>
<quote>Main development of: KAppWizard <indexterm remap="idx"><primary>KAppWizard</primary></indexterm>, printing <indexterm remap="idx"><primary>printing</primary></indexterm> functionality</quote></para>

<para>Ralf Nolden			    <ulink url="mailto:Ralf.Nolden@post.rwth-aachen.de">&lt;Ralf.Nolden@post.rwth-aachen.de&gt;</ulink>
<quote>Main development of: KDevelop&lt;-&gt;Dialog Editor interface, configuration functionality, online-help and handbooks</quote></para>

<para>Jonas Nordin			  <ulink url="mailto:jonas.nordin@cenacle.se">&lt;jonas.nordin@cenacle.se&gt;</ulink>
<quote>Main development of: Classviewer and -parser</quote></para>

<para>Pascal Krahmer 			<ulink url="mailto:pascal@beast.de">&lt;pascal@beast.de&gt;</ulink>
<quote>Main development of: Dialog Editor</quote></para>

<para>Bernd Gehrmann 			<ulink url="mailto:bernd@physik.hu-berlin.de">&lt;bernd@physik.hu-berlin.de&gt;</ulink>
<quote>Main development of: Grep Dialog, CVS integration, new DOC tree</quote></para>

<para>Jörgen Olsson       <ulink url="mailto:jorgen@cenacle.net">&lt;jorgen@cenacle.net&gt;</ulink>
<quote>Main development of: Visual Classtree</quote></para>

<para>Stefan Bartel 			<ulink url="mailto:bartel@rz.uni-potsdam.de">&lt;bartel@rz.uni-potsdam.de&gt;</ulink>
<quote>Main development of: Real-File-Viewer</quote></para>

<para>Walter Tasin        <ulink url="mailto:tasin@e-technik.fh-muenchen.de">&lt;tasin@e-technik.fh-muenchen.de&gt;</ulink>
<quote>Main development of: Enhancements and Bug fixing</quote></para>

<para>John Birch          <ulink url="mailto:jbb@ihug.co.nz">&lt;jbb@ihug.co.nz&gt;</ulink>
<quote>Main development of: Integrated Debugger</quote></para>

<para><emphasis remap="bf">Translation coordination:</emphasis></para>

<para>Martin Piskernig		<ulink url="mailto:martin.piskernig@stuwo.at">&lt;martin.piskernig@stuwo.at&gt;</ulink></para>

<para><emphasis remap="bf">Program and Documentation Translations:</emphasis></para>

<para><itemizedlist>
<listitem>
<para>Martin Spirk 				<ulink url="mailto:spirk@kla.pvt.cz">&lt;spirk@kla.pvt.cz&gt;</ulink> 			-Czech</para>
</listitem>
<listitem>
<para>Steen Rabol    			<ulink url="mailto:rabol@get2net.dk">&lt;rabol@get2net.dk&gt;</ulink>			-Danish</para>
</listitem>
<listitem>
<para>Peeter Russak       <ulink url="mailto:pezz@tkwcy.ee">&lt;pezz@tkwcy.ee&gt;</ulink>	            - Estonian</para>
</listitem>
<listitem>
<para>Sami Kuhmonen 			<ulink url="mailto:sami@iqs.fi">&lt;sami@iqs.fi&gt;</ulink>					-Finnish</para>
</listitem>
<listitem>
<para>Herve Lefebvre 			<ulink url="mailto:hlefebvre@easynet.fr">&lt;hlefebvre@easynet.fr&gt;</ulink>			-French</para>
</listitem>
<listitem>
<para>Martin Piskernig    <ulink url="mailto:martin.piskernig@stuwo.at">&lt;martin.piskernig@stuwo.at&gt;</ulink>	-German</para>
</listitem>
<listitem>
<para>Ralf Funken    <ulink url="mailto:funken.ruk@netcologne.de">&lt;funken.ruk@netcologne.de&gt;</ulink>	-German  ( Debugger work )</para>
</listitem>
<listitem>
<para>Pahan Szabolcs 			<ulink url="mailto:szabczy@bigfoot.com">&lt;szabczy@bigfoot.com&gt;</ulink>			-Hungarian</para>
</listitem>
<listitem>
<para>Massimo Morin       <ulink url="mailto:mmorin@schedsys.com">&lt;mmorin@schedsys.com&gt;</ulink> -Italian</para>
</listitem>
<listitem>
<para>Taiki Komoda        <ulink url="mailto:kom@kde.gr.jp">&lt;kom@kde.gr.jp&gt;</ulink>  - Japanese</para>
</listitem>
<listitem>
<para>Jacek Wojdel 				<ulink url="mailto:wojdel@kbs.twi.tudelft.nl">&lt;wojdel@kbs.twi.tudelft.nl&gt;</ulink>     -Polish</para>
</listitem>
<listitem>
<para>Duarte Loreto 			<ulink url="mailto:dnloreto@esoterica.pt">&lt;dnloreto@esoterica.pt&gt;</ulink>		-Portuguese</para>
</listitem>
<listitem>
<para>Guilherme Ceschiatti B.M.<ulink url="mailto:guiga@cpdee.ufmg.br">&lt;guiga@cpdee.ufmg.br&gt;</ulink>  -Portuguese/Brazil</para>
</listitem>
<listitem>
<para>Ilmar Habibulin    	<ulink url="mailto:ilmar@ints.ru">&lt;ilmar@ints.ru&gt;</ulink>				-Russian</para>
</listitem>
<listitem>
<para>Jan Prokop 					<ulink url="mailto:jprokop@ibl.sk">&lt;jprokop@ibl.sk&gt;</ulink>				-Slovak</para>
</listitem>
<listitem>
<para>Salvador Gimeno 		<ulink url="mailto:salgiza@eui.upv.es">&lt;salgiza@eui.upv.es&gt;</ulink>		-Spanish</para>
</listitem>
<listitem>
<para>Patrik Adolfsson 		<ulink url="mailto:patrik.adolfsson@iname.com">&lt;patrik.adolfsson@iname.com&gt;</ulink>		-Swedish</para>
</listitem>
<listitem>
<para>Kađan Kongar        <ulink url="mailto:kongar@doruk.net.tr">&lt;kongar@doruk.net.tr&gt;</ulink> - Turkish</para>
</listitem>
<listitem>
<para>Sunchange Lee       <ulink url="mailto:leesongchen@263.net">&lt;leesongchen@263.net&gt;</ulink> - Simpl. Chinese (GB2312)</para>
</listitem>
</itemizedlist>
</para>

<para><emphasis remap="bf">Startlogo:</emphasis></para>

<para><itemizedlist>
<listitem>
<para>KDevelop 1.0: Jacek Wojdel 			<ulink url="mailto:wojdel@kbs.twi.tudelft.nl">&lt;wojdel@kbs.twi.tudelft.nl&gt;</ulink></para>
</listitem>
<listitem>
<para>KDevelop 1.1: Ralph Kocher      <ulink url="mailto:RKocher@t-online.de">&lt;RKocher@t-online.de&gt;</ulink></para>
</listitem>
</itemizedlist>
</para>

<para><emphasis remap="bf">Additions, patches and bugfixes:</emphasis></para>

<para><itemizedlist>
<listitem>
<para>Pau Estalella Fernandez <ulink url="mailto:pef@upcnet.upc.es">&lt;pef@upcnet.upc.es&gt;</ulink></para>
</listitem>
<listitem>
<para>Jost Schenk    					<ulink url="mailto:Jost@Schenk.de">&lt;Jost@Schenk.de&gt;</ulink></para>
</listitem>
<listitem>
<para>David Barth    					<ulink url="mailto:dbarth@videotron.ca">&lt;dbarth@videotron.ca&gt;</ulink></para>
</listitem>
<listitem>
<para>Matthias Hipp						<ulink url="mailto:Matthias.Hipp@gmx.de">&lt;Matthias.Hipp@gmx.de&gt;</ulink></para>
</listitem>
<listitem>
<para>Martin Piskernig    		<ulink url="mailto:martin.piskernig@stuwo.at">&lt;martin.piskernig@stuwo.at&gt;</ulink></para>
</listitem>
<listitem>
<para>Jochen Wilhelmy 				<ulink url="mailto:digisnap@cs.tu-berlin.de">&lt;digisnap@cs.tu-berlin.de&gt;</ulink></para>
</listitem>
<listitem>
<para>Matthias Hoelzer-Kluepfel    	<ulink url="mailto:mh@caldera.de">&lt;mh@caldera.de&gt;</ulink></para>
</listitem>
<listitem>
<para>Matt Koss 							<ulink url="mailto:koss@napri.sk">&lt;koss@napri.sk&gt;</ulink></para>
</listitem>
<listitem>
<para>Torsten Uhlmann 				<ulink url="mailto:TUhlmann@debis.com">&lt;TUhlmann@debis.com&gt;</ulink></para>
</listitem>
<listitem>
<para>Stefan Mars             <ulink url="mailto:mars@lysator.liu.se">&lt;mars@lysator.liu.se&gt;</ulink></para>
</listitem>
<listitem>
<para>Nikolay Liber           <ulink url="mailto:nikolay_liber@mail.ru">&lt;nikolay_liber@mail.ru&gt;</ulink></para>
</listitem>
<listitem>
<para>Gordon Tyler            <ulink url="maito:gtyler@iafrica.com">&lt;gtyler@iafrica.com&gt;</ulink></para>
</listitem>
<listitem>
<para>Huy Cuong Nguyen        <ulink url="maito:huyc@iquebec.com">&lt;huyc@iquebec.com&gt;</ulink></para>
</listitem>
<listitem>
<para>John R. Zedlewski       <ulink url="mailto:zedlwski@princeton.edu">&lt;zedlwski@princeton.edu&gt;</ulink></para>
</listitem>
<listitem>
<para>Stephan Uhlmann         <ulink url="mailto:suhlmann@gmx.de">&lt;suhlmann@gmx.de&gt;</ulink></para>
</listitem>
<listitem>
<para>Charles Egan            <ulink url="mailto:cega@oklahoma.net">&lt;cega@oklahoma.net&gt;</ulink></para>
</listitem>
<listitem>
<para>Andrew Morton           <ulink url="mailto:morton@nortelnetworks.com">&lt;morton@nortelnetworks.com&gt;</ulink></para>
</listitem>
<listitem>
<para>p&&lowbar;;george                <ulink url="mailto:p_george@club-internet.fr">&lt;p_george@club-internet.fr&gt;</ulink></para>
</listitem>
<listitem>
<para>Lubos Lunak             <ulink url="mailto:l.lunak@sh.cvut.cz">&lt;l.lunak@sh.cvut.cz&gt;</ulink></para>
</listitem>
<listitem>
<para>Armin L. Schneider      <ulink url="mailto:armin@uumail.de.uu.net">&lt;armin@uumail.de.uu.net&gt;</ulink></para>
</listitem>
<listitem>
<para>Martin Spirk            <ulink url="mailto:spirk@kla.pvt.cz">&lt;spirk@kla.pvt.cz&gt;</ulink></para>
</listitem>
<listitem>
<para>Ralf Palsa              <ulink url="mailto:rpalsa@eso.org">&lt;rpalsa@eso.org&gt;</ulink></para>
</listitem>
<listitem>
<para>Richard Dale            <ulink url="mailto:Richard_Dale@tipitina.demon.co.uk">&lt;Richard_Dale@tipitina.demon.co.uk&gt;</ulink></para>
</listitem>
<listitem>
<para>Holger Schurig          <ulink url="mailto:holger@holger.om.org">&lt;holger@holger.om.org&gt;</ulink></para>
</listitem>
<listitem>
<para>Dag Andersen            <ulink url="mailto:dandersen@c2i.net">&lt;dandersen@c2i.net&gt;</ulink></para>
</listitem>
<listitem>
<para>Alexis Mikhailov        <ulink url="mailto:alexis@abc.cap.ru">&lt;alexis@abc.cap.ru&gt;</ulink></para>
</listitem>
<listitem>
<para>Ulltveit-Moe            <ulink url="mailto:Nils.Ulltveit-Moe@hia.no">&lt;Nils.Ulltveit-Moe@hia.no&gt;</ulink></para>
</listitem>
<listitem>
<para>Nich Hudson             <ulink url="mailto:nick@nthcliff.demon.co.uk">&lt;nick@nthcliff.demon.co.uk&gt;</ulink></para>
</listitem>
<listitem>
<para>R. Imura                <ulink url="mailto:imura@cs.titech.ac.jp">&lt;imura@cs.titech.ac.jp&gt;</ulink></para>
</listitem>
<listitem>
<para>Falk Brettschneider     <ulink url="mailto:gigafalk@yahoo.com">&lt;gigafalk@yahoo.com&gt;</ulink></para>
</listitem>
</itemizedlist>
</para>

<para><emphasis remap="bf">KDevelop contains sourcecode from the following applications:</emphasis></para>

<para><emphasis remap="bf">KWrite 0.98</emphasis> &&copy;;		by Jochen Wilhelmy		<ulink url="mailto:digisnap@cs.tu-berlin.de">&lt;digisnap@cs.tu-berlin.de&gt;</ulink></para>

<para><emphasis remap="bf">KDE Help</emphasis> &&copy;;		by Martin R. Jones 		<ulink url="mailto:mjones@kde.org">&lt;mjones@kde.org&gt;</ulink></para>

<para><emphasis remap="bf">KSwallow</emphasis>	&&copy;; 		by Matthias Hoelzer  <ulink url="mailto:hoelzer@physik.uni-wuerzburg.de">&lt;hoelzer@physik.uni-wuerzburg.de&gt;</ulink></para>

<para><emphasis remap="bf">kcmlocale</emphasis>	&&copy;; 1998 	by Matthias Hoelzer <ulink url="mailto:hoelzer@physik.uni-wuerzburg.de">&lt;hoelzer@physik.uni-wuerzburg.de&gt;</ulink></para>
</chapter>

<chapter id="ksznet">
<title>Köszönet</title>

<para>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.</para>

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

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

<para>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.</para>
</chapter>

<chapter id="copyright">
<title>Copyright </title>

<para><screen>
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.
</screen>
</para>
</chapter>
<![ %addindex; [ &docindex; ]]>
</book>
<!--
Local Variables:
mode: sgml
sgml-omittag: nil
sgml-shorttag: t
sgml-general-insert-case: lower
End:
-->
