]>

# Benutzerhandbuch zu KDevelop

Der Referenzführer zur KDevelop Integrierten Entwicklungsumgebung für Unix Systeme, Version 1.2
Ralf Nolden
The KDevelop Team

    <Ralf.Nolden@post.rwth-aachen.de>

Ralf
Funken

    <rfunken@kdevelop.de>

Version 3.0 , Mär 21,2000

Dieses Handbuch ist Teil der KDevelop Integrierten Entwicklungsumgebung und ist daher ebenso unter der GNU General Public License lizensiert; siehe Copyright.

KDE

## Einführung

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.

Das KDE
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.

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 `make` und dem GNU C++ compiler verpackt und sie zu einem unsichtbaren, integrierten Teil des Entwicklungsprozesses macht. KDevelop beherrscht:

- Alle Entwicklungswerkzeuge, die für C++ Programmierung benötigt werden, wie den Compiler, Linker, automake und autoconf,

- KAppWizard, welcher vollständige, sofort ausführbare Rahmenapplikationen erstellt,

- den Klassengenerator, um neue Klassen zu erzeugen und sie in das aktuelle Projekt zu integrieren,

- Dateimanagement von Quellcode, Headerdateien, Dokumentation etc, die im Projekt eingebunden sind,

- Die Erzeugung von Benutzerhandbüchern in SGML und die automatische Generierung in HTML-Ausgabe mit dem KDE look and feel,

- Automatische HTML-basierte API-Dokumentation für die Klassen ihres Projekts mit Querreferenzierung zu den benutzten Bibliotheken,

- Unterstützung von Internationalisierung Ihrer Applikation, die es Übersetzern erlaubt, ihre Zielsprache zu einem Projekt hinzuzufügen,

- WYSIWYG (What you see is what you get, Was Sie sehen, ist was Sie bekommen)- Erzeugung von Benutzeroberflächen mit dem integrierten Dialogeditor,

- Debuggen ihrer Applikation durch Integrieren von KDbg,

- Bearbeiten von Projekt-spezifischen Pixmaps mit KIconEdit,

- Die Einbeziehung jedes anderen Programms, das Sie zur Entwicklung benötigen durch Hinzufügen zum "Werkzeuge"-Menü nach ihren individuellen Bedürfnissen.

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.

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.

### Neuerungen

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.

Verbesserungen wurden in den folgenden Bereichen durchgeführt:

- schneller Klassenparser und -browser mit graphischer Klassenansicht und Dialog-basierter Bearbeitung von Membern und Klassen,

- CVS-Unterstützung für die meist benötigten Funktionen wie hinzufügen, entfernen, aktualisieren und übertragen von Dateien und Verzeichnissen,

- Aktualisierte und erweiterte Dokumentation, die nun fünf Handbücher umfaßt und mit KDevelop geliefert wird,

- fehlerbereinigter Klassenparser, Dialogeditor und Fehlerfinder,

- Verbesserte Dokumentationsansicht, der Ihnen sofort den Zugang zur Klassendokumentation bis zu jeder Methode von Klassen bietet.

Kommentare und Verbesserungsvorschläge zur IDE und ihrer Dokumentation sind willkommen.

### Über dieses Handbuch

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 KDevelop Programmierer Handbuch zu lesen, das mit KDevelop geliefert wird; dieses deckt Themen ab wie die Funktion der generierten Rahemenapplikationen oder wie vollständige KDE
Applikationen erstellt werden.

Dieses Handbuch ist daher unterteilt in folgende Abschnitte:

- Kapitel Installation, behandelt Systemanforderungen, Installation und Einrichtung der KDevelop Entwicklungsumgebung.

- Kapitel Programme, beschreibt Ihnen, wie Programme mit den Standard-GNU Entwickungswerkzeugen erzeugt und erstellt werden.

- Kapitel Entwicklung mit KDevelop, nimmt Sie mit auf eine kurze Reise, die Ihnen die Funktionalität der Entwicklungsumgebung beschreibt.

- Kapitel Übersicht, erklärt sowohl die Menüs und Dialoge als auch Schnelltasten.

- Kapitel Das Hilfe-System, zeigt die Benuztung des integrierten Dokumentationsbrowsers und zusätzliche Hilfe-funktionen.

- Kapitel Arbeiten mit dem Editor, erklärt die Features des Dateimanagements und -bearbeitung.

- Kapitel Projekte, beschreibt die Erzeugung und Überwachung von Software Projekten.

- Kapitel Erstellungsoptionen, enthält eine Referenz über die Einstellung von Compiler und Linker Flags und der Projekteinstellungen.

- Kapitel Der Klassenbrowser, beschreibt Ihnen ausführlich, wie Sie den KDevelop Klassenbrowser benutzen.

- Kapitel Der Dialogeditor, betrachtet den Integrierten visuellen Dialogeditor und wie er Ihnen C++ Code erzeugt.

- Kapitel Der interne Debugger, gibt eine Übersicht über die Einstellungen zum Debuggen und die Verwendung des internen Debugggers.

- Kapitel CVS Integration, erkärt, wie die Revisions-Kontrollsysteme CVS und RCS mit Ihrem KDevelop Projekt verwendet werden.

- Kapitel Grundsätzliche Konfiguration zeigt Ihnen, wie Sie generelle Einstellungen zur Benutzung von KDevelop vornehmen.

- Kapitel Fragen und Antworten, behandelt Fragen, die bei der Benutzung von KDevelop unter verschiedenen Unix-Systemen vorkommen und generelle Problemlösungen.

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.

### Über das KDevelop Projekt

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.

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.

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.

### Gedruckte Versionen

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

Ebenfalls auf http://www.kdevelop.org erhältlich, sind druckbare Versionen in DVI, PostScript und PDF Format, sowohl in A4 als auch in Letter-Größe.

## Installation

### Verfügbarkeit von KDevelop

KDevelop kann entweder auf der KDE
Applikations-Seite (http://www.kde.org/current.html) oder auf der KDevelop Homepage (http://www.kdevelop.org) bezogen werden. Ebenso ist KDevelop auf Linux-Distributionen vorhanden, wie z.B. SuSE Linux 6.1.

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.

Wenn Sie Probleme mit der Compilierung oder Benutzung von KDevelop haben, lesen Sie bitte das Kapitel Fragen und Antworten 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 kdevelop-request@barney.cs.uni-potsdam.de 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.

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.

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.

### Anforderungen

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.

Benötigt:

- g++ 2.7.2/g++ 2.8.1/egcs 1.1 (oder kompatibler Compiler), erhältlich auf http://www.gnu.org

- GNU make (or compatible), erhältlich auf http://www.gnu.org

- perl 5.004, erhältlich auf http://www.perl.com

- autoconf 2.12, erhältlich auf http://www.gnu.org

- automake 1.2, erhältlich auf http://www.gnu.org

- flex 2.5.4,

- GNU gettext, erhältlich auf http://www.gnu.org

- Qt 1.42, erhältlich auf http://www.troll.no

- KDE
  1.1.x, erhältlich auf http://www.kde.org

Optional:

- enscript zur Nutzung der Druckfunktionen

- ghostview oder kghostview zur Druckvorschau

- glimpse 4.0 für die Nutzung des Suchindexes, erhältlich auf http://glimpse.cs.arizona.edu

- sgmltools 1.0, erhältlich auf http://www.sgmltools.org

- KDE-SDK
  (KDE Software Development Kit)with KDoc, KSgml2Html, KTranslator (erhältlich auf http://developer.kde.org)

- KDbg, erhältlich auf http://members.telecom.at/~johsixt/kdbg.html

- KIconEdit (erhältlich auf http://www.kde.org)

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.

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.

Dokumentation:

Um die KDE
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 KDoc (enthalten im KDE-SDK
).

Zusätzlich bieten wir eine C/C++ Referenz auf unserer Homepage auf http://www.kdevelop.org an, die nach ihrer Installation im Dokumentationsbrowser verfügbar ist. Laden Sie das Paket herunter und kopieren Sie es als `root` in Ihr KDE
Verzeichnis und entpacken Sie es mit `tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz`. 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.

### Compilierung und Installation

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

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

    	(als root)

    	&&percnt;; make install

Da KDevelop `autoconf` benutzt, sollten Sie keine Probleme haben, es zu übersetzen.

Um KDevelop CVS Snapshots zu compilieren, geben Sie folgendes ein:

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

    	Wechseln Sie auf <tt/root/ und geben Sie ein:

    	&&percnt;; make install

Wenn das make-Kommando Ihres Systems `gmake` lautet, geben Sie `gmake` anstatt `make` ein.

### Starten von KDevelop

Wenn Sie KDE
als Window-Manager benutzen, können Sie KDevelop starten, indem Sie "K"&->;"Applications"&->;"KDevelop"&->;"KDevelop 0.4" auswählen. Da KDevelop die KDE
-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
Dateimanager (kfm) auswählen.

Unter anderen Winow-Managern öffnen Sie eine Konsole und geben ein:

    &&percnt;; kdevelop

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

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

Unter jedem Benutzerzugang wird KDevelop einen automatischen Installationsvorgang 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

    &&percnt;; kdevelop  --setup

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

### Das Installationsprogramm

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.

Die Tasten des Installationsdialoges führen folgende Aktionen aus:

Hilfe: Öffnet KDEHelp.

Weiter: Dies started den Installationsprozess und führt folgendes aus:

1. 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 Programme.

2. Prüfen nach KDoc und Glimpse. Diese werden das Erzeugen einer neuen KDE-Bibliothek
   s Dokumentation und eines Suchindexes in einem späteren Einstellungsschritt ermöglichen, wenn sie gefunden werden.

3. 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.

4. 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
   -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.

5. 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.

6. 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.

7. Wenn KDoc gefunden wurde, werden Sie zur Erzeugung/Update Ihrer KDE
   -Bibilotheks-Dokumentation aufgefordert. Dazu benötigen Sie die KDE-Bibliotheken als Quellpaket. Linux-Benutzer, die KDE
   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 http://www.kde.org beziehen und auf Ihrem System entpacken. Wenn Sie das Dokumentations-Paket, das auf http://developer.kde.org 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 http://www.kde.org 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.

   Anmerkung: 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
   -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.

8. 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.

9. 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.

10. 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 KDevelop Setup Dialog, der über das "Einstellungen" Menü aufgerufen wird, einstellen können.

Abbrechen: 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.

## Programme

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.

### Der Compiler

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.

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:

    #include <iostream.h>

    int main(){

    cout << "Hello World" << endl;

    }

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):

    g++ -o myprogram myprogram.cpp

Danach können wir unser Programm starten- geben Sie einfach `myprogram` auf der Konsole ein, und das Programm gibt den String aus und beendet sich.

### Make und Makefiles

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 `make` oder `gmake` 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 `make` oder `gmake` 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:

`man make`

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

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 KDevelop Setup 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ü.

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

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

- Erstellen: ruft make auf und erzeugt das Zielobjekt (die Applikation)

- Alles neu erstellen: löscht alle schon übersetzten Dateien und erstellt das Projekt neu

- Säubern/alles neu erstellen: löscht alle übersetzten Dateien inklusive der Konfigurationsdateien des Projekts und erstellt alles neu

- Stoppen: beendet den aktuellen Prozeß

- Ausführen: erstellt die Zieldatei und führt das Programm aus

- Mit Argumenten ausführen: erstellt die Zieldatei und gibt Ihnen die Möglichkeit, dem Programm vor seiner Ausführung Kommandozeilenoptionen zu übergeben.

- Debuggen: erstellt die Zieldatei und startet KDbg mit dem Programm, um es zu debuggen

Aber dies ist nicht das einzige, wo KDevelop mit make zusammenarbeitet- bei KDE
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.

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 `configure`-Scripts auf den meisten Unix-Plattformen übersetzt werden können.

### Configure

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

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 `make` 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
auf einer Maschine unter ``opt/kde/ installiert sein, auf einer anderen aber unter `usr`local/kde/. In diesem Fall müßten Sie das Makefile immer bearbeiten, um eine korrekte Übersetzung und Installation Ihres Produkts sicherzustellen.

Glücklicherweise haben die GNU-Werkzeuge noch mehr zu bieten als das mächtige `make`- 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.

Der Zweck von `automake` ist generell, die sogenannten `Makefile.in`'s aus der Datei `Makefile.am` 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.

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 `configure.in`, 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. `configure.in` 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.

Wenn Sie z.B. eine KDE
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 `configure.in` 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.

Zusammenfassung: 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:

1. die Quellen Ihres Projekts schreiben

2. eine Makefile.am für jedes Unterverzeichnis erstellen, inklusive dem Hauptverzeichnis Ihres Projekts

3. eine configure.in Datei im Hauptverzeichnis erstellen, das die Makros für die Systemanforderungen enthält

4. automake aufrufen

5. autoconf aufrufen

Dann ist die Hauptarbeit getan. Automake erzeugt die Makefile.in's, autoconf läuft über die `configure.in` und erzeugt das ausführbare Shellscript `configure`. Alles, was Sie dann zu tun haben, ist die Ausführung mit `./configure`, 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.

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.

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:

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
oder die Qt/KDE
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.

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.

### Debuggen

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, `gdb`, 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.

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.

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.

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 `man` Kommando oder über "System GNU Info contents" in der KDE Hilfe nachschlagen können.

## Entwicklung mit KDevelop

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 Das KDevelop Programmierhandbuch 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 Programme 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.

### Was sind KDevelop Projekte ?

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 `configure` Skripte.

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ß.

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.

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.

### Kurzbeschreibung der Werkzeuge von KDevelop

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.

#### Programmierumgebung und Dialogeditor

##### Die Programmierumgebung

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.

##### Der Dialogeditor

Der in KDevelop integrierte Dialogeditor bietet einen einfachen Weg, Benutzerschnittstellen unter Verwendung der Qt
und KDE
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 Der Dialogeditor.

#### KAppWizard und die Klassenwerkzeuge

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
/KDE
Programmierung und die Details des GUI Designs, da Sie sehr schnell zum Ziel gelangen.

##### KAppWizard

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.

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:

- eine SDI-Schnittstelle (für Applikationen mit einem Dokument je Programmansicht), basierend auf dem Document-View-Controller Modell,

- Menüs und Dialoge zum Öffnen, Speichern und Drucken von Dateien,

- eine vollständig funktionsfähige Werkzeugleiste und Statuszeile,

- ein Hilfesystem, das ein SGML-basierendes Benutzerhandbuch und Statuszeilenhilfe enthält,

- eine vollständig HTML-basierte API (Application Programming Interface, Programmmierschnittstelle) Dokumentation zum aktuellen Stand des Projekts

- eine Installationsroutine durch make

Der KAppWizard wird über das Projekt-Menü, Eintrag "Neu..." aufgerufen.

##### Klassenwerkzeuge

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.

###### Erzeugen einer neuen Klasse mit dem Klassengenerator

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.

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.

###### Der Klassenbrowser

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.

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 Der Klassenbrowser

### Der Entwicklungsprozeß

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.

#### Erzeugen eines Programmgerüsts

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.

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.

#### Entwicklung einer Applikation

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

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.

##### Benutzerschnittstellen

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
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
und KDE
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.

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 Der Dialgoeditor nach, Beispiele und Richtlinien finden Sie im KDevelop Programmierhandbuch.

##### Einbinden neuer Elemente

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.

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

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

- ändern der Vererbung der View-Klasse. Wechseln Sie die Vererbung z.B. zu QMultiLineEdit und Ihre Applikation wird ein Editor.

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

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.

##### Der Vollständige Entwicklungsprozeß

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.

###### Organisation des Quellcodes

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 ?

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 Der Klassenbrowser.

###### Erstellen und Ausführen Ihrer Applikation

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.

Den Erstellungsprozeß rufen Sie auf durch:

- Klick auf die Schaltfläche "Erstellen" oder "Alles neu erstellen" in der Werkzeugleiste

- oder durch Auswahl von "Erstellen"/"Alles neu erstellen" aus dem "Bauen"-Menü.

Um ihre Applikation auszuführen, wählen Sie

- das Symbol "Ausführen" oder "Debuggen" (startet KDbg mit Ihrem Programm) aus der Werkzeugleiste

- über die entsprechenden Menüeinträge aus dem Bauen-Menü

- oder über "Mit Argumenten ausführen", um Ihre Applikation mit zusätzlichen Argumenten auszuführen

Um mehr Informationen zum Erstellungsprozess zu erhalten, lesen Sie bitte das Kapitel Projekte.

###### Suchen nach Programmfehlern

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 Linker-Einstellungen). 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.

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 gdb ist ein Debugger, der mit dem GNU Compilern geliefert wird und Programme wie ddd oder KDbg 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 Projekte und das Das KDevelop Programmierhandbuch verwiesen.

### Zusätzliche Informationen

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

- Das KDevelop Programmierhandbuch, behandelt eine vollständige Einführung in das GUI Applikationsdesign und der Programmierung mit den Qt und KDE
  Bibliotheken,

- dieses Handbuch, Abschnitte Übersicht bis \|\|, die alle zur Verfügung stehenden Funktionen innerhalb von KDevelop beschreiben,

- dieses Handbuch, Abschnitt Der Dialogeditor, erklärt die Benutzung des Dialogeditors, um eigene Widgets zu erstellen,

- Die Online-Reference Documentation zur Qt Bibliothek, die Beispiele zur Benutzung des Qt-GUI Toolkits als auch eine Klassenreferenz und Screenshots der wichtigsten sofort benutzbaren Widgets enthält,

- Die KDE-Bibliotheks Klassenreferenz, automatisch durch KDevelop aus den KDE-Bibliotheksquellen generiert, enthält Beschreibungen für alle Klassen und Widgets inklusive Beispielcode zu Ihrer Verwendung,

- Im Internet:

  - http://www.troll.no für Informationen über Qt und zusätzliche Widgets von dritter Seite,

  - http://www.kde.org für Informationen zum KDE Projekt und Entwicklungshinweisen,

  - http://developer.kde.org für zusätzliche Referenzen zur KDE Applikationsentwicklung.

  - Auf der KDevelop Homepage http://www.kdevelop.org

## Übersicht

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.

### Hauptfenster

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 Grundsätzliche Konfiguration). Eine Beschreibung der Editorfunktionen finden Sie im Kapitel Arbeiten mit dem Editor, zum Hilfebrowser schlagen Sie bitte Benutzung des Dokumentationsbrowsers nach.

### Der Klassenbrowser und die Dateiansichten

#### Die Klassenansicht

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 Der Klassenbrowser.

#### Die Logische Dateiansicht

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.

#### Die Aktuelle Dateiansicht

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.

#### Der Dokumentationsbaum

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.

### Ausgabefenster

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

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

- StdOut Fenster: Anzeige für Terminal-basierte Applikationen, die Nachrichten zur Standardausgabe senden. Terminal Applikationen werden jetzt allerdings in Terminal-Fenstern gestartet.

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

### Befehle der Menüleiste

#### Dateimanagement und Druckfunktionen

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:

- Neu STRG+N Ö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.

- Öffnen STRG+O zeigt den "Öffne Datei..." Dialog an und läßt Sie den Dateinamen einer zu öffnenden Datei auswählen.

- Schießen STRG+W Schließt die Datei des aktuellen Bearbeitungsfensters

- Speichern STRG+S 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.

- Speichern unter... öffnet den "Speichere Datei unter..." Dialog, indem Sie der Datei unter einen neuen Namen abspeichern können.

- Alles speichern Speichert alle geänderten Dateien

- Drucken... STRG+P Öffnet den "Drucke Datei" Dialog, in dem Sie die Druckereinstellung für die Verwendung von enscript oder lpr festlegen, um dann zu drucken.

- Verlassen STRG+Q Beendet KDevelop. Wenn Dateien geändert wurden, werden Sie aufgefordert, diese zu speichern.

#### Bearbeiten von Dateien

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.

- Rückgängig STRG+Z Macht die letzte Bearbeitungsfunktion rückgängig

- Wiederherstellen STRG+Z Wiederholt eine Rückgängig gemachte Operation

- Ausschneiden STRG+X Schneidet die aktuelle Auswahl aus und kopiert sie in die Zwischenablage.

- Kopieren STRG+C Kopiert eine Auswahl in die Zwischenablage. Dies gilt auch für Auswahlen, die im Dokumentations-Browser gemacht werden.

- Einfügen STRG+V fügt den Inhalt der Zwischenablage an der aktuellen Position ein.

- Einrücken STRG+I Rückt eine Auswahl nach rechts ein

- Ausrücken STRG+U Rückt eine Auswahlt nach links ein

- Datei einfügen...STRG+Insert läßt Sie eine Datei auswählen, deren Inhalt an der aktuellen Position eingefügt werden soll

- Suchen... STRG+F Öffnet die Suchen-Dialog und sucht den gewählten Ausdruck in der aktuellen Datei. Zur Suche über mehrere Dateien verwenden Sie "Suchen in Dateien...".

- Suche wiederholen F3 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.

- Ersetzen... STRG+R Öffnet den "Suchen und ersetzen" Dialog, der einen gesuchten Ausdruck durch einen neuen ersetzt

- Suchen in Dateien... STRG+Alt+F Zeigt den "Suchen in Dateien" Dialog an, der über `grep` 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.

- Alles auswählen STRG+A Markiert den gesamten Text der Datei, die momentatn geöffnet ist.

- Alles abwählen 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.

- Auswahl umkehren Invertiert die Auswahl, heißt: die aktuelle Auswahl wird entfernt und unmarkierter Text wird ausgewählt.

#### Ansichts-Konfiguration

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.

- Gehe zu Zeile... STRG+GÖ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.

- Nächster Fehler F4Springt 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.

- Vorheriger Fehler Shift+F4 Springt zum vorherigen Fehler.

- Dialogeditor STRG+D Wechselt zum Dialogeditor

- Baumansicht Shift+T Schaltet die Baumansicht links des Hauptfensters ein bzw. aus.

- Ausgabeansicht Shift+O Schaltet das Ausgabefenster unter der Hauptansicht ein bzw. aus

- Toolleiste Schaltet die Werkzeugleiste ein bzw. aus.

- Browser-Toolbar Schaltet die Browser-Werkzeugleiste ein bzw. aus.

- Statusleiste STRG+B Schaltet die Statuszeile ein bzw. aus.

- Aktualisieren Aktualisiert den Klassenbrowser. Der Scanfortschritt wird über eine Anzeige in der Statuszeile angezeigt.

#### Erzeugen und Organisieren von Projekten

Dieser Abschnitt beschreibt Funktionen, die Ihnene im Projekt-Menü zur Verfügung stehen und die der Erzeugung und Organisation von Projekten dienen.

- Neu... Startet den KAppWizard und erlaubt das Erstellen von neuen Projekten über die Auswahl von Typ, Name, Version und andern Optionen.

- Öffnen 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.

- Öffne letztes Projekt... enthält ein Untermenü mit den letzten fünf geöffneten Projekten, um bestehende Projekte schneller zu öffnen.

- Schließen 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.

- Neue Klasse... 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.

- Vorhandene Datei(en) hinzufügen Ö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.

- Neue Übersetzungsdatei hinzufügen Ö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.

- Dateieigenschaften Shift+F7 Ö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.

- Meldungen erstellen und verbinden 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.

- API-Dokumentation erstellen Ruft KDoc auf, aus den Kommentaren Ihrer Headerdateien eine HTML-Dokumentation Ihrer Klassen zu erstellen.

- Benutzerhandbuch erstellen Ruft ksgm2html auf, aus Ihrer SGML-Datei das HTML-Benutzerhandbuch zu erstellen. Wenn ksgml2html nicht installiert ist, wird sgml2html verwendet.

- Distribution erstellen:

  - tar.gz erzeugt die Distributionsdatei Ihres aktuellen Projekts im Projekt-Verzeichnis, die Sie den End-benutzern zur Verfügung stellen. Der Endbenutzer entpackt dann mit `tar zxvf yourproject.tar.gz` das Paket in ein Quellverzeichnis und benutzt die Standard-Kommandos `./configure, make` und `make install`.

- Einstellungen F7 Ö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.

#### Erstellen von Projekten

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

- Datei compilieren... STRG+F8 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.

- Erstellen F8 Ruft das Erstellungsprogramm auf und erzeugt die Zieldatei.

- Alles neu erstellen erstellt alle Objektdateien und die Zieldatei erneut.

- SäubernAlles neu erstellen/ Entfernt alle durch das Erstellungsprogramm erzeugten Dateien und erstellt die Zieldatei erneut.

- Stoppen F10 Stoppt den aktuellen Prozeß.

- Ausführen F9 Führt die Zieldatei nach einem Erstellungsvorgang aus.

- Mit Argumenten ausführen Alt+F9 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.

- Debuggen... Ö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.

- DistClean 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.

- Autoconf und automake 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.

- Configure 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.

#### Aufruf von Werkzeugen

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 Konfiguration des "Werkzeuge" Menüs.

#### Anpassen von KDevelop

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 KDevelop Setup durchführen.

- Editor... Erlaubt die Einstellung des Editors in Bezug auf Zeilenumbruch, Auswahl etc.

- Editor-Farben... Hier können Sie die Farb-Konfiguration des Editors festlegen wie etwa den Hintergrund.

- Editor Voreinstellungen... setzt die Editor-Standardeinstellungen wie Schriftart und Größe

- Hervorhebungen Läßt Sie die Schriftart und Farben der Hervorhebungen für verschiedene Programmiersprachen inklusive HTML einstellen.

- Dokumentationsbrowser In diesem Tabulator-Dialog stellen Sie die Optionen des Hilfebrowsers wie Schriftarten, Farben etc. ein.

- Drucker konfigurieren... Enthält die Einträge der Drucker-Konfigurationsdialoge entsprechend den verwendteten Druckprogrammen.

  - enscriptKonfiguriert den Drucker zur Benutzung von enscript. Für weitere Informationen sehen Sie nach unter "Drucken".

- Werkzeuge... Ö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.

- KDevelop Setup Ö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.

#### Das Fenstermenü

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

#### Verwendung von Lesezeichen

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.

- Lesezeichen setzen öffnet ein Kontextmenü mit bis zu neun konfigurierbaren Lesezeichen. Dies erlaubt ein setzen von Lesezeichen nach logischen Gesichtspunkten.

- Lesezeichen hinzufügen STRG+Alt+A 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.

- Lesezeichen löschen STRG+Alt+C 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.

- Headerfenster 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.

- C/C++ Fenster Enthält die Lesezeichen des C/C++ Fensters. Die Einstellungen gelten wie für das Header-Fenster.

- Browserfenster Enthält die Lesezeichen des Browsers. Die Auswahl eines Lesezeichens öffnet den Browser mit der entsprechenden Seite.

#### Online-Hilfe

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.

- Zurück Alt+ Pfeil links Öffnet die vorherige Dokumentations-Seite

- Vorwärts Alt+ Pfeil rechts Öffnet die nächste Seite, falls Sie mindestens eimal zurück gewählt haben.

- Suche Markierten Text F2 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.

- Suche nach Hilfe zu...Öffnet den "Suche nach Hilfe zu..." Dialog, in dem Sie nach einem spezifischen Ausdruck suchen können.

- Das Benutzerhandbuch zu KDevelop
  F1
  Öffnet das Benutzerhandbuch zu KDevelop (Dieses Handbuch).

- Das KDevelop Programmier-Handbuch
  Öffnet die KDevelop Programmier-Handbuch Indexseite. Dieses Handbuch enthält enthält eine vollständige Anleitung zur Programmierung der KDE.

- KDE Anwendungs Tutorials
  Wechselt zur Indexseite der KDE Anwendungs Tutorials. Dieses Handbuch erklärt, wie man die Qt Tutorial Anwendungen erstellt und führt Sie durch Entwicklung einer Beispielanwendung in die KDE Programmierung ein.

- Der KDE Bibliotheks-Referenzführer
  Wechselt zur Indexseite des KDE Bibliotheks-Referenzführers. Dieses Handbuch enthält detailierte Informationen über die Verwendung der KDE/Qt Bibliotheken, unterteilt in Abschnitte wie z.B. Ereignisbehandlung.

- Programmieren mit KDE 2
  Wechselt zur Indexseite des Buches Programmieren mit KDE 2. Dieses Handbuch enthält Informationen über die neueste KDE Entwicklung und darüber, wie Sie Ihre Anwendungen KDE 2 fertig machen.

- C/C++ Referenz
  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.

- Tip des Tages
  Öffnet den Dialog "Tip des Tages", der Ihnen nützliche Tips zur Arbeit mit KDevelop liefert.

- Homepage von KDevelop
  Öffnet, sofern Internetzugang vorhanden ist, die KDevelop Homepage in Ihrem Browser.

- Bugreport
  ... Öffnet den KDevelop Bugreportdialog, mit dessen Hilfe Sie eine Fehlermeldung direkt per EMail an das KDevelop Team senden können. Siehe auch Melden von Fehlern.

- API-Dokumentation des Projekts
  Wechselt zum Index der Klassendokumentation Ihres Projekts.

- Benutzerhandbuch des Projekts
  Öffnet die Indexseite des Benutzerhandbuches Ihres aktuellen Projekts. Sie können sie verwenden, um sich die von KSgml2Html
  erzeugte HTML
  -Ausgabe
  anzusehen.

- Über KDevelop... Zeigt die Aboutbox von KDevelop, die die verwendete Version, die Namen und Email-Adressen der Autoren sowie die KDevelop Lizenzbestimmungen zeigt.

### Schaltflächen der Werkzeugleisten

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.

#### Die Standard-Werkzeugleiste

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:

- Projekt öffnen - zeigt den "Projekt öffnen"-Dialog an

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

- Datei speichern - speichert die aktuelle Datei

- Datei drucken - öffnet den Druckdialog

- (Trennungsfeld)

- Rückgängig - macht die letzte Aktion rückgängig

- Wiederherstellen - führt eine rückgängig gemachte Aktion erneut aus

- Ausschneiden - schneidet die aktuelle Auswahl aus

- Kopieren - kopiert die aktuelle Auswahl in die Zwischenablage

- Einfügen - fügt den Inhalt der Zwischenablage an die aktuelle Position ein

- (Trennungsfeld)

- Datei compilieren - übersetzt die aktuelle Quellcode-Datei des Quellcodefensters. Im Dialogeditor-Modus ersetzt durch das "Quellen erzeugen" Schaltfeld.

- Erstellen - ruft das Erstellungsprogramm auf

- Alles neu erstellen - erstellt das Projekt neu

- Debuggen - öffnet KDbg mit der Applikations-Binärdatei zum Debuggen im Werkzeugfenster

- Ausführen - fordert die Zieldatei zur Ausführung auf

- Stoppen - beendet den aktuellen Prozeß

- (Trennungsfeld)

- Dialogeditor - wechselt in den Dialogeditor-Modus. Dort ist die Schaltfläche durch "Quellcode-Editor" ersetzt, um zum Editier-Modus zu wechseln.

- Baumansicht - schaltet die Baumansicht ein/aus und zeigt den aktuellen Status als betätigt/ unbetätigt an

- Ausgabeansicht - schaltet die Ausgabeansicht ein/aus und zeigt den aktuellen Status als betätigt/ unbetätigt an

- (Trennungsfeld)

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

#### Die Browser-Werkzeugleiste

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:

- Die Klassen-Combobox - hier können Sie eine Klasse des aktuellen Projekts auswählen, zu der Sie wechseln möchten

- Die Methoden-Combobox - hier können Sie eine Methode der aktuellen Klasse auswählen, um zur Implementierung der Methode zu wechseln.

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

- Zurück - wechselt zur vorherigen Seite des Dokumentationsbrowsers; enthält ein verzögertes Popup-Menü zur Auswahl einer besuchten Seite

- Vorwärts - wechselt zu einer Dokumentations-Seite in Vorwärts-Richtung und enthält ebenfalls ein Popup-Menü zur Auswahl einer besuchten Seite.

- Halt - Stoppt den Browser, die aktuell angeforderte Datei zu laden.

- Erneut laden - stellt die angezeigte Dokumentationsseite erneut dar.

- Benutzerhandbuch - öffnet das Inhaltsverzeichnis des KDevelop-Handbuchs.

- Suche Markierten Text - durchsucht den Dokumentations-Index nach dem ausgewählten Text; arbeitet sowohl im Browser- als auch im Editorfenster.

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

### Tastenbefehle

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 Ändern der Tastaturkürzel.

#### Tastaturbelegung für Textbearbeitung

##### Cursorbewegung

    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

##### Markieren von Text

    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ügen und Kopieren von Text, Tabulator

    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

##### Löschen von Text

    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

##### Text suchen im Editor

    ö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

##### Textsuche mit dem Dokumentations-Browser

    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

##### Browser Schnelltasten

    vorherige Seite                                         ALT+LINKS
    nächste Seite                                           ALT+RECHTS

##### Lesezeichen verwalten

    Lesezeichen hinzufügen                                  STRG+ALT+A
    Lesezeichenliste löschen                                STRG+ALT+C

#### Schnelltasten für Symbole der Werkzeugleisten

    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

#### Fensterverwaltung

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

#### Schnelltasten zum Erstellungsprozeß

    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

## Das Hilfe-System

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.

### "Was ist das...?" und Schnellhilfe

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.

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.

### Die Statuszeilen-Hilfe

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

#### Elemente der Statuszeile

Die Statuszeile enthält:

1. ein allgemeines Nachrichtenfeld am linken Rand. Dies wird zur Anzeige des aktuellen Zustands und Hilfsnachrichten verwendet.

2. 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.

3. 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.

4. eine Zeilenanzeige, die die aktuelle Zeile anzeigt

5. eine Spaltenanzeige, die die aktuelle Spalte in der Zeile anzeigt

#### Hilfe-Nachrichten

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.

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

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.

Die Titelleiste des KDevelop Projekteditors zeigt Ihnen zusätzlich an:

- bei geöffnetem Projekt den Projektnamen, im Dokumentationsbrowser den Titel des Dokuments

- KDevelop und die Versionsnummer Ihrer Kopie von KDevelop

- den Dateinamen der im Editor gerade geöffneten Datei in eckigen Klammern

Damit haben Sie über die Titelleiste eine zusätzliche Kontrollmöglichkeit über den Zustand von KDevelop.

### Konfigurieren des HTML-Browsers

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.

#### Einstellung der Schriftart

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

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.

#### Farbkonfiguration

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.

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

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.

### Benutzung des Dokumentationsbrowsers

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

#### Anforderungen

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
während der Installation anfertigen, Sie können dies aber auch nachholen, indem Sie die entsprechende Funktion im KDevelop Setup Dialog auswählen.

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.

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 KDevelop Programmierhandbuch. 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 KDevelop Setup Dialog auswählen. Zur Verwendung der zur Verfügung stehenden Suchfunktionen lesen Sie bitte auch Verwendung des Suchindexes.

#### Zur Verfügung Stehende Dokumentation

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.

Das zweite Buch ist das KDevelop Programmierhandbuch 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 http://developer.kde.org 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.

Die C/C++-Referenz, die KDevelop zur Zeit verwendet ist nur auf der KDevelop Homepage unter http://www.kdevelop.org 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 `tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz`, 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.

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 KDevelop Setup 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 KDevelop Setup Dialog erstellen.

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.

#### Hinzufügen eigener Dokumentation zum Hilfebrowser

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.

#### Verwendung des Suchindexes

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 KDevelop Setup. Der Index wird ebenfalls automatisch während des Installationsprogramms erstellt.

Die Suchfunktionen stehen Ihnen über verschiedene Wege zur Verfügung:

1. 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: &<;Ausdruck&>;". 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.

2. Im Dokumentationsbrowser: wählen Sie den Text aus, den Sie suchen und wählen Sie wie vor im Kontextmenü den Eintrag "Suche: &<;Ausdruck&>;", optional den Befehl "Suche Markierten Text" oder die Schaltfläche der Werkzeugleiste wie oben.

3. 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.

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

Der Hilfebrowser bietet weiterhin Unterstützung für Grep, um eine Auswahl innerhalb ihres Projektes zu suchen, z.B. wenn Sie die Dokumentationsseite zur `KTMainWindow` Klasse (KDEUI Bibliothek) geöffnet haben und Sie wissen möchten, wo Sie innerhalb ihres Codes der Ausdruck `KTMainWindow` erscheint. Markieren Sie `KTMainWindow` 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.

## Arbeiten mit dem Editor

Ein wichtiger Teil der Integrierten Entwicklungsumgebung ist der Editor. Sie benutzen ihm, um:

- Quellcode- und Projektdateien zu erzeugen, öffnen und speichern

- Quellcode- und Projektdateien zu bearbeiten

- Ihre SGML-Dokumentation zu schreiben

- Ihre Projektdateien zu drucken

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.

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.

### Organisation von Projektdateien

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.

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.

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.

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.

#### Erzeugen und Speichern von Dateien

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.

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.

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.

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 KDevelop Setup.

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.

#### Öffnen und Schließen von Dateien

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 \|\|). 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.

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.

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.

### Navigieren innerhalb von Dateien

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

Wie Sie eine bestimmte Zeile in einer Datei finden

1. Wählen Sie "Gehe zu Zeile" aus dem Menü Ansicht oder die entsprechende Schnelltaste STRG+G. Das Dialogfeld "Gehe zu Zeile" erscheint.

2. Geben Sie die gewünschte Zeilennummer ein, zu der Sie wechseln möchten.

3. Wählen Sie die Schaltfläche OK.

Wie Sie ein Lesezeichen setzen

1. Setzen Sie den Cursor in die Zeile, die Sie über ein Lesezeichen erreichen wollen.

2. Wählen Sie "Lesezeichen setzen" aus dem "Lesezeichen"-Menü.

3. Ein Popup-Menü erscheint, indem Sie die Lesezeichen-Nummer angeben können, über die Sie das Lesezeichen erreichen.

4. Wählen Sie die zu vergebende Lesezeichen-Nummer

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.

Wie Sie Lesezeichen löschen

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.

Wie Sie zu einem Lesezeichen wechseln

1. 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.

2. Wählen Sie den gesuchten Eintrag aus, um zum Lesezeichen zu wechseln.

Wenn Sie ein Browser-Lesezeichen auswählen, wird der Browser mit der entsprechenden Seite geöffnet.

### Arbeiten mit Schnelltasten

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 Übersicht.

    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

### Einstellen des Editors

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.

#### Allgemeine Einstellungen

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.

##### Bearbeitungsoptionen

Automatisch einrücken:

  Setzt den Cursor unter das erste Zeichen der oberen Zeile nach Eingabe von ENTER

Ausrückung:

  Setzt den Cursor unter das erste Zeichen der oberen Zeile nach Eingabe von RÜCKTASTE

Zeilenumbruch:

  automatischer Zeilenumbruch, falls Text über die in "Zeilenumbruch bei:" angegebene Spalte hinausragt

Tabs ersetzen:

  Tabularoren im aktuellen Text durch Tabulatoren der Weite "Tabbreite:" ersetzen

Leerzeichen am Zeilenende:

  entfernt nachfolgende Leerzeichen am Zeilenende

Zeilenumbruch am Cursor:

  Setzt den Cursor an das Ende der oberen Zeile, wenn RÜCKTASTE am Anfang einer Zeile eingegeben wird

Automatische Klammern:

  fügt eine schließende Klammer vor dem Cursor ein, falls eine öffnende Klammer eingegeben wird (jede Klammerart)

##### Auswahloptionen

Durchgehende Auswahl:

  bleibende Auswahl nach Plazierung des Cursors an anderer Stelle

Mehrfache Auswahl:

  erlaubt mehrfache Auswahl innerhalb des Texts

Vertikale Auswahl:

  erlaubt die vertikale Auswahl von Text

Beim Eingeben löschen:

  löscht markierten Text bei Eingabe innerhalb der Auswahl

Alt ein

  aus:/ erlaubt nur eine Auswahl. Eine bereits getroffene Auswahl wird bei erneuter Markierung abgewälht

Zeilenumbruch bei:

  stellt die maximale Spaltenzahl ein, die eine Zeile umfasst. Das letzte Wort wird bei überschreiten der Spaltenzahl in die nächste Zeile umgebrochen.

#### Farben

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

- Hintergrund: Hintergrundfarbe des Editors

- Texthintergrund: Hintergrundfarbe des dargestellten Textes

- Gewählt: Farbdarstellung von markiertem Text

- Gefunden: Farbdarstellung von gefundenen Textstellen bei Suchen über die Einträge "Suchen", "Suche wiederholen" und "Ersetzen" im Menü "Bearbeiten"

- Gewählt + Gefunden: Farbdarstellung von gefundenen Textstellen innerhalb von Auswahlen.

#### Hervorhebungen

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.

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.

### Suchen und Ersetzen

#### Suchen in einer Datei

Wie Sie ein oder mehrere Zeichen im aktuellen Editor finden

1. Wählen Sie "Suchen" aus dem Menü "Bearbeiten". Dies öffnet die Suchen-Dialog

2. Geben Sie den gesuchten Ausdruck im Editierfeld ein. Das Menü bietet die Auswahl eines bereits gesuchten Ausdrucks.

3. Geben Sie zusätzliche Optionen an wie "Nur ganze Wörter"

4. Bestätigen Sie mit OK.

Um eine Suche zu wiederholen, drücken Sie F3.

#### Suchen über mehrere Dateien

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 `grep`-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:

- Der gesuchte Ausdruck

- Die Suchvorlage

- Die Dateierweiterung der zu durchsuchenden Dateien

- Das Startverzeichnis

- Ob die Suche rekursiv über alle Unterverzeichnisse durchgeführt werden soll

Standardmäßig ist der `grep`-Dialog auf das Projektverzeichnis und rekursive Suche über Implementations- und Headerdateien eingestellt.

Sie können die Suche weiter spezifizieren, indem Sie folgende Optionen verwenden:

1. . Jedes Zeichen

2. &ˆ; Beginn einer Zeile

3. $ Ende einer Zeile

4. \< Anfang eines Wortes

5. \> Ende eines Wortes

Um Suchen zu wiederholen, sind folgende Operatoren verfügbar:

1. ? Das vorherige Element höchstens einmal

2. * Das vorherige Element gar nicht oder mehrmals

3. + Das vorherige Element einmal oder mehrmals

4. &&lcub;; n &&rcub;; Das vorherige Element genau n mal

5. &&lcub;; n,&&rcub;; Das vorherige Element n mal und darüber

6. &&lcub;;,n &&rcub;; Das vorherige Element höchstens n mal

7. &&lcub;;n,m&&rcub;; Das vorherige Element mindestens n mal, aber weniger als m mal.

Rückwärtsreferenzen zu eingeklammerten Unterausdrücken sind durch die Notation \n verfügbar.

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.

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:&<;Ihr&&lowbar;;Ausdruck&>;" 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.

#### Suchen innerhalb der Dokumentation

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:

1. den Cursor auf dem gesuchten Wort plazieren oder eine Auswahl markieren

2. Im Menü "Hilfe" den Eintrag "Suche Markierten Text", das entsprechende Werkzeugleistensymbol oder im Kontextmenü "Suche: Ausdruck" auswählen

3. nachdem die Ergebnisseite im Dokumentationsbrowser erscheint, wählen Sie die Seite aus, die die gewünschte Information enthält

4. die ausgewählte Dokumentationsseite wird mit markierem Ergebnis angezeigt. Um das nächste Ergebnis auf der selben Seite anzuzeigen, drücken Sie F3

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 Verwendung des Suchindexes.

#### Ersetzen von Text

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

### Drucken

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 enscript 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.

#### Druckerkonfiguration

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 .

##### Die enscript Konfigurationseinstellungen

###### Kopf

- Eigener Kopf: fügt einen eigenen Kopf ein

- Kopftext: ermöglicht die Einstellung des Kopftextes

  - Text: setzt den Inhalt des Kopftextes

  - Position: setzt die Position des Kopftextes auf links, mittig oder rechts

- Login: fügt die User-ID dem Kopf hinzu

  - Login: schaltet die Hinzufügung ein

  - Position: bestimmt die Position der User ID

- Dateiname: Dateinamen dem Kopf hinzufügen

  - Größe des Dateinamens: gibt den Dateinamen absolut oder relativ an

  - Position: Position des Dateinamens

- Hostname: fügt den Rechnernamen dem Kopf hinzu

  - Hostname: schaltet Hinzufügen ein

  - Größe des Hostnames: Größe des Hostnamens im Kopf

  - Position: Position des Hostnamens

###### Datum und Uhrzeit

- Aktuelles Datum: aktuelles Datum einfügen

  - Aktuelles Datum: schaltet aktuelles Datum ein

  - Position: Position der Datumsangagbe

  - Format: Format des Datums

- Änderungsdatum: einfügen des letzten Änderungsdatums

  - Änderungsdaum: einfügen einschalten

  - Position: Position des Änderungsdatums

  - Format: Datumsformat

- Aktuelle Uhrzeit: aktuelle Uhrzeit angeben

  - Aktuelle Uhrzeit: einfügen einschalten

  - AMPM:/ Verwendung von AM/PM oder 24h Uhrzeitangabe

  - Position: Position der Zeitangabe

  - Format: Format der Zeitangabe

- Änderungsuhrzeit: letzte Änderungsuhrzeit einfügen

  - Änderungsuhrzeit: einfügen einschalten

  - AMPM:/ Verwendung von AM/PM oder 24h Uhrzeitangabe

  - Position: Position der Zeitangabe

  - Format: Format der Zeitangabe

###### Layout

- Nummerierung & Rahmen:

  - Zeilen nummerieren: fügt Zeilennumerierungen ein

  - Rahmen: fügt den Seiten einen Rahmen hinzu

  - Seiten nummerieren: fügt Seitennumerierungen ein

  - Dateien ausrichten: hägt die Dateien zum Ausdruck aneinander an

  - Zeilen pro Seite: maximale Anzahl Zeilen pro Seite

- Schrift and TAB:

  - TAB-Größe: Tabulatorweite bei Ausdruck

  - Schrift für Kopf: Schriftart für Kopftext

  - Schrift für Text: Schriftart für Dateiinhalt

- Textdruck:

  - Zeilen abschneiden: Zeilen abschneiden, die über den Rand hinausragen

  - Ersetze nicht-druckbare Zeichen durch Leerzeichen: ersetzt nicht-druckbare Zeichen durch Leerzeichen

- Andere Optionen:

  - Inhaltsverzeichnis: fügt dem Ausruck ein Inhaltsverzeichnis hinzu

  - Hervorhebungsbalken:

    - Hervorhebung: hebt Zeilen abwechselnd im Ausdruck hervor

    - Zyklus der Änderung: Anzahl der Zeilen, die jeweils im Block hervorgehoben werden

  - Umgebrochene Zeile:

    - Markiere umgebrochene: umgebrochene Zeilen im Ausdruck markieren

    - Wert für umgebrochene: der Aktuelle Wer einer umgebrochenen Zeile

###### Unterlegungen

- Text: Unterlegungstext

- Position: Position des Unterlegungstexts

- Font: Schriftart der Unterlegung

- Winkel: Winkel, unter der der Unterlegungstext von der Horizontalen aus dargestellt wird

- Grauskalierung: Grauskalierung der Unterlegung

- Stil: Darstellung der Unterlegung als ausgefüllten oder umrandeten Text

#### Der Druckdialog

##### Einstellungen zum Sofort-Druck

- Programm: das zu verwendende Druckprogramm: enscript oder lpr

- Drucker: den zu verwendenden Drucker

- in Datei drucken: Ausgabe in Datei umleiten

- Papierformat: Papierformat in Hochformat oder Querformat verwenden

- Kopieren: Seiten beim Ausdruck kopieren

- Ausgabemedium: zu verwendende Papiergröße

- Ausgabeformat: Druck in HTML oder Postscript ausgeben

- Stadardeinstellungen: Standardeinstellugen zur Druckausgabe

- Ausgabe:

  - Seitendruck: eine oder zwei Seiten pro Blatt

  - Seiten: Auswahl von geraden, ungeraden oder allen Seiten bei Verwendung von enscript

  - Schöndruck:

    - Schöndruck: Schöndruckmodus bei Verwendung von enscript

    - Farbe: Farbdarstellung beim Ausdruck verwenden

    - Schöndruckmodus: Schöndruckmodus in Abhängigkeit vom Dateiformat

##### Dateiauswahl

Den Dateiauswahldialog erreichen Sie über die Schaltfläche "Dateien" im Druckdialog. Die Dateiauswahl erlaubt die Angabe der zu druckenden Dateien nach speziellen Kriterien:

- Datei-Auswahl:

  - Aktuelle: die gerade sichtbare Datei im Editor

  - Alle im Projekt: alle Projektdateien ausgeben

  - Selbstgewählte Dateien: erlaubt Auswahl von Dateien zum Ausdruck

  - Alle Headers: druckt alle Headerdateien des Projekts

  - Alle cpp Dateien: druckt alle Implementierungsdateien des Projekts

  - Geänderte Dateien: erlaubt die Angabe eines Zeitraumes für die Dateiauswahl

- Geänderte Dateien:

  - Zwischen: druckt alle Dateien nach:

    - Datum: diesem Datum geändert

    - Zeit: dieser Uhrzeit geändert

  - Und: druckt alle Dateien vor:

    - Datum: diesem Datum geändert

    - Zeit: dieser Uhrzeit geändert

- Selbstgewählte Dateien: verfügbar, falls selbstgewälte Dateien verwendet wird

  - Hinzufügen: fügt die im Editierfeld links eingestellte Datei der Dateiauswahl hinzu

  - Entfernen: entfernt eine markierte Datei aus der Druckauswahl

  - Löschen: löscht die Druckauswahl-Liste

##### Druckvorschau

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

## Projekte

### Projekttypen

#### Programme

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.

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:

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

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

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

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

- ein C-Rahmenprogramm. Dieser Programmtyp ist auf die Verwendung des C-Compilers beschränkt.

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 Grundsätzliche Konfiguration), 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.

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.

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.

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.

#### Bibliotheken

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:

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

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

  - Makefile.am aktualisieren

  - Zur statischen Bibliothek machen

  - Zur dynamischen Bibliothek machen

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

#### Mehrere Zielobjekte

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 ein Ziel vom Entwickler erstellt wird, werden solche Projekte nur in der Weise unterstützt, daß Sie Ihre eigenen Einträge in die Makefile.am
'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).

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.

Mehrere Binärdateien oder Bibliotheken innerhalb Haupt-Projektverzeichnisses sind möglich, wenn Sie sich an die in Projekt Hacking 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) :

- Fügen Sie das Ziel bin&&lowbar;;PROGRAMS hinzu, wenn es eine auführbare Datei ist

- Fügen Sie Ihre Bibliotheksdeklaration hinzu, wenn es sich um eine dynamische Bibliothek handelt

- Fügen Sie dieselben Deklarationen wie beim Originalprojekt hinzu:

  - NeuesZiel&&lowbar;;METASOURCES

  - NeuesZiel&&lowbar;;LD&&lowbar;;FLAGS

  - DISTCLEANFILES

  - Kopieren Sie die messages Einträge und ersetzen Sie Ziel&&lowbar;;SOURCES Ziel.pot durch NeuesZiel&&lowbar;;SOURCES NeuesZiel.pot

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

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

### Neue Projekte

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

Für KDE Anwendungen stehen sechs Projekttypen zur Verfügung :

- Mini: Erzeugt eine KDE Applikation mit leerem Hauptwidget.

- Normal: Erzeugt eine KDE-Applikation mit Session-Management, Menüleiste, Werkzeugleiste, Statusleiste und Unterstützung für das Doc/View Modell.

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

- KDE 2 Normal: Erzeugt eine KDE-2 Applikation mit Session-Management, Menüleiste, Werkzeugleiste, Statusleiste und Unterstützung für das Doc/View Modell.

- KDE 2 Mini: Erzeugt eine KDE-2 Applikation mit leerem Hauptwidget.

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

Wenn Sie keine Abhängigkeiten zu den KDE Bibliotheken wünschen, können Sie eine der vier Qt Anwendungen wählen:

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

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

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

- 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 http://www.geocities.com/gigafalk/qextmdi.htm.

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.

Die beiden Typen C und C++ bieten die Erstellung einer Kommandozeilenanwendung an.

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

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.

Zum Hinzufügen der Revisionskontrolle zu Ihrem Projekt, lesen Sie bitte das Kapitel CVS Integration.

### Öffnen und Schließen von Projekten

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 KDevelop Setup Dialog aus.

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.

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 *.kdevprj 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.

Eine weitere komfortable Möglichkeit ein Projekt zu öffnen, besteht darin, es im KFM, dem KDE
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 `kdevelop projektname.kdevprj`.

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.

### Bearbeiten eines Projekts

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 Setzen der Projekt Optionen, 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 Übersetzung hinzufügen beschrieben.

Erweitern der Projekt Dokumentation 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.

Schließlich wird im Abschnitt Projekt Hacking beschrieben, wie Sie das KDevelop Projektmanagment in bestimmten Fällen umgehen können.

#### Hinzufügen und Entfernen von Dateien und Klassen

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.

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.

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 Setzen der Projekt Optionen).

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

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

#### Setzen der Projekt Optionen

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
Pfad Makros sollten Sie in Ihrer Makefile.am nachsehen, wo diese Makros aufgeführt sind.

#### Übersetzung hinzufügen

Da KDE
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 `docs` Verzeichnis Ihres Projektes anlegen, z.B ``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.

Zuerst müssen Sie alle in Ihrer Anwendung sichtbaren Zeichenketten, die also auf Balken oder in Menüs erscheinen, in einem `i18n()` Makro einschließen. Dieses Makro wird durch die Funktion `klocale->translate()` aus der KLocale Klasse ersetzt ist aber wesentlich einfacher zu verwenden. Da das Makro in der `kapp.h` Includedatei definiert ist, müssen Sie Ihrer Quelldatei ein `&&num;;include &<;kapp.h&>;` hinzufügen. Es sollte auch erwähnt werden, daß obwohl `i18n()` 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 (&<;IhreApp&>;.pot im /po Unterverzeichnis). Dies wird vom xgettext Programm gemacht, welches mit `make messages` aus Ihrem Projektverzeichnis heraus aufgerufen wird. Da xgettext das `i18n()` Makro benötigt, wird Sie die Verwendung der Originalfunktion nicht zum Ziel führen.

Für die Übersetzungen selbst, müssen Sie zunächst die message Datei erzeugen, die alle vom `i18n()` 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 `msgid` Zeile, die die zu übersetzende Zeichenkette enthält, gefolg von einer `msgstr` Zeile. Die `msgstr` Zeile ist leer, bis auf Einträge, die bereits von den KDE Bibliotheken
bereitgestellt werden. Die leeren Zeilen müssen von Ihnen mit der entsprechenden Übersetzung ausgefüllt werden.

Sie könnten die Übersetzungen von Hand schreiben. Das KDE-SDK
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.

Um auf KTranslator zuzugreifen, wählen Sie am einfachsten eine &<;Sprache&>;.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.

Für alle Übersetzungen verwendet `make` das Programm `msgfmt` 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.

Weitere Informationen zur Unterstützung der Internationalisierung finden Sie auf http://www.kde.org; 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 Der Dialogeditor und The KDevelop Programming Handbook wo Fragen der Internationalisierung auch wieder behandelt werden.

#### Erweitern der Projekt Dokumentation

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
macht häufig Gebrauch von diesem Dokumentationstyp zusammen mit dem ksgml2html Programm. Dieses Werkzeug erzeugt die typische Dokumentation im KDE
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.

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 `sect` 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
Logo hinzu. Diese Datei, `logotp3.gif`, 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 `index.html`. 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 KDevelop Programming Handbook.

#### Projekt Hacking

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.

### Compiler und Linker Schalter für Projekte

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 -g Schalter, sowie das Warnen bei allen Fehlern mit -Wall 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 Erstellungsoptionen, um mehr über Compiler Optionen, Warnungen und Linkeroptionen zu erfahren.

### Externe Projekte

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.

## Erstellungsoptionen

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.

Für eine Release Version sollten Sie die folgenden Einstellungen vornehmen:

- Kein Debugging

- Setzen des Optimierungslevels auf -02

- Setzen der Compilerwarnungen auf -Wall

- Erhöhen Sie für jedes Release die Versionsnummer und aktualisieren Sie die .lsm Datei bezüglich Version und Anforderungen.

### Allgemeine Optionen

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.

### Compiler Optionen

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

#### Ziel

Unter Ziel können Sie zwei Optionen einstellen:

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 -b 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.

Optimieren: Setzen Sie hier die -O Option für den GCC. Abschalten der Optimierung bedeutet -O0. 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.

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

#### Debuggen

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).

Debuginfo erzeugen setzt das -g 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.

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

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

Für eine Release Version Ihrer Anwendung schalten Sie Debuggen aus.

#### Zusätzliche Optionen

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 man gcc informieren; man g++ gibt Informationen zum c++ Skript aus, daß zur Steuerung des Compilers verwendet wird.

### Compiler Warnungen

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 `man`-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.

-Wall

  Standard-Warnungen kombiniert

-W

  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.

-Wtraditional

  Warnungen über bestimmte Konstruktionen ausgeben, die sich unter traditionellem und ANSI C verschieden verhalten.

-Wundef

  Warnung anzeigen, falls ein undefinierter Bezeichner in einer '&&num;;if' Direktive verwendet wird

-Wshadow

  Warnung anzeigen, falls eine lokale Variable eine andere lokale Variable überdeckt.

-Wid-clash-LEN

  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.

-Wlarger-then-LEN

  Warnung anzeigen, falls ein Objekt mit einer Größe über LEN Bytes definiert wird.

-Wpointer-arith

  Warne vor allem, das von der Größe eines Funktionstypen oder von einem void abhängt. GNU C weist diesen Typen aufgrund von Komfort von Berechnungen mit void * Zeigern und Zeigern auf Funktionen eine Größe von 1 zu.

-Wbad-function-cast

  Warne, wenn ein Funktionsaufruf eine Umwandlung zu einem nicht passenden Typ ist. Z. B., wenn int malloc() eine Umwandlung zu irgendwas * ist.

-Wcast-equal

  Warne, wenn ein Zeiger gecastet wird und dabei ein Typqualifizierer beim Ziel verloren ginge.Z.B., wenn ein const char * nach char * gecastet würde.

-Wcast-align

  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 char * nach int * gecastet werden soll.

-Wwrite-strings

  Gebe Stringkonstanten den Typ const char&&lsqb;;Länge]i, so daß das Kopieren einer solchen Adresse in einen nicht const char * 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 const in Deklarationen und Prototypen war. Ansonsten werden diese Meldungen nur lästig, weshalb sie mit -Wall nicht erzeugt werden.

-Wconversion

  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.

-Wsign-compare

  Warne, wenn ein Vergleich zwischen signed und unsigned ein falsches Ergebnis geben könnte, weil signed zu unsigned umgewandelt wird.

-Waggregate-return

  Warne, wenn eine Funktion, die eine Struktur oder Union zurückgibt, definiert oder aufgerufen wird.

-Wstrict-prototypes

  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.)

-Wmissing-prototypes

  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.

-Wmissing-declarations

  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.

-Wredundant-decls

  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).

-Wnested-externs

  Warne, wenn eine extern Deklaration in einer Funktion angetroffen wird.

-Winline

  Warne, wenn eine Funktion nicht 'inline' sein kann, sie aber als 'inline' deklariert wurde, oder wenn die -finline-functions-Option angegeben wurde.

-Wold-style-cast

  Warne, wenn eine alte (C-Stil) Umwandlung im Programm benutzt wird.

-Woverloaded-virtual

  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.

-Wsynth

  Warne, wenn das Syntheseverhalten von g++ nicht mit dem von cfront übereinstimmt.

make all warnings into errors

  (-Werror) Warnungen als Fehler ausgeben. Die Kompilierung wird bei jeder Warnung abgebrochen.

Für eine Release Version Ihrer Anwendung sollten Sie -Wall einschalten.

### Linker-Einstellungen

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 "Zusätzliche Bibliotheken" Feld.

#### Linker Flags

Zum Debuggen notwendige Informationen aus der ausführbaren Datei entfernen:

  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.

Benutzung von dynamisch gelinkten Bibliotheken verhindern:

  Auf Systemen, die dynamische Bibliotheken unterstützen, verhindert diese Option das Linken mit diesen. Auf anderen Systemen hat diese Option keine Wirkung.

Zusätzliche Flags:

  Geben Sie hier Linkeroptionen, mit denen der Linker aufgerufen werden soll, ein.

#### Bibliotheken

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.

X11

  Die X11 Bibliothek. Erforderlich für alle X-Window Programme.

Xext

  Die X11 Erweiterungsbibliothek. Die meisten X-Window Programme brauchen auch Xext.

qt

  Die Qt Bibliothek. Erforderlich für Qt und KDE Anwendungen.

kdecore

  Die KDE Core Bibliothek; Enhält die Basisklasssen für KDE Applikationen.

kdeui

  Das KDE Benutzer-Interface; Enthält KDE-specifische Widgets.

khtmlw

  Die KHTML Widget Bibliothek.

kfm

  Die KFM Bibliothek; Enthält Klassen für KFM Funktionen.

kfile

  Die KFile Bibliothek. Enthält File Dialoge etc.

kspell

  Die KSpell Bibliothek. Enthält ein Interface zur Rechtschreibprüfung mit ISpell.

kab

  Die KAdressBook Bibliothek. Benötigt zum Zugriff auf das Adressbuch und auf Adressbuch Widgets

Zusätzliche Bibliotheken: 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. -Ikom .

### Make-Einstellungen

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:

Debug Informationen ausgeben

  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.

Nach Fehlern fortfahren

  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.

Datenbank ausgeben

  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.

Umgebungsvariablen

  Gibt Variablen aus der Betriebssystemumgebung den Vorrang vor Variablen aus den make-Dateien.

Keine eingebauten Regeln

  Schaltet die Verwendung der eingebauten impliziten Regeln aus. Außerdem wird die Standarderweiterungsliste für Dateierweiterungen gelöscht.

'Touch' Dateien

  Führt touch auf Dateien aus ( markiere sie als aktuell, ohne sie wirklich zu verändern). Dies wird verwendet um weitere Aufrufe von make zu täuschen.

Alle Fehler ignorieren

  Ignoriere alle Fehler in Kommandos, die beim Erstellen ausgeführt werden.

Keine Meldungen

  Zeige Kommandos, die ausgeführt werden, nicht an.

Arbeitsverzeichnis ausgeben

  Gibt vor und nach den Prozessen das Arbeitsverzeichnis aus. Dies kann nützlich sein, um Fehler in kompliziert verschachtelten, rekursiven 'Make'-Kommandos zu finden.

Jobanzahl

  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.

Geändert setzen

  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.

Zusätzliche Optionen

  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.

Neu Erstellen bei Ausführen

  Setzt die Aktionen die bei der Auswahl von "Ausführen" durchgeführt werden. Sie können aus drei Optionen auswählen:

  - Immer neu erstellen: Immer neu erstellen, ohne auf geänderte Dateien zu prüfen.

  - Warnung bei Änderung: Warne, wenn Quelldateien verändert wurden und frage, ob neu erstellt werden soll.

  - nur bei Änderung: Prüfe, ob Quelldateien geändert wurden und erstelle neu, wenn ja..

  Die Standardeinstellung ist, immer neu zu erstellen.

## Der Klassenbrowser

### Die Klassenansicht

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.

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:

- Gehe zur Deklaration: wechselt zur Deklaration der Methode

- Gehe zur Definition: wechselt zur Definition der Methode

- Gehe zur Klassen Deklaration: wechselt zur Klassendeklaration

- Neue Klasse: öffnet das Dialogfeld "Neue Klasse"

- Methode hinzufügen: fügt der aktuellen Klasse eine Methode hinzu

- Variable hinzufügen: fügt der aktuellen Klasse eine Variable hinzu

- Zeige graphische Klassenansicht: Öffnet den graphischen Vererbungsbaum

#### Verfügbare Objekte

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.

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.

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 `main()` 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:

- Strukturen

- Funktionen

- Variablen

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

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.

#### Wechseln zu Deklaration und Implementation von Objekten

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

- einer Klasse: zur Klassendeklaration

- einer Methode: zur Methoden-Implementierung

- eines Klassenattributs: zur Deklaration des Attributs innerhalb der Klassendeklaration

- einer Struktur (struct): zur Deklaration der Struktur

- einer globalen Funktion: zur Funktion-Implementierung

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:

- Gehe zu Definition: Wechselt zur Impelentation- auch standardmäßig über einfache Auswahl wie oben beschrieben

- Gehe zu Deklaration: Wechselt zur Deklaration der Methode oder Funktion

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

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.

### Die Klassenwerkzeuge

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.

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:

Parents:

  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 `QWidget` als auch `QDialog` beerben.

Children:

  Zeigt alle Klassen an, die die aktuelle Klasse beerben.

Clients:

  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

Suppliers:

  Klassen, die durch Attribute der Klasse verwendet werden

Attribute:

  Namen der Attribute der ausgewählten Klasse

Methoden:

  Methoden der ausgewählten Klasse

Weiterhin erlaubt das Klassenwerzeug die sortierte Anzeige nach Modifizierer-Attribut alle, public, protected und private.

### Handhabung von Klassen

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).

Wie man einer Klasse eine Methode hinzufügt

1. wählen Sie die Klasse in der Klassenansicht aus, der Sie eine Methode hinzufügen möchten

2. drücken Sie die rechte Maustaste; das Popup-Menü erscheint

3. wählen Sie "Funktion hinzufügen"

4. das Dialogfeld "Funktion hinzufügen" erscheint.

5. geben Sie den Typ, Deklaration und Dokumentation der zu erstellenden Methode an

6. geben Sie den Zugriff und die Modifizierer der Methode an

7. bestätigen Sie mit OK, um den Dialog zu verlassen

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

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.

## Der Dialogeditor

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.

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.

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.

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.

### Das Aussehen des Dialogeditors

#### Die Hauptansicht

Die Haupansicht des Dialogeditors ist logisch unterteilt in:

- Den Widget Tabulator, der die "Widgets", "Dialoge" und "Elemente" Tabs enthält. Beschreibungen finden Sie unter Widgets hinzufügen.

- Den Widget-Editor, der die Editieransicht zur Erstellungen Ihrer Dialoge representiert. Siehe Der Widget Editor.

- Das Eigenschaften-Fenster, das eine Liste der Eigenschaften und ihrer Werte in Abhängigkeit vom zur Zeit gewählten Widget enthält.. Lesen Sie Eigenschaften einstellen um Informationen zum Einstellen des Widgetaussehens und -verhaltens zu erhalten.

#### Unterschiede zur Menüleiste, Werkzeugleiste und Statusleiste von KDevelop

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:

##### Menüleiste

"Datei"-Menü
: "Öffnen" ermöglicht das Öffnen einer Dialogdefinitionsdatei.

"Ansicht"-Menü: 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.

"Erstellen"-Menü: Ersetzt "Datei kompilieren" durch "Quellen erzeugen". Dies ermöglicht das Erzeugen der Quellen für Ihren Dialog.

##### Werkzeugleiste

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

##### Statusleiste

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.

Während Sie die Widgetgröße ändern, zeigt die Statusleiste immer die aktuelle Höhe und Breite des gewählten Widgets an.

### Erzeugen eines neuen Dialoges

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 die 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 KDevelop Programming Handbook.

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.

#### Dialog Klasse

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:

1. QWidget: Die Basisklasse für alle interaktiven Widgets die von QT bereitgestellt werden. Verwendet für Hauptansichten und top-level Widgets.

2. QFrame: 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.

3. Eigene: 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.

4. QDialog: Die Basisklasse für Dialoge die Sie für Benutzerinteraktion verwenden würden, wie Einstellen von Eigenschaften oder Ändern von Werten.

5. QTabDialog: Erbt QDialog und stellt einen Dialog mit vordefinierten Knöpfen und Tabs zu Verfügung, den Sie über die Widgets, die Sie erzeugen, anbieten.

Eigene Eigenschaften

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.

#### Dateien

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.

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 initDialog(), 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.

#### Zielpfad

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.

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 KDevelop Programming Handbook.

### Widgets hinzufügen

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.

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.

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:

- Nach vorne

- Nach hinten

- Ganz nach vorne

- Ganz nach hinten

- Ausschneiden

- Löschen

- Kopieren

- Einfügen

- Hilfe

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

#### Der Widget Tabulator

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.

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.

#### Der Dialoge Tabulator

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.

Bei Auswahl eines Dialoges, wird der Zustand angezeigt, in dem er zuletzt im Widgeteditor gespeichert wurde.

#### Der Elemente Tabulator

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.

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 KDevelop Programming Handbook.

### Der Widget Editor

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.

### Eigenschaften einstellen

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.

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 setText() besitzen.

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.

Eine vollständige Liste der unterstützten Eigenschaften, die im Eigenschaftenfenster eingestellt werden können, finden Sie im KDevelop Programming Handbook.

### Dateien erzeugen

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.

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.

Informationen zur Implementation der Widgetfunktionen erhalten Sie im KDevelop Programming Handbook.

## Der interne Debugger

### Einstellungen

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

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:

- 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

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

- 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 Dynamische Bibliotheken und Unterbrechungen finden Sie Details und Probleme dieser Vorgehensweise. Wenn Sie keine Bibliotheken mit "dlopen" öffnen, lassen Sie diese Option ausgeschaltet.

- 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 Die schwebende Werkzeugleiste.

- 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. Tip: Diese Option wird am sinnvollsten zusammen mit der schwebenden Werkzeugleiste eingesetzt, da so das Terminalfenster nicht vom KDevelopfenster verdeckt wird, wenn Sie den Debugger bedienen.

### Verwendung des internen Debuggers

#### Änderungen in den Baum- und Ausgabeansichten

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

##### In der Baumansicht

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

##### In der Ausgabeansicht

- Breakpoint : Eine Liste der aktuell gesetzten Unterbrechungen und ihr aktueller Status.

- Framestack : Eine Liste der zur Zeit aufgerufenen Funktionen

- Disassemble : Eine Ansicht des Assemblercodes der aktuell ausgeführten Anweisung

#### Änderungen im Debugmenü und im Panel

##### Im Panel

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

##### Im Debugmenü

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

Verfügbare Funktionen:

- Ausführen: Fortsetzen des Programmes von der aktuellen Stelle aus.

- Bis Cursor: Fortsetzen des Programmes bis zur aktuellen Cursorposition.

- Über Funktion: Ausführen einer Codezeile. Alle in dieser Zeile enthaltenen Funktionen werden ausgeführt.

- Über Maschinenanweisung: Ausführen einer Assemblerinstruktion wie oben.

- In Funktion: Ausführen einer Codezeile. Wenn erforderlich wird aber in die enthaltenen Funktionen verzweigt und diese werden angezeigt.

- In Maschinenanweisung: Ausführen einer Assemblerinstruktion wie oben.

- Aus Funktion: Ausführen bis zum Ende des aktuellen Stackframes (Funktion).

- Ansichten: Erlaubt verschieden Ansichten der Daten. Zur Zeit sind implementiert:

  1. Speicher

  2. Disassemblieren

  3. Register

  4. Bibliotheken

- Anhalten: Ausführung der Anwendung unterbrechen.

- Halt: Ausführung der Anwendung unterbrechen und Debugger beenden.

#### Details

##### Unterbrechungen

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.

##### Setzen/Löschen von Unterbrechungen

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.

##### Alternative Manipulation der Unterbrechungen via Menü

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.

##### Editieren von Unterbrechungen

Benutzen Sie das eben beschriebene Menü um Unterbrechungen zu editieren. Es enthält die folgenden Einträge:

1. Bedingung: Geben Sie eine Bedingung an, die erfüllt sein muß, damit gdb die Programmausführung unterbricht.

2. Ignoriere die nächsten: Wie oft der Code den Breakpoint passieren soll, bevor gdb die Programmausführung unterbricht.

3. Aktivieren: Wenn das Kontrollfeld aktiviert ist, hält gdb an dieser Stelle an, sonst wird der Breakpoint ignoriert.

##### Alle Breakpoints löschen

Entfernt alle Unterbrechungen für dieses Programm.

##### Setzen/Löschen von Watchpoints

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.

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

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

##### Setzen/Löschen von Watch Variablen

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 &<;RETURN&>; 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.

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.

##### Ändern von Variablenwerten

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.

### Die schwebende Werkzeugleiste

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.

Zusätzlich zu den Funktionen des Debugmenüs, bietet die schwebende Werkzeugleiste zwei weitere Funktionen an:

- Setze Fokus auf KDevelop : Setzt den Fokus auf KDevelop.

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

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.

### Dynamische Bibliotheken und Unterbrechungen

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.

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.

Dies ist als "lazy breakpoints" bekannt.

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.

## CVS Integration

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.

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.

### Erzeugen eines CVS Archivs

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).

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.

Achtung: 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:

- Erstellen Sie Ihr Projekt lokal

- Importieren Sie das Projekt als Modul auf den CVS Server

- Löschen Sie den lokalen Projektverzeichnisbaum

- Checken Sie das Modul vom CVS Server aus

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

Für weitere Details zu den CVS Kommandos, konsultieren Sie bitte Ihre Systemhilfe, z.B. indem Sie `man cvs` eingeben.

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

VCS Verzeichnis:

  Dies ist das CVS Rootverzeichnis, in das der Projektverzeichnisbaum importiert wird, und in dem Commits, Checkouts und Updates ausgeführt werden.

Archiv in VCS

  Dies ist der Modulname für Ihr Projekt. Da es der Name Ihres Projektverzeichnisses ist, können Sie ihn nicht ändern.

Vendor Zeichen

  Dies ist das Zeichen für den kompletten Zweig.

Log Nachricht

  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.

Release Zeichen

  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.

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.

### Einschalten der CVS Unterstützung

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.

### Verwendung von CVS Kommandos

Damit stehen Ihnen die folgenden Kommandos unter LFV und RFV zur Verfügung:

Für Dateien die nicht im Archiv sind:

- Zum Archiv hinzufügen: Fügt die Datei zum Archiv hinzu. Die Datei wird als hinzuzufügen markiert, wird aber erst beim nächsten `Änderungen einspielen` tatsächlich dem Archiv hinzugefügt.

Für Dateien die bereits im Archiv sind:

- Aktualisieren: Update der ausgewählten Datei von der CVS Version

- Änderungen einspielen: Führt ein "commit" der ausgewählten Datei in das CVS Archiv aus

- Vom Archiv entfernen: Entfernt die Datei aus dem Repositorium

Für Verzeichnisse:

- Zum Archiv hinzufügen: Fügt den Order zum Repositorium hinzu

- Vom Archiv entfernen: Entfernt das Verzeichnis aus dem Repositorium

- Aktualisieren: Synchronisiert das Verzeichnis rekursiv mit dem CVS Archiv

- Änderungen einspielen: Führt ein rekursives "commit" in das CVS Archiv aus

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.

Da die CVS Kommandos von KDevelop nur mit dem `cvs` System Kommando und dessen Kommandozeilenoptionen arbeiten, sollten Sie keine Probleme haben CVS zu benutzen.

## Grundsätzliche Konfiguration

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ü.

### Konfiguration des "Werkzeuge" Menüs

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.

### Optionen der Dateiansicht

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:

- Neue Datei: Öffnet den Neue Datei Dialog. Entspricht dem Kommando "Datei"-"Neu"

- Neue Klasse: Öffnet den Klassengenerator um eine neue Klasse zu erzeugen. Entspricht dem Kommando "Projekt"-"Neue Klasse"

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

- Relativen Pfad anzeigen: Wenn ausgewählt, werden Dateien mit Ihrem Pfad, ausgehend vom Haupt-Projektverzeichnis, angezeigt; sonst wird nur der Dateiname ausgegeben.

Über einem Gruppenordner zeigt das entsprechende Kontextmenü:

- Neue Gruppe: Öffnet den neue Gruppe Dialog wie oben beschrieben.

- Gruppe entfernen: Entfernt die Gruppe aus dem LFV.

- Eigenschaften: Öffnet die Eigenschaften der Gruppe. Dort können Sie den Dateifilter editieren, indem Sie eine, durch Kommata getrennte Liste von Wildcards eingeben.

### KDevelop Setup

Make-Kommando:

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.

Automatisch speichern:

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.

Automatisch wechseln:

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.

Start:

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.

### Ändern der Tastaturkürzel

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.

### Dokumentation

#### Verzeichnisse

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.

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.

#### Optionen

##### KDE-Dokumentation aktualisieren

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 nicht der include Pfad von KDE ! Geben Sie nur den Pfad zu den Qelldateien ein, wie /home/rnolden/kdelibs-1.1/.

Sie können dann zwischen drei verschieden Installationsmodi wählen:

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

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

- 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!

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.

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.

BEACHTE: 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 `kdoc.rules` 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 `kdoc.rules` suchen und die Dokumentation ebenso erzeugen.

##### Suchdatenbank erstellen

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 Benutzung des Dokumentationsbrowsers nach.

##### Auch KDOC-Referenz Ihres Projektes erstellen

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.

### Debugger

Standardmäßig verwendet KDevelop den internen Debugger. 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:

- 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

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

- 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 Dynamische Bibliotheken und Unterbrechungen finden Sie Details und Probleme dieser Vorgehensweise. Wenn Sie keine Bibliotheken mit "dlopen" öffnen, lassen Sie diese Option ausgeschaltet.

- 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 Die schwebende Werkzeugleiste.

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

### Setzen der Pfade

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 KDE Anwendungs Tutorial.

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.

## Fragen und Antworten

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.

### Melden von Fehlern

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 http://bugs.kde.org//db/pa/lkdevelop.html eingesehen werden.

Wenn Sie einen Fehlerbericht senden wollen benutzen Sie bitte die EMail Adresse submit@bugs.kde.org. 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.

### Wo Sie Informationen bekommen

F: Ich habe eine Frage, die weder in der FAQ Datei, noch in den KDevelop Handbüchern behandelt wird. Wohin kann ich mich wenden?

A: Senden Sie alle Anfragen die KDevelop betreffen an die KDevelop Mailingliste. Sie können sich unter kdevelop@barney.cs.uni-potsdam.de 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 http://www.kdevelop.org 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.

### Bibliotheken und System Probleme

F: Falsche JPEG Bibliotheksversion: Bibliothek ist 61, erwartet wird 62

A: Es gibt zwei Möglichkeiten

1. 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.

2. Sie müssen kdesupport ohne die jpeg Bibliothek rekompilieren (./configure --with-libjpeg --with-libgif).

F:

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

A: Workaround für automake-1.4/automake-2.13 Benutzer: Führen Sie "aclocal" von Hand aus, dann wird es sich kompilieren lassen.

F: Was muß ich tun, wenn configure sagt, ich bräuchte giflib23.

A: Versuchen Sie einen neueren Snapshot von kdesupport, oder Sie haben vielleicht eine andere giflib installiert?

F: Wie kann ich ein KDevelop 0.2 Projekt in ein 0.3er konvertieren?

A: Ändern Sie AC&&lowbar;;OUTPUT in configure.in in eine einzeilige Version ab

zum Beispiel:

alte Version:

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

neue Version:

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

F: Ich bekomme folgende Linker Fehler, wenn ich SuSE Linux mit KDE 1.1 verwende, was muß ich tun um KDevelop gelinked zu bekommen?

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

A: 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 ftp://ftp.suse.com

### Fragen zur Verwendung

F: KDevelop erlaubt mir nicht die Verwendung der Entfernen Taste (oder das Löschen von markiertem Text mit Rückschritt).

A: Verwenden Sie "Einstellungen"->"Editor" und schalten Sie "Beim Eingeben löschen" ein, dann funktionieren Backspace und Entfernen.

F: Werden Dateien automatisch hinzugefügt und kompiliert, wenn ich sie einem Projekt hinzufüge?

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

F: Nachdem ich eine Datei entfernt habe, bekomme ich seltsame Linker Meldungen. Was ist falsch an meinem Projekt?

A: 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.

F: 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. A: Installieren Sie das Paket xdevel.

F: 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? A: Editieren Sie die Datei configure.in in Ihrem Projekthauptverzeichnis. Sie müssen hier am Anfang der Datei eingeben:

CXXFLAGS=$(CXXFLAGS) " -DYOURDEFINE" AC&&lowbar;;SUBST(CXXFLAGS)

F: Bei mir läuft ein KDE 2 Schnappschuß und ich möchte KDevelop unter KDE 2 verwenden. Wie kann ich am besten vorgehen? A: 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:

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

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

chmod 755 kdevelop1

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 !

## Autoren

Hauptentwickler:

Sandy Meier <smeier@kdevelop.de> (Projektleiter, Entwicklungskoordinator und Homepage Provider) Hauptentwicklung von: Rahmenstruktur, Gestaltung, Projektmanagement.

Stefan Heidrich <sheidric@rz.uni-potsdam.de> Hauptentwicklung von: KAppWizard, Druckfunktionen

Ralf Nolden <rnolden@kdevelop.de> Hauptentwicklung von: KDevelop<->Dialogeditor Schnittstelle, Konfigurationsfunktionen, Online-Hilfe und Handbücher

Jonas Nordin <jonas.nordin@cenacle.se> Hauptentwicklung von: Klassenbrowser und -analysator

Pascal Krahmer <pascal@beast.de> Hauptentwicklung von: Dialogeditor

Bernd Gehrmann <bernd@physik.hu-berlin.de> Hauptentwicklung von: Grep Dialog, CVS Integration

Jörgen Olsson <jorgen@cenacle.net> Hauptentwicklung von: Graphische Klassenansicht

Stefan Bartel <bartel@rz.uni-potsdam.de> Hauptentwicklung von: Real-File-Viewer

Walter Tasin <tasin@kdevelop.de> Hauptentwicklung von: Verbesserungen und Bugfixing

John Birch <jbb@ihug.co.nz> Hauptentwicklung von: Integrierter Debugger

Übersetzungskoordination:

Martin Piskernig <mpiskernig@kdevelop.de>

Programm- und Dokumentations-Übersetzungen:

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

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

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

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

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

- Martin Piskernig <mpiskernig@kdevelop.de> -German

- Ralf Funken <rfunken@kdevelop.de> -German

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

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

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

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

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

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

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

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

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

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

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

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

Startlogo:

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

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

Zusätzliche Beiträge, Patches und Bugfixes:

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

- Jost Schenk <Jost@Schenk.de>

- David Barth <dbarth@videotron.ca>

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

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

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

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

- Matt Koss <koss@napri.sk>

- Torsten Uhlmann <TUhlmann@debis.com>

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

- Nikolay Liber <nikolay_liber@mail.ru>

- Gordon Tyler <gtyler@iafrica.com>

- Huy Cuong Nguyen <huyc@iquebec.com>

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

- Stephan Uhlmann <suhlmann@gmx.de>

- Charles Egan <cega@oklahoma.net>

- Andrew Morton <morton@nortelnetworks.com>

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

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

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

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

- Ralf Palsa <rpalsa@eso.org>

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

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

- Dag Andersen <dandersen@c2i.net>

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

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

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

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

- Falk Brettschneider <gigafalk@yahoo.com>

- Ralf Funken <rfunken@kdevelop.de>

KDevelop enthält Quellcode aus den folgenden Applikationen:

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

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

GrapeFruit &©; 1999 by Bernd Gehrmann <bernd@physik.hu-berlin.de>

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

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

## Dank

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.

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

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

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.

## Copyright

    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&ß; 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.