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

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

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

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

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

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

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

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

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