Benutzerhandbuch zu KDevelop: Entwicklung mit KDevelop

Weiter Zurück Inhaltsverzeichnis

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

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

### 4.2 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 der Qt Designer

#### Die Programmierumgebung

The Programming Environment is the user interface that KDevelop provides for creating and maintaining projects, implicitly using many other tools by simplifying their use. It's built-in Editor and Helpbrowser as well as the Class Browser reduce the amount of work that development processes usually burden on the programmer. The ease of use make writing applications for Unix an enjoyment on it's own and will probably result in shorter release cycles and better development improvements. From here, you're managing your project throughout all its details, keep the overview over your classes and don't have to use additional consoles for your work, as well as the integration of all user interfaces results in the fact that you only have to work with one window under X and don't have to watch for several ones spread all over your desktop.

#### Qt's Designer

In dem aktuellen Release verwendet KDevelop den Qt Designer für alle KDE 2.0/Qt 2.x Projekt-Schablonen. Bedenken Sie, daß der Designer in ihrer PATH Variable enthalten sein muß, um aus KDevelop heraus automatisch aufgerufen werden zu können. Das configure Skript von KDE 2.0/Qt 2.x Schablonen sucht außerdem automatisch nach uic um C++ Code aus Ihrer .ui Datei, die mit dem Designer erstellt wurde, zu erstellen. KDevelop achtet automatisch darauf, .ui Dateien zu der Makefile.am in der _SOURCES Zeile hinzuzufügen, wobei Abhängigkeiten automatsich durch das am_edit Skript aufgelöst werden.

Zudem enthält KDevelop ein Konverter-Skriot (kdlgdesigner), welches bei der Umsetzung von existierenden *.kdevdlg Dateien, die mit dem KDevelop eigenen Dialogeditor erstellt wurdem, in *.ui Dateien, die mit dem Qt Designer weiter bearbeitet werden können, hilfreich ist. Sie finden es im "tools" Unterverzeichnis Ihrer KDevelop Installation.

Beachten Sie das Unterstützung für KDE innerhalb des Qt Designers durch Neukonfigurierung mit dem "-kde" Schalter erfolgen kann, sobald KDE installiert wurde. Nach der erneuten Erstellung des tools Verzeichnisses, werden Sie einen Qt Designer vorfinden, der die meisten KDE Widgets unterstützt und sich nahtlos in KDE in Bezug auf Aussehen und Bedienung einfügt.

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

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

The Qt Designer coming with Qt can be used to easily create dialogs and user interfaces. You can use the "Switch to Qt Designer" button from KDevelop's menubar. This will bring up the Designer where you can create a new dialog. You can also choose an existing .ui file from the fileview and KDevelop will bring up the Designer with your dialog. You can add dialogs easily by adding a new .ui file from the File menu. The Designer creates .ui files which contain an xml description of the class. Once you added the file to your project, KDevelop will take care that it is included in your Makefile. The build system will automatically create the header- and implementation files for you. Now all you have to do to either create a new class that inherits the dialog class and implement functionality or use the dialog directly. Thus, using the Designer to create dialogs has a clear advantage: Code and layout are scrictly seperated, allowing you to change the design of your dialog without rewriting one line of code. This way you can concentrate on what's really important: the actual coding process. For futher information on the Designer's concepts read the Qt Designer handbook which can also be found in KDevelops docview.

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

### 4.4 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 Projekte , die alle zur Verfügung stehenden Funktionen innerhalb von KDevelop beschreiben,
- dieses Handbuch, Abschnitt Verwendung des QT Designers in Ihrem Projekt, erklärt die Benutzung des Dialogeditors, um eigene Widgets zu erstellen,
- Die Online-Reference Documentation zur Qt Bibliothek, die Beispiele zur Benutzung des Qt-GUI Toolkits als auch eine Klassenreferenz und Screenshots der wichtigsten sofort benutzbaren Widgets enthält,
- Die KDE-Bibliotheks Klassenreferenz, automatisch durch KDevelop aus den KDE-Bibliotheksquellen generiert, enthält Beschreibungen für alle Klassen und Widgets inklusive Beispielcode zu Ihrer Verwendung,
- Im Internet:
  - http://www.troll.no für Informationen über Qt und zusätzliche Widgets von dritter Seite,
  - http://www.kde.org für Informationen zum KDE Projekt und Entwicklungshinweisen,
  - http://developer.kde.org für zusätzliche Referenzen zur KDE Applikationsentwicklung.
  - Auf der KDevelop Homepage http://www.kdevelop.org

Weiter Zurück Inhaltsverzeichnis