# Benutzerhandbuch zu KDevelop

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

    Ralf.Nolden@post.rwth-aachen.de

The KDevelop Team
Version 2.0 , Apr 11,1999

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

Benutzerhandbuch zu KDevelop

KDE
KDevelop

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

Since the last release, the main work was done in three different areas: the class viewer, the dialog editor and the "look-n'-feel" in general, including new editing functions and the creation of
KDE-applications. In order to accomplish all this, we are proud to welcome the newest two team members, Jonas Nordin, who designed a full-featured class parser and -viewer, and Pascal Krahmer, who joined the team to implement an integrated dialog editor. Other work was done in various parts of the IDE, such as a new `grep`-dialog allowing expression search through all project files or even the whole system; extended configuration utilities; reviewed and extended documentation as well as a new project generator.

### Ü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 Herstellungsoptionen, 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 Allgemeine 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.

## 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.cs.uni-potsdam.de/~smeier/kdevelop/index.html) 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@fara3.cs.uni-potsdam.de ein, indem Sie eine Email mit leerer Kopfzeile und "subscribe" 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:

- a2ps oder 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 a2ps und 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.cs.uni-potsdam.de/~smeier/kdevelop/index.html 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-Bibliotheks Dokumentation und eines Suchindexes in einem späteren Einstellungsschritt ermöglichen, wenn sie gefunden werden.

3. Prüfen nach a2ps und 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.cs.uni-potsdam.de/~smeier/kdevelop/index.html

## Ü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 General Configuration). 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 Saves the file opened in the top editing window. If the file has not been saved yet, the "Save File As..." dialog will be opened to let you choose a path and filename for the file to be saved.

- 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 a2ps, 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 "Werzeuge"-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.

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

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

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

- Benutzerhandbuch F1 Öffnet die Inhalts-Seite des KDevelop Benutzerhandbuchs.

- Programmierhandbuch Öffnet das KDevelop Programmierhandbuch

- Tip des Tages Öffnet den Tip des Tages Dialog, um Sie über weitere Features von KDevelop zu informieren.

- KDevelop Homepage Bringt Sie zur Homepage von KDevelop, falls Sie über einen Internet-Zugang verfügen.

- Bugreport... Öffnet den Bugreport-Dialog, in dem Sie dem KDevelop-Team eine Fehlerbeschreibung per E-Mail senden können; siehe auch Bug Report

- C/C++ Referenz Zeigt die Index-Seite der C/C++ Referenz an. Ist diese nicht installiert, zeigt Ihnen eine Fehlerseite an, wie Sie die Referenz nachinstallieren.

- Qt-Bibliothek Wechselt zur Index-Seite der Qt-Dokumentation, die Sie mit Ihrer Kopie der Qt-Bibliothek erhalten haben.

- KDE-Core-Bibliothek Öffnet den Klassenindex der KDE-Core Bibliotheksdokumentation.

- KDE-GUI-Bibliothek Wie vor für die GUI-Bibliothek

- KDE-KFile-Bibliothek Wie vor für die KFile-Bibliothek

- KDE-HTML-Bibliothek Wie vor für die HTML-Bibliothek

- Projekt-API-Dokumentation Wechselt zum Klassendokumentation des Projekts

- Projekt-Benutzerhandbuch Öffnet die Inhaltsseite des Benutzerhandbuchs Ihres aktuellen Projekts. Verwenden Sie diese Funktion zur Kontrolle der HTML-Ausgabe Ihrer Dokumentation.

- Über KDevelop... Öffnet eine Dialogbox mit Informationen zu KDevelop mit Hinweisen zur Version, Autoren, Email-Adressen und Lizenzbestimmungen.

### 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 von Schnelltasten.

#### 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 Benutzen 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.cs.uni-potsdam.de/~smeier/kdevelop/index.html 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.

#### Benutzen 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

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

#### Druckerkonfiguration

Die Druckprogramme können beide über die Auswahl von "Drucken" im Menü "Datei" konfiguriert werden; auf 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 gewählten Programms. Sie können die Programme ebenfalls konfigurieren, indem Sie im Menü "Einstellungen", Untermenü "Drucker konfigurieren" das zu verwendende Programm auswählen (a2ps oder enscript).

##### Die a2ps Konfigurationseinstellungen

###### Druck

- Kopf: fügt der Seite einen Kopfrahmen hinzu

- Dateiname: verwendet den Dateinamen als Text des Kopfrahmens

- Login: fügt die User ID auf der rechten oberen Ecke der Seite hinzu

- Rahmen: zeichnet einen Rahmen um die Textseite

- Datum & Zeit: fügt Datum und Uhrzeit des Drucks ein

- Dateien ausrichten: Druckt Dateien auf die gleiche Seite, verfügbar bei Zwei-Seiten Druck

- TAB-Größe: setzt die zu verwendende Weite von Tabulatoren

- Kopftext: Verfügbar, wenn Dateiname nicht verwendet wird und erlaubt das Einfügen von Text im Kopfrahmen

- Schriftgröße: Setzt die zu verwendende Schriftgröße des Textes. Standardeinstellung beträt 9

###### Textdruck

- Zeilen abschneiden: schneidet das Ende der Zeile ab, wenn sie über den Seitenrand hinausragt. Zeilen werden umgebrochen, wenn "Zeilen abschneiden" deaktiviert ist.

- Interpretiere TAB, BS and FF: interpretiert TAB, Backspace und FastForward Zeichen.

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

- Drucke Nicht-ASCII Zeichen als ISO-Latin 1: druckt Zeichen, die nicht im ASCII Zeichensatz enthalten sind, im ISO-Latin 1 Ausgabemodus.

- Fettdruck: Druckt den ganzen Text in Fettdruck

###### Numerierung

- Zeilen numerieren: numeriert alle Zeilen

- Seiten numerieren: erlaubt Seitennumerierung nach Modus:

  - Dateien einzeln: numeriert die Seiten jeder Datei einzeln beginnend mit 1

  - Dateien zusammen: numeriert alle Seiten der Druckausgabe aufeinander folgend

- Zeilen pro Seite: stellt die maximale Anzahl an Zeilen pro Seite ein

##### 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: a2ps, 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 vorsichtig sein 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.

- eine 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 das Vorhandensein eines C-Compilers beschränkt.

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 dynamische Bibliothek zu erstellen, können Sie ein weiteres Projekt-Unterverzeichnis anlegen. Die Quellcodes, die sich in diesem Unterverzeichnis befinden, werden dem Projekt hinzugefügt und sind daher in der Klassen-Ansicht as Hauptklassen verfügbar. Um eine dynamische Bibliothek zu erzeugen, bietet Ihnen das KDevelop Programming Handbook im Anhang eine Schablone zur Erstellung der entsprechenden Makefile.am an. Wenn das Makefile des neuen Unterverzeichnisses dem configure.in Skript hinzugefügt wurde, müssen Sie nur noch "Autoconf und automake" und "Configure" ausführen, um die Makefiles zu erzeugen. Die Erstellung selbst ist jedoch nur möglich, indem das Erstellungsprogramm aus dem Unterverzeichnis aufgerufen wird, da KDevelop die Erstellung aus dem ursprünglichen Projekt-Unterverzeichnis aufruft. Eine weitere Möglichkeit, eine dynamische Bibliothek zu erstellen wäre, die Makefile.am des ursprünglichen Unterverzeichnisses an die Schablone des Programmierhandbuches anzupassen, indem Sie die Regeln zur Projekt-Modifikation beachten, die im Abschnitt Project Hacking beschrieben werden.

- Um eine dynamische Bibliothek zu installieren, müssen Sie den KDE-Datei-System Standard beachten, wie er im The KDevelop Programming Handbook beschrieben ist.

#### Mehrere Zielobjekte

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

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

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

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

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

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

  - newtarget&lowbar;METASOURCES

  - newtarget&lowbar;LD&lowbar;FLAGS

  - DISTCLEANFILES

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

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

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

### Neue Projekte

The KDevelop Application Wizard allows the creation of four different types of projects, constructing a framework for each. All projects use the GNU standard development tools as described in the requirements section of this handbook. For
KDE applications, the wizard offers two different frameworks, the
KDE-Application, providing a complete application with base
classes for document type, view and application. This includes the creation of a menubar, toolbar and statusbar, the mainwindow inherits the KTMainWindow class. The
KDE-Mini-Application only gives a view which is empty. This type of project can be used for the creation of small desktop tools or other simple applications without too much change on the existing code provided by the framework. A Qt-Application offers the creation of a Qt-only program if you wish no dependencies towards the
KDE-libraries for end-users. The Qt-Application also is created by using tree base
classes like the KDE-standard-Application and provides a menubar, toolbar and statusbar.

The C++ -Application type offers a framework for creating commandline applications. It is ready to run and by default displays "Hello World" as the only action. This may be useful for C++ learners who would like to program applications without using a
GUI first or for those working on commandline programs written in C++ or C. C programmers can also take advantage of the C-only project, which requires any C-compiler at the minimum.

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

### Öffnen und Schließen von Projekten

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

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

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

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

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

### Bearbeiten eines Projekts

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

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

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

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

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

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

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

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

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

#### Setting Project File Options

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

#### Adding Translations

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

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

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

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

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

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

For more information about internationalization support, see http://www.kde.org; a lot of people are doing translations for you to support their language. You will find a list of email-adresses of the translators you could write to and who will help you with this. Also read Der Dialogeditor and The KDevelop Programming Handbook where questions about internationalization are covered again.

#### Extending the Project Documentation

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

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

#### Project Hacking

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

### Compiler and Linker Flags for Projects

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

### External Projects

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

## Build Settings

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

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

- disable debugging

- enable optimization and set optimization level to -02

- set the compiler warnings to -Wall

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

### General Options

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

### Compiler Options

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

#### Target

The target box contains three options that can be set:

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

only syntax-check: If checked, the -fsyntax-only flag is set. This means that the compiler will check your code only for correctness in regards to the syntax, but doesn't check anything beyond that.

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

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

#### Debugging

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

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

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

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

For a release of your project, disable any debugging.

#### Additional Options

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

### Compiler 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

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

-Wbad-function-cast

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

-Wcast-equal

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

-Wcast-align

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

-Wwrite-strings

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

-Wconversion

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

-Wsign-compare

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

-Waggregate-return

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

-Wmissing-prototypes

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

-Wmissing-declarations

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

-Wredundant-decls

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

-Wnested-externs

  Warn if an extern declaration is encountered within an function.

-Winline

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

-Wold-style-cast

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

-Woverloaded-virtual

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

-Wsynth

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

make all warnings into errors

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

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

### Linker-Einstellungen

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

#### Linker Flags

remove all symbol table and relocation information from the executable:

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

prevent using shared libraries:

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

additional flags:

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

#### Libraries

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

X11

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

Xext

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

qt

  The Qt library. Recommended for
  Qt and
  KDE applications.

kdecore

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

kdeui

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

khtmlw

  The KHTML Widget library.

kfm

  The KFM library containing classes for KFM functions.

kfile

  The KFile library. Contains file dialogs etc.

kspell

  The KSpell library. Contains an interface for programs to use ISpell for spellchecking.

kab

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

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

#### Make

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

Print debug information

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

Continue after errors

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

Print the data base

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

Environment variables

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

No built-in rules

  doesn't use built-in rules for make.

Touch files

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

Ignore all errors

  Ignores all errors that occur

Silent operation

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

Print working directory

  prints the current directory during the make-process.

job number

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

set modified

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

additional options

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

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

- Goto Declaration: wechselt zur Deklaration der Methode

- Goto Definition: wechselt zur Definition der Methode

- Goto Class Declaration: wechselt zur Klassendeklaration

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

- Add Method: fügt der aktuellen Klasse eine Methode hinzu

- Add Attribute: fügt der aktuellen Klasse ein Attribut hinzu

#### 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 tag/Suppliers:/ Klassen, die durch Attribute der Klasse verwendet werden

Attributes:

  Namen der Attribute der ausgewählten Klasse

Methods:

  Methoden der ausgewählten Klasse

Virtual Methods:

  Virtuelle Methoden der Klasse

Weiterhin erlaubt das Klassenwerzeug die sortierte Anzeige nach Modifizeirer-Attribut 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 Methdendeklaration und der Implementationskopf dem Quellcode hinzufügen. Da die Klassenansicht sich selbst aktualisiert, haben Sie direkten Zugang zu der Implementation der neuen Methode, sodaß Sie nur die Methode anspringen müssen, um den auszuführenden Code einzugeben.

## Der Dialogeditor

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

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

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

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

### The Dialog Editor View

#### The Mainview

The dialogeditor's view is logically seperated by:

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

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

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

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

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

##### Menubar

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

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

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

##### Toolbar

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

##### Statusbar

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

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

### Creating a New Dialog

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

To create a new dialog, select "New" from the "File"-menu or select "New" from the context menu in the "Dialogs" tab. The "New Dialog" menu appears where you have to give KDevelop the dialog-specific information about the baseclass and the source file names and destination.

#### Dialog Class

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

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

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

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

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

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

Custom Properties

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

#### Files

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

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

#### Location

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

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

### Adding Widgets

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

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

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

- Raise

- Lower

- Raise to top

- Lower to bottom

- Cut

- Delete

- Copy

- Paste

- Help

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

#### The Widgets Tabulator

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

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

#### The Dialogs Tabulator

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

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

#### The Items Tabulator

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

On selecting an item, it gets marked in the edior view, as well as the properties are shown in the properties window. Using the items view is sometimes important if your widgets behavoir depends on the parent-child relationship. For more information see The KDevelop Programming Handbook.

### The Widget Editor

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

### Setting Properties

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

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

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

A complete list of the supported properties that can be set in the properties window for each widget item, see The KDevelop Programming Handbook.

### Generating Files

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

Now that your project contains a new widget, your work as a programmer is to implement functionality to the used slots and eventually add other methods you may need.

For more information about implementation of the widgets functions, see The KDevelop Programming Handbook.

## CVS Integration

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

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

### Enabling CVS Support

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

### Using CVS Commands

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

Over a file not included in the repository:

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

Over a file included in the repository:

- Update: update the selected file with the CVS version

- Commit: commit the selected file to the CVS repository

- Remove from Repository: remove the file from the repository

Over a folder:

- Add: adds the folder to the repository

- Remove: removes the folder from the repository

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

- Commit: commit any changes recursively to the repository

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

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

## General Configuration

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

### Configuring the "Tools" Menu

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

### File Viewer Options

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

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

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

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

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

Over a group folder, the according context menu offers:

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

- Remove group: removes the group from the LFV.

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

### KDevelop Setup

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

Autosave:

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

Autoswitch:

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

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

### Changing Keyboard Shortcuts

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

### Documentation

#### Directories

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

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

#### Options

##### Update KDE-Documentation

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

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

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

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

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

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

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

##### Create Search Database

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

## Questions and Answers

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

### Bug Reporting

Another improvement of KDevelop is the integrated bug-reporting system via email. If you experience a bug, you have the option to send the KDevelop development team a bug report either by your email-client or by the bug-report dialog. All bug-reports are collected on the KDevelop website and can be reviewed on fara3.cs.uni-potsdam.de/~smeier/kdevelop/bugarchive/maillist.html. You can also receive all bug-reports via subscription to the bug-report mailinglist by sending an empty email to kdevelop-bug-report-request@fara3.cs.uni-potsdam.de with "subscribe your&lowbar;email&lowbar;adress" as the body contents.

To send bug reports, please use this email adress by your mail program. If you want to use KDevelop for direct bug-reporting, choose "Bug Report" from the "Help" menu. You are presented the report dialog that lets you enter all necessary information about the bug you found. After pressing "OK", the dialog's contents is sent to the mailinglist automatically.

### Where to get Information

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

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

The KDevelop Homepage at http://www.cs.uni-potsdam.de/~smeier/kdevelop/index.html also contains a mailing-list archive that allows you to browse the mails already send by the subscribers, so you should look there first as most problems should have been adressed already by the team or other users.

### Library and System Problems

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

A: There are 2 ways.

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

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

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

Q:

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

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

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

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

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

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

for example: old version:

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

new version:

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

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

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

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

### Usage Questions

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

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

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

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

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

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

## Autoren

Hauptentwickler:

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

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

Ralf Nolden <Ralf.Nolden@post.rwth-aachen.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

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

Übersetzungskoordination:

Martin Piskernig <martin.piskernig@stuwo.at>

Programm- und Dokumentations-Übersetzungen:

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

Steen Rabol <rabol@get2net.dk> -Danish

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

Massimo Morin <mmorin@schedsys.com> -Italian

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

Sami Kuhmonen <sami@iqs.fi> -Finnish

Herve Lefebvre <hlefebvre@easynet.fr> -French

Pahan Szabolcs <szabczy@bigfoot.com> -Hungarian

Duarte Loreto <dnloreto@esoterica.pt> -Portuguese

Ilmar Habibulin <ilmar@ints.ru> -Russian

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

Jan Prokop <jprokop@ibl.sk> -Slovak

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

Startlogo:

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

Zusätliche Beiträge, Patches und Bugfixes:

Walter Tasin <tasin@e-technik.fh-muenchen.de>

Jost Schenk <Jost@Schenk.de>

David Barth <dbarth@videotron.ca>

Matthias Hipp <Matthias.Hipp@gmx.de>

Martin Piskernig <martin.piskernig@stuwo.at>

Matthias Hoelzer-Kluepfel <mh@caldera.de>

Steen Rabol <rabol@get2net.dk>

Matt Koss <koss@napri.sk>

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

Bernd Gehrmann <bernd@physik.hu-berlin.de>

Torsten Uhlmann <TUhlmann@debis.com>

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, das 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, das uns scnon 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 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.