<!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="de">
<bookinfo>
<title>Benutzerhandbuch zu KDevelop
</title>
<subtitle>Der Referenzführer zur KDevelop Integrierten Entwicklungsumgebung für Unix Systeme, Version 1.2</subtitle>
<authorgroup>
<author>
<surname>Ralf Nolden </surname>
<affiliation>
<orgname>The KDevelop Team</orgname>
<address><email>Ralf.Nolden@post.rwth-aachen.de</email></address>
</affiliation>
</author>
<othercredit role="translator">
<firstname>Ralf</firstname>
<surname>Funken</surname>
<affiliation>
<address><email>rfunken@kdevelop.de</email></address>
</affiliation>
</othercredit>
</authorgroup>
<date>21/03/2000</date>
<releaseinfo>3.00.00</releaseinfo>
<abstract>
<para>Dieses Handbuch ist Teil der KDevelop Integrierten Entwicklungsumgebung und ist daher ebenso unter der GNU General Public License
lizensiert; siehe <link linkend="Copyright">Copyright</link>.</para>
</abstract>
<keywordset>
<keyword>KDE</keyword>
</keywordset>
</bookinfo>

<chapter id="einfhrung">
<title>Einführung</title>

<para>Da alles auf Erden seine Mode hat, scheint die heutige Computerwelt immer mehr zur Benutzung freier Software auch für kommerzielle
Zwecke zu tendieren. Man ist sich mittlerweile einig, daß Linux (genauso wie andere Projekte wie der Webserver, die Scriptsprache 
Perl und die GNU Tools), beweist, das freie Software qualitativ genauso gut sein kann wie kommerzielle Software. Doch trotz
der Qualität hat der Endbenuzter immer noch unter den kryptischen Kommandos vieler Unix-Systeme zu leiden. Damit Linux weiter blühen
kann, braucht es Applikationen, sowohl freie als auch kommerzielle, die einfach zu benutzen sind.</para>

<para>Das KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Projekt versucht dieses Loch zu schließen, indem ein einfacher Desktop und die zugehörigen Bibliotheken bereitgestellt
wird, um die Verfügbarkeit von GNU-basierter Software zu erweitern. Aber da speziell freie Software meist in der Freizeit der Autoren
erstellt wird, ist die Frage für viele Programmierer, wie sehr Sie ihre gegenwärtige Entwicklungsumgebung mögen. KDevelop will einen
weiteren großen Schritt machen: das Programmierleben einfacher und effizienter gestalten. Produkte, die mit KDevelop erstellt wurden,
können eine höhere Stufe der Zuverlässigkeit und Funktionalität in der gleichen Entwicklungszeit erreichen.</para>

<para>Um dieses Ziel zu erreichen, stellt die KDevelop Integrierte Entwicklungsumgebung viele Features bereit, die Entwickler brauchen
genauso, wie es die Funktionalität anderer Programme wie <literal remap="tt">make</literal> und dem GNU C++ compiler verpackt und sie zu einem unsichtbaren,
integrierten Teil des Entwicklungsprozesses macht. KDevelop beherrscht:</para>

<para><itemizedlist>
<listitem>
<para> Alle Entwicklungswerkzeuge, die für C++ Programmierung benötigt werden, wie den Compiler, Linker, automake und autoconf,</para>
</listitem>
<listitem>
<para> KAppWizard, welcher vollständige, sofort ausführbare Rahmenapplikationen erstellt,</para>
</listitem>
<listitem>
<para> den Klassengenerator, um neue Klassen zu erzeugen und sie in das aktuelle Projekt zu integrieren,</para>
</listitem>
<listitem>
<para> Dateimanagement von Quellcode, Headerdateien, Dokumentation etc, die im Projekt eingebunden sind,</para>
</listitem>
<listitem>
<para> Die Erzeugung von Benutzerhandbüchern in SGML und die automatische Generierung in HTML-Ausgabe mit dem KDE look and feel,</para>
</listitem>
<listitem>
<para> Automatische HTML-basierte API-Dokumentation für die Klassen ihres Projekts mit Querreferenzierung zu den benutzten
Bibliotheken,</para>
</listitem>
<listitem>
<para> Unterstützung von Internationalisierung Ihrer Applikation, die es Übersetzern erlaubt, ihre Zielsprache zu einem Projekt
hinzuzufügen,</para>
</listitem>
<listitem>
<para> WYSIWYG (What you see is what you get, Was Sie sehen, ist was Sie bekommen)- Erzeugung von Benutzeroberflächen mit dem
integrierten Dialogeditor,</para>
</listitem>
<listitem>
<para> Debuggen ihrer Applikation durch Integrieren von KDbg,</para>
</listitem>
<listitem>
<para> Bearbeiten von Projekt-spezifischen Pixmaps mit KIconEdit,</para>
</listitem>
<listitem>
<para> Die Einbeziehung jedes anderen Programms, das Sie zur Entwicklung benötigen durch Hinzufügen zum "Werkzeuge"-Menü nach ihren
individuellen Bedürfnissen.</para>
</listitem>
</itemizedlist>
</para>

<para>KDevelop macht es zu einer Freude, mit allen Programmen unter einer Oberfläche zu arbeiten und spart Zeit durch Automatisierung von
Standard-Entwicklungsprozessen, genauso wie es Ihnen direkten und transparenten Zugriff auf alle Informationen bietet, die Sie
brauchen. Die integrierten Browser-Mechanismen wurden entworfen um Dokumentationsanfragen zu unterstützen, die Entwickler in Beziehung
zu Ihrem Projekt haben.</para>

<para>Der Klassenbrowser und der Fehler-Sucher bringen Sie mit einem Mausclick an jede Stelle Ihres Projektcodes, ohne daß Sie nach Dateien
suchen müssen; Dateibäume geben direkten Zugang zu Projektdateien und das integrierte Hilfesystem bietet eine praktischen Zugriff auf
die Online-Dokumentation überall innerhalb der Entwicklungsumgebung.</para>

<sect1 id="neuerungen">
<title>Neuerungen</title>

<para>Version 1.2 kommt mit dem meist benötigten Funktionen zur C/C++ Entwicklung. Während der Entwicklungsphase von
KDevelop machte das Projekt große Fortschritte seit der Release von Version 1.0. Wir glauben, das die aktuelle 
Version,die Entwicklern die Umgebung bietet, die sie brauchen, als die letzte Releaseversion für KDE 1.x angesehen werden kann.</para>

<para>Verbesserungen wurden in den folgenden Bereichen durchgeführt:</para>

<para><itemizedlist>
<listitem>
<para>schneller Klassenparser und -browser mit graphischer Klassenansicht und Dialog-basierter Bearbeitung von 
Membern und Klassen,</para>
</listitem>
<listitem>
<para>CVS-Unterstützung für die meist benötigten Funktionen wie hinzufügen, entfernen, aktualisieren und 
übertragen von Dateien und Verzeichnissen,</para>
</listitem>
<listitem>
<para>Aktualisierte und erweiterte Dokumentation, die nun fünf Handbücher umfaßt und mit KDevelop geliefert 
wird,</para>
</listitem>
<listitem>
<para>fehlerbereinigter Klassenparser, Dialogeditor und Fehlerfinder,</para>
</listitem>
<listitem>
<para>Verbesserte Dokumentationsansicht, der Ihnen sofort den Zugang zur Klassendokumentation bis zu jeder 
Methode von Klassen bietet.</para>
</listitem>
</itemizedlist>
</para>

<para>Kommentare und Verbesserungsvorschläge zur IDE und ihrer Dokumentation sind willkommen.</para>
</sect1>

<sect1 id="ber-dieses-handbuch">
<title>Über dieses Handbuch</title>

<para>Dieses Benutzerhandbuch gibt dem Benutzer eine vollständige Übersicht über die KDevelop Entwicklungsumgebung und beschreibt den grundlegenden
Entwicklungsprozess in Kürze. Für Informationen über spezifische Programmierfragen raten wir, das <ulink url="programming.html">KDevelop Programmierer Handbuch</ulink> zu lesen, das mit KDevelop geliefert wird; dieses deckt Themen ab wie die Funktion der
generierten Rahemenapplikationen oder wie vollständige KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Applikationen erstellt werden.</para>

<para>Dieses Handbuch ist daher unterteilt in folgende Abschnitte:</para>

<para><itemizedlist>
<listitem>
<para>Kapitel <link linkend="Installation">Installation</link>, behandelt Systemanforderungen, Installation und Einrichtung der KDevelop Entwicklungsumgebung.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Programme">Programme</link>, beschreibt Ihnen, wie Programme mit den Standard-GNU Entwickungswerkzeugen erzeugt und erstellt werden.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Entwicklung-mit-KDevelop">Entwicklung mit KDevelop</link>, nimmt Sie mit auf eine kurze Reise, die Ihnen die Funktionalität der Entwicklungsumgebung beschreibt.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="bersicht">Übersicht</link>, erklärt sowohl die Menüs und Dialoge als auch Schnelltasten.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Das-Hilfe-System">Das Hilfe-System</link>, zeigt die Benuztung des integrierten Dokumentationsbrowsers und zusätzliche Hilfe-funktionen.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Arbeiten-mit-dem-Editor">Arbeiten mit dem Editor</link>, erklärt die Features des Dateimanagements und -bearbeitung.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Projekte">Projekte</link>, beschreibt die Erzeugung und Überwachung von Software Projekten.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Erstellungsoptionen">Erstellungsoptionen</link>, enthält eine Referenz über die Einstellung von Compiler und Linker Flags und der Projekteinstellungen.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Der-Klassenbrowser">Der Klassenbrowser</link>, beschreibt Ihnen ausführlich, wie Sie den KDevelop Klassenbrowser benutzen.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Der-Dialogeditor">Der Dialogeditor</link>, betrachtet den Integrierten visuellen Dialogeditor und wie er Ihnen C++ Code erzeugt.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Der-interne-Debugger">Der interne Debugger</link>, gibt eine Übersicht über die Einstellungen zum Debuggen und die Verwendung des internen Debugggers.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="CVS-Integration">CVS Integration</link>, erkärt, wie die Revisions-Kontrollsysteme CVS und RCS mit Ihrem KDevelop Projekt verwendet werden.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Grundstzliche-Konfiguration">Grundsätzliche Konfiguration</link> zeigt Ihnen, wie Sie generelle Einstellungen zur Benutzung von KDevelop vornehmen.</para>
</listitem>
<listitem>
<para>Kapitel <link linkend="Fragen-und-Antworten">Fragen und Antworten</link>, behandelt Fragen, die bei der Benutzung von KDevelop unter verschiedenen Unix-Systemen vorkommen und generelle Problemlösungen.</para>
</listitem>
</itemizedlist>
</para>

<para>Für Programmieranfänger und neue Benutzer dieses Produkts empfehlen wir, sich in dieses Handbuch einzulesen bevor Sie damit beginnen,
mit der Entwicklungsumgebung zu arbeiten, da es die Benutzung vollständig behandelt. Das Verständnis, wie Vorgänge am schnellsten zu erledigen sind,
wird Ihnen viel Zeit ersparen, nach Funktionen und Features zu suchen, genauso, wie es Sie in die Lage versetzt, erstklassige
Entwicklungswerkzeuge noch einfacher zu benutzen.</para>
</sect1>

<sect1 id="ber-das-kdevelop-projekt">
<title>Über das KDevelop Projekt</title>

<para>Das KDevelop Projekt wurde im Sommer 1998, nachdem KDE 1.0 für Linux/Unix verfügar war, aus der Taufe gehoben und hatte zum Ziel,
eine einfach zu benutzende C/C++ IDE zu erstellen, die inbesondere auf die KDE Umgebung abzielt. Seitdem haben sich viele Helfer
und Unterstützer, sowie Sponsoren gefunden, die dem Team dabei helfen, seine Arbeit an der inzwischen weitläufig bekannten
Programmierumgebung fortzusetzen. Innerhalb von anderthalb Jahren, hat sich die IDE zu einer full-featured KDE Anwendung
entwickelt, welche die größtmögliche Funktionalität und Stabilität aufweist, da die Entwickler begannen die IDE mit Hilfe der IDE
selbst weiterzuentwickeln, sobald die erforderliche Funktionalität erreicht war. Dadurch konnten die meisten Fehler von den
Autoren gefunden und sehr schnell behoben, sowie erforderliche Erweiterungen erkannt und implementiert werden.</para>

<para>Das erste offizielle stable Release war die Version 1.0, die am 6. Dezember 1999 erschien. Danach hat das KDevelop Team weitere
Features implementiert und durch neuen oder verbesserten Code eine noch größere Stabilität erreicht. Das Ergebnis war die Version
1.1 vom 28. Februar 2000.</para>

<para>Seitdem fährt das Projekt fort, mehr Funktionalität zu integrieren und die Codebasis zu vereinfachen. Hinzu kommt eine
Internationalierungsgruppe mit vielen Übersetzern, die KDevelop in so viele Sprachen wie möglich transferieren, um der
internationalen Entwicklergemeinde eine IDE in der jeweiligen Muttersprache zur Verfügung zu stellen. Dies beinhaltet auch die
umfangreichen Handbücher, die zu KDevelop gehören oder damit ausgeliefert werden. Viele Anwender haben ihre Erfahrung und ihr
Wissen in das Projekt eingebracht, das sich heute als eines der vielversprechendsten Produkte für Linux/Unix Entwickler
präsentieren kann, um es noch stabiler und auf andere Unices portierbar zu machen.</para>
</sect1>

<sect1 id="gedruckte-versionen">
<title>Gedruckte Versionen</title>

<para>Eine gedruckte Version der kompletten KDevelop Dokumentation ist als Buch unter dem Titel <emphasis remap="bf">Developing
Applications for Linux: KDE Edition</emphasis> erhältlich und kann online entweder auf <ulink url="http://www.kdevelop.org">http://www.kdevelop.org</ulink> oder auf <ulink url="http://www.opendocs.org">http://www.opendocs.org</ulink> bestellt werden. Ein
Teil des Gewinns fließt zurück in das KDevelop Projekt, um die Weiterentwicklung von KDevelop zu unterstützen.</para>

<para>Ebenfalls auf <ulink url="http://www.kdevelop.org">http://www.kdevelop.org</ulink> erhältlich, sind druckbare Versionen in DVI,
PostScript und PDF Format, sowohl in A4 als auch in Letter-Größe.</para>
</sect1>
</chapter>

<chapter id="installation">
<title>Installation</title>

<sect1 id="verfgbarkeit-von-kdevelop">
<title>Verfügbarkeit von KDevelop</title>

<para>KDevelop kann entweder auf der KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Applikations-Seite (<ulink url="http://www.kde.org/current.html">http://www.kde.org/current.html</ulink>) oder auf der KDevelop Homepage (<ulink url="http://www.kdevelop.org">http://www.kdevelop.org</ulink>)
bezogen werden. Ebenso ist KDevelop auf Linux-Distributionen vorhanden, wie z.B. SuSE Linux 6.1.</para>

<para>Wir bieten außerdem wöchentliche Snapshots des KDevelop CVS Repositories auf unserer Homepage an für die, die auf dem aktuellen Stand
von KDevelop sein wollen. Für gewöhnlich sind die Snapshots jedoch nicht zur Produktion geeignet, sondern zum Testen neuer Features und
zum Einblick in den Entwicklungsfortschritt des KDevelop Teams. Außerdem bieten wir verschiedene Software von dritter Seite an, die von
KDevelop benötigt werden wie KDoc und KDbg.</para>

<para>Wenn Sie Probleme mit der Compilierung oder Benutzung von KDevelop haben, lesen Sie bitte das Kapitel
<link linkend="Fragen-und-Antworten">Fragen und Antworten</link> dieses Handbuchs oder die FAQ-Datei, die im KDevelop-Paket 
enthalten ist. Sollte Ihr Problem nicht behandelt sein, tragen Sie sich in die KDevelop Mailingliste 
<ulink url="mailto:kdevelop-request@barney.cs.uni-potsdam.de">kdevelop-request@barney.cs.uni-potsdam.de</ulink> ein, 
indem Sie eine Email mit leerer Kopfzeile und "subscribe ihrer-email-addresse" als Inhalt an obige Adresse senden.
Anfragen und Problemberichte sollten sich jedoch nur auf die Benutzung der KDevelop Entwicklungsumgebung beziehen und nicht auf ein
Implementierungsproblem, das bei der Codierung Ihrer eigenen Applikation entstanden ist.</para>

<para>Auch sollten alle Mails, die an diese Mailingliste gerichtet sind, in Englisch gehalten sein, damit alle Teilnehmer sich an der
Diskussion beteiligen können und eine bessere Hilfe bereitstellen können. Die Mailingliste ist ebenso dazu gedacht, Benutzern, die zum
KDevelop Projekt beitragen möchten, ein Forum zu bieten; auch solche Mails sind willkommen, die Lösungen zu Problemen enthalten, die
bei der Benutzung entstanden, damit wir Fehler korrigieren und dies integrieren können, um Anfängern eine noch qualifizierte Hilfe aus
erster Hand zu bieten.</para>

<para>Ein guter Weg, Probleme zu berichten, ist das übersenden der Ausgabe, die Sie beim Starten von KDevelop aus einer Konsole heraus
erhalten, oder den Inhalt des "Meldungen" Fensters von KDevelop in Ihren Bericht zu kopieren.</para>
</sect1>

<sect1 id="anforderungen">
<title>Anforderungen</title>

<para>Um KDevelop erfolgreich zu compilieren und zu benutzen muß Ihr System die folgenden Programme und Bibliotheken enthalten, die auf den
meisten Plattformen als Pakete enthalten sind und daher einfach zu installieren sind.</para>

<para><emphasis remap="bf">Benötigt:</emphasis>
<itemizedlist>
<listitem>
<para>g++ 2.7.2/g++ 2.8.1/egcs 1.1 (oder kompatibler Compiler), erhältlich auf <ulink url="http://www.gnu.org">http://www.gnu.org</ulink></para>
</listitem>
<listitem>
<para>GNU make (or compatible), erhältlich auf <ulink url="http://www.gnu.org">http://www.gnu.org</ulink></para>
</listitem>
<listitem>
<para>perl 5.004, erhältlich auf <ulink url="http://www.perl.com">http://www.perl.com</ulink></para>
</listitem>
<listitem>
<para>autoconf 2.12, erhältlich auf <ulink url="http://www.gnu.org">http://www.gnu.org</ulink></para>
</listitem>
<listitem>
<para>automake 1.2, erhältlich auf <ulink url="http://www.gnu.org">http://www.gnu.org</ulink></para>
</listitem>
<listitem>
<para>flex 2.5.4,</para>
</listitem>
<listitem>
<para>GNU gettext, erhältlich auf <ulink url="http://www.gnu.org">http://www.gnu.org</ulink></para>
</listitem>
<listitem>
<para>Qt 1.42, erhältlich auf  <ulink url="http://www.troll.no">http://www.troll.no</ulink></para>
</listitem>
<listitem>
<para>KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> 1.1.x, erhältlich auf <ulink url="http://www.kde.org">http://www.kde.org</ulink></para>
</listitem>
</itemizedlist>
</para>

<para><emphasis remap="bf">Optional:</emphasis>
<itemizedlist>
<listitem>
<para>enscript zur Nutzung der Druckfunktionen</para>
</listitem>
<listitem>
<para>ghostview oder kghostview zur Druckvorschau</para>
</listitem>
<listitem>
<para>glimpse 4.0 für die Nutzung des Suchindexes, erhältlich auf <ulink url="http://glimpse.cs.arizona.edu">http://glimpse.cs.arizona.edu</ulink></para>
</listitem>
<listitem>
<para>sgmltools 1.0, erhältlich auf <ulink url="http://www.sgmltools.org">http://www.sgmltools.org</ulink></para>
</listitem>
<listitem>
<para>KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm> (<emphasis remap="bf">KDE S</emphasis>oftware <emphasis remap="bf">D</emphasis>evelopment <emphasis remap="bf">K</emphasis>it)with KDoc, KSgml2Html, KTranslator
(erhältlich auf <ulink url="http://developer.kde.org">http://developer.kde.org</ulink>)</para>
</listitem>
<listitem>
<para>KDbg, erhältlich auf <ulink url="http://members.telecom.at/~johsixt/kdbg.html">http://members.telecom.at/~johsixt/kdbg.html</ulink></para>
</listitem>
<listitem>
<para>KIconEdit (erhältlich auf <ulink url="http://www.kde.org">http://www.kde.org</ulink>)</para>
</listitem>
</itemizedlist>
</para>

<para>KDevelop wurde getestet mit SuSE Linux 5.2 auf einem AMD K6 200 mit 64 MB RAM und FreeBSD 3.0-Release, SuSE Linux 6.0 auf Intel Pentium
200 MMX, 128 MB Ram.</para>

<para>Soweit den Autoren bekannt ist, enthält SuSE Linux und FreeBSD alle benötigten Programme, inklusive enscript als Pakete oder
RPM's, so daß Sie keine Probleme haben sollten, die benötigte zusätzliche Software zu installieren.</para>

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

<para>Um die KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Bibliotheks-Dokumentation zu erstellen, benötigen Sie das kdelibs Paket im Quellcode, wie es vom KDE Projekt
bereitgestellt wird oder in den Quellpaketen ihrer Distribution enthalten ist und <emphasis remap="bf">KDoc</emphasis> (enthalten im KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm>).</para>

<para>Zusätzlich bieten wir eine C/C++ Referenz auf unserer Homepage auf <ulink url="http://www.kdevelop.org">http://www.kdevelop.org</ulink> an, die nach ihrer Installation im Dokumentationsbrowser verfügbar ist. Laden Sie das Paket herunter
und kopieren Sie es als <literal remap="tt">root</literal> in Ihr KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Verzeichnis und entpacken Sie es mit <literal remap="tt">tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz</literal>. Bei
Nichtinstallation zeigt die Auswahl der Referenz im Dokumentationsbaum eine Fehlerseite an mit der URL der KDevelop Homepage, auf der
Sie das Paket erhalten können, und beschreibt den Installationsvorgang.</para>
</sect1>

<sect1 id="compilierung-und-installation">
<title>Compilierung und Installation</title>

<para>Um KDevelop auf Ihrem System zu compilieren und installieren, geben Sie folgendes im Hauptverzeichnis der KDevelop Distribution ein:</para>

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

	(als root)
	
	&&percnt;; make install
</screen>
</para>

<para>Da KDevelop <literal remap="tt">autoconf</literal> benutzt, sollten Sie keine Probleme haben, es zu übersetzen.</para>

<para>Um KDevelop CVS Snapshots zu compilieren, geben Sie folgendes ein:</para>

<para><screen>	&&percnt;; make -f Makefile.cvs
	&&percnt;; ./configure
	&&percnt;; make

	Wechseln Sie auf &lt;tt/root/ und geben Sie ein:
	
	&&percnt;; make install
</screen>
</para>

<para>Wenn das make-Kommando Ihres Systems <literal remap="tt">gmake</literal> lautet, geben Sie <literal remap="tt">gmake</literal> anstatt <literal remap="tt">make</literal> ein.</para>
</sect1>

<sect1 id="starten-von-kdevelop">
<title>Starten von KDevelop</title>

<para>Wenn Sie KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> als Window-Manager benutzen, können Sie KDevelop starten, indem Sie
"K"&-&gt;;"Applications"&-&gt;;"KDevelop"&-&gt;;"KDevelop 0.4" auswählen. Da KDevelop die KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-Mime Typen unterstützt, können Sie
KDevelop auch mit einem Projekt starten, indem Sie eine KDevelop Projektdatei ("*.kdevprj", dargestellt mit dem Projekt-Icon) im
KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Dateimanager (kfm) auswählen.</para>

<para>Unter anderen Winow-Managern öffnen Sie eine Konsole und geben ein:
<screen>&&percnt;; kdevelop
</screen>
</para>

<para>Um KDevelop mit einem bestehenden Projekt zu starten, wechseln Sie in das Projekt-Verzeichnis und geben ein:</para>

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

<para>Unter jedem Benutzerzugang wird KDevelop einen <link linkend="Das-Installationsprogramm">automatischen Installationsvorgang</link>
beim ersten Start aufrufen, der eine Schnellkonfiguration für die benötigten Einstellungen vornimmt. Wenn Ihre Installation verloren
gehen sollte, können Sie KDevelop jederzeit rekonfigurieren, indem Sie</para>

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

<para>eingeben, oder, wenn Sie KDE benutzen,"K"&-&gt;;"Applications"&-&gt;;"KDevelop"&-&gt;;"Setup" auswählen.</para>
</sect1>

<sect1 id="das-installationsprogramm">
<title>Das Installationsprogramm</title>

<para>KDevelop enthält ein automatisches Installationsmodul, das aufgerufen wird wenn KDevelop zum ersten Mal gestartet wird oder die
Benutzer-Konfigurationsdatei kdeveloprc nicht existiert. Wir raten, die folgenden Installationsschritte mit der Auswahl von "Weiter"
durchzuführen, um Ihr System zu prüfen und KDevelop einzurichten.</para>

<para>Die Tasten des Installationsdialoges führen folgende Aktionen aus:</para>

<para><emphasis remap="bf">Hilfe:</emphasis> Öffnet KDEHelp.</para>

<para><emphasis remap="bf">Weiter:</emphasis> Dies started den Installationsprozess und führt folgendes aus:</para>

<para><orderedlist><listitem>
<para> Prüfen nach make/gmake, autoconf, autoheader, automake und Perl um neue Applikationen, die mit KDevelop erstellt wurden zu
erzeugen und zu compilieren. Wenn gmake installiert ist, wird das make-Kommando automatisch auf gmake eingestellt. Andere
Kommandozeilenoptionen zu ihrem Erstellungsprogramm können Sie später im Setup Dialog, der über das "Einstellungen"-Menü zu erreichen
ist, vornehmen; eine Einführung zu Entwicklung unter Unix befindet sich im Abschnitt <link linkend="Programme">Programme</link>.
</para>
</listitem>
<listitem>
<para> Prüfen nach KDoc und Glimpse. Diese werden das Erzeugen einer neuen KDE-Bibliothek <indexterm remap="idx"><primary>KDE-Bibliothek</primary></indexterm>s Dokumentation und eines Suchindexes
in einem späteren Einstellungsschritt ermöglichen, wenn sie gefunden werden.
</para>
</listitem>
<listitem>
<para> Prüfen nach enscript, um sicherzustellen, das die Druckfunktionen verfügbar sind. Eines dieser Programme muß
installiert sein, um korrektes Drucken zu ermöglichen. Wenn keines installiert ist, können Sie dies jederzeit nachholen um das Drucken
zu ermöglichen, ohne das Setup erneut durchzuführen.
</para>
</listitem>
<listitem>
<para> Prüfen nach KDbg, KIconedit und KTranslator. Wir ermutigen Sie, diese Programme zu installieren, da sie gute Helfer bei der
Erstellung von vollständigen KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-Applikationen sind. Beachten Sie, das KDbg direkt zum Debuggen Ihres aktuellen Projekts
innerhalb von KDevelop verwendet wird; KIconedit wird benötigt, um Pixmaps, die in den Dateibäumen ausgewählt werden zu betrachten und
zu bearbeiten. Die Programme KDbg, KIconedit und KTranslator werden gleichzeitig im "Werkzeuge"-Menü der Menüleiste von KDevelop
eingerichtet. Andere Werkzeuge können später hinzugefügt werden, indem Sie "Werkzeuge..." im Einstellungen-Menü aufrufen.
</para>
</listitem>
<listitem>
<para> Zusammenfassung der geprüften Programme: Das Installationsprogramm listet diese Programme mit -gefunden oder -nicht gefunden
auf. Zusätzliche Hinweise signalisieren Ihnen, wenn ein benötigtes Programm erforderlich ist.
</para>
</listitem>
<listitem>
<para>Erkennung des Pfades zur Qt-Online Dokumentation: Dies prüft verschiedene Standardpfade in Ihrem System nach der Dokumentation
und setzt den Pfad automatisch. Wenn Ihre Qt-Dokumentation nicht gefunden wurde, weil sie nicht installiert ist oder sich an einem
anderen Ort befindet, werden Sie aufgefordert, entweder den korrekten Pfad manuell zu setzen oder fortzufahren. Bei Auswahl zum Setzen
des Pfades wird im Haupt-Installationsfenster eine Editierleiste mit einem Ordner-Knopf auf der rechten Seite angezeigt, mit dem Sie
den Pfad auswählen können. Normalerweise ist dies das qt/html Verzeichnis. Nach Beendigung können Sie mit der Auswahl von
"Weiter" mit der Installation fortfahren.
</para>
</listitem>
<listitem>
<para> Wenn KDoc gefunden wurde, werden Sie zur Erzeugung/Update Ihrer KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-Bibilotheks-Dokumentation aufgefordert. Dazu benötigen
Sie die KDE-Bibliotheken als Quellpaket. Linux-Benutzer, die KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> mit Ihrer Distribution installiert haben, sollten das zugehörige
kdelibs-Quellpaket auf Ihr System kopieren und entpacken; FreeBSd Benutzer sollten nach dem zugehörigen Distfile Package in der
Ports-Collection suchen.  Wenn dieses bei Ihnen nicht zutrifft, sollten Sie das Quellpaket durch Download von <ulink url="http://www.kde.org">http://www.kde.org</ulink> beziehen und auf Ihrem System entpacken. Wenn Sie das Dokumentations-Paket, das auf
<ulink url="http://developer.kde.org">http://developer.kde.org</ulink> bereitgestellt wird, benutzen möchten, beenden Sie die
Generierung mit "Abbrechen" und fahren Sie mit der Erstellung des Suchindexes fort. Nach Beendigung der Installation und dem Start von
KDevelop setzen Sie dann den Pfad zum extrahierten Dokumentationssatz im KDevelop Setup Dialog und erzeugen dann den Suchindex erneut.
Alle erforderlichen Einstellungen dazu finden Sie im Setup Dialog.

Der "KDE-Biblotheks-Dokumentation aktualisieren" Dialog ist voreingestellt, die Dokumentation im Verzeichnis
$(HOME)/.kde/share/apps/kdevelop/KDE-Documentation zu erstellen. Das einzige, was Sie tun müssen, ist den Pfad zum entpackten
Quellpaket der Bibliotheken mit dem Auswahl-Knopf im oberen Teil des Dialoges anzugeben und mit "OK" zu bestätigen. Als Beispiel sei
angenommen, das Sie die Bibliothek als kdelibs.tar.gz Paket von <ulink url="http://www.kde.org">http://www.kde.org</ulink> bezogen
und in Ihrem Home-Verzeichnis haben. Öffnen Sie eine Konsole oder Terminal und geben Sie dort "tar zxvf kdelibs.tar.gz" ein. Dies wird
das Quellpaket in ein Verzeichnis $HOME/kdelibs entpacken, das dann die Quelldateien jeder Bibliothek in einem Unterverzeichnis
enthält, z.B. wäre dies für kdecore /home/rnolden/kdelibs/kdecore. Der Pfad, den Sie im Aktualisierungs-Dialog angeben müssen, wäre
dann der zu allen Bibliotheken, hier also /home/rnolden/kdelibs.

Nachdem Sie "OK" gewählt haben, wird Ihnen im Installationsfenster angezeigt, das die Erstellung der Dokumentation durchgeführt wird.
Warten Sie dann bis zur nächsten Meldung.</para>

<para><emphasis remap="bf">Anmerkung:</emphasis> Auf Multi-User Systemen oder Systemen mit Disk-Quotas für Benutzeraccounts würde die Installation einer kompletten
HTML-Dokumentation separat für jeden Benutzer unnötig Plattenplatz verbrauchen. Fragen Sie in diesem Fall Ihren Systemadministrator,
KDevelop unter dem root-Account laufen zu lassen, um Schreibzugriff auf das Wurzelverzeichnis des Systems zu erhalten. Dann
installieren Sie die Dokumentation im KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>-Verzeichnis unter $KDEDIR/share/apps/kdevelop/KDE-Documentation. Der korrekte Pfad für
Einzelbenutzer kann dann später im KDevelop Setup Dialog über das "Einstellungen" Menü gesetzt werden.</para>
</listitem>
<listitem>
<para> Wenn die Systemprüfung das Programm Glimpse gefunden hat, wird Ihnen die Erstellung einer Suchdatenbank angeboten. Die
Suchdatenbank kann mit der Option erstellt werden, die KDE- und Qt-Dokumentation einzubeziehen (Standardeinstellung). Zusätzlich ist
die KDevelop Dokumentation inbegriffen und wird indiziert. Wenn Sie weitere Dokumentationen besitzen, die Sie ebenfalls indizieren
möchten, können Sie die Verzeichnisse auswählen und der Indexerstellung hinzufügen.
</para>
</listitem>
<listitem>
<para> Während der Erstellung des Suchindexes zeigt das Installationsfenster Ihnen eine Nachricht, daß dies ausgeführt wird. Warten Sie
danach bis zur Aufforderung zum nächsten Schritt.
</para>
</listitem>
<listitem>
<para> Wenn alle Installationsschritte erfolgreich durchgeführt wurden, zeigt Ihnen eine abschließende Dialogbox an, das KDevelop
gestartet wird, nachdem Sie "OK" wählen. Beachten Sie, das Sie zusätzliche Optionen wie automatisches Speichern im 
<link linkend="KDevelop-Setup">KDevelop Setup</link> Dialog, der über das "Einstellungen" Menü aufgerufen wird, einstellen können.</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf">Abbrechen:</emphasis> Zeigt einen Warnhinweis an, das der Installationsprozess abgebrochen wird. Diese Warnung erlaubt es Ihnen, nochmals
zur Installation zurückzukehren ("Zurück") oder KDevelop mit den Standardeinstellungen zu starten ("Fortfahren"). Bedenken Sie, das Sie
in diesem Fall alle Optionen mit Hilfe der Konfigurationsdialoge des "Einstellungen" Menüs selbst vornehmen müssen.</para>
</sect1>
</chapter>

<chapter id="programme">
<title>Programme</title>

<para>Nachdem KDevelop erfolgreich installiert und die allgemeinen Einstellungen vorgenommen sind, möchten Sie wahrscheinlich wissen, ob die
Entwicklungsumgebung hält, was sie verspricht. Dieses Kapitel gibt Ihnen einen Leitfaden, wie Programme allgemein mit den GNU Werkzeugen erzeugt werden
und welchen Teil speziell KDevelop in diesem Prozeß übernimmt.</para>

<sect1 id="der-compiler">
<title>Der Compiler</title>

<para>Der Compiler ist letztlich das Programm auf Ihrem System, das mindestens installiert sein muß um laufende Programme zu erzeugen; er ist
derjenige, der den Quellcode in Objektdateien übersetzt und das Programm erzeugt.</para>

<para>Normalerweise würden Sie so starten:
Öffnen Sie einen Editor Ihrer Wahl - benutzen Sie keine Textverarbeitung. Geben Sie etwa dieses ein, um den Quellcode Ihres ersten
Programmes zu schreiben:</para>

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

int main(){

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

}
</screen>
</para>

<para>Nun, alles, was das Programm tun wird, ist den String "Hello World" auf Ihrer Standardausgabe auszugeben. Aber dies ist nur der
Quellcode für ein zu erstellendes Programm, nicht das Programm selbst. Daher benötigen Sie einen Compiler, in diesem Fall ein
C++-Compiler wie etwa g++. Dann können Sie den Quellcode als Datei speichern, sagen wir als myprogram.cpp und den Compiler mit dem
Dateinamen aufrufen (auf einer Konsole):</para>

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

<para>Danach können wir unser Programm starten- geben Sie einfach <literal remap="tt">myprogram</literal> auf der Konsole ein, und das Programm gibt den String aus
und beendet sich.</para>
</sect1>

<sect1 id="make">
<title>Make und Makefiles</title>

<para>Ich habe jetzt alles, was ich brauche: einen Editor, einen Compiler und ich kann mein eigenes C++ Programm ausführen. Aber es ist nicht
ganz so einfach. Was passiert, wenn Sie mehr als eine Quellcodedatei haben? Und, müssen Sie dann die Quellen immer wieder übersetzen,
wenn Sie nur eine Datei geändert haben? Der Übersetzungsvorgang wird immer komplizierter und zeitraubender, weil Sie alle Kommandos
und Optionen selbst eintippen müssen. Deshalb können Sie sich ein sogenanntes "Makefile" schreiben. Man könnte es genausogut anders
nennen, außer dem Namen des Programms, das zu erstellen ist. Dann sollten Sie das Werkzeug <literal remap="tt">make</literal> oder <literal remap="tt">gmake</literal> installiert haben,
oder ein anderes Werkzeug, das den Übersetzungsvorgang überwacht. Fügen Sie alle Compileranweisungen in der speziellen
Erstellungssyntax in das Makefile ein und speichern Sie es; danach brauchen Sie nur noch <literal remap="tt">make</literal> oder <literal remap="tt">gmake</literal> auf der Konsole in
dem Verzeichnis einzugeben, wo sich das Makefile befindet; make übernimmt dann und bringt den Compiler dazu Ihr Programm zu erzeugen.
Das Make-Werkzeug hat noch viele weitere Vorteile und kann zu vielen Zwecken verwendet werden. Um eine Übersicht zu bekommen, öffnen
Sie eine Konsole und geben Sie ein:</para>

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

<para>oder suchen Sie nach "GNU Make" in der KDE-Hilfe unter "System GNU Info contents".</para>

<para>Dies erklärt Ihnen, warum ein Entwickler das Make-Werkzeug benötigt, um den Übersetzungsvorgang seiner Applikation zu vereinfachen. Nun,
das Schreiben der Makefiles ist jetzt nicht nur Handarbeit, Sie müssen sich auch noch in die Syntax und die Optionen hineinarbeiten.
Aber hier ist die gute Nachricht über KDevelop und das Make-Werkzeug: Sie müssen nur das Make-Kommando im <link linkend="KDevelop-Setup">KDevelop Setup</link>  Dialog setzen und Sie sind soweit. Alle Projekte, die von KDevelop erzeugt werden, benutzen das
Make-Kommando um die Zielapplikation zu erstellen, und Sie müssen nichts eingeben. Klicken Sie einfach auf den Make-Knopf in der
Werkzeugleiste oder wählen Sie die gewünschte Funktion aus dem "Erstellen" Menü.</para>

<para>Die Werkzeugleiste und das "Erstellen"-Menü bieten die meist benutzten Funktionen, um make die Arbeit erledigen zu lassen:</para>

<para><itemizedlist>
<listitem>
<para> Datei compilieren: ist nur aktiv, wenn Sie an einer Quellcode-Datei arbeiten. Diese Funktion ruft make mit dem korrekten
Kommando auf, nur die aktuelle Quelldatei zu übersetzen.</para>
</listitem>
<listitem>
<para> Erstellen: ruft make auf und erzeugt das Zielobjekt (die Applikation)</para>
</listitem>
<listitem>
<para> Alles neu erstellen: löscht alle schon übersetzten Dateien und erstellt das Projekt neu</para>
</listitem>
<listitem>
<para> Säubern/alles neu erstellen: löscht alle übersetzten Dateien inklusive der Konfigurationsdateien des Projekts und erstellt alles
neu</para>
</listitem>
<listitem>
<para> Stoppen: beendet den aktuellen Prozeß</para>
</listitem>
<listitem>
<para> Ausführen: erstellt die Zieldatei und führt das Programm aus</para>
</listitem>
<listitem>
<para> Mit Argumenten ausführen: erstellt die Zieldatei und gibt Ihnen die Möglichkeit, dem Programm vor seiner Ausführung
Kommandozeilenoptionen zu übergeben.</para>
</listitem>
<listitem>
<para> Debuggen: erstellt die Zieldatei und startet KDbg mit dem Programm, um es zu debuggen</para>
</listitem>
</itemizedlist>
</para>

<para>Aber dies ist nicht das einzige, wo KDevelop mit make zusammenarbeitet- bei KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Applikationen sind einige Dinge speziell auf die
Unterstützung des Entwicklers abgestimmt wie die Erzeugung der Messages-Datei für die Internationalisierung Ihres Projekts. Diese
Funktionen sind ebenfalls sorgfältig integriert, so daß Sie sich darüber nicht mehr den Kopf zerbrechen müssen.</para>

<para>Bis jetzt wissen Sie schon einiges über Quelldateien, den Compiler und warum make benötigt wird. Im nächsten Abschnitt werden wir
besprechen, warum Projekte, die mit KDevelop erstellt wurden, automatisch durch Verwendung eines <literal remap="tt">configure</literal>-Scripts auf den meisten
Unix-Plattformen übersetzt werden können.</para>
</sect1>

<sect1 id="configure">
<title>Configure</title>

<para>Der Titel dieses Abschnitts- Configure, bedeutend soviel wie Konfiguriere - läßt Sie wahrscheinlich fragen: Konfiguriere ? Was muß
konfiguriert werden ? Oder wer ?</para>

<para>Nun, gehen wir davon aus, daß Sie ein Programm geschrieben haben inklusive einem Makefile. Dann wollen Sie es verbreiten, aber die
compilierte Binärdatei läuft nur auf Ihrem System und auf solchen, die mit Ihrem kompatibel sind. Um andere Plattformen zu unterstützen
wie die verschiedenen Unix-Systeme oder Maschinen wie Alpha's oder RISC's müssen Sie ihr Programm neu übersetzen. Der einfachste Weg
wäre, das Quellpaket auf die Zielmaschine zu kopieren und <literal remap="tt">make</literal> nochmals laufen zu lassen. Aber was wäre, wenn die Zielmaschine
einen anderen Compiler benutzt oder in anderer Weise ein Problem erzeugt, die ein Erstellen des Programms verhindert ? Nicht zu
erwähnen die schwierigeren Dinge wie der Installationspfad für Ihr Programm und Dokumentation- z.B. kann KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> auf einer Maschine
unter <literal remap="tt"></literal>opt/kde/ installiert sein, auf einer anderen aber unter <literal remap="tt">usr</literal>local/kde/. In diesem Fall müßten Sie das Makefile immer
bearbeiten, um eine korrekte Übersetzung und Installation Ihres Produkts sicherzustellen.</para>

<para>Glücklicherweise haben die GNU-Werkzeuge noch mehr zu bieten als das mächtige <literal remap="tt">make</literal>- die allgemein genutzten Pakete automake und
autoconf. Es klingt gut, etwas mit "auto"- es scheint als ob etwas beim Applikations-Design einfach und schnell gemacht werden kann,
was auch genau den Punkt trifft.</para>

<para>Der Zweck von <literal remap="tt">automake</literal> ist generell, die sogenannten <literal remap="tt">Makefile.in</literal>'s aus der Datei <literal remap="tt">Makefile.am</literal> zu erstellen, die Sie für
Ihr Projekt anstatt einer "richtigen" Makefile schreiben müssen. Diese Makefile.am besteht aus Makros, die leicht zu verstehen
ist Komplexität reduziert, die make anbietet, so daß eine Makefile.am fehlerloser und schneller geschrieben werden kann als das letztliche
Makefile.</para>

<para>Aber wer erzeugt mir dann letztlich mein Makefile ?  Nun, hier kommt autoconf. Autoconf benötigt verschiedene Makrodateien für das
Projekt. Diese sind die Makefile.in's, die automake erzeugt hat und eine Datei namesn <literal remap="tt">configure.in</literal>, die auch aus Makros besteht.
Hierbei beinhalten die Makefile.am und .in's die Makros die dafür verantwortlich sind, wie das Ziel erstellt wird in Bezug auf die
Quellen, die übersetzt werden müssen, welche Dateien zum Paket gehören und welchen Namen die letzliche Binärdatei oder Bibliothek nach
einem Erstellungsvorgang hat. <literal remap="tt">configure.in</literal> andererseits beinhaltet die Makros, nach denen das letztliche configure-Skript das System
prüft, auf denen configure ausgeführt wird. Dies können z.B. das Compiler-Kommando, benötigte Bibliotheken zu denen die letzliche
Binärdatei gelinkt wird und include-Dateien, die das Projekt benötigt, sein.</para>

<para>Wenn Sie z.B. eine KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Applikation schreiben und nach der Fertigstellung Ihr Programm Benutzern zur Verfügung stellen möchten, muß
jeder Benutzer die Binärdatei selbst compilieren. Dann würden Sie eine <literal remap="tt">configure.in</literal> Datei, die die Makros für eine KDE-kompatible
Applikation enthält. Diese Makros werden dann expandiert zu einer Systemprüfung, ob die Qt-Bibliothek installiert ist, dem Pfad der
Qt-Headerdateien, den KDE Bibliotheken und Headern etc.</para>

<para><emphasis remap="bf">Zusammenfassung:</emphasis> Um eine GNU-gemäße Applikation zu erstellen, die auf verschiedene Unix-Betriebssysteme und andere Maschinen
als Ihre eigene portabel sein soll, müssen Sie folgendes ausführen:</para>

<para><orderedlist><listitem>
<para> die Quellen Ihres Projekts schreiben</para>
</listitem>
<listitem>
<para> eine Makefile.am für jedes Unterverzeichnis erstellen, inklusive dem Hauptverzeichnis Ihres Projekts</para>
</listitem>
<listitem>
<para> eine configure.in Datei im Hauptverzeichnis erstellen, das die Makros für die Systemanforderungen enthält</para>
</listitem>
<listitem>
<para> automake aufrufen</para>
</listitem>
<listitem>
<para> autoconf aufrufen</para>
</listitem>
</orderedlist>
</para>

<para>Dann ist die Hauptarbeit getan. Automake erzeugt die Makefile.in's, autoconf läuft über die <literal remap="tt">configure.in</literal> und erzeugt
das ausführbare Shellscript <literal remap="tt">configure</literal>. Alles, was Sie dann zu tun haben, ist die Ausführung mit <literal remap="tt">./configure</literal>, und das
Skript wird die Prüfungen durchführen. Schließlich werden die Makefiles erzeugt, die die Ausführung von make (oder gmake) erlauben, um
das Projekt zu erstellen.</para>

<para>Dies alles scheint ein bißchen viel zu sein, nur um eine kleine Applikation zu schreiben und auch viel zu lernen, speziell die
korrekten Makros. Aber allein der Umstand, daß Sie damit einen Kompiliervorgang auf fast allen Unix-Systemen erreichen, macht die
Arbeit früher oder später wett. Schließlich müssen Sie diese Arbeit auch nur einmal für das Projekt machen und im Fall, daß Ihre
Projektdateien anwachsen, brauchen Sie ja nur die Dateinamen den Makros hinzufügen.</para>

<para>Nun, inwiefern unterstützt KDevelop diese Art der Applikationserstellung und wie kompliziert wird es für den Programmierer?
Die gute Nachricht für Sie ist: Sie brauchen noch nicht eimal etwas über Makros und Skripte zu wissen. Alle Details sind hinter einer
einfach zu bedienenden graphischen Benutzeroberfläche versteckt, die die Arbeit für Sie übernimmt. Eine Applikation wird mit den
GNU-Tools deshalb auf sehr benutzerfreundliche Art erstellt:</para>

<para>Erzeugen Sie Ihre Applikation einfach mit dem KAppWizard nach Wahl der Bedürfnisse Ihrer Applikation- es mag ein reines C++
Terminalprogramm sein oder eine Art GUI Programm, das die Qt <indexterm remap="idx"><primary>Qt</primary></indexterm> oder die Qt/KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Bibliothek benutzt. Die ganze Arbeit wird
für Sie erledigt und Ihr Projekt enthält schon die Makefiles, die durch eine automatische Ausführung der GNU-Tools und des
configure-Skripts erstellt wurden.</para>

<para>Das wäre es schon- Sie brauchen nur die Quellen Ihres Projekts zu erweitern, sei es durch Hinzufügen von Klassen, Dialogen,
Übersetzungen oder Dokumentation, was auch vollständig automatisiert abläuft. Konzentrieren Sie sich einfach auf die wirkliche Arbeit
eines Entwicklers, nämlich Ihrer Applikation Funktionalität zu verleihen. In den meisten Fällen werden Sie wahrscheinlich nie mit
Makefiles in Berührung kommen, wenn Sie KDevelop benutzen.</para>
</sect1>

<sect1 id="debuggen">
<title>Debuggen</title>

<para>Der folgende Abschnitt betrachtet einen Terminus, der unter Entwicklern weit verbreitet ist: Debuggen. Das bedeutet, daß, obwohl Ihr
Compiler die letzliche Applikation erzeugt, das Programm aber nicht läuft oder während der Ausführung abstürzt wegen eines sogenannten
"Bugs" (Käfer) im Code. Ein Programmfehler, der mit dem Namen dieser Insekten beschrieben wird, stammt aus der Geschichte des
Computers; einer der ersten Fehler, die eine Maschine zum Absturz brachte, war keine offensichtliche Fehlfunktion- Käfer waren in den
Computer eingedrungen und waren dafür verantwortlich. Daher beschreibt man einen Fehler, der auf den ersten Blick nicht offensichtlich
ist, als einen "Bug", daher bedeutet "Debuggen", die Käfer zu entfernen, wo sie nicht hingehören. Nun, Sie brauchen sie nicht wirklich
zu jagen; vorausgesetzt daß die heutigen Computer konzipiert sind, diese durch einen Schutz fernzuhalten. Sie müssen innerhalb des
Codes gefunden werden, wenn sie die Ausführung eines Programms mit der Nachricht "Segmentation fault" (Speicherverletzung) beenden.
GNU bietet dazu ein weiteres Werkzeug, <literal remap="tt">gdb</literal>, den GNU Debugger. Dieses Terminalprogramm erlaubt es, die internen Werte einer
Applikation und die Ausführung durch setzen von Haltepunkten im Code zu beobachten. Gdb stoppt die Ausführung jedes mal, wenn das
Programm an einen Haltepunkt kommt. Aber wie die meisten Werkzeuge wird auch der debugger von einem anderen Programm gesteuert, das ein
Frontend dazu bietet und es erlaubt, die Werte einfach zu beobachten und Haltepunkte im Code zu setzen.</para>

<para>Zu diesem Zweck wird die Applikation Ihres Projekts standardmäßig mit der Compileroption zum Debuggen erzeugt und speichert daher
zusätzliche Daten in der Binärdatei, um die Werte und Zeilen im Code zu lokalisieren. Als Frontend zu gdb benutzt KDevelop das Programm
KDbg, den KDebugger. Um Ihr Programm zu debuggen, müssen Sie nur "Debuggen" im "Erstellen" Menü auswählen oder den entsprechenden
Werkzeugleistenknopf betätigen, der durch ein Rad mit Brille dargestellt wird und signalisiert, das Sie die Ausführung beobachten
wollen.</para>

<para>KDevelop öffnet dann das Werkzeuge-Fenster und startet Ihr Programm mit KDbg. Die KDbg Oberfläche erscheint dann innerhalb des
Werkzeuge-Fensters und erlaubt die Benutzung genauso als ob Sie den Debugger außerhalb von KDevelop gestartet hätten.</para>

<para>Ganz allgemein zeigen die obigen Schritte, das ein Entwickler zum Schreiben seines eigenen Programms verschiedene Stufen durchlaufen
muß, um ein Projekt zu beginnen. Auch erklärt dies, welchen Teil KDevelop dabei übernimmt und wie die Entwicklungsumgebung die Idee eines einfachen Wegs
zur Unix-Programmierung unterstützt. Um weitere Informationen über die GNU Tools zu erhalten, sollten Sie die zugehörige Dokumentation
lesen, die Sie allgemein über das <literal remap="tt">man</literal> Kommando oder über "System GNU Info contents" in der KDE Hilfe nachschlagen können.</para>
</sect1>
</chapter>

<chapter id="entwicklung-mit-kdevelop">
<title>Entwicklung mit KDevelop</title>

<para>Dieses Kapitel wird Ihnen eine allgemeine Übersicht geben, wie Sie KDevelop und den internen Dialogeditor benutzen können, um eigene
Applikationen zu entwickeln. Dabei werden alle Werkzeuge nach ihrer Verwendung im Entwicklungsprozeß beschrieben. Wenn Sie Anfänger im
Bereich C++/GUI Projektierung und Programmierung sind, sollten Sie auch <ulink url="programming.html">Das KDevelop Programmierhandbuch</ulink> lesen, welches einige Grundlagen in Bezug auf Programmdesign behandelt und detailierter auf die Benutzung von
KDevelop mit Hilfe von Beispielprojekten, denen Sie Schritt für Schritt folgen können, um sich mit der Art und Weise vertraut zu
machen, wie Applikationen mit KDevelop erzeugt werden. Auch sollten Sie das Kapitel <link linkend="Programme">Programme</link> gelesen
haben, um ein generelles Verständnis dafür zu bekommen, warum Unix-Applikationen gebrauch von den gestellten Entwicklungswerkzeugen
machen sollten; dies wird Ihnen die Sache einfacher machen, wenn Sie auf Begriffe wie Makefiles etc. treffen.</para>

<sect1 id="was-sind-kdevelop-projekte">
<title>Was sind KDevelop Projekte ?</title>

<para>Projekte, die mit KDevelop erstellt wurden, machen es für Entwickler sehr einfach, die GNU Standard Entwicklungswerkzeuge zu benutzen.
Im Gegensatz zur Selbsterzeugung von Makefiles, die wegen der Komplexität von Projekten sowieso geschrieben werden müssen, bieten diese
nicht nur einen besseren Weg der Makefilegenerierung sondern auch einen sicheren Weg zur schnellen Anpassung auf verschiedene Systeme
durch autoconf-generierte <literal remap="tt">configure</literal> Skripte.</para>

<para>Die Distribution Ihrer Applikationen verlangt vom Endbenutzer nicht mehr als ein installierter C++ Compiler und die
Entwicklungs-Bibliotheken, was meist der Fall ist; aber Sie können genausogut Binär-Pakete Ihrer Applikation vertreiben. In jedem Fall
braucht der Endbenutzer KDevelop nicht installiert zu haben. Wenn Sie die Quellen jedoch weitergeben, raten wir dazu, die
KDevelop-Projektdatei mitzuliefern. Bei Projekten, an denen mehrere Entwickler, vielleicht an den verschiedensten Orten, arbeiten,
sollte dies generell beachtet werden, um die Konsistenz der Makefiles zu sichern. Speziell bei mehrsprachigen Applikationen werden die
Übersetzer nicht mit dem Quellcode arbeiten außer in Fällen, die eine Korrektur benötigen, um die Internationalisierung zu
gewährleisten. In jedem Fall wird man dankbar darüber sein, da KDevelop deren Arbeit auf ein Minimum reduziert, indem einfach die
gewünschte Sprache hinzugefügt wird und nur die Übersetzung vorgenommen werden muß.</para>

<para>Wenn Sie KDevelop für Ihre eigenen Projekte benutzen, beginnen Sie am besten mit der Erzeugung einer neuen Applikation mit dem
KAppWizard. Dort können Sie auch den Projekttyp nach den Bedürfnissen Ihres Programms einstellen. Dann fangen Sie mit der Entwicklung
der Benutzeroberfläche an, indem Sie Widgets, die schon fertig in den Bibliotheken enthalten sind, hinzufügen und nur von Ihrem
Programm aufgerufen werden müssen, oder durch Eigenkreationen, die mit dem Dialogeditor erstellt werden können. Danach folgt die
Erweiterung der Benutzerschnittstelle durch Änderung oder Erweiterung der Teile, die schon von KDevelop gestellt werden wie die
Statuszeile, Menüleiste oder Werkzeugleiste. Da die Ressourcen in einer Resource-Datei gesammelt sind, können Sie dies einfach durch
hinzufügen von Werten zu den Existierenden gestalten; die Vorgaben können gleichzeitig als eine Richtlinie zur Erzeugung Ihrer
spezifischen genommen werden. Nach der Implementierung der Funktionalität in entsprechenden Methoden die entweder durch den
Dialogeditor erzeugt wurden oder schon Code für Standard-Aktionen enthalten, sollten Sie das Benutzerhandbuch erweitern, indem Sie die
zur Verfügung gestellte SGML Index-Datei auf die Beschreibung Ihrer Applikation anpassen. Der letzte Schritt wäre die Erzeugung der
Übersetzungs-Dateien und die Distribution Ihres Projekts an Übersetzer, die den letzten Schritt zur Internationalisierung übernehmen.</para>

<para>Aber auch für nicht-GUI Programmierer bietet die IDe einen einfachen Weg, neue Projekte zu erzeugen; der Editor und Klassenbrowser in
Verbindung mit dem mächtigen Projektmanagement von KDevelop wird die Entwicklungszeit auf das Minimum reduzieren, das zur
Implementierung von Funktionalität benötigt wird.</para>
</sect1>

<sect1 id="kurzbeschreibung-der-werkzeuge-von-kdevelop">
<title>Kurzbeschreibung der Werkzeuge von KDevelop</title>

<para>Mit KDevelop haben Sie ein Paket gewählt, das, in Verbindung mit der Benutzung ander Werkzeuge, Ihnen eine perfekte und flexible
Umgebung zur objektorientierten Applikationsentwickung unter Unix-Systemen bietet. Ganz allgemein besteht KDevelop aus der
Programmierumgebung und dem Dialogeditor; außerdem sind alle Programme, die zum Design von Applikationen hilfreich sein können, auf die
ein oder andere Weise eingebettet.</para>

<sect2 id="programmierumgebung-und-dialogeditor">
<title>Programmierumgebung und Dialogeditor</title>

<sect3 id="die-programmierumgebung">
<title>Die Programmierumgebung</title>

<para>Die Programmierumgebung ist die Benutzerschnittstelle, die KDevelop zur Erzeugung und Verwaltung von Projekten zur Verfügung stellt und
die implizit viele andere Werkzeuge benutzt, indem sie die Verwendung für den Benutzer vereinfacht. Der integrierte Editor und
Hilfebrowser als auch der Klassenbrowser reduzieren die Menge an Arbeit, die ein Entwicklungsprozeß dem Programmierer abnötigt. Die
einfache Benutzung macht das schreiben von Applikationen für Unix eine Freude an sich und wird sich in kürzeren Release-Zyklen und
besseren Entwickungen niederschlagen. Von hier aus beherrschen Sie Ihr Projekt in all seinen Details, halten die Übersicht über Ihre
Klassen und macht die Verwendung zusätzlicher Konsolen überflüssig, genauso wie die Intergrierung aller Benutzeroberflächen darin
resultiert, das Sie nur mit einem Fenster unter X arbeiten müssen und nicht gleichzeitig mehrere auf Ihrem Desktop im Auge behalten
müssen.</para>
</sect3>

<sect3 id="der-dialogeditor">
<title>Der Dialogeditor</title>

<para>Der in KDevelop integrierte Dialogeditor bietet einen einfachen Weg, Benutzerschnittstellen unter Verwendung der Qt <indexterm remap="idx"><primary>Qt</primary></indexterm> und
KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Bibliotheken zu erstellen und deren direkter Transfer in C++ Code, der dem Projekt automatisch hinzugefügt wird. Da der
Dialogeditor vollständig in die gewohnte Benutzeroberfläche eingebettet ist, stehen Ihnen die gleichen Befehle wie im Programmiermodus
zu Verfügung. Dies erlaubt z.B. die Konstruktion eines Dialogs, die Generierung des Ausgabecodes und des sofortigen Tests im Programm
durch die Verfügbarkeit der Make-Kommandos und Sie können gleichzeitig die Compilerausgabe kontrollieren ohne in den Programmiermodus
zu wechseln. Eine Detailliertere Beschreibung finden Sie im Kapitel <link linkend="Der-Dialogeditor">Der Dialogeditor</link>.</para>
</sect3>
</sect2>

<sect2 id="kappwizard-und-die-klassenwerkzeuge">
<title>KAppWizard und die Klassenwerkzeuge</title>

<para>Der KAppWizard und die Klassenwerkzeuge, die zur Projektgenerierung und automatischer Code-Erweiterung zur Verfügung stehen, sind dazu
gedacht, die Erzeugung von Applikationen so einfach und sicher wie möglich zu gestalten und bieten gerade Anfängern einen guten Start
in die Qt <indexterm remap="idx"><primary>Qt</primary></indexterm>/KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Programmierung und die Details des GUI Designs, da Sie sehr schnell zum Ziel gelangen.</para>

<sect3 id="kappwizard">
<title>KAppWizard</title>

<para>KAppWizard ist dazu gedacht, vollständige Projekte zu erzeugen, die sofort lauffähig sind durch die Verwendung von GNU
Standardwerkzeugen und, bei GUI Programmen, die KDE und Qt Bibliotheken nutzen. Durch Angabe der Mindestinformationen sind
Programmierer in der Lage, an neuen Projekten innerhalb von Sekunden zu arbeiten. Der Aufruf des KAppWizard ist immer der erste Schritt
zur Erstellung von neuen Applikationen mit KDevelop.</para>

<para>KAppWizard bietet Ihnen ein sogenanntes Applikations-Skelett mit allen benötigten C++ Quellcodedateien eines lauffähigen Programms.
Nach der Angabe des Projektnamens und der Einstellung der benötigten Optionen wird Ihr neues Projekt generiert und Sie bekommen eine
vollständige Applikation, die schon einen Menge an Funktionalität beinhaltet (für KDE und Qt Projekte), ohne das Sie selbst eine
einzige Zeile C++ Code eingeben müssen. Bei Nutzung der maximal gebotenen Einstellungen, die der Programmgenerator zur Verfügung
stellt, beihaltet Ihre Applikation bereits:</para>

<para><itemizedlist>
<listitem>
<para>eine SDI-Schnittstelle (für Applikationen mit einem Dokument je Programmansicht), basierend auf dem Document-View-Controller
Modell,</para>
</listitem>
<listitem>
<para>Menüs und Dialoge zum Öffnen, Speichern und Drucken von Dateien,</para>
</listitem>
<listitem>
<para>eine vollständig funktionsfähige Werkzeugleiste und Statuszeile,</para>
</listitem>
<listitem>
<para>ein Hilfesystem, das ein SGML-basierendes Benutzerhandbuch und Statuszeilenhilfe enthält,</para>
</listitem>
<listitem>
<para>eine vollständig HTML-basierte API (Application Programming Interface, Programmmierschnittstelle) Dokumentation zum aktuellen
Stand des Projekts</para>
</listitem>
<listitem>
<para>eine Installationsroutine durch make</para>
</listitem>
</itemizedlist>
</para>

<para>Der KAppWizard wird über das Projekt-Menü, Eintrag "Neu..." aufgerufen.</para>
</sect3>

<sect3 id="klassenwerkzeuge">
<title>Klassenwerkzeuge</title>

<para>Die Bezeichnung "Klassenwerkzeuge" beschreibt eine Vielfalt an Funktionen, die dem Entwickler zur Verfügung stehen, an einem Projekt
nicht nur mit einer Objektorientierten Sprache zu arbeiten, sondern auch die Quellen in einer objektorientierten Weise zu benutzen. Das
Arbeiten mit Klassen anstatt der Suche nach Dateien bietet einen sehr flexiblen Weg, ein Projekt zu erweitern und läßt den Benutzer
sich auf die Objekte des Projekts konzentrieren. Die Werkzeuge, die KDevelop anbietet sind ein Klassengenerator und ein Klassenbrowser,
wobei jeder eine Menge an automatisierter Funktionalität bereitstellt.</para>

<sect4 id="erzeugen-einer-neuen-klasse-mit-dem-klasseng">
<title>Erzeugen einer neuen Klasse mit dem Klassengenerator</title>

<para>Nach der Generierung eines Projekts mit dem KAppWizard ist ihre Arbeit als Entwickler unter anderem, einen Satz von Klassen, die dem
Design der Applikation entsprechen, zu erstellen. Der typische Prozeß ohne die Verwendung von KDevelop wäre, eine neue Header und
Quellcodedatei anzulegen, sie zu den entsprehenden Makefile.am's hinzuzufügen und die Klassendeklaration und Implementation zu
schreiben.  Um diesen ganzen Vorgang zu vereinfachen, geben Sie dem Klassengenerator einfach den Namen der neuen Klasse, die beerbte
Klasse, Vererbungsmodus und zusätzliche Informationen an wie die Klassendokumentation nach ihrer Verwendung im Projekt. Zusätzlich
können Sie die vorgeschlagenen Dateinamen ändern, die der Generator für Sie einfügt und einstellen, ob die Klasse den Qt-Signal/Slot
Mechanismus verwenden soll.</para>

<para>Der Rest der Arbeit wird dann automatisch ausgeführt- Sie brauchen sich nicht mehr um die Makefile.am und die Klasse zu kümmern. Der
erneute Aufruf von "Erstellen" bezieht dann automatisch die neue Klasse in den Übersetzungsvorgang mit ein. Da der Klassenbrowser sich
nach dem Hinzufügen einer Klasse selbst aktualisiert, steht Ihnen der Zugang zur Implemetation und Deklaration sofort zur Verfügung und
Sie können direkt mit der Erweiterung der Klasse beginnen. Den Klassengenerator rufen Sie über das Projekt-Menü, Eintrag "Neue Klasse"
auf.</para>
</sect4>

<sect4 id="der-klassenbrowser">
<title>Der Klassenbrowser</title>

<para>Der Klassenbrowser zeigt alle Typen von Objekten und Funktionen Ihres Programms in einem Baum links des Editorfensters an. Ein
Klassenanalysator scannt alle Dateien nach Methoden und Klassen und macht sie durch graphische Symbole zugänglich. Über diesen bieten
Ihnen Kontextmenüs spezialisiertere Funktionalität an, mit den Quellen über Klassen und Funktionen zu arbeiten.</para>

<para>Die Auswahl einer Klasse öffnet standardmäßig die Datei, die die Deklaration enthält; über Methoden und Funktionen wird Ihnen die
Implementierung angezeigt. Eine vollständige Beschreibung finden Sie unter dem Kapitel <link linkend="Der-Klassenbrowser">Der Klassenbrowser</link></para>
</sect4>
</sect3>
</sect2>
</sect1>

<sect1 id="der-entwicklungsproze">
<title>Der Entwicklungsprozeß</title>

<para>Die Entwicklung einer neuen Applikation mit KDevelop kann generell in zwei Hauptschritte unterteilt werden: Erst müssen Sie ein
Programm-Skelett mit KAppWizard erstellen, dann besteht der "Rest" der Entwicklung durch die Verwendung der Funktionen von KDevelop,
die nur Ihre Fähigkeiten als Programmierer verlangen. Um den Entwicklungsprozeß zu beschreiben, gehen wir hier davon aus, das Sie eine
Qt/KDE Applikation erzeugen möchten, was implizit die Benutzung der meisten Funktionen von KDevelop bei der Bearbeitung dieses
Projekttyps bietet; somit haben Sie einen generellen Überblick.</para>

<sect2 id="erzeugen-eines-programmgersts">
<title>Erzeugen eines Programmgerüsts</title>

<para>Um eine neue Applikation zu erstellen, werden Sie normalerweise KAppWizard aufrufen, den Projektnamen eingeben und das Programm
generieren. Damit erzeugt der Wizard automatisch eine Projektdatei für die Applikation und schreib KDevelop-Bereiche in die
Makefile.am's, die später zur Erweiterung Ihres Programms dienen. Die Projektdatei ist diejenige, die geladen wird, wenn Sie zu einem
späteren Zeitpunkt am Projekt arbeiten wollen.</para>

<para>Sie rufen KAppWizard über das "Projekt"-Menü, Eintrag "Neu..." auf. Nachdem der Wizard erscheint, geben Sie auf der ersten Seite den
Projekttyp an. Über die Schaltfläche "Weiter" kommen Sie zur nächsten Seite, wo Sie den Projektnamen, Version, Verzeichnis und
persönliche Informationen angeben. Seite 3 und 4 erlauben die Bearbeitung von Dateiköpfen für Header- und Quellcodedateien, die
automatisch eingefügt werden. Wenn Sie schon über Dateiköpfe verfügen, die Sie benutzen möchten, können Sie die Datei, die diesen
enthält, angeben. Die letzte Seite enthält das Ausgabefenster und die Fehlermeldungen. Nach Auswahl der Schaltfläche "Erzeugen" wird
die Applikation generiert und die ausgeführten Befehle erscheinen im Ausgabefenster. Sobald dort READY erscheint, können Sie über
die Schaltfläche "Beenden" den Wizard verlassen, um zur Programmierumgebung zurückzukehren. Um die Binärdatei zu erstellen, wählen Sie
"Erstellen" aus dem "Bauen"-Menü oder betätigen Sie die entsprechende Schaltfläche in der Werkzeugleiste. Sie können auch schon die
vorhandenen Funktionen des Programms testen, indem Sie "Ausführen" aus dem "Bauen" Menü wählen.</para>
</sect2>

<sect2 id="entwicklung-einer-applikation">
<title>Entwicklung einer Applikation</title>

<para>Dieser Abschnitt beschreibt die Entwicklungsphase von Applikationen mit KDevelop und dem Dialogeditor- und aller Arbeiten, die
innerhalb der Entwicklungsumgebung erledigt werden können.</para>

<para>Die Entwicklungsschritte sind ganz allgemein die Bearbeitung der Quellcode-Dateien, die Übersetzung des Projekts gefolgt vom Linker,
der alle Objektdateien zur letztlichen Binärdatei bindet. Dann müssen Fehler lokalisiert werden die entweder die Übersetzung oder den
Linkervorgang verhinderten oder semantische Fehler sind, die nur in einer Debug-Sitzung gefunden werden können. Schließlich muß die
Dokumentation erweitert und Übersetzungen hinzugefügt werden. Da aber alle diese Schritte in unterschiedlicher Reihenfolge durchgeführt
werden können, ist es nicht so einfach, einen allgemeinen Weg zur Entwicklung Ihrer eigenen Applikation zu beschreiben. Typischerweise
wird die übliche Prozedur die sein, zuerst alle sichtbaren Teile des Projekts zu erstellen wie die Hauptansicht und die Konstruktion
von Dialogen, um Einstellungen vornehmen zu können; dann den Quellcode zu generieren und alle nötigen Verbindungen zu implementieren,
die noch fehlen, wie etwa Änderungen der Menüleiste und der Werkzeugleisten; hinzufügen der Statuszeilen-Hilfe für neue Menüeinträge
und neue Memberfunktionen zu implementieren, die die Dialoge aufrufen. Dann Übersetzen Sie die Applikation und testen die Funktionen,
korrigieren Fehler und testen erneut. Die folgenden Abschnitte beschreiben, wie dies aussehen könnte; für Ihre eigene Applikation
können Sie aber auch einen anderen Weg wählen- KDevelop läßt Ihnen genug Flexibilität zu entscheiden, was Sie wann tun möchten.</para>

<sect3 id="benutzerschnittstellen">
<title>Benutzerschnittstellen</title>

<para>Die Benutzerschnittstelle einer Applikation ist letztlich das, was der Benutzer sieht und durch die er mit dem Programm interagiert.
Daher besitzt ein Programm ganz generell eine Menüleiste, Werkzeugleisten und eine Statuszeile ebenso wie eine Hauptansicht, die z.B.
ein Texteingabefenster für einen Editor sein kann. Applikationen, die mit KAppWizard generiert werden, enthalten schon eine komplexe
Funktionalität an graphischen Schnittstellen- Die Rahmenanwendung übernimmt Standardelemente wie Leisten und Schaltflächen. Wenn Sie
Ihre Applikation entwickeln, werden Sie die gegebene Struktur erweitern, um dem Programm die Interaktionsmöglichkeiten zu geben, die
Sie dem Benutzer zur Verfügung stellen wollen. Ein Teil dieser Arbeit ist das Design von Dialogen z.B. um Werte zu verändern wie die
Pinselstärke in einem Malprogramm. Dies können Sie sehr einfach mit dem Dialogeditor innerhalb von KDevelop erledigen. Nun, wie erzeugt
man diese gutaussehenden Dialoge ?  Da die Qt Bibliothek ein GUI-Toolkit ist, stellt sie einen grundlegenden Satz an sogenannten
"Widgets" zur Verfügung wie Aufschriften, die nur Text anzeigen, Zeileneingabefelder um Text einzugeben und Schaltflächen zur
Navigation und Befehlsauswahl. Neben diesen "niederen" Teilen von Benutzerschnittstellen werden auch Standarddialoge bereitgestellt,
die sofort zu benutzen sind wie etwa ein Druckdialog. Die KDE-Bibliotheken <indexterm remap="idx"><primary>KDE-Bibliotheken</primary></indexterm> schließlich basieren auf der Qt-Bibliothek und
enthalten Ersetzungen für spezielle Dialoge genauso wie zusätzliche Widgets, die in Ihrer Applikation verwendet werden können. Wenn Sie
also damit beginnen, das Verhalten Ihrer Applikation gegenüber dem Benutzer zu entwerfen, sollten Sie sich zuerst mit den Widgets
vertraut machen, die von Qt <indexterm remap="idx"><primary>Qt</primary></indexterm> und KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> bereitgestellt werden. Die Online-Dokumentation von Qt bietet Screenshots für die
meisten an, deshalb sollten Sie zuerst dort nachsehen. Weiterhin raten wir, das Sie einen näheren Blick auf die KDE-UI Bibliothek
werfen, die weitere Widgets enthält. Bibliotheken wie die KHTMLW Bibliothek enthalten sehr spezialisierte Widgets, die von vielen
Programmen benutzt werden. Es vereinfacht das Applikationsdesign wie die vordefinierten Dialoge von Qt. Für Ihre eigenen Dialoge
benötigen Sie meist die einfachen widgets. Ein Dialog besteht grob gesagt aus einer Kollektion verschiedener Widgets, die in ihrer
Kombination die Schnittstelle bilden und sind technisch gesehen aus C++ Code, der in einer Klasse, die von QWidget oder einer
spezialisierteren Dialogklasse, die von QWidget abgeleitet ist, implementiert wird. Das Programm, das das Widget benutzt braucht
deshalb nur ein Objekt der Klasse- das ist fast alles, was Sie zur Benutzung von Dialogen oder Ansichten verstehen müssen.</para>

<para>Der Dialogeditor von KDevelop bietet einen schönen und angenehmen Weg, Dialoge und Benutzerschnittstellen visuell zu konstruieren,
anstatt die Dialoge über puren C++ Code zu kombinieren- dies ist der harte Weg, Schnittstellen zu erstellen. Wechseln Sie zum
Dialogeditor durch Auswahl des entsprechenden Eintrags im "Ansicht"-Menü (oder durch die Werkzeugleisten-Schaltfläche). Sie können
sehen, das KDevelop sein Aussehen verändert, das jedoch die Menüleiste und die Werkzeugleiste sehr ähnlich sind. Dies macht es sehr
einfach, zwischen den Arbeitsmodi zu wechseln und Sie werden sich nach einer gewissen Zeit in beiden sehr wohl fühlen. Dort können Sie
Ihre Ansichten un dialoge konstruieren, wie Sie möchten und alle verfügbaren Einstellungen an den Elementen vornehmen, die die Ansicht
enthält. Wenn Sie fertig sind, wählen Sie "Quellen erzeugen" aus dem "Bauen"-Menü; der Dialogeditor und das Projektmanagement werden
sich dann um den Rest kümmern. Sie können testen, ob alles richtig durchgeführt wurde, indem Sie "Erstellen" oder "Ausführen"
auswählen; dies wird Ihre Applikation inklusive der neuen Quelldateien erstellen. Aber erwarten Sie nicht, das die Dialoge schon sofort
nutzbar sind- das ist eine Sache der Implementierung wie Sie der Entwickler gewohnt ist. Seien Sie nicht besorgt- es ist nicht sehr
schwer. Um mehr Information zur Erstellung von Dialogen zu erhalten, schlagen Sie unter <link linkend="Der-Dialogeditor">Der Dialgoeditor</link> nach, Beispiele und Richtlinien finden Sie im <ulink url="programming-6.html">KDevelop Programmierhandbuch</ulink>.</para>
</sect3>

<sect3 id="einbinden-neuer-elemente">
<title>Einbinden neuer Elemente</title>

<para>Nachdem Sie Ihre Benutzerschnittstellen erzeugt und den Quellcode generiert haben, sind Sie bereit, Ihrer Applikation beizubringen, sie
durch Objekte zu benutzen. Wie oben beschrieben, besteht ein gewöhnliches GUI-Basiertes Programm aus Leisten und der Hauptansicht;
zusätzlich operiert die Hauptansicht mit den Leisten, die ein Teil der Haupt-Applikationsklasse sind, und dem Dokumentenobjekt, das mit
der Ansicht verbunden ist. Im Terminus Objekt-orientierten Designs würde man die gegebene Architektur als
"Dokumenten-Ansichts-Controller" Modell bezeichnen. Dieses Modell beschreibt die grundlegenden Funktionen von Objekten in einer
Applikation nach ihrer Rolle innerhalb des Programms. Der Controller repräsentiert denjenigen Teil, der die Applikation koordiniert und
die Benutzerinteraktion durch Menüleisten, Werkzeugleisten und Statuszeilen ermöglicht. Die Dokumentenklasse übernimmt die Aufgabe, das
Dokument zu bilden, das der Benutzer bearbeitet. Deshalb sollte die Dokumentenklasse alle Aktionen zum laden und speichern übernehmen.
Die Ansicht ist nun im Zentrum des Anwendungsfensters, zeigt dem Benutzer ein Teil des Dokuments visuell und stellt alle Funktionen zur
Manipulation der Daten durch den Benutzer bereit. Da die Leisten schon vorhanden sind, besteht Ihre Arbeit in der Erzeugung der
Hauptansicht und zusätzlichen Dialogen mit denen der Benutzer die Einstellungen ändern kann oder Zugriff auf weitere Funktionen bieten.</para>

<para>Um Ihre Hauptansicht zu erzeugen, enthält der generierte Quellcode Ihrer Applikation bereits eine Klasse in Form von
&&lt;;IhreApplikation&&gt;;View, die die QWidget Klasse beerbt (dies ist die minimale Klasse die visuelle Schnittstellen in Qt behandelt
und daher ebenso in KDE <indexterm remap="idx"><primary>KDE</primary></indexterm>). Allgemein gibt es drei verschiedene Wege, die gegebene Klasse zu erweitern:</para>

<para><itemizedlist>
<listitem>
<para>entfernen der Dokument-Ansichts Struktur- benutzen Sie eines der vordefinierten "großen" Widgets, die schon viel
Funktionalität enthalten- entfernen Sie einfach die View-Klasse und ersetzen Sie das view-Objekt durch ein anderes.</para>
</listitem>
<listitem>
<para>ändern der Vererbung der View-Klasse. Wechseln Sie die Vererbung z.B. zu QMultiLineEdit und Ihre Applikation wird ein Editor.</para>
</listitem>
<listitem>
<para>wenn ihre Hauptansicht aus mehreren separaten Teilen bestehen soll, erzeugen Sie die Widgets und deren Klassen, die Sie
benötigen, mit dem Dialogeditor und erstellen Sie Objekte dieser Klassen in dem View-Klassen Konstruktor, der mit der Kombination die
Hauptansicht bildet.</para>
</listitem>
</itemizedlist>
</para>

<para>Bei Dialogen sind die Dinge etwas verschieden. Der übliche Weg wäre, einen Dialog über einen Menüleisteneintrag aufzurufen und
zusätzlich über eine Werkzeugleisten-Schaltfläche. Nach der Konstruktion des Dialogs und der Generierung der Quellcodes ist die Klasse
verfügbar, um ein Objekt zu erzeugen, der den Dialog darstellt. Daher müssen Sie sich zuerst nach einem geeigneten Platz in der
Menüleiste umsehen, der den Dialog aufruft, wenn er vom Benutzer ausgewählt wird. Wenn die gegebenen Menüs nicht Ihren Ansprüchen
genügen, erzeugen Sie ein neues Popup Menü wie die anderen und fügen den Eintrag und den Slot hinzu, den Sie aufrufen, wenn der Eintrag
aktiviert wird. Dann implementieren Sie den Slot durch erzeugen einer Instanz der Dialogklasse und rufen den Dialog mit den Methoden
der Basisklasse auf. Zusätzlich müssen Sie dem Menüeintrag eine ID-Nummer geben. Die Rahmenapplikationen beinhalten alle schon
verwendeten ID's in einer Datei resource.h, so das Sie nur die ID und die Nummer hinzufügen müssen. Dann sind Sie fertig- zusätzlich
können Sie ein weiteres Werkzeugleisten-Symbol erzeugen und die Statuszeilen-Hilfe vervollständigen. Ihre Applikation bietet nun eine
neue Funktionalität, die dem Benutzer sichtbar ist. Jetzt fügen Sie noch die entsprechende Implementation von Methoden hinzu, die Ihr
Dialog benötigt, um die gewünschten Werte zu verändern. Schließlich rufen Sie noch das Erstellungsprogramm oder "Ausführen" auf und die
geänderten Dateien werden neu übersetzt; das Ergebnis Ihrer Änderungen können Sie dann sofort testen.</para>
</sect3>

<sect3 id="der-vollstndige-entwicklungsproze">
<title>Der Vollständige Entwicklungsprozeß</title>

<para>Im oberen Abschnitt diskutierten wir den gewöhnlichen Weg, den man nimmt um mit KDevelop eine neue Applikation zu erstellen und die
Benutzerschnittstelle zu erweitern. Nun, dies sind die Standardfunktionen, bei denen Ihnen die Entwicklungsumgebung hilft, aber KDevelop kann mehr als
Ihnen Werkzeuge zur Applikationserstellung und die Gestaltung der visuellen Elemente zur Verfügung zu stellen. Im Folgenden bekommen
Sie eine kurze Beschreibung der Hauptfunktionalität, die Ihnen geboten wird um die Applikationsentwicklung zu vereinfachen.</para>

<sect4 id="organisation-des-quellcodes">
<title>Organisation des Quellcodes</title>

<para>Die KDevelop Entwicklungsumgebung bietet dem Programmierer eine Menge an Funktionalität, um sein Ziel innerhalb der kürzesten Zeit zu erreichen. Wie
oben erklärt, verringern der KAppWizard und der Dialogeditor schon erheblich den Aufwand, den Sie durch herkömmliche Arbeitsweisen vor
sich hätten. Aber dies beinhaltete nicht die Arbeit, die ein Programmierer für gewöhnlich ausführt: die Arbeit an der Implementation
seiner Applikation, um eine saubere Ausführung beim End-Benutzer zu gewährleisten. Nun, warum ist KDevelop die Entwicklungsumgebung, die Sie als
Programmierumgebung bevorzugen würden, auch um Applikationen ohne graphische Oberfläche zu entwickeln ?</para>

<para>Implizit übernimmt die Entwicklungsumgebung die Verwaltung Ihres Projekts; das bedeutet, das Sie sich i.A. nicht um das Abspeichern von Änderungen, die
Makefile-generierung etc. kümmern müssen- es wird volles Projektmanagemnt bereitgestellt, und KDevelop spielt hier seine Stärken in
jeder Art von C++ Applikationsentwickung aus. Es ist sehr einfach nachzuvollziehen, das der Programmierer sich nach der Wegnahme des
Managements voll auf die Implementierung des Quellcodes konzentieren kann. Andererseits ist der Code jedoch über viele verschiedene
Dateien im Projekt verstreut, damit Sie verschiedene Teile unterscheiden können. Aber dies würde immer noch bedeuten, auf umständliche
Art zu arbeiten- als Entwickler müssen Sie sich immer noch mit dem Anlegen neuer Dateien und des Schreibens von Standardinhalten wie
der Dateiköpfe, die das Datum, den Autorennamen und z.B. einen Lizenzhinweis enthalten, abgeben. Zusätzlich verlangt dies von Ihnen,
das Sie sich immer merken müssen, wo Ihre Funktionen, Klassendeklarationen und Implementierung im Projekt sind. Deshalb bietet Ihnen
KDevelop die Klassenwerkzeuge- eine Menge an Funktionen, die schnelles Arbeiten erlauben und das Augenmerk des Entwicklers weg von
Dateien zu Objekten bewegt- Klassen, Strukturen und Methoden. Der Klassengenerator läßt Sie eine Klasse inklusive Vererbung, Attributen
und Dokumentation auf schnelle und einfache Weise erstellen. Zur Objekt-Orientierten Arbeit bringt Sie der Klassenbrowser an den Ort
Ihrer Objekte- es macht also nichts mehr aus, wo sich der Code letztendlich befindet. Der Browser scannt die Quellcodes automatisch und
aktualisiert sich nach dem Hinzufügen von Elementen, um mit Ihrer Arbeit synchron zu bleiben und macht Ihnen neuen Code sofort
zugänglich. Über Kontext-Menüs bietet der Browser noch mehr Funktionalität wie etwa das direkte springen zur Implementation oder
Deklaration von Member-Funktionen. Außerdem wird das Hinzufügen von Membern über graphische Dialoge erledigt- kein Suchen nach Dateien
mehr, wo Sie Ihre Einträge hinzufügen wollen. Schließlich können Sie eine noch spezialisiertere Ansicht der Projektklassen über den
Klassenwerkzeug-Dialog erhalten, der in Baumstruktur die Benutzung, Inhalt und Vererbung der Klassen und Objekte zur Verfügung stellt.
Um mehr Informationen zu erhalten, lesen Sie auch das Kapitel <link linkend="Der-Klassenbrowser">Der Klassenbrowser</link>.</para>
</sect4>

<sect4 id="erstellen-und-ausfhren-ihrer-applikation">
<title>Erstellen und Ausführen Ihrer Applikation</title>

<para>Die KDevelop Entwicklungsumgebung ist speziell dafür entwickelt worden, Ihnen periodisch wiederkehrende Arbeitsschritte wie das Erstellen und Ausführen
Ihres Programms und die Fehlerlokalisierung im Quellcode abzunehmen.</para>

<para>Den Erstellungsprozeß rufen Sie auf durch:
<itemizedlist>
<listitem>
<para>Klick auf die Schaltfläche "Erstellen" oder "Alles neu erstellen" in der Werkzeugleiste</para>
</listitem>
<listitem>
<para>oder durch Auswahl von "Erstellen"/"Alles neu erstellen" aus dem "Bauen"-Menü.</para>
</listitem>
</itemizedlist>
</para>

<para>Um ihre Applikation auszuführen, wählen Sie
<itemizedlist>
<listitem>
<para>das Symbol "Ausführen" oder "Debuggen" (startet KDbg mit Ihrem Programm) aus der Werkzeugleiste</para>
</listitem>
<listitem>
<para>über die entsprechenden Menüeinträge aus dem Bauen-Menü</para>
</listitem>
<listitem>
<para>oder über "Mit Argumenten ausführen", um Ihre Applikation mit zusätzlichen Argumenten auszuführen</para>
</listitem>
</itemizedlist>

Um mehr Informationen zum Erstellungsprozess zu erhalten, lesen Sie bitte das Kapitel <link linkend="Projekte">Projekte</link>.</para>
</sect4>

<sect4 id="suchen-nach-programmfehlern">
<title>Suchen nach Programmfehlern</title>

<para>Da natürlich während des Erstellungsvorgangs Fehler auftauchen (die durch den Compiler entdeckt werden und Syntax-Fehler genannt
werden) oder auch während der Ausführung der Applikation, müssen diese lokalisiert und vom Programmierer entfernt werden. Um dies
vorzunehmen, muß der Entwickler die Information bekommen, was exakt die Ursache war. Wie schon erwähnt, ist der Compiler in der Lage,
Syntax-Fehler selbst zu finden, mit dem Resultat, das die Binärdatei nicht erstellt werden kann (das geschieht auch, wenn der Linker
sog. unresolved Symbols findet-sehen Sie auch <link linkend="Linker-Einstellungen">Linker-Einstellungen</link>). Da er so genau wie
möglich eine Fehlerbeschreibung zurückliefert, kann der Fehler gefunden und entfernt werden. Während des Erstellungsprozesses öffnet
sich das Ausgabefenster und zeigt Ihnen an, was das Erstellungsprogramm und der Compiler gerade ausführen. Im Fall von Fehlern oder
Warnungen klicken Sie einfach mit der Maus auf die Fehlermeldung und der Editor wird die betroffene Datei öffnen und den Cursor an die
Zeile des Fehlers setzen. Dies können Sie auch über die Einträge des "Ansicht" Menüs, "Nächster Fehler" und "Vorheriger Fehler" oder
die entsprechenden Schnelltasten ausführen. Sie werden schnell merken, das dies sehr Funktional ist und Ihnen viel Zeit spart, zum
Fehler zu gelangen, nur zur Beseitigung der Fehlerursache sind Ihre Fähigkeiten als Programmierer gefragt.</para>

<para>Laufzeitfehler, die während der Ausführung auftreten und meist in einer Speicherverletzung (segmentation fault) enden, sind manchmal
sehr schwer zu finden. Deshalb können Sie den Compiler anweisen, zusätzliche Informationen in der Binärdatei zu speichern um die
Ausführung mit dem Quellcode zu beobachten. Ein Debugger ist dann ein weiteres Programm, das Ihnen dies ermöglicht, indem er Ihr
Programm startet und Sie im Quellcode Haltepunkte setzen läßt, an denen die Ausführung anhält; somit können Sie kritische
Implementierungen kontrollieren und damit zumindest die Zeile finden, an der der Fehler ausgelöst wird. Das finden dieser Fehler ist
eine weitere Aufgabe, die dem Progammierer obliegt. Der <emphasis remap="bf">gdb</emphasis> ist ein Debugger, der mit dem GNU Compilern geliefert wird und
Programme wie <emphasis>ddd</emphasis> oder <emphasis>KDbg</emphasis> sind sog. Frontends, die eine einfachere Benutzung erlauben. Deshalb verwendet KDevelop KDbg und
läßt Sie den Debug-Prozeß über die Kommandos "Debug" im Bauen-Menü oder das Debug-Symbol der Werkzeugleiste starten. Zu weiterer
Information zum Debuggen von Applikationen sei auf das Kapitel <link linkend="Projekte">Projekte</link> und das <ulink url="programming-12.html">Das KDevelop Programmierhandbuch</ulink> verwiesen.</para>
</sect4>
</sect3>
</sect2>
</sect1>

<sect1 id="zustzliche-informationen">
<title>Zusätzliche Informationen</title>

<para>Die Themengebiete, die in diesem Kapitel angesprochen wurden, werden detaillierter an folgenden Stellen innerhalb der Dokumentation der
KDevelop Entwicklungsumgebung und anderen Dokumentation behandelt:</para>

<para><itemizedlist>
<listitem>
<para><ulink url="programming.html">Das KDevelop Programmierhandbuch</ulink>, behandelt eine vollständige Einführung in das GUI
Applikationsdesign und der Programmierung mit den Qt und KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Bibliotheken,</para>
</listitem>
<listitem>
<para>dieses Handbuch, Abschnitte <link linkend="bersicht">Übersicht</link> bis <link linkend="Projekte">\|\|</link>, die alle zur Verfügung stehenden
Funktionen innerhalb von KDevelop beschreiben,</para>
</listitem>
<listitem>
<para>dieses Handbuch, Abschnitt <link linkend="Der-Dialogeditor">Der Dialogeditor</link>, erklärt die Benutzung des Dialogeditors, um
eigene Widgets zu erstellen,</para>
</listitem>
<listitem>
<para>Die <emphasis>Online-Reference Documentation</emphasis> zur Qt Bibliothek, die Beispiele zur Benutzung des Qt-GUI Toolkits als auch eine
Klassenreferenz und Screenshots der wichtigsten sofort benutzbaren Widgets enthält,</para>
</listitem>
<listitem>
<para>Die <emphasis>KDE-Bibliotheks Klassenreferenz</emphasis>, automatisch durch KDevelop aus den KDE-Bibliotheksquellen generiert, enthält
Beschreibungen für alle Klassen und Widgets inklusive Beispielcode zu Ihrer Verwendung,</para>
</listitem>
<listitem>
<para>Im Internet:
<itemizedlist>
<listitem>
<para><ulink url="http://www.troll.no">http://www.troll.no</ulink> für Informationen über Qt und zusätzliche Widgets von dritter
Seite,</para>
</listitem>
<listitem>
<para><ulink url="http://www.kde.org">http://www.kde.org</ulink> für Informationen zum KDE Projekt und Entwicklungshinweisen,</para>
</listitem>
<listitem>
<para><ulink url="http://developer.kde.org">http://developer.kde.org</ulink> für zusätzliche Referenzen zur KDE
Applikationsentwicklung.</para>
</listitem>
<listitem>
<para>Auf der KDevelop Homepage <ulink url="http://www.kdevelop.org">http://www.kdevelop.org</ulink></para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect1>
</chapter>

<chapter id="bersicht">
<title>Übersicht</title>

<para>Wenn man KDevelop betrachtet, kann man die Benutzeroberfläche nach Ihrer logischen Aufteilung beschreiben: Das Hauptfenster, die
Baumansicht und das Ausgabefenster, umgeben von der Menüleiste, Werkzeugleisten und der Statuszeile. Dieser Abschnitt beschreibt den
Zweck jedes Teils der Oberfläche, angefangen bei den Fenstern zu den Leisten und den Funktionen, die zur Verfügung stehen.</para>

<sect1 id="hauptfenster">
<title>Hauptfenster</title>

<para>Das Hauptfenster besteht aus vier Tabulatoren, von denen die zwei linken zur Bearbeitung zur Verfügung stehen. Zuerst kommt das
Header/Resourcen-Fenster für Header- und andere Textdateien wie die SGML-Dokumentationen, dann das C/C++ Fenster zur Bearbeitung des
Quellcodes. Auf diese folgt das Dokumentationsfenster, das eine HTML-Formate anzeigt. Ganz rechts befindet sich das Werkzeuge-Fenster
zur Arbeit mit externen Programmen wie KIconedit oder KDbg, die in die Entwicklungsumgebung eingebettet sind. Jedes Werkzeug, das registriert ist,
können Sie über das "Werkzeuge" Menü aufrufen; die Registrierung von weiteren Programmen können Sie über einen Konfigurationsdialog
vornehmen (sehen Sie <link linkend="Grundstzliche-Konfiguration">Grundsätzliche Konfiguration</link>). Eine Beschreibung der Editorfunktionen finden Sie
im Kapitel <link linkend="Arbeiten-mit-dem-Editor">Arbeiten mit dem Editor</link>, zum Hilfebrowser schlagen Sie bitte 
<link linkend="Benutzung-des-Dokumentationsbrowsers">Benutzung des Dokumentationsbrowsers</link> nach.</para>
</sect1>

<sect1 id="der-klassenbrowser-und-die-dateiansichten">
<title>Der Klassenbrowser und die Dateiansichten</title>

<sect2 id="die-klassenansicht">
<title>Die Klassenansicht</title>

<para>Die Klassenansicht (CV, Class Viewer) zeigt alle Klassen Ihres Projekts als auch globale Funktionen und Variablen an. Das Öffnen des
Baumes zeigt Ihnen dann die Memberfunktionen und Mitglieder der Klasse mit Symbolen für Attribute (private, protected und public,
Signale und Slots),  sodaß Sie die Eigenschaften der Members visuell ohne ein Durchsuchen der Headerdatei erkennen können. Die Auswahl
einer Klasse öffnet die zugehörige Header-Datei, die die Klasse enthält, und setzt den Cursor an den Anfang der Klassendeklaration.
Wenn Sie eine Memberfunktion auswählen, wird die Implementierungsdatei geöffnet und der Cursor am Funktionskopf plaziert. Bei
Attributen schlägt KDevelop die Headerdatei auf und setzt den Cursor and die Deklaration des Elements. Die Klassenansicht bietet
weiterhin Kontextmenüs, die Ihnen spezialisiertere Operationen erlauben, sehen Sie dazu <link linkend="Der-Klassenbrowser">Der Klassenbrowser</link>.</para>
</sect2>

<sect2 id="die-logische-dateiansicht">
<title>Die Logische Dateiansicht</title>

<para>Die Logische Dateiansicht (LFV, Logical File Viewer) erlaubt das Sortieren von Dateien mittles Filtern in Gruppen. Individuelle Gruppen
können über den Eintrag "Eigenschaften" im Projektmenü hinzugefügt werden oder einem rechten Mausklick über der Baumansicht. Dies
erlaubt einen spezialisierteren Zugriff auf Dateien, da nur Projektdateien angezeigt werden. Nach Ihrem Mime-Typ werden die Dateien
durch die entsprechenden Programme geöffnet. Sie werden daher den LFV benutzen, um schnellen Zugriff auf z.B. Pixmaps zu haben- dies
wird Ihnen KIconedit (falls auf Ihrem System installiert) im Werkzeuge-Fenster starten und die ausgewählte Datei öffnen.</para>
</sect2>

<sect2 id="die-aktuelle-dateiansicht">
<title>Die Aktuelle Dateiansicht</title>

<para>Die Aktuelle Dateiansicht (RFV, Real File Viewer) zeigt das Projektverzeichnis mit allen Dateien an, sodaß Sie auch
nicht-Projektdateien bearbeiten können wie Makefile.am's. Popup Menüs bieten ebenfalls Funktionen wie das hinzufügen, entfernen oder
löschen von Dateien.</para>
</sect2>

<sect2 id="der-dokumentationsbaum">
<title>Der Dokumentationsbaum</title>

<para>Der Dokumentationsbaum (DOC) zeigt alle verfügbaren HTML-basierten Dokumentationen als Bücher an. Die Auswahl eines Buches öffnet Ihnen
die erste Seite im Browser-Fenster. Über dem Ordner "Andere" bietet Ihnen ein Popup-Menü die Konfiguration von zusätzlichen
Dokumentation im HTML-Format an.</para>
</sect2>
</sect1>

<sect1 id="ausgabefenster">
<title>Ausgabefenster</title>

<para>Das Ausgabefenster ist aufgeteilt in ein Meldungen-Fenster ein StdOut- und ein StdErr-Fenster für folgende Funktionen:</para>

<para><itemizedlist>
<listitem>
<para> Meldungen-Fenster: zeigt die Ausgabe des Compilers an. Klicken über Fehlermeldungen setzt den Cursor im Editor an die Stelle, an
der der Compiler den Fehler fand.
</para>
</listitem>
<listitem>
<para>StdOut Fenster: Anzeige für Terminal-basierte Applikationen, die Nachrichten zur Standardausgabe senden. Terminal Applikationen
werden jetzt allerdings in Terminal-Fenstern gestartet.</para>
</listitem>
<listitem>
<para>StdErr Fenster: zeigt Ihnen alle Fehlermeldungen an, die Ihr Programm an die Standard-Fehlerausgabe sendet. Dies wird häufig zu
Testzwecken benötigt. Das Ausgabefenster wird immer dann automatisch geöffnet, wenn ein externer Prozeß aufgerufen wird wie das
Erstellungsprogramm.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="befehle-der-menleiste">
<title>Befehle der Menüleiste</title>

<sect2 id="dateimanagement-und-druckfunktionen">
<title>Dateimanagement und Druckfunktionen</title>

<para>Dieser Abschnitt behandelt die Funktionen, die KDevelop zur Dateiverwaltung bereitstellt; Sie können über die Einträge des Datei-Menüs
oder die entsprechenden Schaltflächen der Werkzeugleiste aufgerufen werden:</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Neu			STRG+N</emphasis> Öffnet den "Neue Datei" Dialog, der Ihnen das Anlegen einer neuen Datei erlaubt. Die Datei kann mit
verschiedenen Schablonen angelegt werden; weiterhin geben Sie Dateinamen und Pfad an.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Öffnen			STRG+O</emphasis> zeigt den "Öffne Datei..." Dialog an und läßt Sie den Dateinamen einer zu öffnenden Datei auswählen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Schießen		STRG+W</emphasis> Schließt die Datei des aktuellen Bearbeitungsfensters</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Speichern			STRG+S</emphasis>	Speichert die im obersten Editorfenster geöffnete Datei. Ist die Datei bisher noch nicht gespeichert
worden, öffnet sich der "Speichern unter" Dialog, in dem Sie einen Pfad- und Dateinamen eingeben können.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Speichern unter...</emphasis> öffnet den "Speichere Datei unter..." Dialog, indem Sie der Datei unter einen neuen Namen abspeichern können.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Alles speichern</emphasis> Speichert alle geänderten Dateien</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Drucken...	STRG+P</emphasis> Öffnet den "Drucke Datei" Dialog, in dem Sie die Druckereinstellung für die Verwendung von enscript
oder lpr festlegen, um dann zu drucken.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Verlassen  STRG+Q</emphasis> Beendet KDevelop. Wenn Dateien geändert wurden, werden Sie aufgefordert, diese zu speichern.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="bearbeiten-von-dateien">
<title>Bearbeiten von Dateien</title>

<para>Hier wird das "Bearbeiten" Menü und die zugehörigen Symbole der Werkzeugleiste behandelt, die zur Bearbeitung von Dateien verwendet
werden. Die Editierfunktionen sind ebenso über ein Kontext-Menü des Editors erreichbar.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Rückgängig			STRG+Z</emphasis> Macht die letzte Bearbeitungsfunktion rückgängig</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Wiederherstellen	STRG+Z</emphasis> Wiederholt eine Rückgängig gemachte Operation</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ausschneiden			STRG+X</emphasis> Schneidet die aktuelle Auswahl aus und kopiert sie in die Zwischenablage.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Kopieren			STRG+C</emphasis> Kopiert eine Auswahl in die Zwischenablage. Dies gilt auch für Auswahlen, die im Dokumentations-Browser
gemacht werden.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Einfügen		STRG+V</emphasis> fügt den Inhalt der Zwischenablage an der aktuellen Position ein.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Einrücken		STRG+I</emphasis> Rückt eine Auswahl nach rechts ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ausrücken	STRG+U</emphasis> Rückt eine Auswahlt nach links ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Datei einfügen...STRG+Insert</emphasis> läßt Sie eine Datei auswählen, deren Inhalt an der aktuellen Position eingefügt werden soll</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Suchen...		STRG+F</emphasis> Öffnet die Suchen-Dialog und sucht den gewählten Ausdruck in der aktuellen Datei. Zur Suche über mehrere
Dateien verwenden Sie "Suchen in Dateien...".</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Suche wiederholen	F3</emphasis> Wiederholt die letzte Suche. Dies gilt auch für Suchoperationen, die in der Dokumentation durchgeführt
werden, wenn mehr als ein Treffer in der gleichen Seite gefunden wurde.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ersetzen...		STRG+R</emphasis> Öffnet den "Suchen und ersetzen" Dialog, der einen gesuchten Ausdruck durch einen neuen ersetzt</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Suchen in Dateien...		STRG+Alt+F</emphasis> Zeigt den "Suchen in Dateien" Dialog an, der über <literal remap="tt">grep</literal> ganze Verzeichnisse mit
zusätzlichen Wildcards durchsucht. Die Suchergebnisse werden in einer Liste angezeigt, die Dateinamen, Zeile und Ausdruck enthält. Die
Auswahl eines Ausdrucks öffnet die gewählte Datei und setzt den Cursor an die Position des Ergebnisses.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Alles auswählen  STRG+A</emphasis> Markiert den gesamten Text der Datei, die momentatn geöffnet ist.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Alles abwählen</emphasis> Entfernt alle Markierungen in der aktuellen Datei. Dies wird meist nur in Verbindung mit Multi-Auswahl
benötigt, sodaß Sie nicht jede Auswahl separat entfernen müssen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Auswahl umkehren</emphasis> Invertiert die Auswahl, heißt: die aktuelle Auswahl wird entfernt und unmarkierter Text wird ausgewählt.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="ansichts-konfiguration">
<title>Ansichts-Konfiguration</title>

<para>Das Ansicht-Menü bietet Funktionen zum Öffnen und Schließen von Fenstern und Befehle zur Einstellung der Werkzeugleisten und
Statuszeile ebenso wie Funktionen zum Fehlerlokalisierung.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Gehe zu Zeile...	STRG+G</emphasis>Öffnet den "Gehe zu Zeile..." Dialog, in dem Sie die Zeilennummer angeben, zu der Sie springen
möchten. Die Zeilennummer wird gespeichert und markiert, sodaß Sie entweder sofort nochmals zur Zeile springen können oder eine neue
Zeile angeben.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Nächster Fehler		F4</emphasis>Springt zum nächsten Fehler, den KDevelop aus der Ausgabe erkennt. Die Ausgabe-Nachricht von Make oder
anderen Werkzeugen sollten Ihnen eine Hilfe zur Fehlerbehebung sein.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Vorheriger Fehler		Shift+F4</emphasis> Springt zum vorherigen Fehler.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Dialogeditor   STRG+D</emphasis> Wechselt zum Dialogeditor </para>
</listitem>
<listitem>
<para><emphasis remap="bf">Baumansicht	Shift+T</emphasis> Schaltet die Baumansicht links des Hauptfensters ein bzw. aus.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ausgabeansicht	Shift+O</emphasis> Schaltet das Ausgabefenster unter der Hauptansicht ein bzw. aus</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Toolleiste</emphasis> Schaltet die Werkzeugleiste ein bzw. aus.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Browser-Toolbar</emphasis> Schaltet die Browser-Werkzeugleiste ein bzw. aus.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Statusleiste	STRG+B</emphasis> Schaltet die Statuszeile ein bzw. aus.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Aktualisieren </emphasis> Aktualisiert den Klassenbrowser. Der Scanfortschritt wird über eine Anzeige in der Statuszeile
angezeigt.</para>
</listitem>
</itemizedlist>
 </para>
</sect2>

<sect2 id="erzeugen-und-organisieren-von-projekten">
<title>Erzeugen und Organisieren von Projekten</title>

<para>Dieser Abschnitt beschreibt Funktionen, die Ihnene im Projekt-Menü zur Verfügung stehen und die der Erzeugung und Organisation von
Projekten dienen.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Neu...</emphasis> Startet den KAppWizard und erlaubt das Erstellen von neuen Projekten über die Auswahl von Typ, Name, Version und
andern Optionen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Öffnen</emphasis> startet den "Projekt öffnen" Dialog, in dem Sie eine KDevelop Projekt-Datei auswählen können. Nach der Auswahl wird
das Projekt in den Arbeitsbereich geladen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Öffne letztes Projekt...</emphasis> enthält ein Untermenü mit den letzten fünf geöffneten Projekten, um bestehende Projekte schneller
zu öffnen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Schließen </emphasis>Schließt das aktuelle Projekt. Dies wird normalerweise automatisch durch KDevelop vorgenommen, wenn Sie die Entwicklungsumgebung
beenden, ein neues Projekt erstellen oder ein bestehendes Projekt öffnen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Neue Klasse...</emphasis> Startet den Klassengenerator, um eine Klasse zu erstellen, die dem Projekt hinzugefügt wird. Der
Klassengenerator erlaubt die Angabe von Klassennamen, Vererbung und Dateinamen für die neue Klasse.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Vorhandene Datei(en) hinzufügen </emphasis> Öffnet einen Auswahldialog, in dem Sie Dateien selektieren, die Sie dem aktuellen Projekt
hinzufügen mochten. KDevelop kopiert diese dann in das angegebene Verzeichnis und aktualisiert das Projekt.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Neue Übersetzungsdatei hinzufügen</emphasis> Öffnet den Sprachauswahl-Dialog, in dem Sie die hinzuzufügende Sprache angeben können.
Dies wird häufig von Übersetzern verwendet, die ihre Sprache unterstützen möchten.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Dateieigenschaften  Shift+F7</emphasis> Öffnet den Datei-Eigenschaften Dialog, der eine Kopie des LFV enthält und die Einstellungen der
Projektdateien anzeigt.Hier geben Sie die Eigenschaften für Dateien an, z.B. den Installationspfad.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Meldungen erstellen und verbinden</emphasis> Dies erstellt die Meldungsdatei des Projekts, die alle zu übersetzenden Strings der
Quellcodes enthält und von Übersetzern zur erstellung der po-Datei ihrer Sprache benötigt wird.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">API-Dokumentation erstellen</emphasis> Ruft KDoc auf, aus den Kommentaren Ihrer Headerdateien eine HTML-Dokumentation Ihrer Klassen zu
erstellen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Benutzerhandbuch erstellen</emphasis> Ruft ksgm2html auf, aus Ihrer SGML-Datei das HTML-Benutzerhandbuch zu erstellen. Wenn ksgml2html
nicht installiert ist, wird sgml2html verwendet.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Distribution erstellen:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">tar.gz </emphasis> erzeugt die Distributionsdatei Ihres aktuellen Projekts im Projekt-Verzeichnis, die Sie den End-benutzern zur
Verfügung stellen. Der Endbenutzer entpackt dann mit <literal remap="tt">tar zxvf yourproject.tar.gz</literal> das Paket in ein Quellverzeichnis und benutzt die
Standard-Kommandos <literal remap="tt">./configure, make </literal> und <literal remap="tt">make install</literal>.</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Einstellungen  F7</emphasis> Öffnet den Projekt-Optionen Dialog, in dem Sie die verschiedenen Einstellungen Ihres Projekts vornehmen.
Dies könnte z.B. eine neue Versionsnummer oder Compiler-Optionen sein, die Sie etwa auf -02 für eine Release-Version setzten.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="erstellen-von-projekten">
<title>Erstellen von Projekten</title>

<para>Dieser Abschnitt beschreibt das "Bauen" Menü, das alle Befehle zum Aufruf des Erstellungsprogramms enthält.</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Datei compilieren... STRG+F8</emphasis> Aktive, wenn das obere Editor-Fenster einen Quellcode enthält. Dies übersetzt nur die aktuelle
Implementations-Datei und läßt Sie Zeit sparen, wenn Sie Fehler erwarten.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Erstellen  F8</emphasis> Ruft das Erstellungsprogramm auf und erzeugt die Zieldatei.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Alles neu erstellen</emphasis> erstellt alle Objektdateien und die Zieldatei erneut.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Säubern</emphasis>Alles neu erstellen/ Entfernt alle durch das Erstellungsprogramm erzeugten Dateien und erstellt die Zieldatei erneut.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Stoppen  F10</emphasis> Stoppt den aktuellen Prozeß.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ausführen  F9</emphasis> Führt die Zieldatei nach einem Erstellungsvorgang aus.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Mit Argumenten ausführen  Alt+F9</emphasis> Führt die Zieldatei mit Argumenten aus. Zuerst erscheint ein Dialogfeld, in dem Sie die
Argumente angeben (die im Projekt für einen späteren Aufruf gespeichert werden), danach verwendet Ihre Applikation die angegebenen
Komandozeilen-Optionen. Beachten Sie, das Ihre Applikation aus dem Projektverzeichnis ausgeführt wird.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Debuggen...</emphasis> Öffnet KDbg im Werkzeuge-Fenster um Ihre Applikation zu debuggen. In diesem Fall öffnet KDbg autmatisch die
Datei mit der main() funktion und started die Applikation.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">DistClean</emphasis> Löscht alle erzeugten Objektdateien des Projekts. Distclean sollte vor der Distribution Ihres Projekts ausgeführt
werden, damit die Distributionsdatei keine Plattform-spezifischen Dateien enthält wie diejenigen, die Ihr Compiler erzeugt hat.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Autoconf und automake</emphasis> Ruft das Erstellungsprogramm mit der Datei Makefile.dist auf, die sich im Projektverzeichnis befindet.
Makefile.dist enthält alle Kommandos für automake, autoconf etc. um ein Projekt zu erstellen. Wenn Sie Dateien manuell hinzufügen oder
selbst Makros ändern, sollten Sie Autoconf aufrufen, gefolgt von Configure (s.u.), um die Makefiles zu aktualisieren und die Änderungen
in das Projekt einzubinden.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Configure</emphasis> Führt das configure-Skript aus, das durch Autoconf erzeugt wird. Wenn dieses Kommando nicht ausgeführt werden
kann, rufen Sie nochmals Autoconf auf, um das configure-Skript zu erstellen.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="aufruf-von-werkzeugen">
<title>Aufruf von Werkzeugen</title>

<para>Das Werkzeuge-Menü enthält standardmäßig die Einträge für folgende Programme, falls diese installiert sind: KDbg, KIconEdit und
KTranslator. Diese werden durch das KDevelop Installationsprogramm geprüft und in dieser Reihenfolge eingefügt. Der Aufruf eines
Programms öffnet das "Werkzeuge"-Fenster und startet das Programm innerhalb dieses Fensters. Die Programme können Sie über den
"Werkzeuge" Eintrag des Einstellungen-Menüs konfigurieren; lesen Sie dazu 
<link linkend="Konfiguration-des-Werkzeuge-Mens">Konfiguration des "Werkzeuge" Menüs</link>.</para>
</sect2>

<sect2 id="anpassen-von-kdevelop">
<title>Anpassen von KDevelop</title>

<para>Das Optionen-Menü enthält alle Einträge zum Aufruf von Konfigurationsdialogen, mit denen Sie die Standardeinstellungen von KDevelop
anpassen können. Spezielle Einstellungen wie die Editor-Optionen oder Druckereinstellungen haben ihre eigenen Einträge; Einstellungen,
die das generelle Verhalten von KDevelop beeinflussen, können Sie im <link linkend="KDevelop-Setup">KDevelop Setup</link> durchführen.</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Editor...</emphasis> Erlaubt die Einstellung des Editors in Bezug auf Zeilenumbruch, Auswahl etc.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Editor-Farben...</emphasis> Hier können Sie die Farb-Konfiguration des Editors festlegen wie etwa den Hintergrund.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Editor Voreinstellungen...</emphasis> setzt die Editor-Standardeinstellungen wie Schriftart und Größe</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Hervorhebungen </emphasis> Läßt Sie die Schriftart und Farben der Hervorhebungen für verschiedene Programmiersprachen inklusive HTML
einstellen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Dokumentationsbrowser</emphasis> In diesem Tabulator-Dialog stellen Sie die Optionen des Hilfebrowsers wie Schriftarten, Farben etc.
ein.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Drucker konfigurieren...</emphasis> Enthält die Einträge der Drucker-Konfigurationsdialoge entsprechend den verwendteten
Druckprogrammen.</para>
<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">enscript</emphasis>Konfiguriert den Drucker zur Benutzung von enscript. Für weitere Informationen sehen Sie nach unter "Drucken".</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Werkzeuge...</emphasis> Öffnet den Toolsmenu Konfigurations-Dialog. Hier können Sie das "Werkzeuge"-Menü bearbeiten, indem Sie
Programme, die KDevelop im Werkzeugfenster öffnet, hinzufügen oder entfernen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">KDevelop Setup</emphasis> Öffnet den KDevelop Setup-Dialog. Der erste Tabulator enthält generelle Einstellungen, gefolgt von der
Schnelltasten-Konfiguration und den Dokumentations-Einstellungen. Die Dokumentationseinstellungen beinhalten auch die Generierung von
HTML-Dokumentation und die Einrichtung des Such-Indexes für die Benutzung des Hilfe-Browsers.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="das-fenstermen">
<title>Das Fenstermenü</title>

<para>Das Fenstermenü enthält eine Liste aller geöffneten Dateien. Dies erlaubt ein schnelles wechseln zu einer anderen Datei, die Sie gerade
bearbeiten.</para>
</sect2>

<sect2 id="verwendung-von-lesezeichen">
<title>Verwendung von Lesezeichen</title>

<para>Das Lesezeichen-Menü ist zum hinzufügen und entfernen von Lesezeichen gedacht, die Sie in der aktuellen Datei setzen möchten. Da
KDevelop zwei Editierfenster verwendet, verwaltet auch jedes seine eigenen Lesezeichen.
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Lesezeichen setzen</emphasis> öffnet ein Kontextmenü mit bis zu neun konfigurierbaren Lesezeichen. Dies erlaubt ein setzen von
Lesezeichen nach logischen Gesichtspunkten.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Lesezeichen hinzufügen  STRG+Alt+A</emphasis> Fügt die Zeile der aktuellen Cursorposition dem Lesezeichen-menü hinzu. Bedenken Sie, das
Sie u.U. ein Lesezeichen überschreiben, das Sie zuvor mit der "Lesezeichen setzen" Funktion erstellt haben. Wenn der Browser geöffnet
ist, wird dem Browser-Fenster ein Lesezeichen hinzugefügt.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Lesezeichen löschen STRG+Alt+C</emphasis> Löscht die Lesezeichen-Einträge des gerade sichtbaren Fensters, z.B. wenn das Header-Fenster
gerade geöffnte ist, werden alle Einträge des Header-Fensters gelöscht.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Headerfenster</emphasis> Enthält die Lesezeichen des Header-Fensters. Die Auswahl eines Lesezeichens setzt den Crusor an die angezeigte
Zeile. Bedenken Sie, das die Lesezeichen nur an das Fenster gebunden sind und nicht an die Dateien.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">C/C++ Fenster</emphasis> Enthält die Lesezeichen des C/C++ Fensters. Die Einstellungen gelten wie für das Header-Fenster.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Browserfenster</emphasis> Enthält die Lesezeichen des Browsers. Die Auswahl eines Lesezeichens öffnet den Browser mit der
entsprechenden Seite.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="online-hilfe">
<title>Online-Hilfe</title>

<para>Das Hilfe-Menü enthält Einträge zur Navigation im Hilfebrowser als auch Einträge zur Bibliotheks- und Online-Dokumentation für die
meistbenutzten Dokumentationen. Zusätzliche Online-Hilfe können Sie im DOC-Tabulator der Baumansicht auswählen, der sich automatisch
öffnet (falls Autoswitch eingeschaltet ist), wenn Sie auf den Dokumentations-Browser wechseln.</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Zurück  Alt+ Pfeil links</emphasis> Öffnet die vorherige Dokumentations-Seite</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Vorwärts  Alt+ Pfeil rechts</emphasis> Öffnet die nächste Seite, falls Sie mindestens eimal zurück gewählt haben.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Suche Markierten Text		F2</emphasis> Scannt den Suchindex nach dem aktuell markierten Text des Editor- oder Browserfensters. Nach der
Suche wird Ihnen eine Resultats-Seite angezeigt, in der Sie die gewünschte Hilfeseite aufrufen können. Nach der Auswahl zeigt Ihnen der
Browser die gefundene Textstelle markiert an. Mit F3 (Weitersuchen) können Sie das nächste Ergebnis auf derselben Seite anzeigen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Suche nach Hilfe zu...</emphasis>Öffnet den "Suche nach Hilfe zu..." Dialog, in dem Sie nach einem spezifischen Ausdruck suchen
können.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Das Benutzerhandbuch zu KDevelop <indexterm remap="idx"><primary>Das Benutzerhandbuch zu KDevelop</primary></indexterm> F1 <indexterm remap="idx"><primary>F1</primary></indexterm></emphasis> Öffnet das Benutzerhandbuch zu KDevelop (Dieses 
Handbuch). </para>
</listitem>
<listitem>
<para><emphasis remap="bf">Das KDevelop Programmier-Handbuch <indexterm remap="idx"><primary>Das KDevelop Programmier-Handbuch</primary></indexterm></emphasis>
Öffnet die <ulink url="programming/index.html">KDevelop Programmier-Handbuch</ulink>
Indexseite. Dieses Handbuch enthält enthält eine vollständige Anleitung zur Programmierung der KDE.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">KDE Anwendungs Tutorials <indexterm remap="idx"><primary>KDE Anwendungs Tutorials</primary></indexterm></emphasis>
Wechselt zur Indexseite der <ulink url="tutorial/index.html">KDE Anwendungs Tutorials</ulink>. Dieses Handbuch erklärt, wie man
die Qt Tutorial Anwendungen erstellt und führt Sie durch Entwicklung einer Beispielanwendung in die KDE Programmierung ein.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Der KDE Bibliotheks-Referenzführer <indexterm remap="idx"><primary>Der KDE Bibliotheks-Referenzführer</primary></indexterm></emphasis>
Wechselt zur Indexseite des <ulink url="kde_libref/index.html">KDE Bibliotheks-Referenzführers</ulink>. Dieses Handbuch enthält
detailierte Informationen über die Verwendung der KDE/Qt Bibliotheken, unterteilt in Abschnitte wie z.B. Ereignisbehandlung.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Programmieren mit KDE 2 <indexterm remap="idx"><primary>Programmieren mit KDE 2</primary></indexterm></emphasis>
Wechselt zur Indexseite des Buches <ulink url="addendum/index.html">Programmieren mit KDE 2</ulink>. Dieses Handbuch enthält
Informationen über die neueste KDE Entwicklung und darüber, wie Sie Ihre Anwendungen KDE 2 fertig machen.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">C/C++ Referenz <indexterm remap="idx"><primary>Referenz</primary></indexterm></emphasis> Zeigt die Indexseite der Sprachreferenz. Wenn die Referenz nicht installiert ist, wird auf
einer Fehlerseite erkärt, wo Sie die Referenz bekommen, und wie Sie sie installieren.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Tip des Tages <indexterm remap="idx"><primary>Tip des Tages</primary></indexterm></emphasis> Öffnet den Dialog "Tip des Tages", der Ihnen nützliche Tips zur Arbeit mit KDevelop liefert.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Homepage von KDevelop <indexterm remap="idx"><primary>Homepage von KDevelop</primary></indexterm></emphasis> Öffnet, sofern Internetzugang vorhanden ist, die KDevelop Homepage in Ihrem Browser.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Bugreport <indexterm remap="idx"><primary>Bugreport</primary></indexterm>...</emphasis> Öffnet den KDevelop Bugreportdialog, mit dessen Hilfe Sie eine Fehlermeldung direkt per EMail an das
KDevelop Team senden können. Siehe auch <link linkend="Melden-von-Fehlern">Melden von Fehlern</link>.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">API-Dokumentation des Projekts <indexterm remap="idx"><primary>API-Dokumentation des Projekts</primary></indexterm></emphasis> Wechselt zum Index der Klassendokumentation Ihres Projekts.<indexterm><primary>KDoc</primary></indexterm><indexterm><primary>API</primary></indexterm>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Benutzerhandbuch des Projekts <indexterm remap="idx"><primary>Benutzerhandbuch des Projekts</primary></indexterm></emphasis> Öffnet die Indexseite des Benutzerhandbuches Ihres aktuellen Projekts. Sie können
sie verwenden, um sich die von KSgml2Html <indexterm remap="idx"><primary>KSgml2Html</primary></indexterm> erzeugte HTML <indexterm remap="idx"><primary>HTML</primary></indexterm>-Ausgabe <indexterm remap="idx"><primary>Ausgabe</primary></indexterm> anzusehen.
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Über KDevelop...</emphasis> Zeigt die Aboutbox von KDevelop, die die verwendete Version, die Namen und Email-Adressen der Autoren
sowie die KDevelop Lizenzbestimmungen zeigt.</para>
</listitem>
</itemizedlist>
</para>
</sect2>
</sect1>

<sect1 id="schaltflchen-der-werkzeugleisten">
<title>Schaltflächen der Werkzeugleisten</title>

<para>KDevelop bietet schnellen Zugriff auf verschiedene Kommandos durch Werkzeugleisten. Diese sind die Standard- und die Browser-Leiste; im
Dialogeditor-Modus ist nur die Standard-Leiste verfügbar. Beide können Sie mit den entsprechenden Einträgen im "Ansicht" Menü ein- bzw.
ausschalten; auch können Sie die Leisten aus dem Hauptfenster bewegen und an jeder Seite des Arbeitsbereiches bewegen.</para>

<sect2 id="die-standard-werkzeugleiste">
<title>Die Standard-Werkzeugleiste</title>

<para>Die Standard-Werkzeugleiste erlaubt die schnelle Ausführung der meistbenötigten Funktionen zur Dateiverwaltung und -bearbeitung als
auch zur Erstellung Ihrer Applikation. Die Schaltflächen führen von links nach rechts folgende Befehle aus:</para>

<para><itemizedlist>
<listitem>
<para>Projekt öffnen - zeigt den "Projekt öffnen"-Dialog an</para>
</listitem>
<listitem>
<para>Datei öffnen - zeigt den "Datei öffnen"-Dialog an und enthält zusätzlich ein verzögertes Popup-Menü, mit dem Sie schnellen
Zugriff auf die Header- und Quellcodedateien des aktuellen Projekts haben.</para>
</listitem>
<listitem>
<para>Datei speichern - speichert die aktuelle Datei</para>
</listitem>
<listitem>
<para>Datei drucken - öffnet den Druckdialog</para>
</listitem>
<listitem>
<para>(Trennungsfeld)</para>
</listitem>
<listitem>
<para>Rückgängig - macht die letzte Aktion rückgängig</para>
</listitem>
<listitem>
<para>Wiederherstellen - führt eine rückgängig gemachte Aktion erneut aus</para>
</listitem>
<listitem>
<para>Ausschneiden - schneidet die aktuelle Auswahl aus</para>
</listitem>
<listitem>
<para>Kopieren - kopiert die aktuelle Auswahl in die Zwischenablage</para>
</listitem>
<listitem>
<para>Einfügen - fügt den Inhalt der Zwischenablage an die aktuelle Position ein</para>
</listitem>
<listitem>
<para>(Trennungsfeld)</para>
</listitem>
<listitem>
<para>Datei compilieren - übersetzt die aktuelle Quellcode-Datei des Quellcodefensters. Im Dialogeditor-Modus ersetzt durch das
"Quellen erzeugen" Schaltfeld.</para>
</listitem>
<listitem>
<para>Erstellen - ruft das Erstellungsprogramm auf</para>
</listitem>
<listitem>
<para>Alles neu erstellen - erstellt das Projekt neu</para>
</listitem>
<listitem>
<para>Debuggen - öffnet KDbg mit der Applikations-Binärdatei zum Debuggen im Werkzeugfenster</para>
</listitem>
<listitem>
<para>Ausführen - fordert die Zieldatei zur Ausführung auf</para>
</listitem>
<listitem>
<para>Stoppen - beendet den aktuellen Prozeß</para>
</listitem>
<listitem>
<para>(Trennungsfeld)</para>
</listitem>
<listitem>
<para>Dialogeditor - wechselt in den Dialogeditor-Modus. Dort ist die Schaltfläche durch "Quellcode-Editor" ersetzt, um zum
Editier-Modus zu wechseln.</para>
</listitem>
<listitem>
<para>Baumansicht - schaltet die Baumansicht ein/aus und zeigt den aktuellen Status als betätigt/ unbetätigt an</para>
</listitem>
<listitem>
<para>Ausgabeansicht - schaltet die Ausgabeansicht ein/aus und zeigt den aktuellen Status als betätigt/ unbetätigt an</para>
</listitem>
<listitem>
<para>(Trennungsfeld)</para>
</listitem>
<listitem>
<para>Was ist das...? Hilfe-Schaltfläche - ändert den Cursor in einen Fragezeichen-Pfeil und informiert Sie bei einem Klick über
Elementen der KDevelop Benutzeroberfläche über die entsprechende Funktionalität.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="die-browser-werkzeugleiste">
<title>Die Browser-Werkzeugleiste</title>

<para>Die Browser-Werkzeugleiste ist eine weitere Werkzeugleiste, mit der Ihnen eine Reihe nützlicher Funktionen zur Navigation in Dateien
und der Dokumentation zur Verfügung stehen. Die Werkzeugleiste enthält:</para>

<para><itemizedlist>
<listitem>
<para>Die Klassen-Combobox - hier können Sie eine Klasse des aktuellen Projekts auswählen, zu der Sie wechseln möchten</para>
</listitem>
<listitem>
<para>Die Methoden-Combobox - hier können Sie eine Methode der aktuellen Klasse auswählen, um zur Implementierung der Methode zu
wechseln.</para>
</listitem>
<listitem>
<para>Die Klassen-Assistenten Schaltfläche - der Klassen-Assistent bringt Sie abwechselnd zur Deklaration / Implementation der aktuell
ausgewählten Methode. Ein verzögertes Popup-Menü gibt Ihnen Zugriff auf weitere Elemente der Klassenwerkzeuge, um Klassen, Methoden und
Attribute zur aktuellen Klasse hinzuzufügen.</para>
</listitem>
<listitem>
<para>Zurück - wechselt zur vorherigen Seite des Dokumentationsbrowsers; enthält ein verzögertes Popup-Menü zur Auswahl einer besuchten
Seite</para>
</listitem>
<listitem>
<para>Vorwärts - wechselt zu einer Dokumentations-Seite in Vorwärts-Richtung und enthält ebenfalls ein Popup-Menü zur Auswahl einer
besuchten Seite.</para>
</listitem>
<listitem>
<para>Halt - Stoppt den Browser, die aktuell angeforderte Datei zu laden.</para>
</listitem>
<listitem>
<para>Erneut laden - stellt die angezeigte Dokumentationsseite erneut dar.</para>
</listitem>
<listitem>
<para>Benutzerhandbuch - öffnet das Inhaltsverzeichnis des KDevelop-Handbuchs.</para>
</listitem>
<listitem>
<para>Suche Markierten Text - durchsucht den Dokumentations-Index nach dem ausgewählten Text; arbeitet sowohl im Browser- als auch im
Editorfenster.</para>
</listitem>
<listitem>
<para>Suche nach Hilfe zu... - öffnet den "Suche nach Hilfe zu..."-Dialog, in dem Sie den gesuchten Ausdruck eingeben können, um die
Dokumentation zu durchsuchen.</para>
</listitem>
</itemizedlist>
</para>
</sect2>
</sect1>

<sect1 id="tastenbefehle">
<title>Tastenbefehle</title>

<para>Dieser Abschnitt behandelt die vordefinierten als auch die Standard-Konfiguration der Schnelltasten für Kommandos, die Sie in der
KDevelop Entwicklungsumgebung verwenden können. Um die Belegung zu ändern, lesen Sie bitte das Kapitel <link linkend="ndern-der-Tastaturkrzel">Ändern der Tastaturkürzel</link>. </para>

<sect2 id="tastaturbelegung-fr-textbearbeitung">
<title>Tastaturbelegung für Textbearbeitung</title>

<sect3 id="cursorbewegung">
<title>Cursorbewegung</title>

<para><programlisting>um ein Zeichen nach links                               LINKS
um ein Zeichen nach rechts                              RECHTS
um ein Wort nach links                                  STRG+LINKS
um ein Wort nach rechts                                 STRG+RECHTS
eine Zeile nach oben                                    OBEN
eine Zeile nach unten                                   UNTEN
zum Anfang der aktuellen Zeile                          POS 1
zum Ende der aktuellen Zeile                            ENDE
eine Bildschirmseite nach oben                          BILD-OBEN
eine Bildschirmseite nach unten                         BILD-UNTEN
zum Anfang der Datei                                    STRG+BILD-OBEN
zum Ende der Datei                                      STRG+BILD-UNTEN</programlisting>
</para>
</sect3>

<sect3 id="markieren-von-text">
<title>Markieren von Text</title>

<para><programlisting>um ein Zeichen nach links                               UMSCHALT+LINKS
um ein Zeichen nach rechts                              UMSCHALT+RECHTS
um ein Wort nach links                                  STRG+UMSCHALT+LINKS
um ein Wort nach rechts                                 STRG+UMSCHALT+RECHTS
um eine Zeile nach oben                                 STRG+OBEN
um eine Zeile nach unten                                STRG+UNTEN
zum Anfang der aktuellen Zeile                          STRG+POS 1
zum Ende der aktuellen Zeile                            STRG+ENDE
um eine Bildschirmseite nach oben                       UMSCHALT+BILD-OBEN
um eine Bildschirmseite nach unten                      UMSCHALT+BILD-UNTEN
bis zum Anfang der Datei                                STRG+UMSCHALT+BILD-OBEN
bis zum Ende der Datei                                  STRG+UMSCHALT+BILD-UNTEN</programlisting>
</para>
</sect3>

<sect3 id="einfgen-und-kopieren-von-text-tabulator">
<title>Einfügen und Kopieren von Text, Tabulator</title>

<para><programlisting>Einfügemodus ein/ausschalten                            EINFG
markierten Text in die Zwischenablage kopieren          STRG+C, STRG+EINF
Inhalt der Zwischenablage einfügen                      STRG+V, UMSCHALT+EINF
aktuelle Zeile löschen                                  STRG+K
Absatz nach der aktuellen Zeile einfügen                ENDE, dann EINGABETASTE
Absatz vor der aktuellen Zeile einfügen                 POS 1, dann EINGABETASTE
Bearbeitung rückgängig machen                           STRG+Z
Rückgängig gemachte Bearbeitung wiederherstellen        STRG+Y
Tabulator einfügen                                      TAB</programlisting>
</para>
</sect3>

<sect3 id="lschen-von-text">
<title>Löschen von Text</title>

<para><programlisting>Zeichen links vom Cursor löschen                        RÜCKTASTE
Zeichen rechts vom Cursor löschen                       ENTF
markierten Text löschen                                 Text auswählen, dann RÜCKTASTE oder ENTF</programlisting>
</para>
</sect3>

<sect3 id="text-suchen-im-editor">
<title>Text suchen im Editor</title>

<para><programlisting>öffne "Gehe zu Zeile..."-Dialog                         STRG+G
öffne "Suche Text"-Dialog                               STRG+F
letzte Suche wiederholen                                F3
öffnen des "Suchen und Ersetzen"-Dialogs                STRG+R

öffnen des "Suchen in Dateien"-Dialogs                  F4
suche markierten Text mit Grep                          UMSCHALT+F4</programlisting>
</para>
</sect3>

<sect3 id="textsuche-mit-dem-dokumentations-browser">
<title>Textsuche mit dem Dokumentations-Browser</title>

<para><programlisting>suche markierten Editor Text in der Dokumentation       F2
suche markierten Browser Text in der Dokumentation      F2
suche auf aktueller Seite wiederholen                   F3

suche markierten Browser Text im Projekt                UMSCHALT+F2</programlisting>
</para>
</sect3>

<sect3 id="browser-schnelltasten">
<title>Browser Schnelltasten</title>

<para><programlisting>vorherige Seite                                         ALT+LINKS
nächste Seite                                           ALT+RECHTS</programlisting>
</para>
</sect3>

<sect3 id="lesezeichen-verwalten">
<title>Lesezeichen verwalten</title>

<para><programlisting>Lesezeichen hinzufügen                                  STRG+ALT+A
Lesezeichenliste löschen                                STRG+ALT+C</programlisting>
</para>
</sect3>
</sect2>

<sect2 id="schnelltasten-fr-symbole-der-werkzeugleisten">
<title>Schnelltasten für Symbole der Werkzeugleisten</title>

<para><programlisting>Symbol "Datei öffnen"                                   STRG+O
Symbol "Datei speichern"                                STRG+S
Symbol "Datei drucken"                                  STRG+P
Symbol "Rückgängig"                                     STRG+Z
Symbol "Wiederherstellen"                               STRG+Y
Symbol "Ausschneiden"                                   STRG+X
Symbol "Kopieren"                                       STRG+C
Symbol "Einfügen"                                       STRG+V
Symbol "Datei compilieren"                              STRG+F8
Symbol "Erstellen"                                      F8
Symbol "Ausführen"                                      F9
Symbol "Mit Argumenten ausführen"                       ALT+F9
Symbol "Dialogeditor"                                   STRG+D
Symbol "Zurück"                                         ALT+LINKS, falls Browser sichtbar
Symbol "Vorwärts"                                       ALT+RECHTS, falls Browser sichtbar
Symbol "Suche markierten Text"                          F2</programlisting>
</para>
</sect2>

<sect2 id="fensterverwaltung">
<title>Fensterverwaltung</title>

<para>Um zu einem bestimmten Fenster zu wechseln, drücken Sie den unterstrichenen Buchstaben im Fenstertitel; z.B. Werkzeuge über ALT+W</para>
</sect2>

<sect2 id="schnelltasten-zum-erstellungsproze">
<title>Schnelltasten zum Erstellungsprozeß</title>

<para><programlisting>Aktive Quelltextdatei übersetzen                        STRG+F8
Aktuelle Zieldatei erstellen                            F8
Zieldatei nach Erstellung ausführen                     STRG+F9
Zieldatei mit Argumenten ausführen                      ALT+F9
Aktuellen Prozeß beenden                                F10</programlisting>
</para>
</sect2>
</sect1>
</chapter>

<chapter id="das-hilfe-system">
<title>Das Hilfe-System</title>

<para>Eine sehr großes Augenmerk legt KDevelop auf das Hilfe-System. Es kann auch als Beispiel genommen werden, wie Sie Ihre eigene KDE
Applikation mit einem kompletten Satz von Hilfefunktionen ausbauen können und ist zum Teil schon in den Rahmenappliaktionen
realisiert, so das KDE/Qt Applikationen, die mit dem KAppWizard erstellt wurden, schon die Basisfunktionalität an Statuszeilenhilfe und
Dokumentation enthalten, die der Programmierer lediglich ausbauen muß. Deshalb führt dieser Abschnitt in den Gebrauch der allgemeinen
Hilfefunktionen Ihrer Entwicklungsumgebung ein und führt die Verwendung des Hilfebrowsers vor, der es bei intelligentem Einsatz sehr leicht macht, Ihnen
die benötigten Informationen bei der Entwicklung zu geben.</para>

<sect1 id="was-ist-das...-und-schnellhilfe">
<title>"Was ist das...?" und Schnellhilfe</title>

<para>Wenn Sie die obere Werkzeugleiste von KDevelop betrachten, werden Sie am rechten Ende die sog. "Was ist das ?"-Schaltfläche entdecken.
Bei Auswahl dieses Buttons wechselt der Curosor seine Erscheinung in einen Pfeil mit Fragezeichen genauso wie das Symbol in der
Werkzeugleiste. Nun können Sie jedes beliebige Element der Benutzeroberfläche von KDevelop anklicken. Das wird Ihnen ein Hilfefenster
öffnen, in dem Sie eine kurze Beschreibung der Funktion des angeklickten Elements bekommen oder welchem Zweck das Element dient.
Darin einbezogen sind die Hauptansicht, Baumansicht und die Werkzeugleisten, bei denen für jede Schaltfläche Hilfe angeboten wird. Nach
einem weiteren Mausklick oder Tastatureingabe verschwindet das "Was ist das ?" Fenster und der Cursor kehrt zu seiner letzten aktiven
Position zurück. Weiterhin bekommen Sie ein Schnellhilfe-Fenster über Elementen der Werkzeugleisten, wenn Sie den Mauszeiger über die
Schaltfläche bewegen; dies verschwindet ebenfalls, wenn Sie den Mauszeiger fortbewegen.</para>

<para>Für Benutzerdialoge bietet die Schnellhilfe Ihnen Hilfefenster mit einer kurzen Beschreibung des Ausgewählten Elements, für das Sie
Hilfe brauchen. Sie rufen die Schnellhilfe über einen rechten Mausklick auf dem gewünschten Element auf und wählen dann auf dem
Kontextmenü den Eintrag "Schnell-Hilfe". Dies wird Ihnen bei der Arbeit mit Dialogen sehr nützlich sein, wenn Sie noch nicht so sehr
mit KDevelop vertraut sind. Beachten Sie auch, das viele Dialoge über eine Hilfe-Schaltfläche verfügen, über die Sie detailliertere
Kontexthilfe zu den Optionen des Dialogs im mitgelieferten Online-Handbuch erhalten.</para>
</sect1>

<sect1 id="die-statuszeilen-hilfe">
<title>Die Statuszeilen-Hilfe</title>

<para>Die Statuszeile von KDevelop bietet Ihnen viele Funktionen, die Sie über den aktuellen Zustand informiert als auch über
Statusnachrichten eine Kurzbeschreibung zu Befehlen bietet.</para>

<sect2 id="elemente-der-statuszeile">
<title>Elemente der Statuszeile</title>

<para>Die Statuszeile enthält:
<orderedlist><listitem>
<para> ein allgemeines Nachrichtenfeld am linken Rand. Dies wird zur Anzeige des aktuellen Zustands und Hilfsnachrichten verwendet.</para>
</listitem>
<listitem>
<para> die Fortschrittsanzeige, die Sie über den Fortschritt von Aktionen informiert, die eine längere Zeit beanspruchen wie Speichern
von Dateien oder der Scan-Fortschritt des Klassenbrowsers. Die Fortschrittsanzeige erscheint nur während der Ausführung dieser Befehle.</para>
</listitem>
<listitem>
<para> eine Einfügen/Überschreiben Anzeige. Diese zeigt im Editiermodus den Zustand der EINFG-Taste an, wobei INS den Einfügemodus und
OVR den Überschreiben-modus signalisiert.</para>
</listitem>
<listitem>
<para>eine Zeilenanzeige, die die aktuelle Zeile anzeigt</para>
</listitem>
<listitem>
<para>eine Spaltenanzeige, die die aktuelle Spalte in der Zeile anzeigt</para>
</listitem>
</orderedlist>
</para>
</sect2>

<sect2 id="hilfe-nachrichten">
<title>Hilfe-Nachrichten</title>

<para>Die Statuszeile informiert Sie über die Funktion von Einträgen der Menüleiste durch eine Kurznachricht in der Statuszeile. Diese
Nachrichten erhalten Sie, wenn Sie sich über einem Menüpunkt befinden. Weiterhin bekommen Sie diese Hilfe, wenn Sie Schaltflächen der
Werkzeugleiste betätigen; die Aktion aber nicht auslösen wollen. Bewegen Sie dazu nach der Betätigung mit gedrückter Maustaste den
Zeiger von der gewählten Schaltfläche weg.</para>

<para>Bei Aktionen, die gerade ausgeführt werden, zeigt Ihnen KDevelop über die Statuszeile den aktuellen Zustand der Funktion an. Dies gilt
sowohl für Prozesse, die im Hintergrund laufen wie das speichern von Dateien als auch für Dialogfelder. Nach der Beendigung eines
Prozesses wechselt die Statuszeilenanzeige zurück auf "Bereit".</para>

<para>Wenn Sie den Dokumentationsbrowser benutzen, zeigt Ihnen die Statuszeile die mit einem Link verknüpfte Aktion oder Dateinamen des
Dokuments, das Sie durch aktivieren des Links öffnen, solange an, wie sich Ihr Mauszeiger über dem Link befindet. Damit können Sie
leicht herausfiden, ob es sich bei der URL um eine lokale oder entfernte Datei handelt, die evtl. eine Netzwerkverbindung benötigt.</para>

<para>Die Titelleiste des KDevelop Projekteditors zeigt Ihnen zusätzlich an:</para>

<para><itemizedlist>
<listitem>
<para>bei geöffnetem Projekt den Projektnamen, im Dokumentationsbrowser den Titel des Dokuments</para>
</listitem>
<listitem>
<para>KDevelop und die Versionsnummer Ihrer Kopie von KDevelop</para>
</listitem>
<listitem>
<para>den Dateinamen der im Editor gerade geöffneten Datei in eckigen Klammern</para>
</listitem>
</itemizedlist>
</para>

<para>Damit haben Sie über die Titelleiste eine zusätzliche Kontrollmöglichkeit über den Zustand von KDevelop.</para>
</sect2>
</sect1>

<sect1 id="konfigurieren-des-html-browsers">
<title>Konfigurieren des HTML-Browsers</title>

<para>Der in KDevelop integrierte Browser ist vollständig HTML-basiert, daher können Sie die üblichen Einstellungen wie die Hintergrundfarbe
etc. vornehmen. Sie stellen das Verhalten des Browsers ein, indem Sie im Menü "Einstellungen" den Eintrag "Dokumentationsbrowser"
auswählen. Der daraufhin erscheinende Dialog enthält zwei Tabulatoren; auf der ersten Seite stellen Sie dann die Schriftdarstellung
ein, auf der zweiten die Farbauswahl.</para>

<sect2 id="einstellung-der-schriftart">
<title>Einstellung der Schriftart</title>

<para>Die erste Einstellung der Schriftdarstellung ist die Schriftgröße. Verfügbar sind hier klein, mittel und groß. Die Standardeinstellung
beträgt ist "Klein".</para>

<para>Bei der Auswahl der Schriftart geben Sie die Standardschrift für normalen Text, wie er in HTML Dokumenten erscheint, an; die
Proportionalschrift wird zur Anzeige von z.B. Codebeispielen verwendet.</para>
</sect2>

<sect2 id="farbkonfiguration">
<title>Farbkonfiguration</title>

<para>Der Farbkonfigurationsdialog erlaubt die Einstellung der Farbdarstellung von Hintergrund, normalem Text, URL Verknüpfungen und bereits
besuchten Verknüpfungen, deren aktuelle Einstellung auf den zugehörigen Schaltflächen dargestellt sind. Sie ändern eine
Farbdarstellung, indem Sie entweder die Systemeinstellungen verwenden oder durch aktivieren der zugehörigen Schaltfläche die neue
Einstellung im Farbauswahldialog vornehmen; nach Bestätigen des Dialogs erscheint die gewählte Farbe auf der Schaltfläche.</para>

<para>Zur besseren Lokalisierung von Verknüpfungen können Sie zusätzlich einstellen, ob diese unterstrichen dargestellt werden sollen.</para>

<para>Durh aktivieren der Schaltfläche "Übernehmen" aktivieren Sie die durchgeführten Änderungen, während "OK" die Änderungen durchführt und
den Dialog beendet. "Abbrechen" verläßt den Dialog, ohne Änderungen zu übernehmen.</para>
</sect2>
</sect1>

<sect1 id="benutzung-des-dokumentationsbrowsers">
<title>Benutzung des Dokumentationsbrowsers</title>

<para>Der Dokumentationsbrowser erlaubt den schnellen und einfachen Zugriff auf alle Handbücher und Dokumentationen, die Ihnen mit der
KDevelop Entwicklungsumgebung zur Verfügung gestellt wurden oder automatisch generiert wurden, einschließlich der Online-Dokumentation zu den
KDE-Bibliotheken <indexterm remap="idx"><primary>KDE-Bibliotheken</primary></indexterm> und der Dokumentation Ihres aktuellen Projekts. Zusätzlich können Sie den Dokumentationsbaum anpassen, indem Sie
im Kontext-Menü über dem Ordner "Andere" die Option "Eintrag hinzufügen" auswählen.</para>

<sect2 id="anforderungen-0">
<title>Anforderungen</title>

<para>Um alle Fähigkeiten des Hilfe-Browsers zu nutzen, sollten Sie die Programme KDOc und glimpse auf Ihrem System installiert haben. KDoc
wird dann alle Arten von Online-Klassendokumentationen für die KDE-Bibliotheken <indexterm remap="idx"><primary>KDE-Bibliotheken</primary></indexterm> während der Installation anfertigen, Sie können
dies aber auch nachholen, indem Sie die entsprechende Funktion im <link linkend="KDevelop-Setup">KDevelop Setup</link> Dialog auswählen.</para>

<para>KDoc wird weiterhin verwendet, um Ihnen die Erstellung einer API (Application Programming Interface = Applikations
Programmierschnittstelle ) für Ihr Projekt zu ermöglichen. Sie erstellen diese API über das Projektmenü, Eintrag "API Dokumentation
erstellen". Dabei werden alle Header-Dateien Ihres Projekts nach Klassen dokumentiert wobei diese zusätzlich durch Quer-Referenzierung
mit der Qt und KDE-Dokumentation verbunden wird, um Ihnen schnellen Zugriff auf vererbte Klassen zu gewährleisten.</para>

<para>Zur Erzeugung des Projekthandbuchs sollten Sie ksgml2html (enthalten im KDE-SDK) und als Minimum die SGML-Tools auf Ihrem System
installiert haben. Um die Dokumentation Ihres Projekts zu ändern und zu erweitern, müssen Sie die index.sgml Datei editieren. Hinweise
dazu finden Sie im <ulink url="programming.html">KDevelop Programmierhandbuch</ulink>. Nach dem Speichern Ihrer Änderungen rufen Sie
"Benutzerhandbuch erstellen" aus dem Projekt-Menü auf. Falls die SGML-Tools Fehler in der Formatierung entdecken, werden diese im
Ausgabefenster angezeigt, womit Sie wie übllich sofort zur Fehlerzeile springen können. Das Programm "Glimpse" wird zur Erzeugung eines
Persönlichen Such-Indexes zu Ihrer Dokumentation benötigt. Der Index wird gewöhnlich während des Installationsprogramms erstellt, Sie
können dies aber jederzeit nachholen, indem Sie die entsprechende Option im <link linkend="KDevelop-Setup">KDevelop Setup</link>
Dialog auswählen. Zur Verwendung der zur Verfügung stehenden Suchfunktionen lesen Sie bitte auch <link linkend="Verwendung-des-Suchindexes">Verwendung des Suchindexes</link>.</para>
</sect2>

<sect2 id="zur-verfgung-stehende-dokumentation">
<title>Zur Verfügung Stehende Dokumentation</title>

<para>Die KDevelop Entwicklungsumgebung bringt selbst zwei Sätze an Online-Dokumentation mit, die Sie entweder über das Hilfe-Menü oder durch Auswahl im
Dokumentations-Baum im Ordner KDevelop erreichen. Das erste Buch ist dieses Handbuch in der Online-Version, die Ihnen alle benötigten
Informationen in Bezug auf Installation, Konfiguration, verfügbarer Funktionalität und eine Einführung in die Entwicklung von
Applikationen zur Verfügung stellt.</para>

<para>Das zweite Buch ist das <ulink url="programming.html">KDevelop Programmierhandbuch</ulink> in seiner ersten Ausgabe. Das
Programmierhandbuch behandelt die meisten Fragen in Bezug auf die Erzeugung und Erweiterung von Projekten, die mit KDevelop bearbeitet
werden können. Durch eine detaillierte Beschreibung der Rahmenapplikation erhalten Sie einen Überblick, was Ihnen Applikationen, die
mit der Qt- und den KDE-Bibliotheken erstellt werden, leisten können; ebenfalls enthält dieses Handbuch Richtlinien zur Erstellung von
KDE-Kompatiblen Programmen, die Generell die gleichen Instruktionen enthalten, wie Sie auf der Internet-Seite von <ulink url="http://developer.kde.org">http://developer.kde.org</ulink> finden. Jedoch kann dieses Programmierhandbuch keine zusätzliche
Dokumentation ersetzen, die Sie entweder gedruckt oder in elektronischer Form zur C++ Programmiersprache erhalten können, wie auch die
Verwendung der Qt-Bibliothek.</para>

<para>Die C/C++-Referenz, die KDevelop zur Zeit verwendet ist nur auf der KDevelop Homepage unter <ulink url="http://www.kdevelop.org">http://www.kdevelop.org</ulink> erhältlich; bei Distributionen wird diese evtl. mitgeliefert. Sie können diese einfach installieren,
indem Sie das Quellpaket beziehen und in das Haupt-KDE Verzeichnis kopieren ($KDEDIR). Dort entpacken Sie das Paket als Administrator
(root) mit <literal remap="tt">tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz</literal>, die Referenz wird dann in das Dokumentations-Verzeichnis kopiert. Zur Deinstallation
der Referenz löschen Sie den Ordner "reference" unter ($KDEDIR)/share/doc/HTML/default/kdevelop/reference.</para>

<para>Der Qt/KDE-Bibliotheks-Dokumentationsordner erlaubt Ihnen den direkten Zugriff auf die HTML-Online-Dokumentation Ihrer Kopie der
Qt-Bibliothek. Der Pfad zur Bibliotheksdokumentation wird für gewöhnlich durch das KDevelop Installationsprogramm ermittelt, Sie können
diesen aber auch manuell im <link linkend="KDevelop-Setup">KDevelop Setup</link> Dialog einstellen. Weiterhin wird die verfügbare
Dokumentation der KDE-Bibliotheken nach dem Bibliotheksnamen aufgelistet, damit Sie bei Verwendung von Klassen einer Bibliothek sehr
einfach den Biblitheks-typ ermitteln können, um dann die Linker-Einstellungen Ihres Projekts zu aktualisieren. Beachten Sie, das die
ganze KDE-Bibliotheksdokumentation Ihnen nur zur Verfügung steht, wenn Sie diese Mit KDoc, dem im KDE-SDK enthaltenen Programm,
erstellt haben. Da das Installationsprogramm von KDevelop dies automatisch erstellt, sollten Sie daher KDoc vor der Installation von
KDevelop installieren. Sie können die Dokumentation jedoch jederzeit mit den Optionen im 
<link linkend="KDevelop-Setup">KDevelop Setup</link> Dialog erstellen.</para>

<para>Der Dokumentationsbaum enthält weiterhin den Ordner "Andere", der zum Hinzufügen eigener Dokumentation gedacht ist, wie unten
beschrieben. Schließlich gibt Ihnen der Dokumentationsbaum Zugriff auf die API und das Handbuchs Ihres aktuellen
Projekts.</para>
</sect2>

<sect2 id="hinzufgen-eigener-dokumentation-zum-hilfebro">
<title>Hinzufügen eigener Dokumentation zum Hilfebrowser</title>

<para>Um Ihren Hilfe-Browser anzupassen, öffnen Sie die Baumansicht und wählen Sie den "DOC" Tabulator.Sie sehen dann einen geöffneten Baum,
der vier enthält. Der Ordner "Andere" ist Standardmäßig leer. Durch einen rechten Mausklick über diesem Ordner rufen Sie das
Kontextmenü auf, das einen Befehl "Eintrag hinzufügen" enthält. Wählen Sie diesen aus, um das Dialogfeld "Eintrag hinzufügen"
aufzurufen, in dem Sie zwei Werte angeben müssen: der Obere für den Namen, der die Dokumentation im Baum repräsentiert, und darunter
eine Datei-Eingabezeile. Hier geben Sie den Pfad und Dateinamen zur Startseite der Dokumentation an, die bei einer späteren Auswahl
aufgerufen wird. Sie können den Pfad und Dateinamen direkt angeben oder durch einen Dateiauswahl-Dialog setzen, den Sie durch Betätigen
der Schlatfläche mit dem geöffneten Ordner aufrufen. Dies erlaubt Ihnen das Schnelle durchsuchen Ihres Systems nach dem Pfad zur
Startseite. Bedenken Sie, das Sie nur auf HTML-Dokumentation zugreifen können, also nur HTML-Dateien sind zur Auswahl erlaubt. Wählen
Sie OK, um den Eintrag dem Dokumentationsbaum hinzuzufügen.</para>
</sect2>

<sect2 id="verwendung-des-suchindexes">
<title>Verwendung des Suchindexes</title>

<para>KDevelop enthält eine ganze Reihe von Funktionen, die Ihnen helfen, Informationen innerhalb der HTML-Dokumentation zu suchen. Um diese
Fähigkeiten zu nutzen, benötigen Sie das Programm "Glimpse", einem frei erhältlichen Datenbank-Generator, der den Suchindex erstellt
und Anfragen in der Dokumentation bearbeitet. Um den Suchindex zu erstellen, lesen Sie bitte den Abschnitt 
<link linkend="KDevelop-Setup">KDevelop Setup</link>. Der Index wird ebenfalls automatisch während des 
Installationsprogramms erstellt.</para>

<para>Die Suchfunktionen stehen Ihnen über verschiedene Wege zur Verfügung:
<orderedlist><listitem>
<para>Im Editor: wählen Sie den Text aus, zu dem Sie Hilfe benötigen oder plazieren Sie den Cursor im Wort, das Sie suchen. Dann wählen
Sie im Kontextmenü den Eintrag "Suche: &&lt;;Ausdruck&&gt;;". Sie können dies auch über den Eintrag "Suche Markierten Text" aus dem
Hilfe-Menü, die Schnelltaste F2 oder die entsprechende Schlaltfläche der Werkzeugleiste aufrufen.</para>
</listitem>
<listitem>
<para>Im Dokumentationsbrowser: wählen Sie den Text aus, den Sie suchen und wählen Sie wie vor im Kontextmenü den Eintrag "Suche:
&&lt;;Ausdruck&&gt;;", optional den Befehl "Suche Markierten Text" oder die Schaltfläche der Werkzeugleiste wie oben.</para>
</listitem>
<listitem>
<para>Wenn Sie nach einem speziellen Ausdruck suchen, wählen Sie "Suche nach Hilfe zu..." im Hilfe-Menü oder wählen Sie die
entsprechende Schaltfläche aus der Werkzeugleiste, die einen Suchdialog öffnet, in dem Sie den gesuchten Ausdruck eingeben können.</para>
</listitem>
</orderedlist>

Direkten Zugriff auf spezielle Dokumentation erhalten Sie über die entsprechenden Symbole im Dokumentationsbaum oder den Einträgen des
Hilfe-Menüs.</para>

<para>Der Hilfebrowser bietet weiterhin Unterstützung für Grep, um eine Auswahl innerhalb ihres Projektes zu suchen, z.B. wenn Sie die
Dokumentationsseite zur <literal remap="tt">KTMainWindow</literal> Klasse (KDEUI Bibliothek) geöffnet haben und Sie wissen möchten, wo Sie innerhalb ihres Codes
der Ausdruck <literal remap="tt">KTMainWindow</literal> erscheint. Markieren Sie <literal remap="tt">KTMainWindow</literal> und wählen Sie dann entweder "Grep: KTMainWindow" oder die
Schnelltaste UMSCHALT+F2. Der "Suchen in Dateien" Dialog erscheint dann sofort mit den Ergebnissen Ihrer Grep-Suche. Sie können die
entsprechenden Ergebnisse auswählen, um zum Quellcode zu wechseln.</para>
</sect2>
</sect1>
</chapter>

<chapter id="arbeiten-mit-dem-editor">
<title>Arbeiten mit dem Editor</title>

<para>Ein wichtiger Teil der Integrierten Entwicklungsumgebung ist der Editor. Sie benutzen ihm, um:
<itemizedlist>
<listitem>
<para>Quellcode- und Projektdateien zu erzeugen, öffnen und speichern</para>
</listitem>
<listitem>
<para>Quellcode- und Projektdateien zu bearbeiten</para>
</listitem>
<listitem>
<para>Ihre SGML-Dokumentation zu schreiben</para>
</listitem>
<listitem>
<para>Ihre Projektdateien zu drucken</para>
</listitem>
</itemizedlist>

Im allgemeinen unterscheidet sich der Editor nicht so sehr von anderen; speziell da es eine angepasste Version des bekannten KWrite,
auch als "Erweiterter Editor" bekannt, ist. Wenn Sie damit vertraut sind, werden Sie keine Probleme bei der Verwendung zur Verwaltung
Ihrer Projekte haben. Zusätzlich zu normalen Editoren enthält KDevelop ein neues Drucksystem, das speziell auf die Verwendung mit
Quellcode zugeschnitten ist- und Sie können das zu verwendende Druckprogramm auswählen.</para>

<para>Dieser Abschnitt gibt Ihnen weitere Informationen darüber, wie Sie Ihre Projektdateien verwalten und macht Sie mit den Funktionen des
Editors bekannt. Eine Menge Unix-Hardliner würden sicher Emacs oder XEmacs bevorzugen- Sie sind damit zufrieden. Aber letztlich ist es
zur einfachen Programmierung, speziell für Anfänger, nicht nötig, sich in solch starke Editoren einzuarbeiten, die letzendlich doch nur
zur Eingabe des Codes verwendet werden.</para>

<sect1 id="organisation-von-projektdateien">
<title>Organisation von Projektdateien</title>

<para>Der folgende Abschnitt beschreibt, wie Sie Projektdateien anlegen, speichern, öffnen und schließen- beachten Sie, das dies noch nicht
die Übersetzungsdateien und Grafiken beinhaltet. Diese werden automatisch erkannt und mit den entsprechenden Bearbeitungsprogrammen wie
KTranslator geöffnet.</para>

<para>Um Ihnen einen einfachen Zugriff auf Ihre Dateien zu geben, enthält KDevelop zwei einfach zu bedienende Baumansichten, ähnlich eines
Dateimanagers, der die Auswahl einer Datei registriert und sie im entsprechenden Fenster öffnet. Die Haupansicht enthält zwei
Editierfenster, die unabhängig voneinander arbeiten aber über den Projekt-Editor verbunden sind, sodaß Sie die gleichen Menübefehle
verwenden können. Das C/C++ Fenster übernimmt dabei gleichzeitig die Aufgabe, Ihnen das einzelne Übersetzen von Quellcode-Dateien zu
ermöglichen, damit Sie die Implementierung prüfen können, ohne einen vollständigen Erstellungsvorgang aufrufen zu müssen.</para>

<para>Dies können Sie, wenn das C/C++ Fenster sichtbar ist, durch Auswahl von "Datei compilieren" aus dem "Bauen" Menü oder das
entsprechende Symbol der Werkzeugleiste aufrufen. Ihre Datei wird dann gespeichert und übersetzt, wie üblich stehen Ihnen dann die
Compilermeldungen im Ausgabe-Fenster zur Verfügung.</para>

<para>Innerhalb der Entwicklungsumgebung können Sie soviele Dateien öffnen, wie Sie möchten. Alle geöffneten Dateien werden im Fenster-Menü aufgelistet, damit
Sie zwischen den Dateien durch Auswahl des Dateinamens wechseln können. Weiterhin wird der Dateiname der aktuell geöffneten Datei in
der Titelleiste von KDevelop angezeigt.</para>

<sect2 id="erzeugen-und-speichern-von-dateien">
<title>Erzeugen und Speichern von Dateien</title>

<para>Um eine neue Datei anzulegen, wählen Sie "Neu" aus dem Menü "Datei". Dies öffnet das Dialogfeld "Neue Datei", in dem Sie den Dateinamen
und Typ angeben. Zuätzlich können Sie das Verzeichnis auswählen, in dem die Datei angelegt werden soll und ob die Datei dem Projekt
hinzugefügt werden soll. Schließlich können Sie neben fertigen Dateischablonen auch Ihre Header-Vorlage verwenden, um Quelltextdateien
dem Projekt hinzuzufügen.</para>

<para>Nachdem die Datei angelegt wurde, könne Sie diese wie gewohnt bearbeiten; wenn Sie zwischen Dateien wechseln, können Sie wieder
zurückkehren, indem Sie die Datei entweder in den Dateibäumen oder dem Fenster-Menü auswählen.</para>

<para>Um Änderungen zu speichern bietet KDevelop eine Reihe von Möglichkeiten. Normalerweise würden Sie Dateien durch Auswahl von "Speichern"
oder "Speichern unter" aus dem Menü Datei oder über das entsprechende Symbol der Werkzeugleiste sichern. Um alle geänderten Dateien
gleichzeitig zu sichern, können Sie im Menü Datei auch "Alles Speichern" auswählen.</para>

<para>Nun, wenn Sie an einem Projekt arbeiten, wäre es sehr unangenehm, wenn Sie durch kritische Systemzustände Ihre Änderungen verlieren
würden weil das Abspeichern vergessen wurde. KDevelop kann dies für Sie übernehmen, indem es automatisches Abspeichern anbietet, das
Standardmäßig eingeschaltet ist und alle Änderungen in Intervallen von 5 Minuten abspeichert. Sie können auch ein anderes Intervall
einstellen oder das automatische Abspeichern zu verhindern, näheres dazu finden Sie im Abschnitt <link linkend="KDevelop-Setup">KDevelop Setup</link>.</para>

<para>Zusätzlich dazu übernimmt KDevelop die Kontrolle über Ihre Änderungen, wenn Sie zu einem anderen Projekt wechseln oder die Entwicklungsumgebung
verlassen wollen. Sie werden dann gefragt, ob Sie die geänderten Dateien speichern wollen, wobei Sie ebenso angeben können, welche
Datei Sie sichern möchten und welche nicht. Weiterhin werden beim Aufruf eines Erstellungsprozesses Ihre Dateien automatisch
gespeichert, so das Sie sich nie fragen müssen, warum Ihre Applikation nach durchgeführten Änderungen nicht das tut, was Sie
beabsichtigten. Die einzige Ausnahme davon bildet das Kommando "Datei compilieren", welches nur die aktuelle Quellcodedatei speichert
und diese dann übersetzt.</para>
</sect2>

<sect2 id="ffnen-und-schlieen-von-dateien">
<title>Öffnen und Schließen von Dateien</title>

<para>Um eine Quellcodedatei zu öffnen, bieten Sich ebenfalls mehrere Möglichkeiten. Eine könnte sein, das Sie wie bei normalen Editoren den
Eintrag "Öffnen" im Menü Datei auswählen. Dann zeigt sich Ihnen ein "Datei öffnen" Dialog, in dem Sie die zu öffnende Datei auswählen.
Ein weiterer, wahrscheinlich schnellerer Weg ist, die gewünschte Datei aus der Logischen Dateiansicht (LFV) oder dem RFV auszuwählen
(siehe <link linkend="bersicht">\|\|</link>). Der Vorteil der Dateibäume ist, das Sie Ihnen einen schnellen visuellen Zugang zu Ihren Dateien bieten,
besonders der LFV, der nur Ihre Projektdateien nach Typ sortiert anzeigt. Sie können den LFV auch in seiner Sortierfunktion
konfigurieren, indem Sie das Kontextmenü über der Dateiansicht verwenden. Wählen Sie hier "Neue Gruppe" um eine neue Sortierung
hinzuzufügen, "Eigenschaften", um die aktuelle Konfiguration einer Gruppe zu ändern und "Gruppe entfernen" um den Dateifilter und die
Gruppe zu löschen. Beim hinzufügen einer Gruppe geben Sie den Gruppennamen und den Dateifiler an, indem Sie eine durch Kommata
getrennte Liste der Dateierweiterungen angeben.</para>

<para>Die Standardgruppen eines Projekts werden durch den KAppWizard festgelegt durch Header, Sources, GNU und Others. Zusätzlich fügt
KDevelop automatisch eine Gruppe "Translations" (Übersetzungen) beim Anlegen einer Übersetzungsdatei hinzu, die Ihre *.po Dateien
enthält.</para>

<para>Um Dateien zu schließen, wählen Sie die zu schließende Datei aus dem Fenster-Menü, um Sie in den aktuellen Editor zu laden. Dann wählen
Sie aus dem Menü "Datei" den Eintrag "Schließen". Sollte die Datei als geändert markiert sein, werden Sie gefragt, ob Sie die
Änderungen speichern möchten. Wenn Sie ein Projekt schließen, werden alle geöffneten Dateien auf Änderungen geprüft und Sie werden dann
ebenfalls um Abspeicherung gefragt.</para>
</sect2>
</sect1>

<sect1 id="navigieren-innerhalb-von-dateien">
<title>Navigieren innerhalb von Dateien</title>

<para>Folgender Abschnitt gibt Ihnen eine allgemeine Beschreibung, wie Sie bestimmte Positionen innerhalb Ihrer Dateien schneller erreichen.</para>

<para><emphasis remap="bf"> Wie Sie eine bestimmte Zeile in einer Datei finden</emphasis></para>

<para><orderedlist><listitem>
<para>Wählen Sie "Gehe zu Zeile" aus dem Menü Ansicht oder die entsprechende Schnelltaste STRG+G. Das Dialogfeld "Gehe zu Zeile"
erscheint.</para>
</listitem>
<listitem>
<para>Geben Sie die gewünschte Zeilennummer ein, zu der Sie wechseln möchten.</para>
</listitem>
<listitem>
<para>Wählen Sie die Schaltfläche OK.</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf"> Wie Sie ein Lesezeichen setzen</emphasis></para>

<para><orderedlist><listitem>
<para>Setzen Sie den Cursor in die Zeile, die Sie über ein Lesezeichen erreichen wollen.</para>
</listitem>
<listitem>
<para>Wählen Sie "Lesezeichen setzen" aus dem "Lesezeichen"-Menü.</para>
</listitem>
<listitem>
<para>Ein Popup-Menü erscheint, indem Sie die Lesezeichen-Nummer angeben können, über die Sie das Lesezeichen erreichen.</para>
</listitem>
<listitem>
<para>Wählen Sie die zu vergebende Lesezeichen-Nummer</para>
</listitem>
</orderedlist>
</para>

<para>Ein weiterer Weg, Lesezeichen zu Setzen, wäre der Befehl "Lesezeichen hinzufügen" aus dem "Lesezeichen"-Menü. Dies fügt die aktuelle
Zeile der Lesezeichen-Liste hinzu. Der Dokumentationsbrowser bietet ebenfalls das Setzen eines Lesezeichens zur aktuellen Seite über
einen zusätzlichen Eintrag im Kontext-Menü an.</para>

<para><emphasis remap="bf"> Wie Sie Lesezeichen löschen</emphasis></para>

<para>Die Lesezeichen sind für jedes Fenster separat gesetzt- bedenken Sie, das Ihre Lesezeichen nicht mit einer bestimmten Datei verbunden
sind. Um alle Lesezeichen zu löschen, wählen Sie "Lesezeichen löschen" aus dem Lesezeichen-Menü. Dies löscht die Lesezeichen des
aktuell geöffneten Fensters.</para>

<para><emphasis remap="bf"> Wie Sie zu einem Lesezeichen wechseln</emphasis></para>

<para><orderedlist><listitem>
<para>Wählen Sie das Lesezeichen-Menü und öffnen Sie das Menü, das die Lesezeichen für das Fenster enthält, in dem sich die gewünschte
Datei befindet.</para>
</listitem>
<listitem>
<para>Wählen Sie den gesuchten Eintrag aus, um zum Lesezeichen zu wechseln.</para>
</listitem>
</orderedlist>
</para>

<para>Wenn Sie ein Browser-Lesezeichen auswählen, wird der Browser mit der entsprechenden Seite geöffnet.</para>
</sect1>

<sect1 id="arbeiten-mit-schnelltasten">
<title>Arbeiten mit Schnelltasten</title>

<para>Wenn Sie mit dem Editor arbeiten, sollten Sie sich mit den gebotenen Schnelltasten vertraut machen, die es Ihnen vereinfachen, den
Cursor zu positionieren und Dateien zu bearbeiten. Eine vollständige Tastatur-Kurzreferenz finden Sie ebenfalls im Abschnitt <link linkend="bersicht">Übersicht</link>.</para>

<para><programlisting>um ein Zeichen nach links                               LINKS
um ein Zeichen nach rechts                              RECHTS
um ein Wort nach links                                  STRG+LINKS
um ein Wort nach rechts                                 STRG+RECHTS
eine Zeile nach oben                                    OBEN
eine Zeile nach unten                                   UNTEN
zum Anfang der aktuellen Zeile                          POS 1
zum Ende der aktuellen Zeile                            ENDE
eine Bildschirmseite nach oben                          BILD-OBEN
eine Bildschirmseite nach unten                         BILD-UNTEN
zum Anfang der Datei                                    STRG+BILD-OBEN
zum Ende der Datei                                      STRG+BILD-UNTEN
um ein Zeichen nach links                               UMSCHALT+LINKS
um ein Zeichen nach rechts                              UMSCHALT+RECHTS
um ein Wort nach links                                  STRG+UMSCHALT+LINKS
um ein Wort nach rechts                                 STRG+UMSCHALT+RECHTS
um eine Zeile nach oben                                 STRG+OBEN
um eine Zeile nach unten                                STRG+UNTEN
zum Anfang der aktuellen Zeile                          STRG+POS 1
zum Ende der aktuellen Zeile                            STRG+ENDE
um eine Bildschirmseite nach oben                       UMSCHALT+BILD-OBEN
um eine Bildschirmseite nach unten                      UMSCHALT+BILD-UNTEN
bis zum Anfang der Datei                                STRG+UMSCHALT+BILD-OBEN
bis zum Ende der Datei                                  STRG+UMSCHALT+BILD-UNTEN
Einfügemodus ein/ausschalten                            EINFG
markierten Text in die Zwischenablage kopieren          STRG+C, STRG+EINF
Inhalt der Zwischenablage einfügen                      STRG+V, UMSCHALT+EINF
aktuelle Zeile löschen                                  STRG+K
Absatz nach der aktuellen Zeile einfügen                ENDE, dann EINGABETASTE
Absatz vor der aktuellen Zeile einfügen                 POS 1, dann EINGABETASTE
Bearbeitung rückgängig machen                           STRG+Z
Rückgängig gemachte Bearbeitung wiederherstellen        STRG+Y
Tabulator einfügen                                      TAB
Zeichen links vom Cursor löschen                        RÜCKTASTE
Zeichen rechts vom Cursor löschen                       ENTF
markierten Text löschen                                 Text auswählen, dann RÜCKTASTE oder ENTF</programlisting>
</para>
</sect1>

<sect1 id="einstellen-des-editors">
<title>Einstellen des Editors</title>

<para>Den Editor von KDevelop können Sie nach Ihren individuellen Bedürfnissen konfigurieren. Dabei können Sie die Farbdarstellung,
Hervorhebungen (auch konfigurierbar entsprechend der Programmiersprache von Dateien) und automatischen Texteinstellungen wie die
Tabulatorweite und Auswahl-Modi einstellen. Im Folgenden wird Ihnen das Einstellen dieser Optionen durch die Konfigurationsdialoge
beschrieben, die Sie im Menü "Einstellungen" finden.</para>

<sect2 id="allgemeine-einstellungen">
<title>Allgemeine Einstellungen</title>

<para>Die allgemeinen Einstellungen des Editors können Sie durch auswählen des Eintrags "Editor" im "Einstellungen" Menü konfigurieren.
Wählen Sie die gewünschten Einstellungen aus und beenden Sie den Dialog mit OK, um die neue Konfiguration zu übernehmen.</para>

<sect3 id="bearbeitungsoptionen">
<title>Bearbeitungsoptionen</title>

<para><variablelist>
<varlistentry>
<term>Automatisch einrücken:</term>
<listitem>
<para>Setzt den Cursor unter das erste Zeichen der oberen Zeile nach Eingabe von ENTER</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Ausrückung:</term>
<listitem>
<para>Setzt den Cursor unter das erste Zeichen der oberen Zeile nach Eingabe von RÜCKTASTE</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Zeilenumbruch:</term>
<listitem>
<para>automatischer Zeilenumbruch, falls Text über die in "Zeilenumbruch bei:" angegebene Spalte hinausragt</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Tabs ersetzen:</term>
<listitem>
<para>Tabularoren im aktuellen Text durch Tabulatoren der Weite "Tabbreite:" ersetzen</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Leerzeichen am Zeilenende:</term>
<listitem>
<para>entfernt nachfolgende Leerzeichen am Zeilenende</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Zeilenumbruch am Cursor:</term>
<listitem>
<para>Setzt den Cursor an das Ende der oberen Zeile, wenn RÜCKTASTE am Anfang einer Zeile eingegeben wird</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Automatische Klammern:</term>
<listitem>
<para>fügt eine schließende Klammer vor dem Cursor ein, falls eine öffnende Klammer eingegeben wird (jede
Klammerart)</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect3>

<sect3 id="auswahloptionen">
<title>Auswahloptionen</title>

<para><variablelist>
<varlistentry>
<term>Durchgehende Auswahl:</term>
<listitem>
<para>bleibende Auswahl nach Plazierung des Cursors an anderer Stelle</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Mehrfache Auswahl:</term>
<listitem>
<para>erlaubt mehrfache Auswahl innerhalb des Texts</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Vertikale Auswahl:</term>
<listitem>
<para>erlaubt die vertikale Auswahl von Text</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Beim Eingeben löschen:</term>
<listitem>
<para>löscht markierten Text bei Eingabe innerhalb der Auswahl</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Alt ein</term>
<listitem>
<para>aus:/ erlaubt nur eine Auswahl. Eine bereits getroffene Auswahl wird bei erneuter Markierung abgewälht</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Zeilenumbruch bei:</term>
<listitem>
<para>stellt die maximale Spaltenzahl ein, die eine Zeile umfasst. Das letzte Wort wird bei überschreiten der
Spaltenzahl in die nächste Zeile umgebrochen.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect3>
</sect2>

<sect2 id="farben">
<title>Farben</title>

<para>Um die allgemeine Erscheinung des Editors anzupassen, können Sie über den Eintrag "Editor-Farben" im Menü "Einstellungen" folgende
Farbdarstellungen konfigurieren:</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Hintergrund:        </emphasis>       Hintergrundfarbe des Editors</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Texthintergrund:    </emphasis>     	Hintergrundfarbe des dargestellten Textes</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Gewählt:            </emphasis>       Farbdarstellung von markiertem Text</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Gefunden:           </emphasis>       Farbdarstellung von gefundenen Textstellen bei Suchen über die Einträge "Suchen", "Suche
wiederholen" und "Ersetzen" im Menü "Bearbeiten"</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Gewählt + Gefunden: </emphasis>       Farbdarstellung von gefundenen Textstellen innerhalb von Auswahlen.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="hervorhebungen">
<title>Hervorhebungen</title>

<para>Den Hervorhebungs-Modus des KDevelop Quellcode-Editors können Sie über zwei Dialoge konfigurieren; eine Standardeinstellung über das
Dialogfeld "Editor-Voreinstellung" und eine Programmiersprachen-Spezifische im Dialogfeld "Hervorhebungen". Beide Dialoge erreichen Sie
über das Menü "Einstellungen.</para>

<para>Im Dialog "Voreinstellungen" geben Sie für die Elemente (z.B. Schlüsselwörter) jeweils die Standardwerte ein, indem Sie Farbe,
Schriftart und -größe angeben. Um eine Programmiersprachendarstellung anzupassen, geben Sie die entsprechenden Werte im
"Hervorhebungen"-Dialog an. Dort können Sie die Standardwerte verwenden, indem Sie für die gewählten Elemente jeweils die Option
"Standard" markieren.</para>
</sect2>
</sect1>

<sect1 id="suchen-und-ersetzen">
<title>Suchen und Ersetzen</title>

<sect2 id="suchen-in-einer-datei">
<title>Suchen in einer Datei</title>

<para><emphasis remap="bf"> Wie Sie ein oder mehrere Zeichen im aktuellen Editor finden</emphasis>
<orderedlist><listitem>
<para>Wählen Sie "Suchen" aus dem Menü "Bearbeiten". Dies öffnet die Suchen-Dialog</para>
</listitem>
<listitem>
<para>Geben Sie den gesuchten Ausdruck im Editierfeld ein. Das Menü bietet die Auswahl eines bereits gesuchten Ausdrucks.</para>
</listitem>
<listitem>
<para>Geben Sie zusätzliche Optionen an wie "Nur ganze Wörter"</para>
</listitem>
<listitem>
<para>Bestätigen Sie mit OK.</para>
</listitem>
</orderedlist>
</para>

<para>Um eine Suche zu wiederholen, drücken Sie F3.</para>
</sect2>

<sect2 id="suchen-ber-mehrere-dateien">
<title>Suchen über mehrere Dateien</title>

<para>Da die Suchfunktion standardmäßig nur über die aktuelle Datei läuft, wären Sie darauf beschränkt. Oft benötigen Sie jedoch
Suchfunktionen über Ihr ganzes Projekt. Daher bietet KDevelop einen <literal remap="tt">grep</literal>-Dialog an, mit dem Sie diese Suchfunktion durchführen
können. Dort können Sie das Startverzeichnis und/oder Dateierweiterung der zu durchsuchenden Dateien angeben, um die zur Suche
benötigte Zeit zu reduzieren und die Ergebnisse auszugeben. Um eine Suche über mehrere Dateien durchzuführen, wählen Sie "Suche in
Dateien" aus dem Menü "Bearbeiten". Der Suchdialog erscheint und läßt sie angeben:</para>

<para><itemizedlist>
<listitem>
<para>Der gesuchte Ausdruck</para>
</listitem>
<listitem>
<para>Die Suchvorlage</para>
</listitem>
<listitem>
<para>Die Dateierweiterung der zu durchsuchenden Dateien</para>
</listitem>
<listitem>
<para>Das Startverzeichnis</para>
</listitem>
<listitem>
<para>Ob die Suche rekursiv über alle Unterverzeichnisse durchgeführt werden soll</para>
</listitem>
</itemizedlist>
</para>

<para>Standardmäßig ist der <literal remap="tt">grep</literal>-Dialog auf das Projektverzeichnis und rekursive Suche über Implementations- und Headerdateien
eingestellt.</para>

<para>Sie können die Suche weiter spezifizieren, indem Sie folgende Optionen verwenden:</para>

<para><orderedlist><listitem>
<para><emphasis remap="bf">.</emphasis> Jedes Zeichen</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&circ;;</emphasis> Beginn einer Zeile</para>
</listitem>
<listitem>
<para><emphasis remap="bf">$</emphasis> Ende einer Zeile</para>
</listitem>
<listitem>
<para><emphasis remap="bf">\&lt; </emphasis> Anfang eines Wortes</para>
</listitem>
<listitem>
<para><emphasis remap="bf">\&gt; </emphasis> Ende eines Wortes</para>
</listitem>
</orderedlist>
</para>

<para>Um Suchen zu wiederholen, sind folgende Operatoren verfügbar:
<orderedlist><listitem>
<para><emphasis remap="bf">?</emphasis> Das vorherige Element höchstens einmal</para>
</listitem>
<listitem>
<para><emphasis remap="bf">*</emphasis> Das vorherige Element gar nicht oder mehrmals</para>
</listitem>
<listitem>
<para><emphasis remap="bf">+</emphasis> Das vorherige Element einmal oder mehrmals</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;; n &&rcub;;</emphasis> Das vorherige Element genau <emphasis>n</emphasis> mal</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;; n,&&rcub;;</emphasis> Das vorherige Element <emphasis>n</emphasis> mal und darüber</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;;,n &&rcub;;</emphasis> Das vorherige Element höchstens <emphasis>n</emphasis> mal</para>
</listitem>
<listitem>
<para><emphasis remap="bf">&&lcub;;n,m&&rcub;;</emphasis> Das vorherige Element mindestens <emphasis>n</emphasis> mal, aber weniger als <emphasis>m</emphasis> mal.</para>
</listitem>
</orderedlist>
</para>

<para>Rückwärtsreferenzen zu eingeklammerten Unterausdrücken sind durch die Notation <emphasis>\n</emphasis> verfügbar.</para>

<para>Nach der Spezifizierung der Suche betätigen Sie die Schaltfläche "Suchen". Die Ergebnisse werden dann im Ergebnis-Fenster angezeigt. Um
zu einer Datei und Zeile zu springen, wählen Sie das Ergebnis aus und drücken Sie EINGABE oder doppelklicken Sie auf das Ergebnis. Der
Editor öffnet dann automatisch die Datei und setzt den Cursor an die gewünschte Zeile. Dies erlaubt eine vollständige Spezifikation von
Suchaktionen und liefert Ihnen exakte Ergebnisse.</para>

<para>KDevelop bietet darüberhinaus noch weitere spezielle Funktionen, mit der Sie grep innerhalb des Editors und Browsers verwenden können.
Wählen Sie den Suchausdruck in einem Fenster aus und drücken Sie UMSCHALT+F2 oder wählen Sie "grep:&&lt;;Ihr&&lowbar;;Ausdruck&&gt;;" aus dem
Kontextmenü. Dies führt automatisch eine Suche über Ihr Projektverzeichnis aus und zeigt die Ergebnisse sofort an. Wechseln Sie
zwischen den Ergebnissen wie vor. Innerhalb des Editors genügt es, den Cursor auf ein Wort zu plazieren; dieses wird dann als
Suchausdruck verwendet.</para>
</sect2>

<sect2 id="suchen-innerhalb-der-dokumentation">
<title>Suchen innerhalb der Dokumentation</title>

<para>Wenn Sie an einem Projekt arbeiten, benötigen Sie oft Informationen über die Parameter von Memberfunktionen, die Sie verwenden möchten-
meist behalten Sie den Funktionsnamen, den sie benutzen wollen, aber die Parameter sind sehr schwer zu merken. Daher und zu anderen
Gelegenheiten bietet Ihnen KDevelop eine Suchfunktion, die die Suche nach Ausdrücken in Dateien innerhalb der Dokumentation ermöglicht.
Um diese Suchfunktion zu verwenden, sollte der Dokumentationsbrowser korrekt eingerichtet sein und der Suchindex vorhanden sein. Eine
Suche führen Sie durch, indem Sie:</para>

<para><orderedlist><listitem>
<para>den Cursor auf dem gesuchten Wort plazieren oder eine Auswahl markieren</para>
</listitem>
<listitem>
<para>Im Menü "Hilfe" den Eintrag "Suche Markierten Text", das entsprechende Werkzeugleistensymbol oder im Kontextmenü "Suche:
Ausdruck" auswählen</para>
</listitem>
<listitem>
<para>nachdem die Ergebnisseite im Dokumentationsbrowser erscheint, wählen Sie die Seite aus, die die gewünschte Information enthält</para>
</listitem>
<listitem>
<para>die ausgewählte Dokumentationsseite wird mit markierem Ergebnis angezeigt. Um das nächste Ergebnis auf der selben Seite
anzuzeigen, drücken Sie F3</para>
</listitem>
</orderedlist>
</para>

<para>Dies erlaubt es Ihnen, sehr einfach und schnell die gewünschte Information zu finden. Um die Ergebnisse besser zu verwenden, erlaubt
der Dokumentationsbrowser, eine Auswahl zu markieren und in die Zwischenablage zu kopieren. Dann wechseln Sie zurück zum Editor und
fügen den Inhalt der Zwischenablage über das Menü "Bearbeiten"-"Einfügen" and der gewünschten Stelle ein. Eine vollständige
Beschreibung zur Verwendung der Dokumentation finden Sie unter <link linkend="Verwendung-des-Suchindexes">Verwendung des Suchindexes</link>.</para>
</sect2>

<sect2 id="ersetzen-von-text">
<title>Ersetzen von Text</title>

<para>Um einen Ausdruck zu ersetzen, wählen Sie "Suchen und Ersetzen" aus dem Menü "Bearbeiten". Das Dialogfeld "Suchen und Ersetzen" läßt
Sie den zu ersetzenden Ausdruck und den Ersatztext angeben. Dann bestätigen Sie mit OK. Das erste Ergebnis wird markiert dargestellt,
damit Sie sehen, wo sich der Ausdruck befindet und in welchem Kontext. Dann können Sie über ein Dialogfeld bestimmen, ob Sie die
Textstelle ersetzen wollen oder nicht. Wenn das Dateiende erreicht wird, werden Sie gefragt, ob Sie die Suche am Anfang der Datei
weiterführen möchten. Sind Sie mit dem ersetzen fertig, wählen Sie "Abbrechen".</para>
</sect2>
</sect1>

<sect1 id="drucken">
<title>Drucken</title>

<para>Da KDevelop so entworfen wurde, daß Entwicklern der bestmögliche Zugriff auf Dateien und Informationen ermöglicht wird, um so 
die Anzahl der Entwicklungszyklen zu verringern, enthält es auch ein Druck Utility das Gebrauch von <emphasis>enscript</emphasis> macht. 
Außerdem können Sie auch mit Hilfe von lpr direkt auf dem Druckerport ausgeben. Da die Verwendung von enscript ein Höchstmaß 
an Druckeroptionen zur Verfügung stellt, sollten Sie es installieren. Es wird bei den meisten Distributionen mitgeliefert, es sollte 
also kein Problem sein es zu bekommen. Bevor Sie jedoch drucken, sollten Sie einen Blick auf die verfügbaren 
Konfigurationsdialoge werfen, um die Ausgabe Ihren Bedürfnissen anzupassen. Der folgende Abschnitt beschreibt die Konfiguration 
von KDevelop zum Ausdrucken von Dateien.</para>

<sect2 id="druckerkonfiguration">
<title>Druckerkonfiguration</title>

<para>Das Druckprogramm kann über die Auswahl von "Drucken" im Menü "Datei" konfiguriert werden; in dem Druckdialog wählen Sie das
zu verwendende Programm über die Combobox in der linken oberen Ecke. Dann betätigen Sie die Schaltfläche "Einstellungen" auf der
rechten Seite. Dies öffnet den Konfigurationsdialog des Programms. Sie können das Programm ebenfalls konfigurieren, indem
Sie im Menü "Einstellungen", Untermenü "Drucker konfigurieren" enscript auswählen .</para>

<sect3 id="die-enscript-konfigurationseinstellungen">
<title>Die enscript Konfigurationseinstellungen</title>

<sect4 id="kopf">
<title>Kopf</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Eigener Kopf:</emphasis> fügt einen eigenen Kopf ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Kopftext:</emphasis> ermöglicht die Einstellung des Kopftextes
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Text:</emphasis> setzt den Inhalt des Kopftextes</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> setzt die Position des Kopftextes auf links, mittig oder rechts</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Login:</emphasis> fügt die User-ID dem Kopf hinzu
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Login:</emphasis> schaltet die Hinzufügung ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> bestimmt die Position der User ID</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Dateiname:</emphasis> Dateinamen dem Kopf hinzufügen
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Größe des Dateinamens:</emphasis> gibt den Dateinamen absolut oder relativ an</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> Position des Dateinamens</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Hostname:</emphasis> fügt den Rechnernamen dem Kopf hinzu
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Hostname:</emphasis> schaltet Hinzufügen ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Größe des Hostnames:</emphasis> Größe des Hostnamens im Kopf</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> Position des Hostnamens</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect4>

<sect4 id="datum-und-uhrzeit">
<title>Datum und Uhrzeit</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Aktuelles Datum:</emphasis> aktuelles Datum einfügen
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Aktuelles Datum:</emphasis> schaltet aktuelles Datum ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> Position der Datumsangagbe</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Format:</emphasis> Format des Datums</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Änderungsdatum:</emphasis> einfügen des letzten Änderungsdatums
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Änderungsdaum:</emphasis> einfügen einschalten</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> Position des Änderungsdatums</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Format:</emphasis> Datumsformat</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Aktuelle Uhrzeit:</emphasis> aktuelle Uhrzeit angeben
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Aktuelle Uhrzeit:</emphasis> einfügen einschalten</para>
</listitem>
<listitem>
<para><emphasis remap="bf">AM</emphasis>PM:/ Verwendung von AM/PM oder 24h Uhrzeitangabe</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> Position der Zeitangabe</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Format:</emphasis> Format der Zeitangabe</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Änderungsuhrzeit:</emphasis> letzte Änderungsuhrzeit einfügen
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Änderungsuhrzeit:</emphasis> einfügen einschalten</para>
</listitem>
<listitem>
<para><emphasis remap="bf">AM</emphasis>PM:/ Verwendung von AM/PM oder 24h Uhrzeitangabe</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> Position der Zeitangabe</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Format:</emphasis> Format der Zeitangabe</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect4>

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

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Nummerierung & Rahmen:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Zeilen nummerieren:</emphasis> fügt Zeilennumerierungen ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Rahmen:</emphasis> fügt den Seiten einen Rahmen hinzu</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Seiten nummerieren:</emphasis> fügt Seitennumerierungen ein</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Dateien ausrichten:</emphasis> hägt die Dateien zum Ausdruck aneinander an</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Zeilen pro Seite:</emphasis> maximale Anzahl Zeilen pro Seite</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Schrift and TAB:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">TAB-Größe:</emphasis> Tabulatorweite bei Ausdruck</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Schrift für Kopf:</emphasis> Schriftart für Kopftext</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Schrift für Text:</emphasis> Schriftart für Dateiinhalt</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Textdruck:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Zeilen abschneiden:</emphasis> Zeilen abschneiden, die über den Rand hinausragen</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ersetze nicht-druckbare Zeichen durch Leerzeichen:</emphasis> ersetzt nicht-druckbare Zeichen durch Leerzeichen</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Andere Optionen:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Inhaltsverzeichnis:</emphasis> fügt dem Ausruck ein Inhaltsverzeichnis hinzu</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Hervorhebungsbalken:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Hervorhebung:</emphasis> hebt Zeilen abwechselnd im Ausdruck hervor</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Zyklus der Änderung:</emphasis> Anzahl der Zeilen, die jeweils im Block hervorgehoben werden</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Umgebrochene Zeile:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Markiere umgebrochene:</emphasis> umgebrochene Zeilen im Ausdruck markieren</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Wert für umgebrochene:</emphasis> der Aktuelle Wer einer umgebrochenen Zeile</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect4>

<sect4 id="unterlegungen">
<title>Unterlegungen</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Text:</emphasis> Unterlegungstext</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Position:</emphasis> Position des Unterlegungstexts</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Font:</emphasis> Schriftart der Unterlegung</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Winkel:</emphasis> Winkel, unter der der Unterlegungstext von der Horizontalen aus dargestellt wird</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Grauskalierung:</emphasis> Grauskalierung der Unterlegung</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Stil:</emphasis> Darstellung der Unterlegung als ausgefüllten oder umrandeten Text</para>
</listitem>
</itemizedlist>
</para>
</sect4>
</sect3>
</sect2>

<sect2 id="der-druckdialog">
<title>Der Druckdialog</title>

<sect3 id="einstellungen-zum-sofort-druck">
<title>Einstellungen zum Sofort-Druck</title>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Programm:</emphasis> das zu verwendende Druckprogramm: enscript oder lpr</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Drucker:</emphasis> den zu verwendenden Drucker</para>
</listitem>
<listitem>
<para><emphasis remap="bf">in Datei drucken:</emphasis> Ausgabe in Datei umleiten</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Papierformat:</emphasis> Papierformat in Hochformat oder Querformat verwenden</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Kopieren:</emphasis> Seiten beim Ausdruck kopieren</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ausgabemedium:</emphasis> zu verwendende Papiergröße</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ausgabeformat:</emphasis> Druck in HTML oder Postscript ausgeben</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Stadardeinstellungen:</emphasis> Standardeinstellugen zur Druckausgabe</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Ausgabe:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Seitendruck:</emphasis> eine oder zwei Seiten pro Blatt</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Seiten:</emphasis> Auswahl von geraden, ungeraden oder allen Seiten bei Verwendung von enscript</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Schöndruck:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Schöndruck:</emphasis> Schöndruckmodus bei Verwendung von enscript</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Farbe:</emphasis> Farbdarstellung beim Ausdruck verwenden</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Schöndruckmodus:</emphasis> Schöndruckmodus in Abhängigkeit vom Dateiformat</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect3>

<sect3 id="dateiauswahl">
<title>Dateiauswahl</title>

<para>Den Dateiauswahldialog erreichen Sie über die Schaltfläche "Dateien" im Druckdialog. Die Dateiauswahl erlaubt die Angabe der zu
druckenden Dateien nach speziellen Kriterien:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Datei-Auswahl:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Aktuelle:</emphasis> die gerade sichtbare Datei im Editor</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Alle im Projekt:</emphasis> alle Projektdateien ausgeben</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Selbstgewählte Dateien:</emphasis> erlaubt Auswahl von Dateien zum Ausdruck</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Alle Headers:</emphasis> druckt alle Headerdateien des Projekts</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Alle cpp Dateien:</emphasis> druckt alle Implementierungsdateien des Projekts</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Geänderte Dateien:</emphasis> erlaubt die Angabe eines Zeitraumes für die Dateiauswahl</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Geänderte Dateien:</emphasis>
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Zwischen:</emphasis> druckt alle Dateien nach:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Datum:</emphasis> diesem Datum geändert</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Zeit:</emphasis> dieser Uhrzeit geändert</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Und:</emphasis> druckt alle Dateien vor:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Datum:</emphasis> diesem Datum geändert</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Zeit:</emphasis> dieser Uhrzeit geändert</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Selbstgewählte Dateien:</emphasis> verfügbar, falls selbstgewälte Dateien verwendet wird
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Hinzufügen:</emphasis> fügt die im Editierfeld links eingestellte Datei der Dateiauswahl hinzu</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Entfernen:</emphasis> entfernt eine markierte Datei aus der Druckauswahl</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Löschen:</emphasis> löscht die Druckauswahl-Liste</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</itemizedlist>
</para>
</sect3>

<sect3 id="druckvorschau">
<title>Druckvorschau</title>

<para>Die Druckvorschau steht Ihnen zur Verfügung, um die Ausgabe zu kontrollieren. Zur Vorschau selbst verwendet KDevelop entweder
<emphasis>ghostview</emphasis> oder <emphasis>kghostview</emphasis>. Wenn Sie die Schaltfläche "Vorschau" betätigen, wird Ihnen eine Schablone anzeigen, wie die
Ausgabe durch die aktuellen Einstellungen aussehen wird.</para>
</sect3>
</sect2>
</sect1>
</chapter>

<chapter id="projekte">
<title>Projekte</title>

<sect1 id="projekttypen">
<title>Projekttypen</title>

<sect2 id="programme-1">
<title>Programme</title>

<para>KDevelop erzeugt standardmäßig Projektdateien mit der Dateierweiterung .kdevprj. Diese Datei enthält alle Projektinformationen, sodaß
Sie darauf achten sollten sollten, sie nicht zu löschen. Die Datei wird im Hauptverzeichnis des Projekts gespeichert und muß zum Laden des
Projekts geöffnet werden. Die Projektdatei enthält alle Informationen ihrer Dateien wie Dateieigenschaften, Installationspfade,
Distributionsstatus und die Compileroptionen (CXXFLAGS). Das Setzen von Dateioptionen erlaubt Ihnen anzugeben, wohin die Dateien
installiert werden sollen.</para>

<para>Mit dem KAppWizard können Sie ein neues Applikationsprojekt nach dem gewünschten Typ anlegen. Zur Zeit generiert der KAppWizard vier
verschiedene Arten von Rahmenapplikationen:</para>

<para><itemizedlist>
<listitem>
<para>eine SDI-(Single Document Interface, Einzeldokument-Schnittstelle) KDE-Applikation inklusive Menüleiste, Werkzeugleiste und
Statuszeile. Dieser Typ enthält alle Elemente zur einfachen Erweiterung zu einer vollständigen KDE-Applikation. Der Programmrahmen
verwendet bereits Statuszeilen-Hilfenachrichten, wie sie aus kommerziellen Produkten bekannt sind und wie auch KDevelop sie verwendet.
Aus Sicht des Programmierers ist dieses Rahmenprogramm an das MVC (Modell-Ansicht-Controller) Konzept durch Aufteilung des Codes in
drei Klassen ausgelegt. Dieser Applikationstyp bietet bereits eine logische Strukturierung zur Erstellung von Anwendungen mit einer
graphischen Benutzerschnittstelle.
</para>
</listitem>
<listitem>
<para>ein KDE-basiertes Rahmenprogramm. Dieser Applikationstyp bietet die größte Flexibilität für diejenigen, die ihr Programm von
Grund auf entwickeln möchten, kann aber auch als Ausgangspunkt von Wizards und Modulen verwendet werden.
</para>
</listitem>
<listitem>
<para>ein rein Qt-basiertes Rahmenprogramm. Für Entwickler, die nur die Qt-Bibliothek als graphische Benutzerschnittstelle verwenden
möchten, bieten wir dieses intelligente Rahmenprogramm, um die Applikationsenwicklung zu vereinfachen. Da die Qt-Programmierung
vollständig unterstützt wird, sollten Sie keine Probeme bei der Erstellung vollständiger, rein Qt-basierter Applikation haben.
</para>
</listitem>
<listitem>
<para>ein C++ Rahmenprogramm. Dieser Applikationstyp ist für die Entwickler gedacht, die ein Terminal-basiertes C++ Programm schreiben
möchten. Enfernen Sie einfach die Zeile mit "Hello World" in der main()-Funktion und konstruieren Sie Ihre Klassen wie gewöhnlich mit
KDevelop.
</para>
</listitem>
<listitem>
<para>ein C-Rahmenprogramm. Dieser Programmtyp ist auf die Verwendung des C-Compilers beschränkt.</para>
</listitem>
</itemizedlist>
</para>

<para>Desweiteren erlaubt es KDevelop, Projekte für KDE 2 und Qt 2.x zu erstellen. Diese machen, bevor Sie ein Projekt erstellen, die
Installation der benötigten Bibliotheken, sowie das Setzen des entsprechenden Installationspfades im KDevelop Setupdialog,
erforderlich (siehe auch <link linkend="Grundstzliche-Konfiguration">Grundsätzliche Konfiguration</link>), damit sichergestellt ist,
daß alles automatisch funktioniert. Der KDevelop 1.2 Applikations-Wizard enthält zusätzlich ein GNOME-Projekttyp, damit Entwickern die
Möglichkeit gegeben wird, mit KDevelop GTK+-basierte Programme zu erstellen.</para>

<para>Zusätzlich bietet sich KDevelop an, um mit bereits existierenden Projekten zu arbeiten. Diese können jede Option haben, die der
Programmierer selbst in configure und Makefiles gesetzt hat. Soweit es die Ausführung und den Erstellungsprozess betrifft, sind zur
Zeit nur die gleichen Strukturen wie bei der Erstellung von Rahmenprogrammen erlaubt. Erzeugen Sie ein eigenes Projekt mit dem
Applikations-wizard und fügen Sie Ihre Dateien dem Projekt hinzu, um die Bearbeitung mit dem Klassenbrowser zu ermöglichen.</para>

<para>Um den Erstellungsvorgang sicherzustellen, muß Ihr Projekt alle Quellcodes in einem Unterverzeichnis bereithalten, das dem
kleingeschriebenen Projektnamen entspricht; die Ausführung der Binärdatei ist ebenfalls auf den Namen des kleingeschriebenen
Projektnamens beschränkt.</para>

<para>Beachten Sie, das KDevelop selbst keine Informationen in die Makefiles oder Konfigurationsdateien schreibt - Sie sind für das Verhalten
des Projekts vollständig selbst verantwortlich.</para>
</sect2>

<sect2 id="bibliotheken">
<title>Bibliotheken</title>

<para>Ein allgemeiner Projekt-Typ zur Erstellung von Bibliotheken ist zur Zeit nicht verfügbar. Andererseits ist es jedoch nicht unmöglich
mit KDevelop Bibliotheken zu erstellen. Hier erhalten Sie ein paar Richtlinien und Anleitungen:</para>

<para><itemizedlist>
<listitem>
<para>Wann immer Sie in Ihrem Projekt-Unterverzeichnis ein weiteres Unterverzeichnis erstellen, das Quellcodes enthält, wird KDevelop
daraus eine statische Bibliothek erzeugen. Das bedeutet, das statische Bibliotheken grundsätzlich schon durch das Projektmanagement
unterstützt wird, um die Projektdateien übersichtlicher zu sortieren. Beachten Sie, das die statische Bibliothek später ein Teil der
Binärdatei wird und daher nicht installiert wird.</para>
</listitem>
<listitem>
<para>Um eine shared library (dynamische Bibliothek) zu erzeugen, bietet Ihnen KDevelop einen einfachen Weg an, um eine wie oben
beschriebene statischen Bibliothek zu einer dynamischen zu konvertieren: Öffnen Sie den RFV am linken Rand des KDevelop-Hauptfensters
und wechseln Sie zum erzeugten Unterverzeichnis. Dort benutzen Sie den rechten Maus-Button über dem Unterverzeichnis. Das Popup-Menü
bietet dann die folgenden Optionen:
<itemizedlist>
<listitem>
<para>Makefile.am aktualisieren</para>
</listitem>
<listitem>
<para>Zur statischen Bibliothek machen</para>
</listitem>
<listitem>
<para>Zur dynamischen Bibliothek machen</para>
</listitem>
</itemizedlist>

Verwenden Sie "Zur dynamischen Bibliothek machen", um die standardmäßig erzeugte statische Bibliothek zu einer dynamischen zu
konvertieren. Sie können Ihre Entscheidung später auch rückgängig machen, falls Sie sich dazu entscheiden sollten, doch eine statische
Bibliothek zu verwenden- wiederholen Sie einfach die selben Schritte und wählen Sie "Zur statischen Bibliothek machen".</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="mehrere-zielobjekte">
<title>Mehrere Zielobjekte</title>

<para>Für manche Projekte reichen die Möglichkeiten von KDevelop zur Zeit noch nicht aus. Dies sind Projekte, die mehrere Zielobjekte beinhalten, wie 
Pakete, die mehrere Anwendung enthalten. Da Kommandos wie "Ausführen" erfordern, daß nur <emphasis>ein</emphasis> Ziel vom Entwickler erstellt  wird, werden 
solche Projekte nur in der Weise unterstützt, daß Sie Ihre eigenen Einträge in die Makefile.am <indexterm remap="idx"><primary>Makefile.am</primary></indexterm>'s vornehmen und Ihre eigenen Verzeichnisse für 
die zu erstellenden zusätzlichen Bibliotheken oder ausführbaren Dateien erstellen müssen. Dennoch ruft ein Erstellungsprozeß immer Ihr 
Makeprogramm auf, unabhängig davon welche Ziele tatsächlich erstellt werden; diese Funktionen können also weiterhin verwendet werden (mit der 
Einschränkung, daß das Erstellen aus dem Haupt-Projektverzeichnis heraus aufgerufen wird).</para>

<para>Eine weitere Methoden mit diesem Typ von Projekt umzugehen und denoch den Zugriff auf die ausführbaren Dateien zu erhalten, ist das Erstellen von
leeren Projekten mit anschließendem Verschieben der Unterverzeichnisse mit den kdevprj Dateien in das Verzeichnis, das später alle Ihre Quellen 
enthalten wird. Sie könnten dann jedes Ziel unabhängig von den anderen mit Hilfe der zugehörigen kdevprj Datei laden; dies ermöglicht Ihnen auch 
das Ausführen und Debuggen des Zieles.</para>

<para>Mehrere Binärdateien oder Bibliotheken innerhalb Haupt-Projektverzeichnisses sind möglich, wenn Sie sich an die in  
<link linkend="Projekt-Hacking">Projekt Hacking</link> erläuterten Regeln und an die folgenden Richtlinien zum Editieren von Makefile.am im
Projektverzeichnis halten (alle Modifikationen müssen außerhalb der KDevelop write area erfolgen) :</para>

<para><itemizedlist>
<listitem>
<para>Fügen Sie das Ziel bin&&lowbar;;PROGRAMS hinzu, wenn es eine auführbare Datei ist</para>
</listitem>
<listitem>
<para>Fügen Sie Ihre Bibliotheksdeklaration hinzu, wenn es sich um eine dynamische Bibliothek handelt</para>
</listitem>
<listitem>
<para>Fügen Sie dieselben Deklarationen wie beim Originalprojekt hinzu:
<itemizedlist>
<listitem>
<para>NeuesZiel&&lowbar;;METASOURCES</para>
</listitem>
<listitem>
<para>NeuesZiel&&lowbar;;LD&&lowbar;;FLAGS</para>
</listitem>
<listitem>
<para>DISTCLEANFILES</para>
</listitem>
<listitem>
<para>Kopieren Sie die messages Einträge und ersetzen Sie Ziel&&lowbar;;SOURCES Ziel.pot durch NeuesZiel&&lowbar;;SOURCES NeuesZiel.pot</para>
</listitem>
</itemizedlist>
</para>
</listitem>
<listitem>
<para>Fügen Sie Ihre Quellcodes, die sie für Ihre Binärdatei oder Bibliothek benötigen, wie im KDevelop Schreib-Bereich aufgeführt außerhalb des Schreibbereiches hinzu.</para>
</listitem>
<listitem>
<para>Um statische Bibliotheken zu installieren, erzeugen Sie die Bibliothek mit KDevelop's automatischer Generierung innerhalb von Unterverzeichnissen. Dann ändern Sie die 
Makefile.am außerhalb des Schreibbereichs gemäß den von Ihnen benötigten Einstellungen.</para>
</listitem>
</itemizedlist>
</para>
</sect2>
</sect1>

<sect1 id="neue-projekte">
<title>Neue Projekte</title>

<para>Der KDevelop Application Wizard ermöglicht die Erstellung von verschiedenen Projekttypen. Alle Projekte verwenden die Standard GNU
Entwicklungswerkzeuge wie unter Anforderungen beschrieben.</para>

<para>Für KDE Anwendungen stehen sechs Projekttypen zur Verfügung :
<itemizedlist>
<listitem>
<para>Mini: Erzeugt eine KDE Applikation mit leerem Hauptwidget.</para>
</listitem>
<listitem>
<para>Normal: Erzeugt eine KDE-Applikation mit Session-Management, Menüleiste, Werkzeugleiste, Statusleiste und Unterstützung für das 
Doc/View Modell. </para>
</listitem>
<listitem>
<para>Normal-OpenGL: Erzeugt eine KDE-Applikation mit Session-Management, Menüleiste, Werkzeugleiste, Statusleiste und Unterstützung für das 
Doc/View Modell. Zusätzlich OpenGL(tm) (Mesa3D) Unterstützung.</para>
</listitem>
<listitem>
<para>KDE 2 Normal: Erzeugt eine KDE-2 Applikation mit Session-Management, Menüleiste, Werkzeugleiste, Statusleiste und Unterstützung für das 
Doc/View Modell. </para>
</listitem>
<listitem>
<para>KDE 2 Mini: Erzeugt eine KDE-2 Applikation mit leerem Hauptwidget.</para>
</listitem>
<listitem>
<para>KDE 2 MDI: Erzeugt eine KDE-2 MDI (Multiple Document Interface) Applikation mit Session-Management, Menüleiste, Werkzeugleiste, 
Statusleiste und Unterstützung für das Doc/View Modell.</para>
</listitem>
</itemizedlist>
</para>

<para>Wenn Sie keine Abhängigkeiten zu den KDE Bibliotheken wünschen, können Sie eine der vier Qt Anwendungen wählen:
<itemizedlist>
<listitem>
<para>Normal: Erzeugt eine Qt-Applikation mit einem Hauptfenster, das eine Menüleiste, Werkzeugleiste und Statusleiste enthält, einschließlich 
Unterstützung für ein rudimentäres Doc/View-Modell.</para>
</listitem>
<listitem>
<para>QT 2.x SDI: Erzeugt eine Qt-Applikation mit einem Hauptfenster, das eine Menüleiste, Werkzeugleiste und Statusleiste enthält, einschließlich 
Unterstützung für ein Single Document-view Interface (SDI) Modell.</para>
</listitem>
<listitem>
<para>QT 2.1 MDI: Erzeugt eine Qt-2.1 Applikation mit einem Hauptfenster, das eine Menüleiste, Werkzeugleiste und Statusleiste enthält, 
einschließlich Unterstützung für ein Multiple Document Interface (MDI) Modell.</para>
</listitem>
<listitem>
<para>QextMDI: Erzeugt eine auf der QextMDI Bibliothek und Qt2.0x basierende MDI Anwendung. Ermöglicht das Umschalten zwischen den beiden 
Modi Toplevel und Kind-Frame. Benötigt QextMDI. Mehr Informationen erhalten Sie auf
<ulink url="http://www.geocities.com/gigafalk/qextmdi.htm">http://www.geocities.com/gigafalk/qextmdi.htm</ulink>.</para>
</listitem>
</itemizedlist>
</para>

<para>Weiterhin bietet der Applikations-Wizard eine Schablone, um GNOME-konforme Applikationen mit der GTK+ C-Bibliothek zu erstellen, die
standardmäßig schon ein Hauptfenster mit Menüleiste, Werkzeugleiste und Statuszeile enthält.</para>

<para>Die beiden Typen C und C++ bieten die Erstellung einer Kommandozeilenanwendung an. </para>

<para>Außerdem können Sie ein völlig leeres Projekt erzeugen, um beispielsweise mit bereits vorhandene Projekten zu arbeiten.</para>

<para>Der Wizard fragt Sie nach dem Projektnamen, Version und dem Verzeichnis in dem das Projekt erstellt werden soll. Außerdem können Sie Ihren 
Namen und Ihre EMail Adresse angeben. Diese werden in den Header und cpp Schablonen am Anfang Ihrer Quelldateien eingetragen und werden 
außerdem für die Einträge in die -lsm Datei verwendet.</para>

<para>Zum Hinzufügen der Revisionskontrolle zu Ihrem Projekt, lesen Sie bitte das Kapitel <link linkend="CVS-Integration">CVS Integration</link>.</para>
</sect1>

<sect1 id="ffnen-und-schlieen-von-projekten">
<title>Öffnen und Schließen von Projekten</title>

<para>KDevelop ist standardmäßig so eingestellt, daß das zuletzt geöffnete Projekt beim Start geladen wird. Dies ermöglicht einen schnellen Start, aber 
möglicherweise wollen Sie es ändern, so daß die Entwicklungsumgebung ohne ein Projekt gestartet wird. Zum Ändern des Standardverhaltens 
schalten Sie 'Letztes Projekt Laden' im <link linkend="KDevelop-Setup">KDevelop Setup</link> Dialog aus.</para>

<para>Zum Öffnen eines anderen Projekts wählen Sie "Öffnen" aus dem Projektmenü oder drücken den "Projekt öffnen" Schalter auf der Werkzeugleiste. Im
Falle, daß Sie schon ein Projekt geöffnet haben, wird dieses geschlossen. Wenn Ihr aktuelles Projekt nicht gesicherte Dateien enthält, werden Sie 
gefragt ob Sie diese Dateien speichern wollen. Sie können sich dann entscheiden, welche Dateien gesichert werden sollen und welche nicht, oder 
Sie können alle Dateien auf einmal speichern.</para>

<para>Sie erhalten einen "Projekt öffnen" Dialog, in dem Sie zu dem Verzeichnis wechseln können, das Ihre zu ladende Projektdatei enthält. KDevelop 
Projektdateien haben einen <emphasis>*.kdevprj</emphasis> Mimetypen der auch durch ein Projekt Icon dargestellt wird. Wählen Sie die Projektdatei und betätigen Sie 
"Öffnen". Wenn ein Projekt geladen wird, scannt der Klassenbrowser alle Dateien und baut den Klassenbaum auf, so daß Sie sofort mit der Arbeit 
beginnen können, indem Sie den Klassenbrowser benutzen.</para>

<para>Eine weitere komfortable Möglichkeit ein Projekt zu öffnen, besteht darin, es im KFM, dem KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Datei Manager anzuwählen. Dies startet 
KDevelop  zusammen mit dem gewählten Projekt. Sie könnten es genausogut von der Kommandozeile starten, indem Sie eingeben 
<literal remap="tt">kdevelop projektname.kdevprj</literal>.</para>

<para>Wenn Sie KDevelop schließen, wird Ihre Projektdatei automatisch gespeichert und die Entwicklungsumgebung stellt fest, ob irgendwelche 
Projektdateien verändert wurden. Sie werden dann gefragt, ob Sie die Änderungen speichern wollen. Die verfügbaren Optionen sind die gleichen wie 
beim Schließen eines Projekts.</para>
</sect1>

<sect1 id="bearbeiten-eines-projekts">
<title>Bearbeiten eines Projekts</title>

<para>Nachem Sie ein Projekt mit dem KAppWizard erstellt haben, werden Soe normalerweise das Projekt erweitern, indem Sie Quelldateien, Klassen, 
Pixmaps, Bilder und was immer Ihr Projekt benötigt, hinzufügen. Nun, editieren eines Projektes bedeutet, daß Sie das Standardprojekt nach der 
Erstellung mit Hilfe von Menüs und Dialogen Ihren Anforderungen gemäß verändern können. Der nächste Abschnitt beschreibt deshalb, wie Sie 
bereits existierende Dateien und Klassen hinzufügen und wie Sie neue Dateien erstellen können. Dies ist notwendig um Ihr Projekt zu erstellen, wird 
aber nicht dem End-User beim Installieren helfen. Deshalb beschreibt der Abschnitt 
<link linkend="Setzen-der-Projekt-Optionen">Setzen der Projekt Optionen</link>, wie Sie die Dateieigenschaften, insbesondere für zusätzliche Dateien, die 
installiert werden sollen, setzen können. Dies betrifft z.B. Dokumentationen oder Pixmaps. Eine weitere Arbeit bei der Wartung Ihres Programms ist das 
Hinzufügen von Übersetzungen, die die Internationalisierung unterstützen. Dies wird in 
<link linkend="bersetzung-hinzufgen">Übersetzung hinzufügen</link> beschrieben.</para>

<para><link linkend="Erweitern-der-Projekt-Dokumentation">Erweitern der Projekt Dokumentation</link> behandelt Fragen, wie ein guter Satz an Dokumentationen 
für Online Hilfe erstellt werden kann, die dem Endbenutzer die Verwendung Ihres Produktes ermöglicht und Ihn in die Lage versetzt, sich bei Problemen 
selbst helfen zu können.</para>

<para>Schließlich wird im Abschnitt <link linkend="Projekt-Hacking">Projekt Hacking</link> beschrieben, wie Sie das KDevelop Projektmanagment in bestimmten 
Fällen umgehen können.</para>

<sect2 id="hinzufgen-und-entfernen-von-dateien-und-klas">
<title>Hinzufügen und Entfernen von Dateien und Klassen</title>

<para>Das Hinzufügen neuer Dateien wird oft benötigt, wenn Sie Ihre Klassenimplementationsdatei in mehrere Dateien aufteilen wollen. Dann ist es nötig eine neue Datei zu erzeugen, 
die den Teil der Implementation enthält, den Sie  auslagern wollen. Sie können dies erreichen, indem Sie "Neu" aus dem Dateimenü wählen, wodurch der "Datei-Neu" Dialog 
aufgerufen wird. Dies gibt Ihnen die Möglichkeit, den Dateitypen, den Namen und Speicherort anzugeben. Während Sie den Dateinamen angeben, fügt KDevelop automatisch 
eine Erweiterung hinzu, Sie können diese Erweiterung jedoch auch noch Ihren Bedürfnissen anpassen. Außerdem können Sie die Vorlagendatei für Quelldateien einbinden, so 
daß Sie den Kopf nicht von Hand in Ihre Datei kopieren müssen. Des weiteren können Sie entscheiden, ob die Datei dem Projekt hinzugefügt werden soll oder nicht. Denken 
Sie daran, daß dies nichts mit der späteren Installation zu tun hat; diese Konfiguration erfolgt später innerhalb der Dateivoreinstellungen.</para>

<para>Nachdem die neue Datei erzeugt wurde, werden sowohl die Projektdatei, als auch die zugehörigen Makefile.am's aktualisiert. Zum Hinzufügen einer kompletten Klasse, können 
Sie mit Hilfe des Klassengenerators eine neue Klasse konstruieren. Dieser wird durch Wahl von "Neue Klasse" aus dem Projektmenü aufgerufen.</para>

<para>Im Falle, daß Sie ein existierendes Projekt haben und bestimmte Klassen hinzufügen wollen, die Sie in Ihrem Projekt wiederverwenden wollen, wählen Sie "Vorhandene Datei(en) 
hinzufügen..." aus dem Projektmenü. In dem erscheinenden Dialog können Sie wählen, welche Dateien Sie hinzufügen wollen und welches das Zielverzeichnis sein soll. 
Denken Sie daran, daß die Dateien in das Zielverzeichnis kopiert und dem Projekt hinzugefügt werden. Sie sollten nach dem Hinzufügen Make aufrufen, damit Ihre Dateien dem 
Erstellungsprozeß hinzugefügt werden. Für den Fall, daß Sie z.B. Pixmaps hinzufügen wollen, die später durch den Endbenutzer installiert werden sollen, sollten Sie die Dateieigenschaften 
anpassen und den Installationspfad angeben (siehe <link linkend="Setzen-der-Projekt-Optionen">Setzen der Projekt Optionen</link>).</para>

<para>Um Dateien dem Projekt hinzuzufügen, die sich bereits im Projektverzeichnis befinden, wechseln Sie in die RFV Ansicht, in der Sie zugehörige Dateien an Hand des Icons 
ausmachen können. Wählen Sie die hinzuzufügende Datei und betätigen Sie die rechte Maustaste um das Popup-Menü zu öffnen. Dann wählen Sie "Datei zum Projekt 
hinzufügen...".</para>

<para>Sie können auch Dateien vom Projekt entfernen. Dies wird dann nötig, wenn Sie nicht die vom KAppWizard vorgenerierten Dateien verwenden wollen. Beim Entfernen von 
Dateien haben Sie zusätzlich die Möglichkeit, die Datei komplett von der Festplatte zu entfernen. Zum Entfernen vom Projekt, wählen Sie die Datei im LFV oder im RFV, drücken 
die rechte Maustaste und wählen "Datei vom Projekt entfernen...". Zum Löschen der Datei wählen Sie "Datei von der Festplatte entfernen...".</para>
</sect2>

<sect2 id="setzen-der-projekt-optionen">
<title>Setzen der Projekt Optionen</title>

<para>Auf den Dateieigenschaftendialog kann über das Projektmenu oder innerhalb des LFV mit einem Klick der rechten Maustaste zugegriffen werden. Er zeigt die Projektdateien 
in Gruppen, so wie sie auch im LFV angeordnet sind und zeigt die Dateieigenschaften wie Größe, Dateityp, ob die Datei zum Projekt gehört sowie den Pfad, in den die Datei 
durch das make install Kommando des Endnutzers installiert wird. Es ist wichtig, diesen Pfad für Dokumentationsdateien und Pixmaps anzugeben, Sie müssen diese Pfade also 
hier einstellen. Für Standard KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Pfad Makros sollten Sie in Ihrer Makefile.am nachsehen, wo diese Makros aufgeführt sind.</para>
</sect2>

<sect2 id="bersetzung-hinzufgen">
<title>Übersetzung hinzufügen</title>

<para>Da KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> die Konfiguration Ihres Desktops und des Verhaltens Ihrer Anwendungen ermöglicht, haben Sie auch die Möglichkeit die Sprache, die Ihre Anwendung verwendet 
zu wählen. Dies betrifft die Verwendung der Online-Dokumentation genauso wie das gesamte Aussehen Ihrer Applikation. In Bezug auf die Dokummentationsdateien scheint dies 
ein triviales Unterfangen zu sein. Sie würden ein Unterverzeichnis mit dem Kürzel der jeweiligen Sprache im <literal remap="tt">docs</literal> Verzeichnis Ihres Projektes anlegen, z.B <literal remap="tt"></literal>de/ für 
Deutsch und die englische Dokumentation in dieses Verzeichnis kopieren. Dann würden Sie die Dokumentation erzeugen und alle Projekt Optionen bezüglich der 
Installationsverzeichnisse setzen. Dann könnten Sie damit beginnen die sgml Datei zu übersetzen und die Dokumentation neu zu erzeugen. Das ist alles. Für die Anwendung 
selber scheint dies ein wenig schwieriger zu sein. Wir wollen deshalb hier erklären, wie man die Internationalisierung unterstützt und wie man die Sprachen die man unterstützen 
möchte einbindet.</para>

<para>Zuerst müssen Sie alle in Ihrer Anwendung sichtbaren Zeichenketten, die also auf Balken oder in Menüs erscheinen, in einem <literal remap="tt">i18n()</literal> Makro einschließen. Dieses Makro 
wird durch die Funktion <literal remap="tt">klocale-&gt;translate()</literal> aus der KLocale Klasse ersetzt ist aber wesentlich einfacher zu verwenden. Da das Makro in der <literal remap="tt">kapp.h</literal> Includedatei 
definiert ist, müssen Sie Ihrer Quelldatei ein <literal remap="tt">&&num;;include &&lt;;kapp.h&&gt;;</literal> hinzufügen. Es sollte auch erwähnt werden, daß obwohl <literal remap="tt">i18n()</literal> ein Makro ist und Sie deshalb 
denken, Sie könnten die Originalfunktion verwenden, dies nicht funktionieren wird. Das liegt daran, daß die Zeichenketten, die übersetzt werden sollen, aus den Quelldateien 
ausgelesen und in der Übersetzungsdatei der Anwendung gespeichert werden (&&lt;;IhreApp&&gt;;.pot im /po Unterverzeichnis). Dies wird vom xgettext Programm gemacht, welches 
mit <literal remap="tt">make messages</literal> aus Ihrem Projektverzeichnis heraus aufgerufen wird. Da xgettext das <literal remap="tt">i18n()</literal> Makro benötigt, wird Sie die Verwendung der Originalfunktion  nicht zum 
Ziel führen.</para>

<para>Für die Übersetzungen selbst, müssen Sie zunächst die message Datei erzeugen, die alle vom <literal remap="tt">i18n()</literal> Makro eingeschlossenen Zeichenketten aus Ihrem Quellcode enthält. 
Dies wird durch Auswahl von "Meldungen erstellen und verbinden" aus dem Projektmenü erreicht. Dann müssen die Sprachen, die Ihr Projekt unterstützen soll, hinzugefügt 
werden. Dazu wählen Sie "Neue Übersetzung hinzufügen..." aus dem Projektmenü. Dies öffnet den Sprachauswahldialog. Wählen Sie eine Sprache und bestätigen Sie mit OK. 
Es wird eine ASCII Datei erzeugt, die Einträge für den Dateinamen und die Zeilennummer des Vorkommens der Zeichenkette enthält. Sie sehen dann jeweils eine <literal remap="tt">msgid</literal> 
Zeile, die die zu übersetzende Zeichenkette enthält, gefolg von einer <literal remap="tt">msgstr</literal> Zeile. Die <literal remap="tt">msgstr</literal> Zeile ist leer, bis auf Einträge, die bereits von den KDE Bibliotheken <indexterm remap="idx"><primary>KDE Bibliotheken</primary></indexterm> 
bereitgestellt werden. Die leeren Zeilen müssen von Ihnen mit der entsprechenden Übersetzung ausgefüllt werden.</para>

<para>Sie könnten die Übersetzungen von Hand schreiben. Das KDE-SDK <indexterm remap="idx"><primary>KDE-SDK</primary></indexterm> bietet jedoch auch das Programm KTranslator, welches die Dateien bereits auf Ihrem System installierter 
Programme liest, so daß Sie bereits übersetzte Zeichenketten wiederverwenden können.</para>

<para>Um auf KTranslator zuzugreifen, wählen Sie am einfachsten eine &&lt;;Sprache&&gt;;.po Datei aus dem /po Verzeichnis entweder in LFV oder RFV. Dies öffnet KTranslator und 
ermöglicht es, auf einfache die Übersetzung durchzuführen. Denken Sie daran das Sie KTranslator konfigurieren müssen, damit der Autorenname, sowie Sprache und Zieldatei 
korrekt gesetzt sind. Standardmäßig öffnet KTranslator nur die Übersetzungsdatei.</para>

<para>Für alle Übersetzungen verwendet <literal remap="tt">make</literal> das Programm <literal remap="tt">msgfmt</literal> für die Formatierungen Ihrer in der ausführbaren Datei verwendeten Meldungen, Sie brauchen sich darüber 
aber keine Gedanken zu machen; dies wird alles von KDevelop automatisch gemacht.</para>

<para>Weitere Informationen zur Unterstützung der Internationalisierung finden Sie auf <ulink url="http://www.kde.org">http://www.kde.org</ulink>; eine Menge Leute machen 
Übersetzungen für Sie. Sie finden dort auch eine Liste mit EMail Adressen der Übersetzer, denen Sie schreiben könnten und die Ihnen dabei helfen können. Lesen Sie
auch  <link linkend="Der-Dialogeditor">Der Dialogeditor</link> und <ulink url="programming/index-11.html">The KDevelop Programming Handbook</ulink> 
wo Fragen der Internationalisierung auch wieder behandelt werden.</para>
</sect2>

<sect2 id="erweitern-der-projekt-dokumentation">
<title>Erweitern der Projekt Dokumentation</title>

<para>Alle mit KDevelop erstellten Projekte enthalten eine vorkonfigurierte Dokumentation, die bereits Standardkapitel zu Installation, Projektname und Version, sowie Autorname und 
Emailadresse beinhaltet. Da KDevelop SGML Schablonen verwendet, ist es sehr einfach die Dokumentation zu einem kompletten Hilfesystem zu erweitern. Alles was Sie dazu 
tun müssen, ist die sgml Datei, die sich in docs/en unter dem Namen index.sgml befindet, zu editieren. Die Referenz Dokumentation Ihres sgml-tools Paketes kann dem 
Hilfebrowser hinzugefügt werden, erlaubt direkten Zugriff auf spezielle Tags und enthält eine kurze Beschreibung, wie die Dokumentation zu erweitern ist.
SGML hat eine Reihe von Vorteilen und KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> macht häufig Gebrauch von diesem Dokumentationstyp zusammen mit dem ksgml2html Programm. Dieses Werkzeug erzeugt 
die typische Dokumentation im KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Stil und sorgt dafür, daß sie schöner aussieht. Trotzdem sind auch die sgmtools alleine schon ausreichend, die html Ausgabe zu  
erzeugen, die Ihre Applikation beinhaltet. Wenn Sie die Dokumentation mit ksgml2html erzeugen wollen, installieren Sie dieses Programm und rufen "Benutzerhandbuch erstellen" 
aus dem Projektmenü auf. Der Dokumentationsbrowser ermöglicht die sofortige Kontrolle der Ausgabe, indem Sie entweder "Benutzerhandbuch des Projekts" aus dem Hilfemenü 
oder das entsprechende Icon aus der DOC Baumansicht wählen. Dadurch können Sie direkt in KDevelop durch die Dokumentation browsen und haben so eine bessere 
Übersicht über die Fehler, die durch fehlende Tags entstehen.</para>

<para>Nun, während Sie die Dokumentation erweitern, ergibt es sich zwangsläufig, daß zusätzliche Dateien erzeugt werden, die zum Projekt hinzugefügt werden müssen, da jeder 
<literal remap="tt">sect</literal> Tag eine neue HTML Datei erzeugt. Die Ausgabe des KAppWizard gehört bereits zum Projekt, so daß Sie sich um die Installationspfade keine Gedanken machen 
müssen. Worauf Sie achten müssen, sind index-xx.html Dateien bei denen xx größer als 6 ist (die ersten sechs Dateien gehören bereits zum Projekt). Nachdem Sie die 
Dokumentation erzeugt haben, wechseln Sie zum RFV und kontrollieren Ihr Dokumentationsverzeichnis. Drücken Sie die rechte Maustaste über den Dateien und wählen Sie 
"hinzufügen". Des weiteren fügt ksgm2html dem Dokumentationsverzeichnis das KDE <indexterm remap="idx"><primary>KDE</primary></indexterm> Logo hinzu. Diese Datei, <literal remap="tt">logotp3.gif</literal>, müssen Sie ebenfalls dem Projekt hinzufügen. 
Dann müssen Sie "Dateieigenschaften" entweder aus dem Projektmenü oder mit Hilfe des Popup Menüs in den Ansichten wählen. Der einfachste Weg den Installationspfad zu 
setzen, ist eine bereits zur Installation vorgesehene Dokumentationsdatei zu wählen, wie <literal remap="tt">index.html</literal>. Sie sehen, daß "Installieren" angekreuzt ist und "Installationsverzeichnis 
und Dateiname" bereits ein Ziel enthält. Markieren Sie diesen Eintrag und geben Sie STRG+C ein um den Eintrag in's Clipboard zu kopieren. Dann wählen Sie die Datei die Sie 
als zu installieren spezifizieren wollen. Markieren Sie "Installieren", dies wird das "Installationsverzeichnis und Dateiname" Feld aktivieren, welches dann schon den 
Dateinamen enthält. Plazieren Sie den Cursor vor dem Dateinamen und geben Sie STRG+V zum Einfügen des Clipboardinhalts ein. Dies ist die schnellste Methode, den 
Installationspfad einzugeben. Weitere Informationen zur Angabe von Installationszielen finden Sie im <ulink url="programming/index-14.html">KDevelop Programming Handbook</ulink>.</para>
</sect2>

<sect2 id="projekt-hacking">
<title>Projekt Hacking</title>

<para>Wenn Sie mit einem Projekt arbeiten, sollten Sie nie die Projektdatei von Hand bearbeiten. Das würde es KDevelop unter bestimmten Umständen unmöglich machen, das 
Projekt korrekt zu laden und Änderungen würden eventuell nicht richtig in die Makedateien eingetragen. Zum Ändern irgendwelcher Projekt-Einstellungen, müssen Sie 
immer die vorhandenen Menüeinträge benutzen, z.B. zum Hinzufügen von Dateien oder das Setzen von Dateieigenschaften. Experten, die nicht zufrieden mit bestimmten 
Optionen sind, z.B. Linkeroptionen oder zusätzliche Möglichkeiten zur Projektkonfiguration benötigen, können sich in die Makefile.am Makros einarbeiten und alle Änderungen 
in die Makefile.am, hinter dem mit "KDevelop write area" gekennzeichneten Bereich, eintragen. Da die GNU Werkzeuge diese Kommandos verwenden, können Sie damit die 
KDevelop Einstellungen überschreiben. Denken Sie daran, daß dies die Verwendung von KDevelop für Änderungen an der Projektkonfiguration verhindert.</para>
</sect2>
</sect1>

<sect1 id="compiler-und-linker-schalter-fr-projekte">
<title>Compiler und Linker Schalter für Projekte</title>

<para>Jedes neue Projekt enthält alle benötigten Optionen für den Compiler und den Linker, sowie generelle Einstellungen. Standardmäßig ist Debuggen durch den <emphasis>-g</emphasis> Schalter, sowie 
das Warnen bei allen Fehlern mit <emphasis>-Wall</emphasis> eingestellt. Dies stellt sicher, daß Sie Ihre Applikation debuggen können und Konstruktionen erkennen können, die möglicherweise 
Programmfehler verursachen würden. Für manche Anwendungen benötigen Sie jedoch noch zusätzliche Compiler- oder Linkerschalter, insbesondere wenn Sie Bibliotheken 
verwenden, die so nicht eingebunden werden. Dann müssen Sie Ihr Projekt mit Hilfe der Optionen aus dem Projektmenü rekonfigurieren. Lesen Sie das Kapitel 
<link linkend="Erstellungsoptionen">Erstellungsoptionen</link>, um mehr über Compiler Optionen, Warnungen und Linkeroptionen zu erfahren.</para>
</sect1>

<sect1 id="externe-projekte">
<title>Externe Projekte</title>

<para>Existierende Projekte können in KDevelop Projekte konvertiert werden, indem sie "Neu" aus dem Projektmenü und anschließend "Eigenes Projekt" wählen. Der folgende 
Dialog erstellt eine leere Projektdatei mit dem Projektnamen, Versionsnummer und Typinformation, sowie Ihrem Namen und Ihrer EMailadresse. Kopieren Sie dann alle Ihre 
Kompilations- und Konstruktionsdateien in das neue Projektverzeichnis und wählen Sie "Dateien hinzufügen" aus dem Projektmenü. Die ausgewählten Dateien werden in Ihr 
Projektverzeichnis kopiert und die Makefile.am's werden aktualisiert. Bitte ändern Sie alle Makefile.am Einträge, die vor der Konvertierung schon bestanden, gemäß den 
Einträgen die KDevelop in der KDevelop write area vorgenommen hat. Testen Sie, ob sich Ihr Programm nach der Konvertierung immer noch kompilieren und installieren läßt, 
um so die Konsistenz des Projekts zu prüfen.</para>
</sect1>
</chapter>

<chapter id="erstellungsoptionen">
<title>Erstellungsoptionen</title>

<para>Der Projekt Optionen Dialog, den Sie über das Projekt Menü erreichen können, ermöglicht es Ihnen alle Parameter einzustellen, 
die für die Programmerstellung notwendig sind. Die Parameter werden für die Makefile.am's und für das configure.in Skript verwendet 
(z.B. Versionsnummer oder Compilerwarnungen) und beeinflussen auch die Compilervoreinstellungen. Nach einer Änderung dieser 
Optionen sollten Sie ein 'DistClean' oder 'Alles neu erstellen' ausführen, damit Ihr Projekt mit den neuen Optionen kompiliert wird. 
Denken Sie daran, daß Sie nur debuggen können, wenn Sie das Erzeugen von Debuginformation eingeschaltet haben. Die Menge 
an Debuginformation kann mit Hilfe des Debug-Levels eingestellt werden (0-3). Wenn Sie Funktionen hinzufügen, die zu einer 
Bibliothek gehören, die nicht mit Hilfe der Linkereinstellungen eingebunden wurde, wird Ihr Programm nicht korrekt gebunden werden. 
Behalten Sie also die Linker Flags im Auge.</para>

<para>Für eine Release Version sollten Sie die folgenden Einstellungen vornehmen:</para>

<para><itemizedlist>
<listitem>
<para>Kein Debugging</para>
</listitem>
<listitem>
<para>Setzen des Optimierungslevels auf  <emphasis remap="bf">-02</emphasis></para>
</listitem>
<listitem>
<para>Setzen der Compilerwarnungen auf <emphasis remap="bf">-Wall</emphasis></para>
</listitem>
<listitem>
<para>Erhöhen Sie für jedes Release die Versionsnummer und aktualisieren Sie die .lsm Datei bezüglich Version und Anforderungen.</para>
</listitem>
</itemizedlist>
</para>

<sect1 id="allgemeine-optionen">
<title>Allgemeine Optionen</title>

<para>Auf der ersten Seite der Projekt Optionen können Sie die allgemeinen Einstellungen für Ihr Projekt vornehmen. Dies sind der Name 
des Projekts, die Versionsnummer, der Name des Autors und seine Email-Adresse. Außerdem können Sie angeben ob und welche 
Versionsverwaltung Sie verwenden wollen. Sie können im Feld "Kurze Information" auch noch zusätzliche Angaben über den 
Verwendungszweck o.ä. Ihres Programmes machen.</para>
</sect1>

<sect1 id="compiler-optionen">
<title>Compiler Optionen</title>

<para>Unter Compileroptionen können Sie die Compilerflags für Zielcomputer, Debuggen und zusätzliche Optionen setzen.</para>

<sect2 id="ziel">
<title>Ziel</title>

<para>Unter Ziel können Sie zwei Optionen einstellen:</para>

<para>Zielcomputer : Sie können hier den Maschinentyp für Ihr Programm eingeben. Andere Typen als Ihre Maschine werden gewöhnlich 
nur benötigt, um vorcompilierte Pakete zu erstellen. i386v übergibt <emphasis>-b</emphasis> an den Compiler und ist für Cross-Compiler gedacht, 
um ein Binary für ein Intel-System, das mit Unix System V läuft, zu erstellen. Normalerweise können Sie die Standardeinstellung 
verwenden.</para>

<para>Optimieren: Setzen Sie hier die <emphasis>-O</emphasis> Option für den GCC. Abschalten der Optimierung bedeutet <emphasis>-O0</emphasis>. Je höher der 
Level, desto länger dauert der Compiliervorgang. Allerdings ist dann die Ausführgeschwindigkeit höher. Es können 
Optimierungslevel von 0 (keine Optimierung) bis 3 (maximale Optimierung) eingestellt werden.</para>

<para>Für eine Release Version Ihrer Anwendung schalten Sie die Optimierung ein und wählen Level 2.</para>
</sect2>

<sect2 id="debuggen-1">
<title>Debuggen</title>

<para>Rechts vom Zielkasten sehen Sie die Debug-Einstellungen. Dies bedeutet, daß Sie den Compiler dazu veranlassen können, 
Informationen für Debugger in die ausführbare Datei zu schreiben, so daß der Programmierer in der Lage ist, die Anwendung 
im Kontext mit dem Quellcode zu debuggen (Symbolisches Debuggen).</para>

<para>Debuginfo erzeugen setzt das <emphasis>-g</emphasis> Flag; Debuglevel gibt an, wieviele Informationen in die ausführbare Datei geschrieben 
werden. Sie können ein Level zwischen 1 und 3 setzen. Denken Sie daran, daß die ausführbare Datei mit Erhöhung des Levels 
sowohl größer als auch langsamer wird.</para>

<para>Informationenen für gprof erzeugen: Es werden zusätzliche Informationen für den Profiler gprof generiert. Diese Option setzt 
das <emphasis>-pg</emphasis> Flag.</para>

<para>Temporäre Dateien speichern: Speichert die üblichen temporären Dateien im aktuellen Verzeichnis. Das bedeutet, daß das 
Compilieren der Datei  <emphasis>foo.c</emphasis> die Dateien <emphasis>foo.o, foo.i</emphasis> und <emphasis>foo.s</emphasis> erzeugt.</para>

<para>Für eine Release Version Ihrer Anwendung schalten Sie Debuggen aus.</para>
</sect2>

<sect2 id="zustzliche-optionen">
<title>Zusätzliche Optionen</title>

<para>Das Texteingabefeld am unteren Rand dient dazu manuell weitere Optionen einzugeben. Diese Optionen setzen die CXXFLAGS 
Umgebungsvariable in den Make Dateien. Make setzt die Flags vor der Erstelling und setzt sie anschließend wieder zurück. 
Eine vollständige Beschreibung aller Compileroptionen finden Sie in Ihrer Compilerdokumentation; für gcc und egcs können Sie 
sich mit <emphasis remap="bf">man gcc</emphasis> informieren; <emphasis remap="bf">man g++</emphasis> gibt Informationen zum c++ Skript aus, daß zur Steuerung des Compilers verwendet 
wird.</para>
</sect2>
</sect1>

<sect1 id="compiler-warnungen">
<title>Compiler Warnungen</title>

<para>Im folgenden werden die möglichen Einstellungen für die Compiler-Warnungen des Projekt-Optionen Dialogs, Seite 3, erläutert. Die
Erklärungen selbst sind der <literal remap="tt">man</literal>-page des GCC, egcs Version 1.1.1 entnommen.
Die Warnungen selbst sind diagnostische Meldungen, die anzeigen, das die entsprechenden Programmanweisungen möglicherweise Fehler
verursachen.</para>

<para><variablelist>
<varlistentry>
<term>-Wall</term>
<listitem>
<para>Standard-Warnungen kombiniert</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-W</term>
<listitem>
<para>Compiliere mit -W. Diese Einstellung fügt Warnungen hinzu, die nicht in -Wall enthalten sind. Bitte lesen Sie die
GCC-Info für weitere Informationen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wtraditional</term>
<listitem>
<para>Warnungen über bestimmte Konstruktionen ausgeben, die sich unter traditionellem und ANSI C verschieden verhalten.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wundef</term>
<listitem>
<para>Warnung anzeigen, falls ein undefinierter Bezeichner in einer '&&num;;if' Direktive verwendet wird</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wshadow</term>
<listitem>
<para>Warnung anzeigen, falls eine lokale Variable eine andere lokale Variable überdeckt.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wid-clash-LEN</term>
<listitem>
<para>Warnung anzeigen, falls zwei verschieden Bezeichner in den ersten LEN Buchstaben übereinstimmen. Dies kann bei der
Übersetzung eines Programms mit einigen nicht mehr zu verwendenden Compilern helfen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wlarger-then-LEN</term>
<listitem>
<para>Warnung anzeigen, falls ein Objekt mit einer Größe über LEN Bytes definiert wird.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wpointer-arith</term>
<listitem>
<para>Warne vor allem, das von der <emphasis>Größe</emphasis> eines Funktionstypen oder von einem <emphasis>void</emphasis> abhängt. 
GNU C weist diesen Typen aufgrund von Komfort von Berechnungen mit <emphasis>void *</emphasis> Zeigern und Zeigern auf Funktionen eine 
Größe von 1 zu.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wbad-function-cast</term>
<listitem>
<para>Warne, wenn ein Funktionsaufruf eine Umwandlung zu einem nicht passenden Typ ist. Z. B., wenn 
<emphasis>int malloc()</emphasis> eine Umwandlung zu <emphasis>irgendwas *</emphasis> ist.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wcast-equal</term>
<listitem>
<para>Warne, wenn ein Zeiger gecastet wird und dabei ein Typqualifizierer beim Ziel verloren ginge.Z.B., wenn 
ein <emphasis>const char *</emphasis>  nach <emphasis>char *</emphasis> gecastet würde.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wcast-align</term>
<listitem>
<para>Warne, wenn ein Zeiger so gecastet wird, daß das erforderliche Alignment des Zieles vergrößert würde. Z.B. 
wenn auf Maschinen, auf denen Integer nur 2- oder 4-Byte aligned sein können <emphasis>char *</emphasis> nach <emphasis>int *</emphasis> gecastet werden 
soll.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wwrite-strings</term>
<listitem>
<para>Gebe Stringkonstanten den Typ <emphasis>const char&&lsqb;;Länge]</emphasis>i, so daß das Kopieren einer solchen Adresse in 
einen nicht <emphasis>const char *</emphasis> Zeiger eine Warnung erzeugt. Diese Warnungen können helfen zur Compilezeit Code zu finden, der 
versucht in eine Strinkonstante zu schreiben, aber nur wenn man sehr aufmerksam beim Gebrauch von <emphasis>const</emphasis> in Deklarationen 
und Prototypen war. Ansonsten werden diese Meldungen nur lästig, weshalb sie mit <emphasis>-Wall</emphasis> nicht erzeugt werden.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wconversion</term>
<listitem>
<para>Warne, wenn ein Prototyp eine Typumwandlung verursacht, die anders ist als die, die durchgeführt würde, 
wäre der Prototyp nicht da. Dies beinhaltet Konvertierungen von Festpunkt nach Fließkomma und umgekehrt und Konvertierungen, 
die die Breite oder Vorzeichenbehaftung eines Festpunktargumentes betreffen, es sei den es entspräche der Standarderweiterung. 
Ebenso wird gewarnt, wenn eine negative, ganzzahlige Konstante implizit in einen vorzeichenlosen Typ umgewandelt wird.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wsign-compare</term>
<listitem>
<para>Warne, wenn ein Vergleich zwischen signed und unsigned ein falsches Ergebnis geben könnte, weil 
signed zu unsigned umgewandelt wird.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Waggregate-return</term>
<listitem>
<para>Warne, wenn eine Funktion, die eine Struktur oder Union zurückgibt, definiert oder aufgerufen wird.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wstrict-prototypes</term>
<listitem>
<para>Warne, wenn eine Funktion ohne Argumenttypen deklariert oder definiert wird. (Eine Funktionsdefinition 
im alten Stil ist ohne Warnung erlaubt, wenn vorher eine Deklaration steht, die die Argumenttypen deklariert.)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wmissing-prototypes</term>
<listitem>
<para>Warne, wenn eine globale Funktion ohne vorherige Prototypdeklaration definiert wird (auch wenn die 
Def. selbst einen Prototyp enthält). Benutzen Sie diese Option, um globale Funktionen zu finden, die nicht in Headerdateien 
deklariert sind.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wmissing-declarations</term>
<listitem>
<para>Warne, wenn eine globale Funktion ohne vorherige Deklaration definiert wird (auch wenn die Def. 
selbst einen Prototyp enthält. Benutzen Sie diese Option, um globale Funktionen zu finden, die nicht in Headerdateien deklariert 
sind.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wredundant-decls</term>
<listitem>
<para>Warne, wenn etwas mehr als einmal in demselben Sichtbarkeitsbereich deklariert wurde (auch in Fällen, 
wo die mehrfache Deklaration gültig ist und nichts ändert).</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wnested-externs</term>
<listitem>
<para>Warne, wenn eine <emphasis>extern</emphasis> Deklaration in einer Funktion angetroffen wird.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Winline</term>
<listitem>
<para>Warne, wenn eine Funktion nicht 'inline' sein kann, sie aber als 'inline' deklariert wurde, oder wenn die 
<emphasis>-finline-functions</emphasis>-Option angegeben wurde.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wold-style-cast</term>
<listitem>
<para>Warne, wenn eine alte (C-Stil) Umwandlung im Programm benutzt wird.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Woverloaded-virtual</term>
<listitem>
<para>Warne, wenn die Deklaration einer Methode in einer abgeleiteten Klasse möglicherweise ein fehlerhafter 
Versuch ist, eine virtuelle Methode zu definieren (nur C++). In einer abgeleiteten Klasse müssen die Definitionen virtueller Methoden 
in der Schnittstelle mit der Deklaration dieser virtuellen Methode in der Basisklasse übereinstimmen. Mit dieser Option warnt der 
Compiler, wenn eine Funktionsdeklaration im Namen, aber nicht in der Schnittstelle mit der Deklaration einer virtuellen Methode in 
der Basisklasse übereinstimmt, wenn also die virtuelle Methode nicht definiert, sondern überladen würde.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-Wsynth</term>
<listitem>
<para>Warne, wenn das Syntheseverhalten von g++ nicht mit dem von cfront übereinstimmt.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>make all warnings into errors</term>
<listitem>
<para>(-Werror) Warnungen als Fehler ausgeben. Die Kompilierung wird bei jeder Warnung 
abgebrochen.</para>
</listitem>
</varlistentry>
</variablelist>
</para>

<para>Für eine Release Version Ihrer Anwendung sollten Sie <emphasis remap="bf">-Wall</emphasis> einschalten.</para>
</sect1>

<sect1 id="linker-einstellungen">
<title>Linker-Einstellungen</title>

<para>Die Linker Optionen für Ihr aktuelles Projekt können Sie auf der nächsten Seite der Projektoptionen eingeben. Sie müssen die
Bibliotheken anwählen, die Ihr Programm verwendet. Wenn Ihr Programm z.B. die Klasse KFileDialog benutzt, müssen Sie KFile 
wählen, da KFileDialog ein Teil dieser Bibliothek ist. Für Klassen oder Funktionen die Sie nicht ankreuzen können, verwenden 
Sie das <emphasis remap="bf">"Zusätzliche Bibliotheken"</emphasis> Feld.</para>

<sect2 id="linker-flags">
<title>Linker Flags</title>

<para><variablelist>
<varlistentry>
<term>Zum Debuggen notwendige Informationen aus der ausführbaren Datei entfernen:</term>
<listitem>
<para>Wenn Sie einen Debugger benützen wollen, 
sollten Sie diese Informationen in den Objektdateien behalten. Es ist sinnlos, den Compiler Debuginformationen erzeugen zu lassen 
und sie mit dieser Option zu entfernen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Benutzung von dynamisch gelinkten Bibliotheken verhindern:</term>
<listitem>
<para>Auf Systemen, die dynamische Bibliotheken unterstützen, 
verhindert diese Option das Linken mit diesen. Auf anderen Systemen hat diese Option keine Wirkung.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Zusätzliche Flags:</term>
<listitem>
<para>Geben Sie hier Linkeroptionen, mit denen der Linker aufgerufen werden soll, ein.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect2>

<sect2 id="bibliotheken-0">
<title>Bibliotheken</title>

<para>Dieser Abschnitt enthält Ankreuzboxen für die für QT/KDE Entwicklung am häufigsten benötigten Bibliotheken. Sie müssen 
diese Bibliotheken auswählen, sonst beschwert sich der Linker über nicht aufgelöste Symbole.
<variablelist>
<varlistentry>
<term>X11</term>
<listitem>
<para>Die X11 Bibliothek. Erforderlich für alle X-Window Programme.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Xext</term>
<listitem>
<para>Die X11 Erweiterungsbibliothek. Die meisten X-Window Programme brauchen auch Xext.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>qt</term>
<listitem>
<para>Die Qt Bibliothek. Erforderlich für Qt und KDE Anwendungen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>kdecore</term>
<listitem>
<para>Die KDE Core Bibliothek; Enhält die Basisklasssen für KDE Applikationen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>kdeui</term>
<listitem>
<para>Das KDE Benutzer-Interface; Enthält KDE-specifische Widgets.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>khtmlw</term>
<listitem>
<para>Die KHTML Widget Bibliothek.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>kfm</term>
<listitem>
<para>Die KFM Bibliothek; Enthält Klassen für KFM Funktionen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>kfile</term>
<listitem>
<para>Die KFile Bibliothek. Enthält File Dialoge etc.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>kspell</term>
<listitem>
<para>Die KSpell Bibliothek. Enthält ein Interface zur Rechtschreibprüfung mit ISpell.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>kab</term>
<listitem>
<para>Die KAdressBook Bibliothek. Benötigt zum Zugriff auf das Adressbuch und auf Adressbuch Widgets</para>
</listitem>
</varlistentry>
</variablelist>

<emphasis remap="bf">Zusätzliche Bibliotheken:</emphasis> Hier können Sie zusätzliche von Ihrem Programm benötigte Bibliotheken wie z.B. die KOM Bibliothek 
eingeben. Setzen Sie die Bibliothek mit der -I Option, z.B. <emphasis>-Ikom</emphasis> .</para>
</sect2>
</sect1>

<sect1 id="make-einstellungen">
<title>Make-Einstellungen</title>

<para>Da GNU make einige nützliche Optionen bereitstellt, enthält der Projekt Optionen Dialog eine Seite mit Makeoptionen, auf der Sie 
die Optionen ein- oder ausschalten können. Die verfügbaren Einstellungen sind:</para>

<para><variablelist>
<varlistentry>
<term>Debug Informationen ausgeben</term>
<listitem>
<para>Es werden zusätzliche Debugginginformationen ausgegeben. Diese Informationen sagen Ihnen 
welche Dateien für die Neuerstellung in Betracht gezogen werden, welche Datei-Zeiten verglichen werden und mit welchem 
Ergebnis, welche Dateien tatsächlich neu erstellt werden müssen, welche impliziten Regeln in Betracht kommen und welche 
angewendet werden... Alles was interessant ist um zu sehen, wie make entscheidet was zu tun ist.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Nach Fehlern fortfahren</term>
<listitem>
<para>Arbeite soweit möglich nach Fehlern weiter. Während das Ziel bei dem der Fehler auftrat und von 
diesem Ziel abhängige Dateien nicht erstellt werden können, ist es dennoch möglich, andere Abhängigkeiten zu bearbeiteten.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Datenbank ausgeben</term>
<listitem>
<para>Gibt die Datenbank aus ( Regeln und Variablenwerte) die sich aus dem Lesen der make-Dateien ergeben; 
danach wird normal oder wie sonst angegeben weitergearbeitet. Außerdem wird die Versionsnummer ausgegeben.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Umgebungsvariablen</term>
<listitem>
<para>Gibt Variablen aus der Betriebssystemumgebung den Vorrang vor Variablen aus den make-Dateien.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Keine eingebauten Regeln</term>
<listitem>
<para>Schaltet die Verwendung der eingebauten impliziten Regeln aus. Außerdem wird die 
Standarderweiterungsliste für Dateierweiterungen gelöscht.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>'Touch' Dateien</term>
<listitem>
<para>Führt <emphasis>touch</emphasis> auf Dateien aus ( markiere sie als aktuell, ohne sie wirklich zu verändern). Dies wird 
verwendet um weitere Aufrufe von make zu täuschen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Alle Fehler ignorieren</term>
<listitem>
<para>Ignoriere alle Fehler in Kommandos, die beim Erstellen ausgeführt werden.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Keine Meldungen</term>
<listitem>
<para>Zeige Kommandos, die ausgeführt werden, nicht an.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Arbeitsverzeichnis ausgeben</term>
<listitem>
<para>Gibt vor und nach den Prozessen das Arbeitsverzeichnis aus. Dies kann nützlich sein, um Fehler 
in kompliziert verschachtelten, rekursiven 'Make'-Kommandos zu finden.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Jobanzahl</term>
<listitem>
<para>Gibt die Anzahl der Jobs (Kommandos) an, die gleichzeitig abgearbeitet werden. Wenn Sie ein System mit nur einer 
CPU haben, ist es nicht empfehlenswert, mehr als 2 zu wählen.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Geändert setzen</term>
<listitem>
<para>Täusche vor, daß die Zieldatei gerade verändert wurde. Dies ist fast das gleiche wie 'touch' auf die Datei 
auszuführen, allerdings wird die Änderungszeit nur für 'Make' geändert. Wenn Sie den Ordnerknopf auf der linken Seite drücken, 
können Sie eine Datei geändert setzen. Diese wird beim nächsten Aufruf von 'make' neu gebaut.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Zusätzliche Optionen</term>
<listitem>
<para>Wählen Sie hier andere zusätzliche Optionen für Ihr Make-Programm. Sie können weitere Informationen 
zu Make Optionen auf den manpages finden.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Neu Erstellen bei Ausführen</term>
<listitem>
<para>Setzt die Aktionen die bei der Auswahl von "Ausführen" durchgeführt werden. Sie können 
aus drei Optionen auswählen:
<itemizedlist>
<listitem>
<para>Immer neu erstellen: Immer neu erstellen, ohne auf geänderte Dateien zu prüfen.</para>
</listitem>
<listitem>
<para>Warnung bei Änderung: Warne, wenn Quelldateien verändert wurden und frage, ob neu erstellt werden soll.</para>
</listitem>
<listitem>
<para>nur bei Änderung: Prüfe, ob Quelldateien geändert wurden und erstelle neu, wenn ja..</para>
</listitem>
</itemizedlist>

Die Standardeinstellung ist, immer neu zu erstellen.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>
</chapter>

<chapter id="der-klassenbrowser-0">
<title>Der Klassenbrowser</title>

<sect1 id="die-klassenansicht-0">
<title>Die Klassenansicht</title>

<para>Die Klassenansicht von KDevelop ist eine der nützlichsten und wichtigsten Werkzeuge, die die Entwicklungsumgebung dem Entwickler zur
Bearbeitung seiner Projektdateien bietet. Sobald ein Projekt geladen wird, liest der Klassenanalysator die Projektdateien nach
Funktionen, Klassen etc. durch und zeigt das Ergebnis in der CV-Baumansicht an. Dieses Kapitel erläutert Ihnen, wie Sie die
Klassenansicht und weitere Funktionen verwenden und wie Sie Ihre Arbeit vereinfachen können.</para>

<para>Klassen und deren Methoden können Sie ebenfalls über die Browser-Werkzeugleiste auswählen. Dort befinden sich in der linken Combobox
die Klassen, in der rechten können Sie die zugehörigen Methoden auswählen. Wenn Sie eine Methode gewählt haben, wird Sie der
Klassenbrowser automatisch zur Implementationsdatei bringen und den Cursor an die Methode setzen. Schließlich bietet Ihnen die
Schaltfläche des Klassenassistenten rechts der Methoden-Combobox an, Sie beim ersten betätigen zur Deklaration der Methode zu bringen;
bei einer weiteren Betätigung wieder zurück zur Definition. Das verzögerte Popup-Menü, das durch den Abwärtspfeil dargestellt wird,
bietet zusätzliche Funktionen, die ebenfalls in den Kontextmenüs der Klassenansicht zur Verfügung stehen:</para>

<para><itemizedlist>
<listitem>
<para>Gehe zur Deklaration: wechselt zur Deklaration der Methode</para>
</listitem>
<listitem>
<para>Gehe zur Definition: wechselt zur Definition der Methode</para>
</listitem>
<listitem>
<para>Gehe zur  Klassen Deklaration: wechselt zur Klassendeklaration</para>
</listitem>
<listitem>
<para>Neue Klasse: öffnet das Dialogfeld "Neue Klasse"</para>
</listitem>
<listitem>
<para>Methode hinzufügen: fügt der aktuellen Klasse eine Methode hinzu</para>
</listitem>
<listitem>
<para>Variable hinzufügen: fügt der aktuellen Klasse eine Variable hinzu</para>
</listitem>
<listitem>
<para>Zeige graphische Klassenansicht: Öffnet den graphischen Vererbungsbaum</para>
</listitem>
</itemizedlist>
</para>

<sect2 id="verfgbare-objekte">
<title>Verfügbare Objekte</title>

<para>Mit verfügbaren Objekten beschreiben wir den Umstand, das man C++ Code auch als eine Sammlung von Objekten betrachten kann- Klassen,
deren Member-Funktionen, globale Funktionen und so weiter. Der Klassenbaum zeigt diese Objekte logisch und nach ihrem
Charakter geordnet an, sodass sie sehr einfach durch ihr zugehöriges Symbol im Baum lokalisiert werden können. Daher enthält der
Klassenbaum einen "Klassen" und "Globals"-Ordner, wobei der "Klassen" Ordner allgemein die Klassen des Projekts enthält; wenn Ihr
Projekt Unterordner beinhaltet, um Quelldateien besser zu sortieren, werden die darin enthaltenen Klassen durch den Namen des
Unterordners ebenfalls in Ordnern untergebracht.</para>

<para>Weiterhin zeigt Ihnen der Klassenbaum bei Auswahl einer Klasse den Inhalt nach Methoden und Attributen an. Da diese ebenfalls Attribute
wie public, private und protected besitzen, werden diese mit leicht geänderten Symbolen angezeit. Sie sehen, das eine Klasse, die im
Klassenbrowser angezeigt wird, alle Objekte enthält wie sie in der Klassendeklaration erscheinen.</para>

<para>Nun, Klassen sind wohl die üblichsten Objekte, wenn man in C++ programmiert und werden den meisten Teil des Codes abdecken. Aber
Applikationen enthalten auch Elemente, die eine "Globale" Erscheinung im Programm aufweisen. Dies wären Strukturen, Funktionen etc.
Speziell die <literal remap="tt">main()</literal> Funktion erscheint in jeder Applikation und Sie werden Sie in der ein oder anderen Weise modifizieren wollen.
Um auf diese Objekte zuzugreifen, enthält die Klassenansicht einen Ordner "Globals", der wiederum Unterordner für folgende Objekttypen
enthält:</para>

<para><itemizedlist>
<listitem>
<para>Strukturen</para>
</listitem>
<listitem>
<para>Funktionen</para>
</listitem>
<listitem>
<para>Variablen</para>
</listitem>
</itemizedlist>
</para>

<para>Da die Symbole, die diese Elemente repräsentieren, denen der Klassen sehr ähnlich sind, ist ihre Bedeutung leicht zu merken.</para>

<para>Schließlich können wir sagen, das die Klassenansicht Ihr Projekt graphisch durch die Objekte darstellt, wie sie im Code erscheinen. Im
folgenden werden Sie mit der Benutzung der Klassenansicht und seiner Werkzeuge in Verbindung mit Ihrem Code vertraut gemacht.</para>
</sect2>

<sect2 id="wechseln-zu-deklaration-und-implementation-v">
<title>Wechseln zu Deklaration und Implementation von Objekten</title>

<para>Die größte Stärke der Klassenansicht sind die zur Verfügung stehenden Funktionen, den Code durch seinen Inhalt zugängig zu
machen, unabhängig von der Plazierung in den Projektdateien. Daher bringt Sie die Auswahl über</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">einer Klasse:</emphasis>  zur Klassendeklaration</para>
</listitem>
<listitem>
<para><emphasis remap="bf">einer Methode:</emphasis> zur Methoden-Implementierung</para>
</listitem>
<listitem>
<para><emphasis remap="bf">eines Klassenattributs:</emphasis> zur Deklaration des Attributs innerhalb der Klassendeklaration</para>
</listitem>
<listitem>
<para><emphasis remap="bf">einer Struktur (struct):</emphasis> zur Deklaration der Struktur</para>
</listitem>
<listitem>
<para><emphasis remap="bf">einer globalen Funktion:</emphasis> zur Funktion-Implementierung</para>
</listitem>
</itemizedlist>
</para>

<para>Nun, dies bietet Ihnen die meistbenötigten Funktionen, um Objekte zu lokalisieren. Gelegentlich ist es jedoch nötig eine
Funktionsdeklaration oder ähnliches zu ändern, wobei sie zum Ort der Deklaration innerhalb der Klasse als auch zur Implementation
gelangen müssen. Die Klassenansicht unterstützt Sie dabei über Kontextmenüs über Elementen. Über einer Methode oder Funktion bedeutet
dies, das Sie wählen können, wohin Sie wollen:</para>

<para><itemizedlist>
<listitem>
<para><emphasis remap="bf">Gehe zu Definition:</emphasis> Wechselt  zur Impelentation- auch standardmäßig über einfache Auswahl wie oben beschrieben</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Gehe zu Deklaration:</emphasis> Wechselt zur Deklaration der Methode oder Funktion</para>
</listitem>
</itemizedlist>
</para>

<para>Mit diesem Verhalten bietet Ihnen der Klassenbrowser unbeschränkten Zugang zu allen Orten, die Sie bei der Programmierung von C++
Applikationen benötigen.</para>

<para>Der folgende Abschnitt gibt Ihnen eine Beschreibung der weiteren Werkzeuge, die der Klassenbrowser bietet- Sie werden sie sehr
nützlich finden, wenn Sie an größeren Projekten arbeiten, da Sie die Idee der Objekt-Orientierten Arbeit an C++ Programmen stark
erweitern.</para>
</sect2>
</sect1>

<sect1 id="die-klassenwerkzeuge">
<title>Die Klassenwerkzeuge</title>

<para>Die Klassenwerkzeuge sind Dialogfelder, die es dem Entwickler noch einfacher machen, informationen über die Klassen seines Projekts zu
erhalten. Die Klassenansicht zeigt alle Objekte nach ihrer Erscheinung im Code an, aber manchmal benötigen Sie weitere Informationen,
ohne unbedingt in den Code zu schauen. Daher sind die Klassenwerkzeuge darauf ausgerichtet, spezifische Klasseninformationen
anzuzeigen.</para>

<para>Der Klassenwerkzeug-Dialog wird über ein Popup Menü über einer Klasse in der Klassenansicht aufgerufen. Wählen Sie "Klassenwerkzeuge",
um zum Dialogfeld zu gelangen. Um informationen über eine Klasse zu erhalten, wählen Sie den Klassennamen in der Combobox am oberen
Rand aus. Dann bieten Ihnen die Schaltflächen darunter folgende Funktionen zur Anzeige spezifischer Bäume Ihrer Klasse. Diese sind:</para>

<para><variablelist>
<varlistentry>
<term> Parents:</term>
<listitem>
<para>Die Eltern der ausgewählten Klasse (Klassen, die die Klasse beerbt). Dies ist nützlich in Bezug auf die Verwendung
multipler Vererbung als auch um herauszufinden, warum die Klasse sich in der ein oder anderen Weise verhält, z.B. können Dialogfelder
sowohl <literal remap="tt">QWidget</literal> als auch <literal remap="tt">QDialog</literal> beerben.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Children:</term>
<listitem>
<para>Zeigt alle Klassen an, die die aktuelle Klasse beerben.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Clients:</term>
<listitem>
<para>Klassen, die die ausgewählte Klasse durch Attribute in ihrer Klassendeklaration verwenden
Classes that make use of the selected class by an attribute in their class declaration</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Suppliers:</term>
<listitem>
<para>Klassen, die durch Attribute der Klasse verwendet werden</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Attribute:</term>
<listitem>
<para>Namen der Attribute der ausgewählten Klasse</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Methoden:</term>
<listitem>
<para>Methoden der ausgewählten Klasse</para>
</listitem>
</varlistentry>
</variablelist>

Weiterhin erlaubt das Klassenwerzeug die sortierte Anzeige nach Modifizierer-Attribut alle, public, protected und private.</para>
</sect1>

<sect1 id="handhabung-von-klassen">
<title>Handhabung von Klassen</title>

<para>Der Klassenbrowser erlaubt weiterhin das direkte Hinzufügen von Methoden und Attributen zu Klassen über Dialogfelder. Dies bedeutet,
das Sie die Klassendeklaration und Implementationskopf nicht mehr selbst eingeben müssen. Nach dem Hinzufügen einer Methode müssen Sie
lediglich die Formalparameter dem Implementationskopf hinzufügen (falls diese nicht in der Methodendeklaration enthalten sind).</para>

<para><emphasis remap="bf"> Wie man einer Klasse eine Methode hinzufügt</emphasis></para>

<para><orderedlist><listitem>
<para>wählen Sie die Klasse in der Klassenansicht aus, der Sie eine Methode hinzufügen möchten</para>
</listitem>
<listitem>
<para>drücken Sie die rechte Maustaste; das Popup-Menü erscheint</para>
</listitem>
<listitem>
<para>wählen Sie "Funktion hinzufügen"</para>
</listitem>
<listitem>
<para>das Dialogfeld "Funktion hinzufügen" erscheint.</para>
</listitem>
<listitem>
<para>geben Sie den Typ, Deklaration und Dokumentation der zu erstellenden Methode an</para>
</listitem>
<listitem>
<para>geben Sie den Zugriff und die Modifizierer der Methode an</para>
</listitem>
<listitem>
<para>bestätigen Sie mit OK, um den Dialog zu verlassen</para>
</listitem>
</orderedlist>
</para>

<para>Um eine Variable hinzuzufügen führen Sie die gleichen Schritte aus, wählen dabei jedoch "Variable hinzufügen" im Popup-Menü.</para>

<para>Der Unterschied zwischen diesen Dialogen ist, das beim Hinzufügen einer Variable nur die Variable in der Klassendeklaration erklärt,
das Hinzufügen einer Methode wird die Methodendeklaration und der Implementationskopf dem Quellcode hinzufügen. Da die Klassenansicht
sich selbst aktualisiert, haben Sie direkten Zugang zu der Implementation der neuen Methode, so daß Sie nur die Methode anspringen
müssen, um den auszuführenden Code einzugeben.</para>
</sect1>
</chapter>

<chapter id="der-dialogeditor-0">
<title>Der Dialogeditor</title>

<para>Der in KDevelop integrierte Dialog Editor ermöglicht die einfache graphische Konstruktion von Widgets und Dialogen für die Verwendung in Ihren Applikationen. Sie 
können Ihren Dialog, so wie der Benutzer ihn sehen wird, direkt am Bildschirm kontrollieren. Nachdem Sie Ihr Projekt mit dem KAppWizard gestartet haben, ist die Verwendung 
des Dialog Editors ist normalerweise der erste Schritt, in dem Sie das Hauptfenster, die interaktiven Dialoge und, nach Beendigung der graphischen Arbeiten, den Code 
erzeugen. Auf diese Art und Weise, enthält Ihr Projekt die als "schwierig" angesehenen Teile, deren Implementierung normalerweise eine längere Zeit in Anspruch nimmt. 
Der "Rest" der Arbeit ist dann die Implementierung der Funktionalität in den generierten Code. Dieses Kapitel behandelt die Verwendung des Dialogeditors zur Erzeugung 
der Widgets, sowie Hinweise zur Vorgehensweise in dem Falle, daß Sie während des weiteren Entwicklungsprozesses erkennen, daß Ihre Widgets Korrekturen oder zusätzliche 
Eigenschaften  benötigen.</para>

<para>Sie können den Dialogeditor entweder durch Wahl des Editors im "Ansicht"-Menü oder über das Icon in der Werkzeugleiste starten. Der Wechsel zum Projekteditor erfolgt 
entweder durch Wahl von "Quellcodeeditor" aus dem Menü "Ansicht" des Dialogeditors oder wiederum über das Icon in der Werkzeugleiste.</para>

<para>Wie hilft Ihnen das Interface des Dialogeditors noch? Hauptsächlich dadurch, daß sein Erscheinungsbild fast vollständig dem des Projekteditors entspricht, dies ermöglicht eine 
sehr kurze Eingewöhnungszeit und da er vollständig mit der Projektverwaltung interagiert, können Sie im Dialogeditor bleiben, wenn Sie den Erstellungsprozeß kontrollieren 
wollen. Aktionen die einen Wechsel zu KDevelop erfordern, tun dies automatisch, wie zum Beispiel der Zugriff auf den Dokumentationsbrowser. Wählen Sie einfach ein 
Menükommando, und KDevelop reagiert entsprechend.</para>

<para>Die folgenden Kapitel geben eine Übersicht über das Dialogeditorinterface, darüber wie ein neuer Dialog erzeugt wird und wie man die Eigenschaften der Kind-Widgets, die Ihr 
Dialog enthält, einstellt.</para>

<sect1 id="das-aussehen-des-dialogeditors">
<title>Das Aussehen des Dialogeditors</title>

<sect2 id="die-hauptansicht">
<title>Die Hauptansicht</title>

<para>Die Haupansicht des Dialogeditors ist logisch unterteilt in:
<itemizedlist>
<listitem>
<para>Den Widget Tabulator, der die "Widgets", "Dialoge" und "Elemente" Tabs enthält. Beschreibungen finden Sie unter 
<link linkend="Widgets-hinzufgen">Widgets hinzufügen</link>.</para>
</listitem>
<listitem>
<para>Den Widget-Editor, der die Editieransicht zur Erstellungen Ihrer Dialoge representiert. Siehe <link linkend="Der-Widget-Editor">Der Widget Editor</link>.</para>
</listitem>
<listitem>
<para>Das Eigenschaften-Fenster, das eine Liste der Eigenschaften und ihrer Werte in Abhängigkeit vom zur Zeit gewählten Widget enthält.. 
Lesen Sie <link linkend="Eigenschaften-einstellen">Eigenschaften einstellen</link> um Informationen zum Einstellen des Widgetaussehens und -verhaltens zu erhalten.</para>
</listitem>
</itemizedlist>
</para>
</sect2>

<sect2 id="unterschiede-zur-menleiste-werkzeugleiste-un">
<title>Unterschiede zur Menüleiste, Werkzeugleiste und Statusleiste von KDevelop</title>

<para>Im Dialogeditormodus ändert KDevelop die Menüleiste, Werkzeugleiste und Statusleiste leicht ab, um die Funktionalität, die Sie zum Erstellen von Widgets benötigen, 
bereitzustellen:</para>

<sect3 id="menleiste">
<title>Menüleiste</title>

<para><emphasis remap="bf">"Datei"-Menü <indexterm remap="idx"><primary>"Datei"-Menü</primary></indexterm>:</emphasis> "Öffnen" ermöglicht das Öffnen einer Dialogdefinitionsdatei.</para>

<para><emphasis remap="bf">"Ansicht"-Menü:</emphasis> Ersetzt "Baumansicht" durch "Widgetsansicht", ermöglicht ein/auschalten der Widgets Tabulatoren; fügt die "Eigenschaften-Ansicht" hinzu und ermöglicht
ein/auschalten dieser Ansicht; fügt "Gitter" hinzu, damit Sie die Gittergröße in horizontalen und vertikalen Pixeln angeben können.</para>

<para><emphasis remap="bf">"Erstellen"-Menü:</emphasis> Ersetzt "Datei kompilieren" durch  "Quellen erzeugen". Dies ermöglicht das Erzeugen der Quellen für Ihren Dialog.</para>
</sect3>

<sect3 id="werkzeugleiste">
<title>Werkzeugleiste</title>

<para>Die Werkzeugleiste enthält ein neues Icon für "Neuen Dialog" sowie eine Ersetzung von "Datei kompilieren" durch  "Quellen erzeugen".</para>
</sect3>

<sect3 id="statusleiste">
<title>Statusleiste</title>

<para>Die Statusleiste stellt Informationen über das aktuell gewählte Widget zur Verfügung, insbesondere eine Anzeige der X und Y Werte im Koordinatensystem. Hilfe zur 
Statusleiste steht in gleicher Weise wie im Projekt-Editiermodus zur Verfügung.</para>

<para>Während Sie die Widgetgröße ändern, zeigt die Statusleiste immer die aktuelle Höhe und Breite des gewählten Widgets an.</para>
</sect3>
</sect2>
</sect1>

<sect1 id="erzeugen-eines-neuen-dialoges">
<title>Erzeugen eines neuen Dialoges</title>

<para>Nachdem Sie Ihr Projektgerüst erstellt haben, haben Sie eine lauffähige Anwendung gemäß Ihrer Voreinstellungen. Da KDevelop die Projekttypen KDE und QT zur Verfügung 
stellt, erkennt der Dialog Editor dies und bietet <emphasis>die</emphasis> Widgets an, die in der verwendeten Bibliothek vorhanden sind. Um Zeit zu sparen, sollten Sie bereits ein Design 
im Kopf haben, das die beabsichtigten Aktionen ermöglicht. Lesen Sie zum Widget Design auch das <ulink url="programming/index-6.html">KDevelop Programming Handbook</ulink>.</para>

<para>Zum Erzeugen eines neuen Dialogs, wählen Sie "Neu" aus dem "Datei"-Menü oder wählen Sie "Neu" aus dem Kontextmenü im
"Dialoge"-Tab. Der "neue Datei" Dialog, in dem Sie das Element Qt/KDE Dialog(*.kdevdlg) wählen können, erscheint. Geben Sie den
Dateinamen für Ihren Dialog ein. In dieser Datei wird Ihr Layout gespeichert. Dann drücken Sie OK und Ihr neuer Dialog erscheint.
Wenn Sie den Dialog fertig bearbeitet haben, wählen Sie "Alle Quellen erzeugen" aus dem "Erstellen"-Menü. Der Dialog zur
Erzeugung der Widgetquellen wird angezeigt. Dort müssen Sie KDevelop die nötigen Informationen zu Basisklasse, Quelldateinamen und
Ziel geben.</para>

<sect2 id="dialog-klasse">
<title>Dialog Klasse</title>

<para>Die Dialog Klasse die Sie auswählen können, ist die Klasse, die Ihr neues Widget erbt, das technisch gesehen selbst durch eine Klasse repräsentiert wird.
Sie haben die folgenden Möglichkeiten:
<orderedlist><listitem>
<para><emphasis remap="bf">QWidget:</emphasis> Die Basisklasse für alle interaktiven Widgets die von QT bereitgestellt werden. Verwendet für Hauptansichten und top-level Widgets.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">QFrame:</emphasis> Erbt QWidget und wird für viele Widgets als Basisklasse verwendet. Sie ist sinnvoll für Widgets, die zusätzlich zu den QWidget Methoden eine QFrame 
Funktionalität aufweisen sollen.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Eigene:</emphasis> Erbt eine eigene Klasse die in "Eigene Eigenschaften" angegeben werden muß. Dies könnte eine schon erstellte Klasse Ihres Projektes oder aus den 
Bibliotheken sein.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">QDialog:</emphasis> Die Basisklasse für Dialoge die Sie für Benutzerinteraktion verwenden würden, wie Einstellen von Eigenschaften oder Ändern von Werten.</para>
</listitem>
<listitem>
<para><emphasis remap="bf">QTabDialog:</emphasis> Erbt QDialog und stellt einen Dialog mit vordefinierten Knöpfen und Tabs zu Verfügung, den Sie über die Widgets, die Sie erzeugen, anbieten.</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf">Eigene Eigenschaften</emphasis></para>

<para>Für die Vererbung einer eigenen Klasse, wie im Dialog Klassen Feld ausgewählt, müssen Sie einen Klassennamen unter "Eigene Klasse" angeben. Der Dialogeditor verwendet 
diesen Namen für die Codeerzeugung, deshalb müssen Sie ebenfalls das Feld "Eigene Header" mit dem Namen der Headerdatei der Klasse ausfüllen.</para>
</sect2>

<sect2 id="dateien">
<title>Dateien</title>

<para>Im "Dateien" Abschnitt müssen Sie die spezifischen Informationen für das Widget eingeben. Dies sind der Klassenname (z.B. KColorSelectDlg für einen Dialog, der die Farbe 
für einen Stift wählt), die Header, C++ und die Data Dateinamen. Wenn Sie den Klassennamen eingeben, werden die Dateinamen automatisch eingetragen, Sie können diese 
Namen jedoch natürlich auch ändern.</para>

<para>Nun, was ist mit den Dateien? Wenn Sie mit der visuellen Konstruktion des Widgets fertig sind, müssen Sie die Dateien erzeugen, die die Implementation Ihres Widgets enthalten. 
Da dies eine Klasse sein wird, ist der Dialog existent, sobald eine Headerdatei mit der entsprechenden Klassendeklaration existiert, eine C++ Datei, welche die Methoden und 
Slots Ihres Widgets implementiert. Die Data Datei enthält eine Funktion <emphasis>initDialog()</emphasis>, die vom Konstruktor Ihres Widgets aufgerufen wird. Diese Datei sollte nicht verändert 
werden, da sie den vom Dialogeditor erzeugten Code enthält, um Ihr Widget auf dem Bildschirm anzuzeigen. Wenn Sie jemals Werte ändern müssen, sollten Sie dies im 
Konstruktor tun oder Sie müssen sich sicher sein, daß der Dialog nicht mehr geändert wird, da die Data Datei jedesmal überschrieben wird, wenn der Code für Ihr Widget neu erzeugt 
wird. Die Header- und C++ Dateien enthalten Abschnitte, in die der Dialogeditor hineinschreibt; diese Abschnitte sind durch Kommentare gekennzeichnet. Nach der 
Dateierstellung können Sie beliebige Werte und Einstellungen außerhalb dieser Abschnitte ändern; andernfalls verlieren Sie Ihre Änderungen bei der nächsten Coderzeugung.</para>
</sect2>

<sect2 id="zielpfad">
<title>Zielpfad</title>

<para>Zur Erzeugung der Widget Quellen, muß der Dialogeditor wissen, wo diese Dateien erstellt werden sollen. Standardmäßig wird als Zielverzeichnis das aktuelle 
Projekt-Unterverzeichnis, das auch die bereits existierenden Quellen enthält, gewählt.</para>

<para>Nachdem Sie "OK" gedrückt haben, wird mit Ihren Standardwerten generiert, und es wird ein leerer Widgetkonstruktor geöffnet. Sie können dann sofort Ihr eigenes Widget 
erstellen. Denken Sie daran, daß der Dialogeditor zur Zeit nur statische Widgets ohne Geometriemanagment unterstützt. Sollten Sie dies für Ihr Widget benötigen, müssen Sie 
sich mit den Klassen vertraut machen, die QT hierfür bereitstellt, eine neue Klasse mit dem Klassengenerator erzeugen und Ihr Widget von Hand schreiben. Weitere 
Informationen erhalten Sie im <ulink url="programming/index.html">KDevelop Programming Handbook</ulink>.</para>
</sect2>
</sect1>

<sect1 id="widgets-hinzufgen">
<title>Widgets hinzufügen</title>

<para>Nach der Angabe der Dialog oder Widget Klassen- und Dateinamen, sind Sie nun bereit Ihr Widget zu erstellen und es mit Inhalt zu füllen. Das Hinzufügen von 
low-level Widgets ist sehr einfach. Wählen Sie einfach das Widget, das Sie hinzufügen wollen aus dem Widget Tabulator durch einfaches Anklicken aus. Das Widget wird 
in der linken, oberen Ecke des aktuell gewählten Hauptwidgets abgelegt. Ein hinzugefügtes Widget erhält eine Standardgröße von 100x30 Pixeln. Zum Bewegen, aktivieren Sie 
den Zeichenrahmen des Widgets durch einfaches Anklicken. Der Rahmen wird dunkelgrau dargestellt und enthält Zugpunkte an jeder Ecke und in der Mitte jeder Kante. Ein 
Kreuz-Cursor zeigt an, daß das Widget bewegt werden kann. Zum Bewegen, halten Sie die Maustaste im Rahmen gedrückt und bewegen Sie den Rahmen zur gewünschten 
Stelle.</para>

<para>Zur Größenänderung, aktivieren Sie den Rahmen und ziehen das Widget an den Zugpunkten auf die gewünschte Größe. Klicken Sie dazu den Zugpunkt mit der rechten 
Maustaste an. Ein Doppelpfeil zeigt Ihnen jeweils die mögliche Richtung an.</para>

<para>Weiterhin enthält der Widgeteditor eine ganze Reihe von Kontextmenüs, die Ihnen bei der Arbeit helfen. Sie sind für jedes Element im Widgettabulator erhältlich und zeigen 
jeweils den Klassennamen des Widgets und eine kurze Beschreibung.
Über einem ausgewählten Widget im Widgeteditor, zeigt das Kontextmenü den Klassennamen und bietet folgende Möglichkeiten:</para>

<para><itemizedlist>
<listitem>
<para>Nach vorne</para>
</listitem>
<listitem>
<para>Nach hinten</para>
</listitem>
<listitem>
<para>Ganz nach vorne</para>
</listitem>
<listitem>
<para>Ganz nach hinten</para>
</listitem>
<listitem>
<para>Ausschneiden</para>
</listitem>
<listitem>
<para>Löschen</para>
</listitem>
<listitem>
<para>Kopieren</para>
</listitem>
<listitem>
<para>Einfügen</para>
</listitem>
<listitem>
<para>Hilfe</para>
</listitem>
</itemizedlist>
</para>

<para>Nachdem Sie Größe und Position eingestellt haben, können Sie die Voreinstellungen im Einstellungen-Fenster editieren.</para>

<sect2 id="der-widget-tabulator">
<title>Der Widget Tabulator</title>

<para>Der Widget Tab präsentiert die verfügbaren Widgets, die Sie auf dem Dialog plazieren können. Wenn Sie Information zu einem bestimmten Widget erhalten wollen, 
drücken Sie die rechte Maustaste über dem Widget Icon und wählen Sie Schnellhilfe. Denken Sie daran, daß der Dialogeditor automatisch erkennt, ob Sie ein 
nur-Qt oder KDE Projekt erzeugt haben. Dies verhindert die Verwendung von KDE Widgets in einer reinen Qt Anwendung.</para>

<para>Nachdem Sie ein Widget ausgewählt haben, wird es mit Standardgrößen und -werten auf dem Editorfenster abgelegt und mit einem Rahmen als gewählt markiert. Zur 
Größenänderung, aktivieren Sie den Rahmen und ziehen das Widget an den Zugpunkten auf die gewünschte Größe. Klicken Sie dazu den Zugpunkt mit der rechten 
Maustaste an und halten Sie die Taste gedrückt. Ein Doppelpfeil zeigt Ihnen jeweils die mögliche Richtung an. Während Sie die Größe ändern, werden die aktuellen 
X und Y Werte der Position in der Statusleiste angezeigt.</para>
</sect2>

<sect2 id="der-dialoge-tabulator">
<title>Der Dialoge Tabulator</title>

<para>Der Dialoge Tabulator dient dazu, die Dialoge Ihres Projektes mit einem Mausklick zu öffnen. Da die Struktur der Dialoge in einer *.kdevdlg Datei im gleichen Verzeichnis, das 
auch die erzeugten Dateien enthält, gespeichert ist, werden nur die Dialogdefinitionsdateien angezeigt. Achten Sie auch darauf, diese Dateien nicht zu löschen.</para>

<para>Bei Auswahl eines Dialoges, wird der Zustand angezeigt, in dem er zuletzt im Widgeteditor gespeichert wurde.</para>
</sect2>

<sect2 id="der-elemente-tabulator">
<title>Der Elemente Tabulator</title>

<para>Der Elemente Tabulator gibt Ihnen eine hierarchische Übersicht über die zur Zeit im Dialog vorhandenen Widgets. Das bedeutet, daß, da der Hintergrund den Vater aller 
Widgets im Dialog repräsentiert, er am Kopf des Baumes angezeigt wird. Die Kinder des Hauptdialoges werden dann in der nächsten Baumebene angezeigt.</para>

<para>Durch Auswahl eines Elementes wird es im Editorfenster markiert und seine Eigenschaften werden im Widgeteigenschaftenfenster angezeigt. Die Verwendung der 
Elementeansicht ist manchmal wichtig, wenn das Verhalten eines Widgets von der Eltern - Kind Beziehung abhängt. Weitere Informationen finden Sie im 
<ulink url="programming/index-6.html">KDevelop Programming Handbook</ulink>.</para>
</sect2>
</sect1>

<sect1 id="der-widget-editor">
<title>Der Widget Editor</title>

<para>Der Widget Editor ist die Hauptansicht, die in der Mitte plaziert ist und in der Sie Ihre Widgets konstruieren. Nach dem Hinzufügen von Elementen, können sie ausgewählt, 
in der Größe verändert sowie dorthin bewegt werden, wo Sie sie haben möchten. Für alle Elemente stehen Popupmenüs zur Verfügung, die schnellen Zugriff auf Funktionen 
wie Ausschneiden, Kopieren und Einfügen ermöglichen.</para>
</sect1>

<sect1 id="eigenschaften-einstellen">
<title>Eigenschaften einstellen</title>

<para>Das Fenster "Widgeteigenschaften" auf der rechten Seite ist der Ort, an dem Sie das Standardverhalten Ihres Widgets und seiner Elemente einstellen. Es zeigt die 
voreingestelllten Werte für jedes ausgewählte Element sofort an; ändern der Werte ruft sofort Änderungen in der Editoransicht hervor, z.B. das Benennen von Labeln oder 
Knöpfen.</para>

<para>Zur Trennung bestimmter Werte nach ihrem Effekt, enthält das Eigenschaftenfenster vier Ordner; die Auswahl eines Ordners zeigt alle Werte für diese Gruppe von 
Einstellungen. Die möglichen Werte werden weiter unten beschrieben. Denken Sie daran, daß die möglichen Eigenschaften vom Widget abhängen, so haben z.B. Label und 
Knöpfe eine Einstellungen für ihren Namen auf dem Bildschirm, während Zeilentextfelder Einstellungen für Methoden wie <emphasis>setText()</emphasis> besitzen.</para>

<para>Für eine komplette Liste der möglichen Werte pro Element, sollten Sie sich die Klassenreferenz des Widgets ansehen, in der erklärt wird, welche Methoden verwendet 
werden und welche Werte möglich sind. Machen Sie sich klar, daß die meisten Werte in QWidget implementiert sind und von allen erbenden Widgets verwendet werden. 
Denken Sie außerdem daran, daß der fertige Code keine Methodenaufrufe enthält, die nicht vom Benutzer verändert werden und benutzen Sie deshalb die Standardwerte, wie 
sie von den Konstruktoren vorgegeben werden.</para>

<para>Eine vollständige Liste der unterstützten Eigenschaften, die im Eigenschaftenfenster eingestellt werden können, finden Sie im 
<ulink url="programming/index-6.html">KDevelop Programming Handbook</ulink>.</para>
</sect1>

<sect1 id="dateien-erzeugen">
<title>Dateien erzeugen</title>

<para>Nachdem Sie ein Widget erzeugt haben, müssen Sie den Sourcecode erstellen, damit Sie es in Ihrem Projekt verwenden können. Dies wird entweder durch Wahl von 
"Quellen erzeugen" aus dem "Erstellen"-Menü oder mit Hilfe des entsprechenden Icons in der Dialogeditor-Werkzeugleiste erreicht. Die Makedateien werden automatisch 
aktualisiert, damit das neue Widget beim Kompilieren berücksichtigt wird. Daher können Sie nach dem Aufruf von "Quellen erzeugen", das Projekt aus dem Dialogeditor heraus 
neu erstellen. Das Ausgabefenster erscheint, wie im Projekteditormodus, unterhalb des Widgeteditors.</para>

<para>Jetzt, da Ihr Projekt ein neues Widget enthält, ist es Ihre Aufgabe als Programmierer, den verwendeten Slots Funktionalität zu implementieren und wenn nötig weitere Methoden, 
die Sie benötigen mögen, hinzuzufügen.</para>

<para>Informationen zur Implementation der Widgetfunktionen erhalten Sie im <ulink url="programming/index-6.html">KDevelop Programming Handbook</ulink>.</para>
</sect1>
</chapter>

<chapter id="der-interne-debugger">
<title>Der interne Debugger</title>

<sect1 id="einstellungen">
<title>Einstellungen</title>

<para>Standardmäßig verwendet KDevelop den internen Debugger. Dies kann unter "Einstellungen" geändert werden. Wählen Sie 
"KDevelop setup" und dann "Debugger" .</para>

<para>Aktivieren Sie das Kontrollkästchen "Verwende externen Debugger", wenn Sie einen anderen Debugger verwenden wollen und geben 
Sie den Namen des externen Debuggers ein. Zur Bedienung Ihres Debuggers konsultieren Sie bitte die entsprechende Dokumentation.</para>

<para>Bei Auswahl des internen Debuggers erhalten Sie eine Anzahl zusätzlicher Optionen aus denen Sie auswählen können:</para>

<para><itemizedlist>
<listitem>
<para>Zeige static members: Die Anzeige von statischen Elementen verlangsamt gdb bei der Datenenerzeugung in kde und qt. Die 
"Signatur" der Daten auf die sich QString und friend-Funktionen verlassen, könnte verändert werden. Wenn Sie jedoch diese Werte 
debuggen müssen, markieren Sie die Option</para>
</listitem>
<listitem>
<para>Zeige Teil-Namen an: Bei der Anzeige von disassembliertem Code können Sie sich Teil-Namen der Methoden anzeigen lassen. 
Vollständige Namen sind jedoch einfacher zu lesen.</para>
</listitem>
<listitem>
<para>BPs beim Laden von Bibliotheken setzen: Hiermit wird versucht "schwebende" Breakpoints beim Laden von Bibliotheken zu
setzen. Wenn GDB eine Bibliothek die mittels "dlopen" geladen werden soll noch nicht kennt, weigert er sich Unterbrechungen in 
diesem Code anzunehmen. Es ist jedoch möglich beim Laden der Bibliothek anzuhalten und dann zu versuchen die "schwebenden" 
Breakpunkte zu setzen. Im Kapitel <link linkend="Dynamische-Bibliotheken-und-Unterbrechungen">Dynamische Bibliotheken und Unterbrechungen</link>
finden Sie Details und Probleme dieser Vorgehensweise. Wenn Sie keine Bibliotheken mit "dlopen" öffnen, lassen Sie diese Option 
ausgeschaltet.</para>
</listitem>
<listitem>
<para>Schwebende Werkzeugleiste: Dies erlaubt Ihnen zusätzlich die Steuerung des Debuggers mit Hilfe der schwebenden 
Werkzeugleiste. Die Werkzeugleiste ist bestens zum Debuggen von GUI Anwendungen geeignet. Details finden Sie unter 
<link linkend="Die-schwebende-Werkzeugleiste">Die schwebende Werkzeugleiste</link>.</para>
</listitem>
<listitem>
<para>Separates Terminal für Anwendungs I/O einschalten: Dies ermöglicht Ihnen, Terminaleingaben zu machen, wenn Ihre Anwendung
Terminaleingabecode enthält (z.B. cin, fgets etc.). Wenn Ihre Anwendung solchen Code enthält, wählen Sie diese Option, sonst
lassen Sie sie ausgeschaltet. <emphasis remap="bf">Tip:</emphasis> Diese Option wird am sinnvollsten zusammen mit der <link linkend="Die-schwebende-Werkzeugleiste">schwebenden Werkzeugleiste</link> eingesetzt, da so das Terminalfenster nicht vom KDevelopfenster verdeckt wird,
wenn Sie den Debugger bedienen.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="verwendung-des-internen-debuggers">
<title>Verwendung des internen Debuggers</title>

<sect2 id="nderungen-in-den-baum-und-ausgabeansichten">
<title>Änderungen in den Baum- und Ausgabeansichten</title>

<para>Bei Verwendung des internen Debuggers werden den Baum- und Ausgabeansichten drei Tabs 
hinzugefügt.</para>

<sect3 id="in-der-baumansicht">
<title>In der Baumansicht</title>

<para><itemizedlist>
<listitem>
<para>VAR Tab : Eine Baumansicht der lokalen Variablen des aktuellen Stackframes. 
Es können auch Variablen der aufrufenden Funktion angezeigt werden. Außerdem 
enthält dieses TAb ein Watch Fenster. Dies ermöglicht es globale Variablen anzuzeigen; 
oder Sie wollen vielleicht nur eine lokale Variable anzeigen anstatt sie in einer 
langen Liste lokaler Variablen zu suchen.</para>
</listitem>
</itemizedlist>
</para>
</sect3>

<sect3 id="in-der-ausgabeansicht">
<title>In der Ausgabeansicht</title>

<para><itemizedlist>
<listitem>
<para>Breakpoint : Eine Liste der aktuell gesetzten Unterbrechungen und ihr aktueller Status.</para>
</listitem>
<listitem>
<para>Framestack : Eine Liste der zur Zeit aufgerufenen Funktionen</para>
</listitem>
<listitem>
<para>Disassemble : Eine Ansicht des Assemblercodes der aktuell ausgeführten Anweisung</para>
</listitem>
</itemizedlist>
</para>
</sect3>
</sect2>

<sect2 id="nderungen-im-debugmen-und-im-panel">
<title>Änderungen im Debugmenü und im Panel</title>

<sect3 id="im-panel">
<title>Im Panel</title>

<para>Ihnen stehen zwei normale und zwei Dropdown-Knöpfe zur Verfügung, sobald Sie den Debugger starten.</para>
</sect3>

<sect3 id="verfgbare-funktionen">
<title>Im Debugmenü</title>

<para>Wenn Sie den Debugger starten, werden die zehn Einträge zu Steuerung des Debuggers eingeschaltet.</para>

<para>Verfügbare Funktionen: 
<itemizedlist>
<listitem>
<para>Ausführen: Fortsetzen des Programmes von der aktuellen Stelle aus.</para>
</listitem>
<listitem>
<para>Bis Cursor: Fortsetzen des Programmes bis zur aktuellen Cursorposition.</para>
</listitem>
<listitem>
<para>Über Funktion: Ausführen einer Codezeile. Alle in dieser Zeile enthaltenen Funktionen 
werden ausgeführt.</para>
</listitem>
<listitem>
<para>Über Maschinenanweisung: Ausführen einer Assemblerinstruktion wie oben.</para>
</listitem>
<listitem>
<para>In Funktion: Ausführen einer Codezeile. Wenn erforderlich wird aber in die enthaltenen 
Funktionen verzweigt und diese werden angezeigt.</para>
</listitem>
<listitem>
<para>In Maschinenanweisung:  Ausführen einer Assemblerinstruktion wie oben.</para>
</listitem>
<listitem>
<para>Aus Funktion: Ausführen bis zum Ende des aktuellen Stackframes (Funktion).</para>
</listitem>
<listitem>
<para>Ansichten: Erlaubt verschieden Ansichten der Daten.
Zur Zeit sind implementiert:
<orderedlist><listitem>
<para> Speicher</para>
</listitem>
<listitem>
<para> Disassemblieren</para>
</listitem>
<listitem>
<para> Register</para>
</listitem>
<listitem>
<para> Bibliotheken</para>
</listitem>
</orderedlist>
</para>
</listitem>
<listitem>
<para>Anhalten: Ausführung der Anwendung unterbrechen.</para>
</listitem>
<listitem>
<para>Halt: Ausführung der Anwendung unterbrechen und Debugger beenden.</para>
</listitem>
</itemizedlist>
</para>
</sect3>
</sect2>

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

<sect3 id="unterbrechungen">
<title>Unterbrechungen</title>

<para>Unterbrechungen können auf Quellcodezeilen gesetzt werden (sog. Breakpoints), oder auch auf Variablen (sog. Watchpoints) . Beide 
Arten von Unterbrechung können jederzeit gesetzt werden, Watchpoints auf lokale Variablen sind jedoch nur im jeweiligen 
Gültigkeitsbereich von Bedeutung. Sinnvoller ist die Verwendung von Watchpoints für globale Variablen.</para>
</sect3>

<sect3 id="setzenlschen-von-unterbrechungen">
<title>Setzen/Löschen von Unterbrechungen</title>

<para>Klicken Sie im Editor in der gewünschten Zeile den schmalen "Icon"-Rand auf der linken Seite des Quelltextes an, um eine 
Unterbrechung zu setzen. Nochmaliges Klicken entfernt die Unterbrechung wieder.</para>
</sect3>

<sect3 id="alternative-manipulation-der-unterbrechungen">
<title>Alternative Manipulation der Unterbrechungen via Menü</title>

<para>Wenn Sie den Breakpoint entweder im Editor oder in der Breakpointliste mit der rechten Maustaste anklicken, öffnet sich ein Menü mit 
Optionen. Dort können Sie die Unterbrechung entfernen oder editieren, oder alle Unterbrechungen löschen.</para>
</sect3>

<sect3 id="editieren-von-unterbrechungen">
<title>Editieren von Unterbrechungen</title>

<para>Benutzen Sie das eben beschriebene Menü um Unterbrechungen zu editieren. Es enthält die folgenden Einträge:
<orderedlist><listitem>
<para>Bedingung: Geben Sie eine Bedingung an, die erfüllt sein muß, damit gdb die Programmausführung unterbricht.</para>
</listitem>
<listitem>
<para>Ignoriere die nächsten: Wie oft der Code den Breakpoint passieren soll, bevor gdb die Programmausführung unterbricht.</para>
</listitem>
<listitem>
<para>Aktivieren: Wenn das Kontrollfeld aktiviert ist, hält gdb an dieser Stelle an, sonst wird der Breakpoint ignoriert.</para>
</listitem>
</orderedlist>
</para>
</sect3>

<sect3 id="alle-breakpoints-lschen">
<title>Alle Breakpoints löschen</title>

<para>Entfernt alle Unterbrechungen für dieses Programm.</para>
</sect3>

<sect3 id="setzenlschen-von-watchpoints">
<title>Setzen/Löschen von Watchpoints</title>

<para>Klicken Sie in der Variablenansicht mit der rechten Maustaste auf eine Variable. Es öffnet sich ein Popup Menü in dem Sie einen 
Watchpoint auf diese lokale Variable setzen können. Diese Funktionalität ist auf den Gültigkeitsbereich dieser Variablen eingeschränkt. 
Sobald der Gültigkeitsbereich verlassen werden soll, wird das Programm angehalten und der Watchpoint gelöscht.</para>

<para>WARNUNG: Dies ist als problematisch bekannt. Seien Sie also vorsichtig, wenn Sie Unterbrechungen auf lokale Variablen setzen.</para>

<para>Eine Unterbrechung kann auch gesetzt werden, indem Sie mit der rechten Maustaste auf eine vorher eingegebene Unterbrechung 
klicken und "Watchpoint umschalten" auswählen.</para>
</sect3>

<sect3 id="setzenlschen-von-watch-variablen">
<title>Setzen/Löschen von Watch Variablen</title>

<para>Am unteren Ende der Variablenansicht befindet sich das "Watch"-Feld in dem man den Variablennamen eingeben kann, den man sich 
in der Watchliste anzeigen lassen will. Geben Sie den Variablennamen gefolgt von &&lt;;RETURN&&gt;; ein oder klicken Sie auf 
"Hinzufügen" . Ein Klick mit der rechten Maustaste auf den Variablennamen in der Baumansicht öffnet ein Menü, in dem Sie die 
Variable wieder aus der Liste entfernen können.</para>

<para>Sie können eine Watchvariable auch eingeben, indem Sie mit der rechten Maustaste im Editorfenster auf den Variablennamen klicken. 
Dies öffnet ein Popoup Menü mit einem "Beobachten : Variablenname" Eintrag.</para>
</sect3>

<sect3 id="ndern-von-variablenwerten">
<title>Ändern von Variablenwerten</title>

<para>Das ändern von Variablenwerten erfolgt mit Hilfe einer Watchvariablen. Wenn Sie eine Variable "test" haben, können Sie die Variable 
auf 5 setzen, indem Sie im Watch-Feld "test=5" eingeben und die Variable zur Liste hizufügen. Beachten Sie, daß "test" JEDESMAL 
auf 5 gesetzt wird, wenn das Programm an dieser Stelle angehalten wird. Sie sollten eine Variable deshalb wieder aus der Liste 
entfernen nachdem sie einmal gesetzt worden ist.</para>
</sect3>
</sect2>
</sect1>

<sect1 id="die-schwebende-werkzeugleiste">
<title>Die schwebende Werkzeugleiste </title>

<para>Die schwebende Werkzeugleiste ist ein Feature des internen Debuggers, das den Komfort beim Debuggen von GUI Anwendungen 
erheblich verbessert. Die Werkzeugleiste "schwebt" entweder über allen angezeigten Fenstern, oder sie ist in die Kontrolleiste gedockt. 
Wenn sie gedockt ist, können Sie den Code durch anklicken des gedockten Icons ausführen. Die dabei ausgeführte Funktion ist die 
"Step Over" Funktion. Mit Hilfe der rechten Maustaste können sie die Werkzeugleiste wiederherstellen und optional KDevelop den 
Fokus geben.</para>

<para>Zusätzlich zu den <link linkend="Verfgbare-Funktionen">Funktionen  des Debugmenüs</link>, bietet die schwebende Werkzeugleiste 
zwei weitere Funktionen an:
<itemizedlist>
<listitem>
<para>Setze Fokus auf KDevelop : Setzt den Fokus auf KDevelop.</para>
</listitem>
<listitem>
<para>Setze Fokus auf Applikation : Setzt den Fokus auf das Fenster das ihn hatte als "Setze Fokus auf KDevelop" gedrückt wurde. 
Dies ist ein Kompromiß, der Fokus sollte eigentlich auf die zu debuggende Anwendung gesetzt werden, aber dies ist schwierig. Wenn 
jemand eine bessere Lösung hat, laßt es uns wissen.</para>
</listitem>
</itemizedlist>
</para>

<para>Wenn gdb das Programm unterbricht, weil z.B. ein Breakpoint erreicht wurde, wird "Setze Fokus auf KDevelop" mit einem Highlight 
versehen. Wir geben nicht automatisch KDevelop den Fokus, damit Sie die Ausgabe Ihres Programmes sehen können. Klicken Sie auf 
"Setze Fokus auf KDevelop" oder einen anderen Knopf um die gewünschte Funktion auszuführen.</para>
</sect1>

<sect1 id="dynamische-bibliotheken-und-unterbrechungen">
<title>Dynamische Bibliotheken und Unterbrechungen </title>

<para>Die Verwendung Breakpoints innerhalb von dynamischen Bibliotheken führt zu einem Problem, für das es eine annehmbare Lösung gibt. 
Das Problem ist, daß gdb keine Breakpoints akzeptiert, die innerhalb des Quellcodes einer dynamischen Bibliothek liegen, solange 
diese noch nicht mittels dlopen geöffnet wurde. </para>

<para>Die Lösung besteht darin, gdb dazu zu bringen uns zu benachrichtigen, wenn eine dynamische Bibliothek geöffnet wurde. Das heißt, 
wenn der Benutzer dort eine Unterbrechung setzt, markieren wir dies als "in der Schwebe", und wenn gdb anhält, weil die Bibliothek 
geöffnet wurde, versuchen wir die Breakpoints zu setzen. Ist dies erfolgreich, wird die Unterbrechung als aktiv markiert, wenn nicht, 
bleibt der Breakpoint "schwebend". In jedem Falle wird anschließend ein "continue" ausgeführt.</para>

<para>Dies ist als "lazy breakpoints" bekannt.</para>

<para>Es kann jedoch zu einem Problem kommen, wenn Sie das "Über Funktion" Kommando benutzen und über Code springen, der eine Bibliothek lädt. 
Es wird eine Unterbrechung beim Laden der Bibliothek ausgelöst, und der Debugger würde normalerweise ein "continue" ausführen (d.h. er würde
bis zur nächsten Unterbrechung oder bis zum Ende des Codes ausführen). Der Benutzer erwartet jedoch, daß das Programm in der nächsten Zeile 
anhält. Deshalb wird in dieser Situation kein "continue" ausgeführt, sondern wir lassen das Programm an diesem Punkt (dies wird irgendwo innerhalb 
des dlopen Kommandos sein). Das mag etwas verwirren, kann aber nicht vermieden werden.</para>
</sect1>
</chapter>

<chapter id="cvs-integration">
<title>CVS Integration </title>

<para>KDevelop unterstützt auch die Verwaltung Ihrer Projekte mit Hilfe von CVS Archiven. CVS (Concurrent Version 
System) hat zum Ziel, Gruppen von Entwicklern das voneinander unabhängige Arbeiten am gleichen Quellcode zu 
ermöglichen und die Änderungen im Repositorium zu verschmelzen. Normalerweise befindet sich das Repositorium 
auf einem Server. Das anfängliche Archiv enthält einen Grundstock an Dateien; die Verzeichnisse und Dateien 
werden dann von den Entwicklern dem CVS hinzugefügt oder aus ihm entfernt.</para>

<para>Der Entwickler arbeitet lokal mit seiner Kopie des CVS Baumes. Er nimmt die Änderungen an seinen Dateien vor und testet, ob sein 
Projekt weiterhin arbeitet, wenigstens insoweit, daß unvollständige Quellen nicht die Arbeit der anderen Entwickler, die seine 
Änderungen erhalten, behindern oder unmöglich machen.</para>

<sect1 id="erzeugen-eines-cvs-archivs">
<title>Erzeugen eines CVS Archivs</title>

<para>Wenn Sie ein neues Projekt mit KDevelop erstellen, können Sie dieses Projekt direkt als CVS-Modul importieren. Um dies
einzuschalten, muß CVS installiert sein ( das sollte bereits der Fall sein, wenn nicht, passen Sie Ihre Systeminstallation an oder
kontaktieren Sie Ihren Systemadministrator).</para>

<para>Wählen Sie "CVS" auf der dritten Seite des Application Wizard (VCS Unterstützung). Dadurch werden die Eingabefelder auf dieser
Seite aktiviert und Sie können die Importparameter eingeben. Der AppWiz wird daraufhin Ihr Projekt als Modul in das CVSROOT
Verzeichnis importieren und Ihr Projekt als lokale Kopie des zugehörigen CVS Verzeichnisses erstellen, d.h. Sie arbeiten immer mit
einer Kopie Ihres Projektes.</para>

<para><emphasis remap="bf">Achtung:</emphasis> Damit Sie ein Archiv erstellen können, benötigen Sie Schreibrechte im CVSROOT Verzeichnis ! Außerdem muß sich
das Rootverzeichnis auf derselben Maschine wie KDevelop befinden ! Wenn Sie Ihr Archiv auf einem Remote Server haben wollen,
müssen Sie entweder Kontakt mit dem Systemadministrator aufnehmen, damit dieser ein Archiv auf dem Server anlegt, oder Sie führen
die folgenden Schritte aus:</para>

<para><itemizedlist>
<listitem>
<para>Erstellen Sie Ihr Projekt lokal</para>
</listitem>
<listitem>
<para>Importieren Sie das Projekt als Modul auf den CVS Server</para>
</listitem>
<listitem>
<para>Löschen Sie den lokalen Projektverzeichnisbaum</para>
</listitem>
<listitem>
<para>Checken Sie das Modul vom CVS Server aus</para>
</listitem>
<listitem>
<para>Schalten Sie, nachdem Sie das Projekt geladen haben, die CVS-Unterstützung in den Projektoptionen ein. Wie Sie die
Unterstützung einschalten können, wird weiter unten beschrieben.</para>
</listitem>
</itemizedlist>
</para>

<para>Für weitere Details zu den CVS Kommandos, konsultieren Sie bitte Ihre Systemhilfe, z.B. indem Sie <literal remap="tt">man cvs</literal> eingeben.</para>

<para>Im folgenden, werden wir die Optionen beschreiben, die zur Verfügung stehen, wenn Sie ein Archiv mit dem KAppWizard erzeugen.</para>

<para><variablelist>
<varlistentry>
<term>VCS Verzeichnis:</term>
<listitem>
<para>Dies ist das CVS Rootverzeichnis, in das der Projektverzeichnisbaum importiert wird, und in dem Commits,
Checkouts und Updates ausgeführt werden.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Archiv in VCS</term>
<listitem>
<para>Dies ist der Modulname für Ihr Projekt. Da es der Name Ihres Projektverzeichnisses ist, können Sie ihn nicht
ändern.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Vendor Zeichen</term>
<listitem>
<para>Dies ist das Zeichen für den kompletten Zweig.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Log Nachricht</term>
<listitem>
<para>ist die erste Log-Nachricht des neuen Moduls. Wenn Sie Dateien zum Archiv hinzufügen oder commiten, werden Sie
jedesmal nach einer Log-Meldung gefragt, um die Änderungen zu dokumentieren.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Release Zeichen</term>
<listitem>
<para>Dies gibt an, unter welchem Zeichen Ihr Projekt gefunden werden kann. Das bedeutet, Sie können mehrere
Module mit dem gleichen Namen im CVS haben, die sich aber in diesem Zeichen unterscheiden, Sie haben also verschiedene Zweige
Ihres Projekts. Beispiel: KDE 2 wird unter dem HEAD (Standardzweig) entwickelt, KDE 1.1.2 hat das Zeichen (den
Tag) KDE&&lowbar;;1&&lowbar;;1&&lowbar;;2&&lowbar;;RELEASE.</para>
</listitem>
</varlistentry>
</variablelist>
</para>

<para>Nachdem Sie Ihr Projekt mit dem Applicattion Wizard erstellt haben, ist die CVS Unterstützung für Ihr Projekt eingeschaltet (wenn
Sie dies ausgewählt haben), Sie können also Änderungen, wie im Abschnitt "Verwendung von CVS Kommandos" beschrieben, commiten und
hinzufügen.</para>
</sect1>

<sect1 id="einschalten-der-cvs-untersttzung">
<title>Einschalten der CVS Unterstützung</title>

<para>Da CVS Unterstützung im allgemeinen nur von professionellen Entwicklern oder Firmen, sowie von KDE Entwicklern, die Ihre Projekte 
über den KDE CVS Server verwalten benötigt wird, ist die Verwendung der CVS Kommandos in KDevelop optional. Die CVS 
Unterstützung kann eingeschaltet werden, indem Sie im Projekt Optionen Dialog die Einstellung für Versionskontrolle auf "CVS" ändern.</para>
</sect1>

<sect1 id="verwendung-von-cvs-kommandos">
<title>Verwendung von CVS Kommandos</title>

<para>Damit stehen Ihnen die folgenden Kommandos unter LFV und RFV zur Verfügung:</para>

<para>Für Dateien die nicht im Archiv sind:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Zum Archiv hinzufügen</emphasis>: Fügt die Datei zum Archiv hinzu. Die Datei wird als hinzuzufügen markiert, wird aber erst beim 
nächsten <literal remap="tt">Änderungen einspielen</literal> tatsächlich dem Archiv hinzugefügt.</para>
</listitem>
</itemizedlist>
</para>

<para>Für Dateien die bereits im Archiv sind:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Aktualisieren</emphasis>: Update der ausgewählten Datei von der CVS Version</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Änderungen einspielen</emphasis>: Führt ein "commit" der ausgewählten Datei in das CVS Archiv aus</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Vom Archiv entfernen</emphasis>: Entfernt die Datei aus dem Repositorium</para>
</listitem>
</itemizedlist>
</para>

<para>Für Verzeichnisse:
<itemizedlist>
<listitem>
<para><emphasis remap="bf">Zum Archiv hinzufügen</emphasis>: Fügt den Order zum Repositorium hinzu</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Vom Archiv entfernen</emphasis>: Entfernt das Verzeichnis aus dem Repositorium</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Aktualisieren</emphasis>: Synchronisiert das Verzeichnis rekursiv mit dem CVS Archiv</para>
</listitem>
<listitem>
<para><emphasis remap="bf">Änderungen einspielen</emphasis>: Führt ein rekursives "commit" in das CVS Archiv aus</para>
</listitem>
</itemizedlist>
</para>

<para>Die CVS Kommandos benötigen eine funktionierende Netzverbindung zum CVS Server. Wenn Sie ein Kommando aufrufen, sehen Sie 
einen Dialog der Ihnen anzeigt, welches Kommando gesendet wurde und wie die Antwort des Servers war. Dadurch haben Sie eine 
Kontrolle darüber, welche Aktionen tatsächlich durchgeführt wurden, und ob Ihr Kommando erfolgreich abgeschlossen werden konnte.</para>

<para>Da die CVS Kommandos von KDevelop nur mit dem <literal remap="tt">cvs</literal> System Kommando und dessen Kommandozeilenoptionen arbeiten, sollten 
Sie keine Probleme haben CVS zu benutzen.</para>
</sect1>
</chapter>

<chapter id="grundstzliche-konfiguration">
<title>Grundsätzliche Konfiguration</title>

<para>Diese Kapitel beschreibt, wie Sie Ihre individuelle Voreinstellungen für die Arbeitsweise von KDevelop einstellen können. Alle unten 
beschriebenen Einstellungen finden Sie unter den entsprechenden Einträgen im Einstellungen Menü.</para>

<sect1 id="konfiguration-des-werkzeuge-mens">
<title>Konfiguration des "Werkzeuge" Menüs</title>

<para>Da KDevelop in seinem Benutzer-Interface auch die Verwendung von Drittanbieterprogrammen unterstützt, haben Sie die Möglichkeit 
jedes Programm Ihrer Wahl für die Programmentwicklung mit KDevelop zu konfigurieren. Dies wird erreicht, indem Sie ihr Programm 
den bereits vordefinierten Programmen im "Werkzeuge" Menü hinzufügen. Zum Ändern des "Werkzeuge" Menüs, wählen Sie 
"Werkzeuge..." aus dem Einstellungen Menü. Dieser Dialog ermöglicht Ihnen die Eingabe eines Titels, des Programmnamens und 
zusätzlicher Parameter, die Sie dem Programm übergeben wollen. Wenn Sie ein Programm aus dem Menü entfernen wollen, selektieren 
Sie den Titel und wählen dann "Löschen". Zum Hinzufügen eines Programms, geben Sie einen Titel ein, wobei der einem & folgende 
Buchstabe als Tastaturkürzel dient; Sie können die bereits definierten Einträge zum Vergleich heranziehen. Wählen Sie die ausführbare 
Datei und evtl. Parameter. Dann drücken Sie "Hinzufügen" und der Eintrag wird dem Menü hinzugefügt. Nachdem Sie den 
Konfigurationsdialog verlassen haben, aktualisiert sich das Werkzeuge Menü selbst, so daß die neue Konfiguration sofort und ohne 
Neustart von KDevelop zur Verfügung steht.</para>
</sect1>

<sect1 id="optionen-der-dateiansicht">
<title>Optionen der Dateiansicht</title>

<para>Die logische Dateiansicht (LFV) kann komplett über Kontextmenüs konfiguriert werden. Da die Intention die ist, Dateien logisch zu 
trennen um eine bessere Übersicht über komplexe Projekte zu erhalten, ist eine der meistgenutzten Konfigurationmöglichkeiten das 
Erzeugen von Dateigruppen. Diese Gruppen können gebildet werden, indem Sie das Kontextmenü, durch einen Klick mit der rechten 
Maustaste über dem Projekt-Icon am Beginn des Baumes, öffnen. Das Menü bietet folgende Punkte an:
<itemizedlist>
<listitem>
<para>Neue Datei: Öffnet den Neue Datei Dialog. Entspricht  dem Kommando "Datei"-"Neu"</para>
</listitem>
<listitem>
<para>Neue Klasse: Öffnet den Klassengenerator um eine neue Klasse zu erzeugen. Entspricht dem Kommando 
"Projekt"-"Neue Klasse"</para>
</listitem>
<listitem>
<para>Neue Gruppe: Öffnet einen Dialog zu Erstellung einer neuen Gruppe. Dort können einen Gruppenname und einen Filter für die 
Dateien, die in dieser Gruppe dargestellt werden, eingeben.</para>
</listitem>
<listitem>
<para>Relativen Pfad anzeigen: Wenn ausgewählt, werden Dateien mit Ihrem Pfad, ausgehend vom Haupt-Projektverzeichnis, 
angezeigt; sonst wird nur der Dateiname ausgegeben.</para>
</listitem>
</itemizedlist>
</para>

<para>Über einem Gruppenordner zeigt das entsprechende Kontextmenü:
<itemizedlist>
<listitem>
<para>Neue Gruppe: Öffnet den neue Gruppe Dialog wie oben beschrieben.</para>
</listitem>
<listitem>
<para>Gruppe entfernen: Entfernt die Gruppe aus dem LFV.</para>
</listitem>
<listitem>
<para>Eigenschaften: Öffnet die Eigenschaften der Gruppe. Dort können Sie den Dateifilter editieren, indem Sie eine, durch Kommata 
getrennte Liste von Wildcards eingeben.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="kdevelop-setup">
<title>KDevelop Setup</title>

<para><emphasis remap="bf">Make-Kommando:</emphasis></para>

<para>Der Allgemeine Optionen Dialog erlaubt es, die generellen Einstellungen für KDevelop vorzunehmen. Als erstes sollten Sie das auf 
Ihrem System installierte Make-Kommando angeben. Wenn das angegebene Programm nicht existiert, erhalten Sie eine Warnung von 
KDevelop, wenn Sie das nächste Mal Make ausführen wollen.</para>

<para><emphasis remap="bf">Automatisch speichern:</emphasis></para>

<para>Wenn Automatisch speichern angekreuzt ist, wird KDevelop in periodischen Zeitintervallen alle geänderten Dateien speichern. Das 
Intervall kann auf 3, 5, 15 oder 30 Minuten eingestellt werden.</para>

<para><emphasis remap="bf">Automatisch wechseln:</emphasis></para>

<para>Wenn eingeschaltet, werden sich die KDevelop Fenster entsprechend der momentane Nutzung ein- und ausschalten, wenn Sie z.B. zu 
einer Dokumentation im Hilfemenü wechseln, wird sich der Dokumentationsbrowser zusammen mit dem Dokumentationsbaum öffnen, 
während sich das Ausgabefenster schließt.</para>

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

<para>Sie können wählen, ob das Start-Logo von KDevelop während des Ladens angezeigt werden soll. Weiterhin können Sie das Öffnen 
des letzten Projektes unterdrücken, sowie einstellen, ob Sie den Tip des Tage angezeigt bekommen.</para>
</sect1>

<sect1 id="ndern-der-tastaturkrzel">
<title>Ändern der Tastaturkürzel</title>

<para>Der Dialog "Tasten" läßt Sie die Tastenzuordnung in KDevelop einstellen. Beachten Sie, daß globale Tastenkürzel wie Datei öffnen oder 
Drucken, im KDE Kontrollcenter eingestellt werden können. Eine Tastenfunktion kann eingestellt werden, indem Sie einen Menüeintrag 
auswählen und dann den zuzuordnenden Wert wie ALT/STRG u.s.w. eingeben.</para>
</sect1>

<sect1 id="dokumentation">
<title>Dokumentation</title>

<sect2 id="verzeichnisse">
<title>Verzeichnisse</title>

<para>Damit der Dokumentationsbrowser korrekt arbeiten kann, braucht KDevelop einige Informationen bezüglich des Pfades, in dem die 
HTML-Dokumentation auf Ihrem System installiert ist. Daher ist es notwendig sowohl den Pfad zu Ihre Qt Onlinedokumentation, als auch 
den zu Ihrer KDE Bibliothekendokumentation anzugeben.</para>

<para>Normalerweise wird die Qt-Dokumentation im gleichen Verzeichnis wie Qt selber abgelegt; wenn sich z.B. Qt in /usr/local/qt befindet, 
ist der einzugebende Pfad /usr/local/qt/html. Für die KDE-Dokumentation müssen Sie das Wurzelverzeichnis aller Dokumentationen 
angeben, wobei angenommen wird, daß sich die KDE-Bibliothekendokumentation im selben Verzeichnis befindet. Beide Pfade können 
durch Betätigen der entsprechenden Knöpfe selektiert werden, die eine Pfadauswahl anzeigen. Wenn sich keine Dokumentation der 
KDE Bibliotheken auf Ihrem System befindet, sollten Sie zuerst im nächsten Dialog "KDE Dokumentation aktualisieren" wählen. Dadurch 
wird die Dokumentation in einem Pfad Ihrer Wahl erzeugt und es wird automatisch der richtige Pfad in KDevelop gesetzt.</para>
</sect2>

<sect2 id="optionen">
<title>Optionen</title>

<sect3 id="kde-dokumentation-aktualisieren">
<title>KDE-Dokumentation aktualisieren</title>

<para>Für Benutzer die keine aktuelle Dokumentation der KDE Bibliotheken haben, insbesondere die Dokumentation der auf Ihrem System 
installierten Dateien, erzeugt dieser Dialog eine neue oder aktualisiert eine bestehende Dokumentation. Diese Funktion erfordert, daß 
kdoc und qt2kdoc auf Ihrem System instaliert sind, welche Teil des kdesdk Paketes sind. Zuerst müssen Sie den Pfad zu den aktuellen 
Quellen der KDE Bibliotheken setzen. Dies ist <emphasis>nicht</emphasis> der include Pfad von KDE ! Geben Sie nur den Pfad zu den Qelldateien ein, 
wie /home/rnolden/kdelibs-1.1/.</para>

<para>Sie können dann zwischen drei verschieden Installationsmodi wählen:</para>

<para><itemizedlist>
<listitem>
<para> Alte Dokumentation löschen und in aktuellem Doku-Verzeichnis installieren: Es wird davon ausgegangen, daß Sie bereits eine 
Dokumentation installiert haben. Wenn Sie dies ankreuzen, wird die aktuelle Dokumentation gelöscht und mit der neu erzeugten 
überschrieben.</para>
</listitem>
<listitem>
<para> Alte Dokumentation löschen und in neues Doku-Verzeichnis installieren:  Wenn Sie dies ankreuzen, wird die aktuelle 
Dokumentation wie oben gelöscht. Sie können jedoch im Eingabefeld einen Pfad wählen, in dem die neu erzeugte Dokumentation 
installiert wird.</para>
</listitem>
<listitem>
<para> Alte Dokumentation nicht ändern und in neues Doku-Verzeichnis installieren:  Hiermit wird Ihre aktuelle Dokumentation nicht 
gelöscht und Sie können einen neuen Pfad für die Kdelibs-Dokumentation eingeben. Achtung: Bitte geben Sie nicht den Pfad an, wo 
Ihre jetzige Dokumentation installiert ist - dadurch könnten alte und neue Dateien vermischt werden!</para>
</listitem>
</itemizedlist>
</para>

<para>Der "neue" Pfad zu den KDE Bibliotheksdokumentationen muß für die Optionen 2 und 3 angegeben werden. Es ist außerdem empfohlen 
für Benutzer, die eine komplett neue Dokumentation generieren wollen.</para>

<para>Nachdem Sie OK gedrückt haben, wird KDevelop ein Unterverzeichnis "kdoc-reference" im Dokumentationspfad erzeugen, das die 
kdoc Referenzdateien enthält. Als erstes wird die Qt Klassendokumentation indiziert, so daß eine Verbindung zur Dokumentation der 
KDE Bibliotheken erstellt werden kann. Daher ist es wichtig, das Sie vorher den Pfad zur Qt Dokumentation eingegeben haben, damit 
qt2kdoc die Dateien finden kann. Schließlich werden die KDE Bibliotheken indiziert und die Dokumentation wird mit den Querverweisen 
erstellt, um so ein Höchstmaß an Funktionalität beim Browsen zur Verfügung zu stellen.</para>

<para><emphasis remap="bf">BEACHTE:</emphasis> Wenn Sie KDoc 2 verwenden, können Sie einen Dokumentationssatz für die Bibliotheken des KDE Basispakets
und für KOffice hinzufügen. Um dies zu tun, erstellen Sie die KDE Bibliotheksdokumentation wie oben beschrieben. Dann öffnen Sie
den Dialog erneut und wählen im Stammverzeichnis der Quelldateien den Pfad zur <literal remap="tt">kdoc.rules</literal> Datei des KDEbase- bzw.
KOfficepakets (für KDEBase ist dies das Verzeichnis der Quellen, für KOffice ist es koffice/lib). Wählen Sie die Option 3 (Alte
Dokumentation unverändert lassen) und lassen Sie den Ausgabepfad so wie er ist. Dadurch bleibt die KDE Bibliotheksdokumentation
erhalten und die neue Dokumentation der KDE Bibliotheken (bzw. der KOffice Bibliotheken) wird in diesem Pfad hinzugefügt. Nach der
Erstellung, stehen die Dokumentationen automatisch im DOC Baum zur Verfügung. Für weitere KDE Pakete, die mit weiteren
Bibliotheken ausgeliefert werden, sollten Sie nach der <literal remap="tt">kdoc.rules</literal> suchen und die Dokumentation ebenso erzeugen.</para>
</sect3>

<sect3 id="suchdatenbank-erstellen">
<title>Suchdatenbank erstellen</title>

<para>Der Dialog "Suchdatenbank erstellen", der über den "Erzeugen" Knopf erreicht werden kann, erlaubt es dem Programmierer eine 
Suchdatenbank zu erstellen, in der interaktiv nach Schlüsselworten gesucht werden kann. Zum Erzeugen der Datenbank und zur 
Benutzung der Suchfunktionalität muß entweder glimpse oder ht://Dig installiert sein. Voreingestellt ist sowohl die Indizierung der KDE 
Bibliotheksdokumentation, als auch die der Qt Dokumentation, wobei davon ausgegangen wird, daß die Pfade korrekt eingestellt 
wurden. Es können auch noch zusätzlich zu indizierende Verzeichnisse angegeben werden. Nach Eingabe eines zusätzlichen Pfades 
muß die Hinzufügen Taste betätigt werden. Ein so gesetzter Pfad kann durch Auswählen des Eintrages und Betätigen der Entfernen 
Taste wieder aus der Liste entfernt werden. Außerdem werden dem Benutzer drei verschiedene Indexgrößen zur Auswahl angeboten: 
winzig, klein und mittel. Je höher die Indexgröße gewählt wird, um so größer werden auch die Indexdateien. Auf der anderen Seite wird 
die Suche in einer größeren Suchdatenbank beschleunigt und die Trefferquote ist höher, so daß wir eine mittlere Größe empfehlen. Zur 
Verwendung der Suchfunktion, sehen Sie unter 
<link linkend="Benutzung-des-Dokumentationsbrowsers">Benutzung des Dokumentationsbrowsers</link> nach.</para>
</sect3>

<sect3 id="auch-kdoc-referenz-ihres-projektes-erstellen">
<title>Auch KDOC-Referenz Ihres Projektes erstellen</title>

<para>Diese Option ermöglicht es, eine Crossreferenz für Ihr Projekt zu erstellen, wenn Sie die API Dokumentation mit KDoc erzeugen.
Diese Datei wird im Referenzverzeichnis erstellt und stellt Ihr Projekt im Dokumentationsbaum zur Verfügung. Wenn Sie im
Referenzverzeichnis kein Schreibrecht haben, müssen Sie diese Option ausschalten, damit Sie Ihre API Dokumentation fehlerfrei
generieren können.</para>
</sect3>
</sect2>
</sect1>

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

<para>Standardmäßig verwendet KDevelop den <link linkend="Der-interne-Debugger">internen Debugger</link>. Aktivieren Sie das Kontrollkästchen
"Verwende externen Debugger", wenn Sie einen anderen Debugger verwenden wollen und geben Sie den Namen des externen Debuggers ein.
Zur Bedienung Ihres Debuggers konsultieren Sie bitte die entsprechende Dokumentation.
Bei Auswahl des internen Debuggers erhalten Sie eine Anzahl zusätzlicher Optionen aus denen Sie auswählen können:</para>

<para><itemizedlist>
<listitem>
<para>Zeige static members: Die Anzeige von statischen Elementen verlangsamt gdb bei der Datenenerzeugung in kde und qt. Die 
"Signatur" der Daten auf die sich QString und friend-Funktionen verlassen, könnte verändert werden. Wenn Sie jedoch diese Werte 
debuggen müssen, markieren Sie die Option</para>
</listitem>
<listitem>
<para>Zeige Teil-Namen an: Bei der Anzeige von disassembliertem Code können Sie sich Teil-Namen der Methoden anzeigen lassen. 
Vollständige Namen sind jedoch einfacher zu lesen.</para>
</listitem>
<listitem>
<para>BPs beim Laden von Bibliotheken setzen: Hiermit wird versucht "schwebende" Breakpoints beim Laden von Bibliotheken zu
setzen. Wenn GDB eine Bibliothek die mittels "dlopen" geladen werden soll noch nicht kennt, weigert er sich Unterbrechungen in 
diesem Code anzunehmen. Es ist jedoch möglich beim Laden der Bibliothek anzuhalten und dann zu versuchen die "schwebenden" 
Breakpunkte zu setzen. Im Kapitel <link linkend="Dynamische-Bibliotheken-und-Unterbrechungen">Dynamische Bibliotheken und Unterbrechungen</link>
finden Sie Details und Probleme dieser Vorgehensweise. Wenn Sie keine Bibliotheken mit "dlopen" öffnen, lassen Sie diese Option 
ausgeschaltet.</para>
</listitem>
<listitem>
<para>Schwebende Werkzeugleiste: Dies erlaubt Ihnen zusätzlich die Steuerung des Debuggers mit Hilfe der schwebenden 
Werkzeugleiste. Die Werkzeugleiste ist bestens zum Debuggen von GUI Anwendungen geeignet. Details finden Sie unter 
<link linkend="Die-schwebende-Werkzeugleiste">Die schwebende Werkzeugleiste</link>.</para>
</listitem>
<listitem>
<para>Separates Terminal für Anwendungs I/O einschalten: Dies ermöglicht Ihnen, Terminaleingaben zu machen, wenn Ihre Anwendung
Terminaleingabecode enthält (z.B. cin, fgets etc.). Wenn Ihre Anwendung solchen Code enthält, wählen Sie diese Option, sonst
lassen Sie sie ausgeschaltet.</para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="setzen-der-pfade">
<title>Setzen der Pfade</title>

<para>Auf dem Tabulator "Pfad" können Sie die Pfade zu Ihren Qt 2.x und KDE 2 Installationen eingeben, sowie das Verzeichnis, in dem 
neue Projekte erstellt werden sollen. Um mehr über die Installation von Qt 2.x / KDE 2 und die Konfiguration von KDevelop für Qt 
2.x / KDE 2 zu erfahren, lesen Sie bitte das <ulink url="tutorial/index.html">KDE Anwendungs Tutorial</ulink>. </para>

<para>Standardmäßig erstellt KDevelop neue Projekte im Homeverzeichnis des Benutzers. Wenn Sie dieses Verhalten ändern möchten, können 
Sie das gewünschte Verzeichnis unter Standard Projektpfad eintragen.</para>
</sect1>
</chapter>

<chapter id="fragen-und-antworten">
<title>Fragen und Antworten</title>

<para>Dieses Kapitel behandelt sowohl Fragen von Benutzern die aktuelle KDevelop Version betreffend,die vom KDevelop Team oder seinen Helfern 
in der KDevelop Mailingliste beantwortet wurden, als auch das Melden von Fehlern generell.</para>

<sect1 id="melden-von-fehlern">
<title>Melden von Fehlern </title>

<para>Eine weitere Verbesserung in KDevelop ist das integrierte Fehlermeldesystem via EMail. Wenn Sie einen Fehler finden, können Sie dem 
KDevelop Team den Fehlerreport entweder über Ihren EMail Client oder mit Hilfe des Fehler Report Dialoges senden. Alle 
Fehlermeldungen werden auf der KDevelop Website gesammelt und können unter 
<ulink url="http://bugs.kde.org//db/pa/lkdevelop.html">http://bugs.kde.org//db/pa/lkdevelop.html</ulink> eingesehen werden.</para>

<para>Wenn Sie einen Fehlerbericht senden wollen benutzen Sie bitte die EMail Adresse 
<ulink url="mailto:submit@bugs.kde.org">submit@bugs.kde.org</ulink>. Wenn Sie KDevelop zum Berichten von Fehlern benutzen 
wollen, wählen Sie "Bugreport" aus dem Hilfe Menü. Ihnen wird dann der Reportdialog angezeigt, in dem Sie alle notwendigen 
Informationen zum gefundenen Fehler eingeben können. Nachdem Sie mit OK bestätigt haben, wird automatisch eine EMail gesendet.</para>
</sect1>

<sect1 id="wo-sie-informationen-bekommen">
<title>Wo Sie Informationen bekommen</title>

<para><emphasis remap="bf">F:</emphasis> Ich habe eine Frage, die weder in der FAQ Datei, noch in den KDevelop Handbüchern behandelt wird. Wohin kann ich 
mich wenden?</para>

<para><emphasis remap="bf">A:</emphasis>  Senden Sie alle Anfragen die KDevelop betreffen an die KDevelop Mailingliste. Sie können sich 
unter <ulink url="mailto:kdevelop@barney.cs.uni-potsdam.de">kdevelop@barney.cs.uni-potsdam.de</ulink> 
einschreiben, indem Sie eine Mail mit leerem Header und mit "subscribe" als Inhalt, senden. Damit können Sie 
auch an den Diskusionen teilnehmen. Alle Fragen sollten dorthin gehen und werden auch von dort aus 
beantwortet. Wenn Sie sich daran halten, werden Sie die gößtmögliche Hilfe von den Entwicklern und den anderen 
Benutzern erhalten, gleichzeitig helfen Sie die FAQs aktuell zu halten. 
Die KDevelop Homepage unter <ulink url="http://www.kdevelop.org">http://www.kdevelop.org</ulink> enthält ebenfalls ein Mailinglist 
Archiv in dem Sie in den bereits eingegangenen Mails stöbern können. Sie sollten also zuerst dort nachsehen, da die meisten Fragen bereits 
von den Entwicklern oder anderen Benutzern beantwortet wurden.</para>
</sect1>

<sect1 id="bibliotheken-und-system-probleme">
<title>Bibliotheken und System Probleme</title>

<para><emphasis remap="bf">F:</emphasis> Falsche JPEG Bibliotheksversion: Bibliothek ist 61, erwartet wird 62</para>

<para><emphasis remap="bf">A:</emphasis>  Es gibt zwei Möglichkeiten
<orderedlist><listitem>
<para> Wenn die kdelibs installiert werden, werden auch die Headerdateien für die jpeg Bibliotheken installiert, und zwar Version 61. 
Die meisten Distributionen (RedHat) verwenden jedoch 62er Bibliotheken. Um den Fehler zu beheben entfernen Sie jpeglib.h aus 
$KDEDIR/include. Die Headerdatei für Version 62 sollte jetzt gefunden werden. Wenn man sich jedoch obige Fehlermeldung betrachtet, 
könnte es auch umgekehrt sein, stellen Sie also in jedem Fall sicher, daß Sie nur eine Version der Headerdatei und der Bibliothek haben 
und daß diese konsistent sind. Es ist nützlich das locate Kommando zu verwenden, um dies herauszufinden, z.B. updatedb, locate libjpeg, 
locate jpeglib.
</para>
</listitem>
<listitem>
<para> Sie müssen kdesupport ohne die jpeg Bibliothek rekompilieren (./configure --with-libjpeg --with-libgif).</para>
</listitem>
</orderedlist>
</para>

<para><emphasis remap="bf">F:</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 für automake-1.4/automake-2.13 Benutzer: Führen Sie "aclocal" von Hand aus, dann wird es sich 
kompilieren lassen.</para>

<para><emphasis remap="bf">F:</emphasis>  Was muß ich tun, wenn configure sagt, ich bräuchte giflib23.</para>

<para><emphasis remap="bf">A:</emphasis>  Versuchen Sie einen neueren Snapshot von kdesupport, oder Sie haben vielleicht eine andere giflib installiert?</para>

<para><emphasis remap="bf">F:</emphasis> Wie kann ich ein KDevelop 0.2 Projekt in ein 0.3er konvertieren?</para>

<para><emphasis remap="bf">A:</emphasis> Ändern Sie AC&&lowbar;;OUTPUT in configure.in in eine einzeilige Version ab</para>

<para>zum Beispiel:</para>

<para>alte Version:
<screen>AC_OUTPUT(Makefile \
kdevelop/kwrite/Makefile \
kdevelop/templates/Makefile
)
</screen>

neue Version:
<screen>AC_OUTPUT(Makefile kdevelop/kwrite/Makefile kdevelop/templates/Makefile)
</screen>
</para>

<para><emphasis remap="bf">F:</emphasis>  Ich bekomme folgende Linker Fehler, wenn ich SuSE Linux mit KDE 1.1 verwende, was muß ich tun um KDevelop gelinked 
zu bekommen?
<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> Wenn Sie die SuSE rpm´s von KDE-1.1 haben, müssen Sie die kdelibs ohne den Patch von SuSE rekompilieren und sie 
erneut installieren oder Sie besorgen sich ein aktuelleres rpm der kdelibs von <ulink url="ftp://ftp.suse.com">ftp://ftp.suse.com</ulink></para>
</sect1>

<sect1 id="fragen-zur-verwendung">
<title>Fragen zur Verwendung</title>

<para><emphasis remap="bf">F:</emphasis> KDevelop erlaubt mir nicht die Verwendung  der Entfernen Taste (oder das Löschen von markiertem Text mit Rückschritt).</para>

<para><emphasis remap="bf">A:</emphasis>  Verwenden Sie "Einstellungen"-&gt;"Editor" und schalten Sie "Beim Eingeben löschen" ein, dann funktionieren Backspace 
und Entfernen.</para>

<para><emphasis remap="bf">F:</emphasis> Werden Dateien automatisch hinzugefügt und kompiliert, wenn ich sie einem Projekt hinzufüge?</para>

<para><emphasis remap="bf">A:</emphasis> Ja, sie werden in Makefile.am eingetragen und wenn Sie "Alles neu erstellen" wählen dem Projekt hinzugefügt (./configure 
aktualisiert die Makedateien).</para>

<para><emphasis remap="bf">F:</emphasis> Nachdem ich eine Datei entfernt habe, bekomme ich seltsame Linker Meldungen. Was ist falsch an meinem Projekt?</para>

<para><emphasis remap="bf">A:</emphasis> Wenn es sich dbei der entfernten Datei um eine Headerdatei handelt, die automatisch von automoc bearbeitet wird (der 
automatisch den Qt-Meta-Object-Compiler über alle Header laufen läßt), ist die entfernte Datei immer noch als von moc erzeugte 
*.moc.cpp Datei vorhanden und kompiliert. Entfernen Sie die entsprechende *.moc.cpp Datei und erstellen Sie Ihr Projekt neu.</para>

<para><emphasis remap="bf">F:</emphasis> Configure beschwert sich darüber, daß es eine kleine KDE Anwendung nicht ausführen kann. Eine Untersuchung der
config.log zeigt, daß die Bibliothek libXext nicht gefunden wird.
<emphasis remap="bf">A:</emphasis> Installieren Sie das Paket xdevel.</para>

<para><emphasis remap="bf">F:</emphasis> Ich entwickle eine Anwendung, für die ich die -D Option des Präprozessors einschalten muß. Wenn ich dies in KDevelop
in den Projektoptionen einstelle, ist alles in Ordnung. Wenn ich aber eine Distribution meines Projektes erstelle, wird die -D
Option nicht verwendet. Was muß ich machen, damit es funktioniert?
<emphasis remap="bf">A:</emphasis> Editieren Sie die Datei configure.in in Ihrem Projekthauptverzeichnis. Sie müssen hier am Anfang der Datei
eingeben:</para>

<para>CXXFLAGS=$(CXXFLAGS) " -DYOURDEFINE"
AC&&lowbar;;SUBST(CXXFLAGS)</para>

<para><emphasis remap="bf">F:</emphasis> Bei mir läuft ein KDE 2 Schnappschuß und ich möchte KDevelop unter KDE 2 verwenden. Wie kann ich am besten vorgehen?
<emphasis remap="bf">A:</emphasis> Da KDevelop für KDE 2 sich zur Zeit noch in der Entwicklung befindet, sollten Sie in Betracht ziehen, die stabile 1.x
Version von KDevelop zu verwenden. Sie können dies mit Hilfe eines Shellskripts machen:</para>

<para>&&num;;/bin/bash
QTDIR=/usr/lib/qt-1.44 export QTDIR
KDEDIR=/opt/kde export KDEDIR
exec /opt/kde/bin/kdevelop</para>

<para>Speichern Sie diese Datei zum Beispiel als kdevelop1 und machen Sie sie ausführbar, indem Sie eingeben:</para>

<para>chmod 755 kdevelop1</para>

<para>Sie können nun KDevelop 1.x unter KDE 2 ausführen, indem Sie kdevelop1 aufrufen. Zum Erstellen von KDE 2 Anwendungen mit KDevelop
1.x, müssen Sie den korrekten Pfad im KDevelop-Setup eingeben, auch wenn Sie KDevelop unter KDE 2 ausführen !</para>
</sect1>
</chapter>

<chapter id="autoren">
<title>Autoren</title>

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

<para>Sandy Meier 			<ulink url="mailto:smeier@kdevelop.de">&lt;smeier@kdevelop.de&gt;</ulink>
(Projektleiter, Entwicklungskoordinator und Homepage Provider)
<quote>Hauptentwicklung von: Rahmenstruktur, Gestaltung, Projektmanagement.</quote></para>

<para>Stefan Heidrich			<ulink url="mailto:sheidric@rz.uni-potsdam.de">&lt;sheidric@rz.uni-potsdam.de&gt;</ulink>
<quote>Hauptentwicklung von: KAppWizard, Druckfunktionen</quote></para>

<para>Ralf Nolden			<ulink url="mailto:rnolden@kdevelop.de">&lt;rnolden@kdevelop.de&gt;</ulink>
<quote>Hauptentwicklung von: KDevelop&lt;-&gt;Dialogeditor Schnittstelle, Konfigurationsfunktionen, Online-Hilfe und Handbücher</quote></para>

<para>Jonas Nordin			<ulink url="mailto:jonas.nordin@cenacle.se">&lt;jonas.nordin@cenacle.se&gt;</ulink>
<quote>Hauptentwicklung von: Klassenbrowser und -analysator</quote></para>

<para>Pascal Krahmer 			<ulink url="mailto:pascal@beast.de">&lt;pascal@beast.de&gt;</ulink>
<quote>Hauptentwicklung von: Dialogeditor</quote></para>

<para>Bernd Gehrmann 			<ulink url="mailto:bernd@physik.hu-berlin.de">&lt;bernd@physik.hu-berlin.de&gt;</ulink>
<quote>Hauptentwicklung von: Grep Dialog, CVS Integration</quote></para>

<para>Jörgen Olsson       <ulink url="mailto:jorgen@cenacle.net">&lt;jorgen@cenacle.net&gt;</ulink>
<quote>Hauptentwicklung von: Graphische Klassenansicht</quote></para>

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

<para>Walter Tasin        <ulink url="mailto:tasin@kdevelop.de">&lt;tasin@kdevelop.de&gt;</ulink>
<quote>Hauptentwicklung von: Verbesserungen und Bugfixing</quote></para>

<para>John Birch          <ulink url="mailto:jbb@ihug.co.nz">&lt;jbb@ihug.co.nz&gt;</ulink>
<quote>Hauptentwicklung von: Integrierter Debugger</quote></para>

<para><emphasis remap="bf">Übersetzungskoordination:</emphasis></para>

<para>Martin Piskernig		<ulink url="mailto:mpiskernig@kdevelop.de">&lt;mpiskernig@kdevelop.de&gt;</ulink></para>

<para><emphasis remap="bf">Programm- und Dokumentations-Übersetzungen:</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:mpiskernig@kdevelop.de">&lt;mpiskernig@kdevelop.de&gt;</ulink>	-German</para>
</listitem>
<listitem>
<para>Ralf Funken         <ulink url="mailto:rfunken@kdevelop.de">&lt;rfunken@kdevelop.de&gt;</ulink>	-German</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, 1.2: Ralph Kocher      <ulink url="mailto:RKocher@t-online.de">&lt;RKocher@t-online.de&gt;</ulink></para>
</listitem>
</itemizedlist>
</para>

<para><emphasis remap="bf">Zusätzliche Beiträge, Patches und 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>
<listitem>
<para>Ralf Funken             <ulink url="mailto:rfunken@kdevelop.de">&lt;rfunken@kdevelop.de&gt;</ulink>
</para>
</listitem>
</itemizedlist>
</para>

<para><emphasis remap="bf">KDevelop enthält Quellcode aus den folgenden Applikationen:</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">GrapeFruit</emphasis>	&&copy;; 1999 	by Bernd Gehrmann <ulink url="mailto:bernd@physik.hu-berlin.de">&lt;bernd@physik.hu-berlin.de&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="dank">
<title>Dank</title>

<para>Wir möchten an dieser Stelle unseren Familienmitgliedern und Freunden unseren besonderen Dank ausdrücken, die uns in vielerlei Art und
Weise unterstützten, KDevelop zu programmieren und zu verbessern.</para>

<para>Weiterhin danken wir Jochen Wilhelmy für das Angebot seines Programms kwrite und seiner Hilfe bei der Integration in KDevelop.</para>

<para>Dank sei auch dem KDE Team und Stephan Kulow gesagt, die uns die Möglichkeit gaben, KDevelop über das CVS System zu bearbeiten.</para>

<para>Wir hoffen, daß unsere freie Arbeit an diesem Produkt zu einer besseren Akzeptanz freier Software und ihrer Entwicklung
führt. Ohne die Hilfe und den Idealismus vieler wäre die KDevelop Entwicklungsumgebung nicht in solch einer kurzen Zeit realisiert worden und wir sind
Stolz daüber, daß uns schon so viele Benutzer über ihre guten Erfahrungen mit KDevelop berichteten und KDevelop zu seiner Bestimmung
brachten: Freien Software-Programmierern zu helfen, eine bessere Welt zu gestalten, in der die Benutzer die Freiheit haben,
auszuwählen.</para>
</chapter>

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

<para><screen>
KDevelop Copyright 1998,1999,2000 The KDevelop Team.

Dieses Programm ist Freie Software; Sie können Sie  weitergeben und/oder verändern
entsprechend den Bestimmungen der GNU General Public License, wie von der Free Software
Foundation veröffentlicht, entweder entsprechend Version 2 der Bestimmungen oder
(nach ihrer Wahl) jeder späteren Version.

Dieses Programm wird in der Hoffnung, da&&szlig;; es nützlich ist, aber OHNE EINE GARANTIE verbreitet;
sogar ohne die implizite Garantie der MARKTGÄNGIGKEIT oder EIGNUNG FüR EINEN BESTIMMTEN ZWECK.
Lesen Sie die GNU General Public License, um weitere Details zu erfahren.

Sie sollten eine Kopie der GNU General Public License zusammen mit diesem Programm erhalten haben;
wenn nicht, so schreiben Sie an die
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:
-->
