KDE Entwicklung
Aus Wikibooks
 |
Dieses Buch ist verwaist. Es ist herrenlos und sucht dringend einen neuen Autor! Vielleicht kannst du etwas zum Inhalt beitragen? Wenn du dich traust, kannst du das Buch auch gern als neuer Autor übernehmen. Es gibt eine Liste von weiteren verwaisten Büchern, vielleicht findest du dort ein Buch, welches du gern weiterschreiben willst? |
 |
Diese Seite hat mittlerweile eine Größe erreicht, die es als geeignet erscheinen lässt, sie in mehrere einzelne Seiten zu zerlegen. In welche Teile diese Seite zerlegt werden könnte, kann auf der Diskussionsseite besprochen werden. Wie man es macht, steht im Wikibooks-Lehrbuch im Abschnitt Buch in Kapitel untergliedern. |
[Bearbeiten] Vorwort
Viele Open-Source-Projekte bringen zwar ausreichend Dokumentation mit, aber umfassende Bücher zu diesen fehlen entweder oder sind nur sehr dürftig zu älteren Versionen verfügbar. Nur wenige sehr populäre Open-Source-Projekte bieten wirklich eine gute Auswahl an Literatur, z.B. Apache, aber auch diese Literatur bezieht sich selten auf die Entwicklung dieser Software.
KDE hat eine sehr ausführliche Dokumentation und auch fast alle Standardanwendungen sind gut dokumentiert. Wenn es aber um die Entwicklung für diese Desktop-Plattform geht, dann sieht es düster aus. Es gibt einige freie Online-Bücher, vor allem ein KDE 2-Entwicklungsbuch und ein Qt 3-Entwicklungsbuch. Außerdem sind auch noch einige Tutorials zu speziellen Entwicklungsthemen und zu KDevelop sowie die API-Dokumentation verfügbar. Keines dieser Angebote ist aber ein geeigneter Einstieg für das Erlernen professioneller und umfassender Entwicklung auf der KDE-Plattform. Vor allem ist dies dann nicht der Fall, wenn man noch kein professioneller Entwickler ist. Aber da genau diese Leute für Open-Source begeistert werden sollen und aus Begeisterung diese Idee unterstützen sollen, sind Bücher wie dieses dringend nötig.
Das Interesse an teuren Büchern für Open-Source-Entwicklung ist wohl nicht besonders groß und passt nicht in das Konzept kommerzieller Verlage. Also scheint ein Wiki-Buch die ideale Alternative zu sein, um
- ein immer aktuelles,
- möglichst fehlerfreies,
- umfassendes und
- professionelles
KDE-Entwicklungsbuch zu schaffen.
Ziel dieses Projekts ist, dass möglichst viele KDE-Experten und -Entwickler ihre Beiträge zu diesem Buch liefern und es zu einer hervorragenden Quelle für KDE-Entwickler zu machen. Als erstes Ziel wurde angepeilt bis zur aKademy 2005 ein vollständiges Buch fertigzustellen. Jedoch fehlt noch viel - und viele Punkte sind weiter ausbaufähig. Deshalb ist jede Unterstützung erwünscht!!! Eine Übersetzung ins Englische ist geplant, aber das wird wohl erst später Sinn ergeben... und die Unterstützung von Muttersprachlern benötigen.
[Bearbeiten] Einleitung
[Bearbeiten] Warum ein Buch zur KDE-Entwicklung?
Wer KDE kennt, wovon bei den Lesern dieses Buches auszugehen ist, weiß, dass es über sehr mächtige Fähigkeiten verfügt und weit mehr zu bieten hat, als man anfangs annimmt. Viele dieser Fähigkeiten basieren auf einer äußerst ausgeklügelten Architektur, die weit über die der zu Grunde liegenden Qt-Bibliothek hinaus gehen. So erreicht man zum Beispiel dank der KIO-Slaves Netzwerktransparenz in allen KDE-Anwendungen. Diese Architekturen bei Entwicklung zu verwenden oder gar selbst durch eigene Komponenten zu erweitern ist eine nicht besonders schwere Aufgabe, dennoch benötigt man dazu einen guten, zusammenhängenden Leitfaden. Diesen soll dieses Buch liefern.
[Bearbeiten] Was in diesem Buch behandelt wird
Dieses Buch richtet sich zunächst an C++-Entwickler, die ein Interesse daran haben, eigene Anwendungen für KDE zu entwickeln. Dabei genügen C++ Grundkenntnisse zur Syntax und zur Objektorientierung. Das Buch fängt zunächst mit einer Einführung in die Qt/KDE-Entwicklung von Anwendungen an und erklärt dann über Beispiele die Erstellung von dialog- und dokumentbasierten Anwendungen. In diesem Zusammenhang werden dann auch KDE-Technologien, wie KIO-Slaves und KParts eingeführt. Abschließend behandelt dieses Buch die Erstellung von eigenen Kicker-Applets, Controlcenter-Modulen und von DCOP-Anbindungen.
[Bearbeiten] Was dieses Buch nicht behandelt
Dieses Buch ist keine Einführung zu KDE und setzt grundlegende Kenntnisse zu KDE voraus. Themen wie die Installation oder die Konfiguration von KDE werden hier bewusst nicht behandelt, da diese in anderen Informationsquellen, wie z.B. der KDE Dokumentation, bereits behandelt werden. Dieses Buch gibt außerdem keine Einführung in die C++ Programmierung, da diese den Rahmen dieses Buches sprengen würde und auch nichts mit KDE Entwicklung zu tun hat. An dieser Stelle sei auf die vielen guten verfügbaren C++ Bücher verwiesen. Dieses Buch behandelt auch nicht die Verwendung von Anbindungen anderer Sprachen als C++ zur KDE Entwicklung, da diese nicht zur eigentlichen KDE Komponenten Entwicklung, sondern nur für spezielle Anwendungen und Dialoge gedacht sind.
[Bearbeiten] Syntax
[Bearbeiten] Code-Einbindung
Diese Buch verwendet die folgende Syntax für Quellcode:
#include <qapplication.h>
int main(int argc, char *argv[])
{
QApplication qapp(argc, argv);
return qapp.exec();
}
Dabei enthält das Buch kleinere Beispiele an Code, die zur Erklärung gedacht sind. Das gesamte Programm ist jeweils in einen eigenen verlinkten Artikel ausgelagert.
Alle Qt-Klassen und Funktionen beginnen mit einem Q und alle KDE-Klassen und Funktionen mit einem K, z.B. QApplication und KApplication. Alle Namen werden klein geschrieben und nur der Wortanfang mit einem Großbuchstaben markiert, z.B. KMyWidget. Makros werden groß geschrieben, z.B. Q_OBJECT.
[Bearbeiten] Begrifflichkeit
Wir verwenden in diesem Buch verschiedene Begriffe für technische Operationen. So sind zum Beispiel Übersetzen und Kompilieren in diesem Buch Synonyme. Das Erstellen steht für Kompilieren und Linken.
Widgets sind Segmente der Oberfläche, die einen bestimmten Zweck erfüllen. Beispiele sind Buttons, Texteingabefenster oder Container.
[Bearbeiten] Navigation
Die Navigation durch die Oberfläche ist immer kursiv geschrieben. Dabei werden Untermenüs mit einem -> verbunden. Also zum Beispiel Hauptmenü->Untermenü->Unteruntermenü, oder F8 für die F8-Taste.
[Bearbeiten] Oberfläche
Für die Screenshots wurde KDE 3.3.2 mit KDevelop 3.1.2 verwendet. Das Iconset ist Crystal (Standard), Stil und Fenstermanager sind Plastik.
[Bearbeiten] Benötigte Software
Als Basissystem für die hier aufgelistete Software sollte ein POSIX-kompatibles Betriebssystem, wie eine Linux Distribution http://distrowatch.org oder FreeBSD http://www.freebsd.org dienen. Folgende Software wird in diesem Buch verwendet:
[Bearbeiten] g++ - GNU C++ Compiler
Selbstverständlich können Sie auch einen anderen C++ ANSI kompatiblen Compiler verwenden, allerdings werden fast alle OpenSource-Anwendungen mit der GNU Compiler Collection programmiert und funktionieren daher damit am besten. Wir verwenden in diesem Buch g++. http://gcc.gnu.org
[Bearbeiten] automake - GNU automake Tool
Automake erzeugt selbstständig alle nötigen configure-Skripts und Makefiles. Dieses Tool wird in den meisten OpenSource Paketen verwendet und ist auch der Standard für KDevelop KDE Entwicklung. Wir verwenden in diesem Buch automake. http://www.gnu.org/software/automake/
[Bearbeiten] qt-Bibliothek - Q-Toolkit von Trolltech
Dieses Toolkit ist die Basis für die KDE GUI. Es ist vergleichbar mit GTK für GNOME. Qt Anwendungen ermöglichen die Entwicklung einer Oberfläche, die dann für Windows, Mac OS X, GNU/Linux, BSD's und andere Betriebssysteme verwendet werden kann. http://www.trolltech.com/products/qt
[Bearbeiten] KDE-Libs - KDE Bibliotheken
KDE-Libs enthält die KDE Bibliotheken und Header und ist die Plattform für jede KDE Anwendung. http://www.kde.org
[Bearbeiten] KDE-Base - KDE Basisprogramme
KDE-Base enthält die KDE Basisprogramme, wie Konqueror oder Kicker.
[Bearbeiten] KDE-SDK - KDE Software Development Kit
KDE-SDK enthält verschiedene Tools, die man zum Entwickeln in und für KDE benötigt.
[Bearbeiten] KDevelop - IDE für KDE
KDevelop ist eine integrierte Entwicklungsumgebung, die von Projektmanagment über Debugger, Profilerintegration und vorbereiteten Standardprojekten bis hin zu umfangreichen Dokumentationen die OpenSource Entwicklung zugänglich macht. Wir verwenden KDevelop in diesem Buch.
[Bearbeiten] Entwicklungsumgebung
Das wichtigste zum Entwickeln ist eine geeignete Entwicklungsumgebung. Dabei sind deren Fähigkeiten nicht so wichtig, viel wichtiger ist, dass sie den Bedürfnissen des aktuellen Projekts gewachsen ist. Viele OpenSource-Entwickler bevorzugen Texteditoren wie vi oder emacs und entwickeln für riesige Projekte mit kleinen einzelnen Tools.
Das hat verschiedene Gründe. Zum Einen waren am Anfang der OpenSource-Bewegung keine freien großen Entwicklungsumgebungen verfügbar und so sind diese Entwickler (einfache) Texteditoren gewohnt. Zum Anderen benötigt man viel Zeit sich in eine komplexe Entwicklungsumgebung einzuarbeiten und alle ihre Funktionen zu verstehen. Ändert sich die Umgebung oder ist sie für eine gewünschte Plattform nicht verfügbar, dann muss man sich komplett umstellen. Ein Vorteil dieser Lösung ist außerdem, dass die einzelnen Tools beliebig kombiniert werden können und jeder Entwickler seine eigene Umgebung hat. Deshalb halten viele Entwickler an ihren alten, aber keineswegs veralteten, Werkzeugen fest.
Moderne Entwicklungsumgebungen haben aber ganz klar viele Vorteile und mittlerweile gibt es solche auch als OpenSource Software. KDevelop ist zum Beispiel eine solche Umgebung. Entgegen der Empfindung vieler "Texteditorenanhänger" ist KDevelop sehr anpassungsfähig und kombiniert viele nützliche OpenSource Entwicklungssoftware in sich. Es ist dabei gezielt auf die Entwicklung von KDE eingestellt und bietet darüber hinaus aber auch hervorragende Möglichkeiten für die Entwicklung in anderen Bereichen, wie z.B. GNOME- und Java-Anwendungen oder Python-Skripte. Es nimmt dem Entwickler viele Handgriffe automatisch ab und macht nützliche Funktionen leicht erreichbar. KDevelop basiert dabei zum Beispiel auf einem frei wählbaren Texteditor. Standardmäßig stehen der Qt-Editor, KDE-Vim und Kate zur Verfügung.
Kate ist in der Regel die beste Wahl, da Kate ebenfalls sehr modular aufgebaut ist und an sich schon ein sehr professioneller Editor ist. Für kleinere Softwareprojekte genügt Kate durchaus und man muss keine große Umgebung wie KDevelop erlernen.
[Bearbeiten] KDevelop
Wir verwenden für alle Projekte in diesem Buch KDevelop. Deshalb ist es äußerst sinnvoll dies auch zu tun, vor allem wenn Sie noch keine Entwicklungsumgebung haben. Im Folgenden wird kurz erklärt wie man mit KDevelop arbeitet. Ausgefeilte Features werden Sie im Laufe dieses Buches kennenlernen. Sollten Sie sich für weitere KDevelop Informationen interessieren, dann empfehlen wir Ihnen das Qt Designer and KDevelop-3.0 for beginners Tutorial oder die KDevelop Dokumentation.
[Bearbeiten] Die KDevelop-Oberfläche
Sollten Sie KDevelop zum ersten mal starten, dann sollte diese Oberfläche erscheinen. Wie man sehen kann ist diese zunächst noch sehr übersichtlich. Erst mit dem Öffnen eines Projekts werden die dazu passenden Funktionen verfügbar und angezeigt.
[Bearbeiten] Einstellungen
Im Menü unter Einstellungen->KDevelop einrichten finden sie den folgenden Dialog.
Die meisten der verfügbaren Einstellungen sind selbsterklärend oder unterstützen die direkte Hilfe (? in der Fensterleiste). Am besten Sie probieren die Unterschiede ein bisschen aus und entscheiden sich dann. Das bereits erwähnte Tutorial zu KDevelop und die Dokumentation können Sie dabei unterstützen.
Sie sollten vor allem darauf achten, dass sich unter Dokumentation->Doxygen-Dokumentation ein Eintrag mit der KDE API Reference befindet, da wir diese beim Entwickeln noch benötigen werden. Sollte der Eintrag nicht da sein, dann besorgen Sie sich die API Referenz und geben Sie bei Hinzufügen das Root-Verzeichnis, in der Regel $KDEDIR/share/doc/HTML/en/kdelibs-apidocs, der Dokumentation an. Wir verwenden in diesem Buch zunächst die Standardeinstellungen und weisen Sie daraufhin, falls Änderungen nötig sind.
[Bearbeiten] Projektmanagement
Um ein neues Projekt anzulegen wählen Sie Projekt->Neues Projekt. Es öffnet sich ein Dialog. Wählen Sie im Reiter Alle Projekte C++->KDE->Simple KDE Application aus. Wählen Sie einen Ordner aus in dem Sie ihre Projekte speichern wollen und geben Sie als Projektnamen khello an. Für ihr neues Projekt wird dann im angegebenen Ordner ein Unterordner mit dem Projektnamen angelegt.
Im weiteren Dialog können Sie Lizenzrechte ihrer Daten und die Version der Software eingeben. Am Ende des Dialogs wird dann die Anwendung erzeugt. Die Datei khello.cpp wird nun geöffnet und Sie können sich an die Arbeit machen... aber dazu später.
Wollen Sie für Projekt weitere Einstellungen machen, dann finden Sie unter Projekt->Projekteinstellungen alle möglichen Einstellungen.
Wieder empfiehlt sich einfach ein bisschen zu stöbern und sich mit den verschiedenen Einträgen vertraut zu machen sowie eventuell in den Hilfequellen nachzuschlagen. Im Allgemeinen muss nichts verändert werden. Hilfreich ist das Hinzufügen der KDE Header zur Codekomplettierung, da Ihnen dann bei der Eingabe einer Klasse oder einer Funktion die Parameter und die verschiedenen Konstruktoren aufgelistet werden. Um diese hinzuzufügen müssen Sie die KDE Header-Dateien installiert haben. Wählen Sie unter C++ Besonderheiten den Reiter Codekomplettierung.
Öffnen Sie Persistenten Klassenspeicher hinzufügen.... Im Dialog wählen Sie den KDELIBS Import für persitenten Klassenspeicher aus. Im nächsten Fenster sollte ein Eintrag erscheinen, diesen wählen Sie aus und führen den Dialog zu Ende. Nun werden Ihnen bei allen KDE-Objekten die Klassenfunktionen angezeigt.
Anmerkung: Interessant ist sicher auch der Eintrag Einstellung für configure. Dort können Sie ihr Projekt an ihre Umgebung anpassen und z.B. als configure-Argument --with-qt-dir=/IHR QT-VERZEICHNIS angeben um ihre Anwendung in anderen Umgebungen als der Standardumgebung testen.
Im Projektmenü können Sie ihr Projekt auch schließen, ein anderes Projekt laden oder Projekte mit Hilfe eines Wizards aus externem Quellcode erstellen. Standardmäßig wird beim Laden von Kdevelop das letzte geöffnete Projekt erneut geöffnet.
[Bearbeiten] Anwendungen erstellen
Um ihre Anwendung zu testen müssen Sie diese natürlich erst erstellen. Dazu gibt es den Menüeintrag Erstellen. Sie können ihr ganzes Projekt mit Erstellen->Projekt erstellen oder mit F8 erstellen. Beim ersten Aufrufen dieses Befehls werden Sie dann gefragt, ob Sie autorun und Konsorten ausführen möchten. Dies müssen Sie beim ersten Kompilieren und bei jeder Änderung an den eingebundenen Headern machen, sonst kann die Anwendung in der Regel nicht erstellt werden. Wie sie nun feststellen werden, öffnet sich unten ein kleiner Displaybereich, der Ihnen aktuelle Informationen zur Erstellung ihrer Anwendung liefert. Dieser Bereich wird von verschiedenen Funktionen in Kdevelop genutzt, um Ihnen Statusinformationen anzuzeigen. So werden Sie beim Ausführen einer Anwendung mit den aktuellen stdout- und stderr-Nachrichten informiert. Sie werden später beim Gebrauch noch häufiger die Vorzüge dieser integrierten Liste zu schätzen lernen.
Sie können die Funktionen zur Erstellung und zum Ausführen ihrer Anwendung auch direkt in der Taskleiste erreichen:
Klicken Sie zum Beispiel auf das Zahnrad, um die bereits erstellte Anwendung zu starten. Es sollte sich folgende Anwendung öffnen:
[Bearbeiten] Seitliche Funktionsleisten
Die Leiste am linken Rand von Kdevelop gibt Ihnen schnellen Zugriff auf einige Funktionen von Kdevelop. So können Sie mit dem Neue Datei-Reiter verschiedene neue Dateien anlegen. Die Dateiliste zeigt Ihnen alle momentan geöffneten Dateien an und unterlegt die momentan bearbeitete Datei gelb. Der Reiter Datei-Selektor gibt Ihnen schnellen Zugriff zum Öffnen von Dateien. Lesezeichen zeigt Ihnen alle Lesezeichen, die Sie unter Lesezeichen im Menü setzen können an. Am rechten Rand finden Sie Dokumentation für den schnellen Zugriff auf alle Dokumentationen. Außerdem finden Sie dort einen Reiter für Quelltext-Schnipsel und Automake-Manager.
[Bearbeiten] Editor Einstellungen
Unter Einstellungen->Editor->Einstellungen finden Sie viele Einstellungen zu Ihrem in den Kdevelop-Einstellungen gewählten Editor. Wir verwenden Kate mit Kdevelop und empfehlen das auch weiter. Mehr zu diesen Einstellungsmöglichkeiten finden Sie unter Kate.
Tipp: Mit F11 oder Ansicht->Zeilennummern anzeigen können Sie sich unabhängig vom Editor die Codezeilennummerierung anzeigen lassen.
[Bearbeiten] Sonstiges
Wir haben die meisten Einstellungen hier gar nicht angesprochen und wollen das auch nicht tun, da dies sonst den Rahmen dieses Buches sprengen würde. Falls Sie Lust haben, noch mehr über Kdevelop zu erfahren, dann sollten Sie in den bereits erwähnten Quellen stöbern, oder einfach selbst ein wenig experimentieren. Wir werden in diesem Buch in geeignetem Kontext noch einige Funktionen von Kdevelop kennen lernen.
[Bearbeiten] Kate
Kate ist ein mächtiger Editor von KDE und die standardmäßige Editor-Komponente von KDevelop. Kate hat für einen Texteditor schon sehr ausgefeilte Features, wie ein eigenes Projektmanagement. Sollten Sie Kate bereits kennen, dann können Sie die ersten Beispiele auch mit Kate erstellen. Dazu müssen Sie aber viele Schritte, die KDevelop für Sie erledigt, selbst ausführen. Zum Beispiel erstellt Kate keine Makefiles und hat auch keinen eingebauten Debugger.
[Bearbeiten] Einstellungen
Die Kate-Einstellungen für den Editor sind identisch mit den Einstellungen für KDevelop, wenn Sie Kate als Editorkomponente verwenden (Standard). Auf die Einstellungen Programm gehen wir hier nicht näher ein und verweisen auf die Kate-Dokumentation.
Eigentlich sind die Standardeinstellungen für den Editor gut gewählt und bedürfen nur selten Anpassungen. Wir verwenden die Standardeinstellungen.
Tipp: Nützlich ist die Einstellung Bearbeiten->Automatische Klammern, die beim Öffnen einer Klammer immer automatisch die schließende Klammer anhängt.
[Bearbeiten] Qt-Designer
Der Qt-Designer ist ein Tool von Trolltech und ist daher nicht so gut in KDE integriert wie KDevelop und Kate. Zum momentanen Zeitpunkt stellt der Qt-Designer die einzige stabile Umgebung für die grafische Oberflächengestaltung dar. Dies wird sich aber mit einem ausgereiften Release von KFormDesigner ändern. Der Qt-Designer ist auf allen Plattformen, auf die Qt portiert wurde, verfügbar und somit für die Qt-Entwicklung typisch. Neben den grafischen Gestaltungsmöglichkeiten enthält der Qt-Designer auch einen Editor um die Quellcodedateien Editieren zu können. Da dieser nicht für die KDE-Entwicklung ausgerichtet ist, nicht von den KDE-Entwicklern integriert ist und der Qt-Designer standardmäßig Qt- und keine KDE-Widgets verwendet, sollte man in der Regel von diesem Editor absehen. Dies soll nicht heißen, dass der Editor schlecht ist oder dass er nicht zu KDE passt, er ist lediglich nicht so gut integriert wie seine beiden Konkurrenten. Deshalb wird er in diesem Buch auch nicht verwendet.
[Bearbeiten] Sonstige Quellen für die Entwicklung
Die wichtigsten Artikel zur KDE-Entwicklung finden Sie unter http://developer.kde.org/documentation. Darunter sind auch das bereits erwähnte Tutorial für KDevelop und ein Buch für KDE 2 Entwicklung. Das Buch C++ GUI Programming with QT 3 ist unter http://www.informit.com/title/0131240722# als PDF download erhältlich.
[Bearbeiten] Qt/KDE-Anwendungs Stil
Qt- und KDE-Anwendungen verwenden im Prinzip ganz einfaches ANSI C++. Dieses wird durch Qt mit einigen Macros erweitert und bietet so z.B. eine zusätzliche Technologie für Signals und Slots an. Ansonsten werden Anwendungen mit einfachen Methoden der Objektorientierung, jedes GUI-Element ist ein Objekt, in C++ erstellt. Templates oder etwa komplexe Streambearbeitung werden für die Oberflächenerstellung in Qt oder KDE nicht benötigt. Dies macht es möglich, dass Qt und KDE-Oberflächen sehr schnell und einfach erstellt werden können.
[Bearbeiten] Einbettung in Standard C++
Möchte man eine eigene Anwendung mit Qt oder KDE erstellen, so setzt man sich in der Regel zunächst ein Widget aus verschiedenen Standardwidgets zusammen und erhält so die gewünschte Oberfläche. Dieses Widget repräsentiert dann ein Objekt und wird als solches in die eigentliche Anwendung eingebunden. Um dem Widget Funktionalität hinzuzufügen, muss man die verschiedenen Objektfunktionen bearbeiten. In der eigentlichen main-Funktion von C++ ruft man dann nur noch den Konstruktor für das erstellte Widget auf und voilà, die Oberfläche ist eingebunden. Bevor man dieses jedoch einbinden kann, muss man allerdings zuerst noch ein QApplication-Objekt bei Qt-Anwendungen oder ein KApplication-Objekt bei KDE-Anwendungen erzeugen. Angenommen unsere erstellte Widgetklasse heißt KMyWidget, dann sieht die main-Funktion beispielsweise so aus:
#include <kapplication.h>
#include "kmyapplication.h"
int main(int argc, char **argv){
// Erstellen des KApplication Objekts
KApplication kapp;
// erstellen des Widget-Objekts
KMyWidget *kmywidget = new KMyWidget();
// setzen des Widgets als Hauptwidgets für die Anwendung
kapp->setMainWidget(kmywidget);
// wir wollen das Widget ja auch sehen ;-)
kmywidget->show();
// hier wird das Objekt erst "ausgeführt"
return kapp.exec();
}
Hier fehlt noch die Behandlung der Kommandozeilenargumente, aber im Grunde genommen erzeugt er eine vollständige KDE-Anwendung mit einem KMyWidget-Objekt als GUI.
[Bearbeiten] Signale und Slots
Qt implementiert, wie bereits erwähnt, sogenannte Signals und Slots. Diese Technologie ermöglicht das einfache Zusammenstecken von Funktionen. So wird beim Aufruf von button->clicked() z.B. app->close() aufgerufen. Diese Technologie wird mit Hilfe von Macros erstellt und ist damit ANSI C++ kompatibel. Auf diese Weise ist es ganz einfach möglich beliebige Ereignisse mit beliebigen Funktionen (Slots) zu verknüpfen. Zu beachten ist, dass die Signalfunktion mindestens genausoviele und gleichartige Parameter haben muss wie die Slotfunktion. Beispiel für den Aufruf:
connect(SIGNALOBJEKT, SIGNAL(signalFunction()), SLOTOBJEKT, SLOT(slotFunction()));
Um diese Schreibweise nutzen zu können, muss man am Anfang seiner Klassenspezifikation das Q_OBJECT Macro einbinden...
class MyWidget : public QWidget
{
Q_OBJECT
...
};
...und dann die entsprechenden Signals und Slots erstellen:
class MyWidget : public QWidget
{
Q_OBJECT
signals:
void signal();
public slots:
void slot();
};
Um diese beiden Signale dann zu verbinden, würde man dann folgende Zeile für zwei Widgets widget1 und widget2 verwenden:
connect(widget1, SIGNAL(signal()), widget2, SLOT(slot()));
Achtung: Sollte ein Objekt, welches einen Slot zur Verfügung stellt, vorzeitig zerstört werden, treten Fehler auf!
[Bearbeiten] Typische Qt/KDE-Objekte und deren Hierarchie
Die Qt-Objekt-Hierarchie beginnt mit der QObject-Klasse. Sie stellt allen Qt- und KDE-Klassen ihre Funktionen zur Verfügung. Auch die QApplication-Klasse, von der KApplication abgeleitet ist, ist von QObject abgeleitet. QWidget ist die Basisklasse für jedes Widget, alle Qt- und KDE-Widgets sind von dieser Klasse abgeleitet. Einige wichtige Basisklassen sind außerdem QString für Strings, in welche auch einfaches HTML eingebettet werden kann.
[Bearbeiten] Internationalisierung in KDE
KDE verwendet eigene Funktionen zur Internationalisierung, die sich von denen der Qt-Bibliothek unterscheiden. Um einen String, z.B. in einem QString-Objekt, für die Internationalisierung zugänglich zu machen, sollten Sie die Funktion i18n("Your English String.") verwenden.
QString* i18n(const char *string)
Diese Technologie ermöglicht es den KDE-Übersetzern oder Ihnen, je nach dem ob Ihre Anwendung in KDE CVS ist oder nicht, Ihre Strings in viele verschiedene Sprachen zu übersetzen, so dass diese international einsetzbar sind. Sie können die i18n-Funktion auch mit zwei Strings als Argumente aufrufen, wobei dann der erste String eine Beschreibung für den Zweiten liefert. Nur der Zweite wird als QString zurückgegeben. Dies sollten Sie möglichst häufig tun, um später eine eindeutige Übersetzung leichter zu gestalten! Bitte beachten Sie bei der Gestaltung ihrer Oberfläche, dass die übersetzten Strings eventuell deutlich länger sein können als z.B. in Englisch. Möchten Sie variable Werte, also z.B. Variablen oder definierte Konstanten, in ihren String einfügen, dann verwenden Sie bitte folgendes Schema zum Funktionsaufruf, da dieses den Kontext des Satzes wahrt:
QString msg=i18n("Do you want to replace %1 with %2?").arg(oldFile).arg(newFile)
Bitte verwenden Sie immer UTF-8 Funktionen um die Buchstaben aus einem QString in einen char*-String zu verwandeln, also QString::utf8(). Um Dateinamen aus einem QFile-Objekt zu extrahieren verwenden Sie bitte QCString QFile::encodeName ( const QString & fileName ) oder um einen String in einen QFile-Dateinamen zu wandeln QString QFile::decodeName ( const QCString & localFileName ).
Sollte sich ihre Anwendung bereits in KDE-CVS befinden, dann wird die Übersetzung von den KDE-Übersetzern ausgeführt, andernfalls müssen Sie das selbst tun (bzw. tun lassen). Sie benötigen die beiden Programme gettext und extractrc (aus dem Paket kdesdk) in ihrem Pfad. Wenn Sie dann
make -f admin/Makefile.common package-messages
in dem Hauptordner ihrer Anwendung aufrufen, wird ein Unterordner po erstellt. Dort können Sie für jede Übersetzung eine Datei in dem Format <languagecode>.po anlegen. Sollte ihr Projekt zu einem größeren Projekt gehören und die Übersetzung aus diesem verwenden, dann rufen Sie am Anfang der main-Funktion einfach folgenden Befehl auf,
KLocale::setMainCatalogue("<HAUPTANWENDUNG>");
mit <HAUPTANWENDUNG> als Name für das übergeordnete Projekt.
[Bearbeiten] Lokalisierung
Die Lokalisierung beschäftigt sich anders als die Internationalisierung mit den lokalen Formaten innerhalb eines Programms, wie z.B. mit dem Datum oder Geldwerten. Sie befindet sich in der Klasse KLocale. Hauptsächlich beschäftigt sich die Lokalisierung mit der regionsbezogenen Darstellung von Zahlen. So werden die Dezimalen im englischsprachigen Raum durch ein einen "." im Deutschen durch ein "," abgetrennt. Daher sollten Sie anstatt den nummerischen String direkt auszugeben die i10n-Funktionen verwenden. Folgende Funktionen dienen der Ausgabe:
QString formatMoney(double num, const QString & currency, int digits=-1) // bzw. QString formatMoney(const QString & numStr) QString formatNumber(double num, int precision=-1) // bzw. QString formatNumber(const QString & numStr)
Um Benutzereingaben einzulesen verwendet man:
double readNumber( const QString & numStr, bool * ok = 0 ) // bei ok===false ist der String nicht nummerisch readMoney( const QString & numStr, bool * ok = 0 )
Hinweis: Genauere Informationen finden Sie in den Dokumentationen.
[Bearbeiten] Kalender und Zeitangaben
Um Zeit- oder Datumsausgaben zu erzeugen verwenden Sie folgende Funktionen:
QString formatDate(const QDate & pDate, bool shortFormat=false) QString formatTime(const QTime & pTime, bool includeSecs=false) QString formatDateTime(const QDateTime &pDateTime, bool shortFormat=true, bool includeSecs=false)
Auch andere Kalenderdaten unterscheiden sich weltweit. Hier sind weniger die schon genannten Aus- und Eingabefunktionen von Datums- und Zeitangaben, als viel mehr die feinen lokalen Unterschiede im Kalender gemeint. Beispiele sind dafür Problemstellungen wie
- der erste Tag der Woche-> int weekStartDay()
- die Anzahl der Monate -> int monthsInYear(const QDate & date)
- "Ära"-basierte Kalender oder
- das 24h / 12h pm/am Zeitformat -> bool use12Clock()
[Bearbeiten] Einfache dialogbasierte Anwendungen
Eine einfache dialogbasierte Anwendung ist eine Anwendung die einen kleinen Dialog verwendet um dem Nutzer eine bestimmte, in der Regel einfache, Funktionalität zugänglich zu machen. Sie hat eine einfache genau definierte Aufgabe und versucht auch nur diese zu lösen. Wir werden mit einem einfachen Hello World anfangen und uns dann langsam mit verschiedenen einfachen Widgets vertraut machen. Am Ende möchten wir ein kleines Spiel Zahlenraten implementieren.
[Bearbeiten] Erstellung einfacher Widgets
Zunächst wollen wir einige einfache Widgets erstellen um mit dem Programmieren für KDE vertraut zu werden. Wir werden dabei natürlich keine grandiosen Anwendungen erstellen, aber dafür sehr gut mit dem Basiswissen vertraut machen.
[Bearbeiten] Hello World
Quelldateien:
Die "Hello World"-Anwendung haben wir bereits im Kapitel 2.6.1.4 Anwendungen erstellen kennengelernt. Wie diese Anwendung genau funktioniert werden wir jetzt genauer untersuchen.
[Bearbeiten] Dateistruktur
Nachdem Sie das Projekt mit KDevelop angelegt haben, finden Sie im Unterordner src des Projekts die für die Entwicklung eigentlich relevanten Dateien. Die meisten anderen Dateien dienen der Erstellung der Makefiles. Im Datei-Selektor an der linken Randleiste von KDevelop können Sie jederzeit Dateien aus diesem Ordner öffnen. Die Datei khello.cpp aus diesem Ordner ist bereits geöffnet. Zusätzlich benötigen wir noch khello.h aus diesem Ordner.
[Bearbeiten] Klassenstruktur
In khello.h erkennt man, dass sich die khello-Klasse, die die khello-Anwendung darstellt, von der KMainWindow-Klasse ableitet.
class khello : public KMainWindow
In khello.cpp wird der Konstruktor mit dem Konstruktor der Basisklasse aufgerufen:
khello::khello(): KMainWindow( 0, "khello" )
Um herauszufinden wie man die KMainWindow-Klasse konstruiert, öffnen wir mit einem Rechtsklick ein Dropdownmenü und wählen Dokumentationen suchen. Nach einem kurzen Moment öffnet sich auf der rechten Seite im Reiter Dokumentation eine Liste mit verfügbaren Dokumenten. Wir wählen nun Index->KMainWindow. Es erscheint ein Dokument zur Ansicht, das Ihnen eine ganze Menge Informationen zur KMainWindow-Klasse bereitstellt. Der erste Eintrag zum Konstruktor verrät uns, dass das erste Argument, die 0, für das Elternfenster steht und das zweite Argument den Namen angibt. Die 0 bedeutet, dass das Fenster kein Parentfenster hat, also selbst das oberste Parentfenster ist und somit die Kernoberfläche präsentiert.
Anmerkung: Wenn Sie am Anfang für dieses Projekt einen persistenten Klassenspeicher angelegt haben, dann erscheinen die Konstruktoren bereits beim Eingeben des Klassennamens.
[Bearbeiten] Das khello-Widget
Mit Hilfe des Konstruktors von khello wird das eigentliche Hauptfenster erzeugt. Dabei gibt es in der khello.cpp zunächst nur zwei Einträge. Die Einbindung der khelloui.rc mit Hilfe von setXMLFile() dient zur Darstellung der Menüstruktur der Anwendung, dazu später mehr, und das Erzeugen eines QLabel-Objekts. Die Dokumentation sagt uns, dass der QLabel-Konstruktur hier mit den Argumenten Text, Elternwidget und Name aufgerufen wurde und demnach ein Pointer auf ein QLabel mit dem Labeltext Hello World!, dem Namen hello world und dem Elternwidget this erzeugt wird. Dieses QLabel erzeugt also den Schriftzug Hello World!, den wir in der Anwendung sehen.
QLabel *hello = new QLabel( "Hello World", this, "hello label" );
[Bearbeiten] Layoutmanagement
Als nächstes möchten wir andere Widgets hinzufügen, da sich kaum eine Anwendung mit einem QLabel als Hauptfenster zufriedenstellen wird. Nun stellt sich die Frage, wie man dieses Widget hinzufügt. Fügen wir einfach nur ein weiteres QLabel oder ein anderes Widget hinzu, wo wird dieses dann angezeigt? Über, unter, rechts oder links des anderen QLabels? Wenn Sie es ausprobieren, werden Sie feststellen, dass nur das zweite QLabel angezeigt wird, da das andere von ihm einfach überdeckt wird. Genau für dieses Problem benötigt man ein Layoutmanagement, das alle Widgets in der gewünschten Reihenfolge anordnet. Außerdem sorgt das so geschaffene Layout bei Größenänderungen des Fenster automatisch dafür, dass die Widgets sich den vorhanden Raum möglichst ideal aufteilen. Um die Anwendung zu erweitern erstellen wir also zunächst ein Layout. Dazu gibt es verschiedene Möglichkeiten:
#include <qhbox.h> // Header für QHBox <qvbox.h>->QVBox QHBox ( QWidget * parent = 0, const char * name = 0, WFlags f = 0 ) // eine horizontale Box QVBox ( QWidget * parent = 0, const char * name = 0, WFlags f = 0 ) // eine vertikale Box QGrid ( int n, QWidget * parent = 0, const char * name = 0, WFlags f = 0 ) // ein Raster (Grid) // n steht hier für die Spaltenzahl
Bei diesen Klassen genügt es die Layoutklasse als Elternobjekt bei der Konstruktion anzugeben. Dadurch wird das Widget automatisch in der entsprechenden Struktur angeordnet.
Möchte man ein ausgefeilteres Management verwenden so verwendet man die entsprechenden Layout-Klassen. Diese müssen sowohl als Elternobjekt angegeben sein, als auch explizit durch den Aufruf der Funktion LayoutKlasse->addWidget(QWidget * widget,...) hinzugefügt werden. Diese Manager werden wie folgt konstruiert:
#include <qlayout.h> // der Header für diese Layoutklassen QGridLayout ( QWidget * parent, int nRows = 1, int nCols = 1, int margin = 0, int space = -1, const char * name = 0 ) QBoxLayout ( QWidget * parent, Direction d, int margin = 0, int spacing = -1, const char * name = 0 ) //oder die entsprechenden abgeleiteten horizontalen und vertikalen Klassen: QHBoxLayout ( QWidget * parent, int margin = 0, int spacing = -1, const char * name = 0 ) QVBoxLayout ( QWidget * parent, int margin = 0, int spacing = -1, const char * name = 0 )
Wir wollen nun ein einfaches QHBoxLayout verwenden um 2 QLabels in unserem khello-Widget anzuordnen und fügen daher in den khello-Konstruktur folgendes ein:
#include <qlayout.h> // der Header für die Layout-Boxen
...
QHBoxLayout *qhboxlayout=new QHBoxLayout(this); // erstellt ein Layout
QLabel *qhello = new QLabel( "Hello World", this, "hello label" ); // erstes Label
QLabel *qbye = new QLabel("Bye World!", this, "bye label"); // zweites Label
qhboxlayout->addWidget(qhello); //wir fügen die Labels hinzu
qhboxlayout->addWidget(qbye);
Anmerkung: Aus irgendwelchen Gründen hat das nicht mit einer QHBox funktioniert!?! Wenn jemand herausfindet warum das so ist, dann sollte er die entsprechende Information hier hinzufügen!
[Bearbeiten] Eingabefelder
Zu den Eingabefeldern zählen neben den Texteingabefeldern, auch Schieber, Spinboxen oder jedes andere Widget, das irgendeine Benutzereingabe entgegennimmt. Dabei ist darauf zu achten, dass das Widget immer sowohl den Usability-Anforderungen als auch dem Zweck der Eingabe am nähesten kommt.
[Bearbeiten] Einzeilige Texteingabefelder
Als einzeiliges Eingabefeld dient die QLineEdit-Klasse. Sie wird ganz einfach erzeugt:
#include <qlineedit.h> // Header QLineEdit ( QWidget * parent, const char * name = 0 ) // erzeugt ein QLineEdit-Objekt
Wir ersetzen das zweite QLabel einfach durch ein QLineEdit in der Form von
QVBoxLayout *qvboxlayout=new QVBoxLayout(this); QLabel *qinputlabel = new QLabel( "Eingabe:", this, "line edit label" ); QLineEdit *qlineedit = new QLineEdit(this, "line edit"); qvboxlayout->addWidget(qinputlabel); qvboxlayout->addWidget(qlineedit);
und erhalten eine Anwendung mit einem QLabel und einer einzeiligen Eingabebox.
[Bearbeiten] Infoboxen
[Bearbeiten] About-Boxen
[Bearbeiten] Verschiedene Basiswidgets
[Bearbeiten] Öffnen weiterer Fenster
[Bearbeiten] Zahlenraten
[Bearbeiten] Grafische Widgeterstellung
[Bearbeiten] Qt-Designer
[Bearbeiten] KFormDesigner
[Bearbeiten] Integration in KDevelop
[Bearbeiten] Komplexere Widgets
[Bearbeiten] Multimedia Anwendungen
[Bearbeiten] KDE Multimedia Backends
[Bearbeiten] arts
[Bearbeiten] gstreamer
[Bearbeiten] Andere Backends
[Bearbeiten] Ein Audio-Player
[Bearbeiten] Konfiguration in KDE
...
[Bearbeiten] Ein Video-Player
...
[Bearbeiten] Einfache Spiele
[Bearbeiten] 2D Ping-Pong Spiel
[Bearbeiten] Spielablauf
[Bearbeiten] Programmaufbau
[Bearbeiten] Grafiken
[Bearbeiten] OpenGL Anbindungen
[Bearbeiten] Einfache dokumentbasierte Anwendungen
[Bearbeiten] Textbasierte Anwendungen
[Bearbeiten] Ein Texteditor
[Bearbeiten] Integration von fremden KParts
[Bearbeiten] Ein einfacher Webbrowser
[Bearbeiten] Grafikanwendungen
[Bearbeiten] Ein Paintprogramm
...
[Bearbeiten] Komplexe dokumentbasierte Anwendungen
[Bearbeiten] Einbindung von KIO-Slaves
[Bearbeiten] Ein einfacher Mail-Client
[Bearbeiten] Erstellung von KParts
[Bearbeiten] Ein KPart für Bittorrent Dateien
[Bearbeiten] Komplexe Spiele
[Bearbeiten] Einbindung eines 3D-Spiels
...
[Bearbeiten] Erweiterte Funktionen
[Bearbeiten] DCOP
[Bearbeiten] Audio-Player Anbindung
[Bearbeiten] Drag and Drop
[Bearbeiten] Paintprogramm
...
[Bearbeiten] Andere Anwendungen
[Bearbeiten] Kicker-Applets
[Bearbeiten] OpenGL Animation
[Bearbeiten] Kontrollzentrummodul
[Bearbeiten] OpenGL Information
[Bearbeiten] Kontactmodul
[Bearbeiten] Mail-Client Integration
[Bearbeiten] KDE 3D - Ein Bildschirmschoner
...
[Bearbeiten] KWin-Dekorationen
...
[Bearbeiten] KIO-Slaves
...
[Bearbeiten] Appendix
[Bearbeiten] Die Qt-Bibliothek
[Bearbeiten] Plattformen für KDE
[Bearbeiten] KDE auf Linux
[Bearbeiten] KDE auf FreeBSD, NetBSD und OpenBSD
[Bearbeiten] KDE auf MacOS
[Bearbeiten] KDE auf Windows
Es gibt verschiedene Projekte, die sich mit der Portierung von KDE bzw. KDE-Programmen auf Windows beschäftigen. Das Problem bei der Portierung ist, dass die Qt unter Windows bis zur Version 4 nicht unter der GPL stand. Mit der Version 4 hat sich dies nun geändert, so dass zu erwarten ist, dass mit KDE 4 auch KDE-Programme für Windows erhältlich sind. Das für und wider der Unterstützung von Windows wird in einem Artikel erörtert.
[Bearbeiten] KDE auf Cygwin
Das Projekt KDE on Cygwin dient als Übergangslösung für diejenigen, die unter Windows die KDE Programme vermissen. Diese Portierung verwendet die X11 Version von der Qt (welche unter der GPL steht) und benötigt somit einen Laufenden X11 Server auf dem Rechner, was für das verwenden einiger Programme nicht gerade komfortabel ist.
