Weiter Zurück Inhaltsverzeichnis

### 3. KDE Applikationsklassen

Die KDE-Bibliotheken, in Verbindung mit der Qt-Bibliothek, bieten Entwicklern den kompletten Rahmen zur Anwendungsentwicklung. Da KDE auf Unix Betriebssysteme zugeschnitten ist, die das X11-System nuzen, könnte man denken, man müsse Unix und X11 beherrschen - da die Bibliotheken dieses komplexe Grafik-Subsystem kapseln, muß man in den meißten Klassen hierüber nichts wissen. Wenn man mit Qt bereits vertraut ist, wird KDE keine großen Unterschiede bezüglich Klassen und Widgets aufweisen.

Anfänger haben jedoch oft Probleme mit:

- Anwendungsentwicklung mit GUI-Komponenten
- Aufteilung von Anwendungen
- Erstellung von Widgets
- Inter-widget Kommunikation (Signals und slots)

Das Folgende wird Ihnen helfen zu verstehen, wo Sie im Allgemeinen Klassen, wie sie in KDE-Anwendungen benutzt werden, finden können, einschließlich der entsprechenden Ersetzungen der Qt-Klassen, für diejenigen, die mit Qt vertraut sind und keinen Gebrauch von KDE-Bibliotheken gemacht haben. Da sind die Anwendungsobjekte, ihr Verhalten und ihre Erstellung. Sie werden etwas erfahren über:

- die am häufigsten benötigen Objekte einer KDE-Anwendung
- den Unterschied zwischen Ihrem Code und der Rahmenanwendung
- KDE Anwendungsklassen, die die Window Manager-Kommunikation kapseln
- die Klasse `QWidget`, von denen alle GUI-Komponenten abgeleitet sind
- grafische Objekte
- die Zwischenablage

Mehr Informationen über KDE-Anwendungen können in den folgenden Sektionen nachgeschlagen werden:

- The KDevelop Programming Handbook
- KDE Application Tutorials Handbook

Zu Informationen über Qt-Anwendungsdesign, schauen Sie bitte in die Qt-Onlinereferenz.

### 3.1 Die Anwendungs-Instanz

Im Allgemeinen wird eine KDE-Anwendung begonnen, indem man eine Instanz (und nur eine!) der Klasse `KApplication`, die von der `kdecore`-Bibliothek bereitgestellt wird, erstellt. Die Klasse `KApplication` ist abgeleitet von der entsprechenden Qt-Klasse `QApplication`.

Was genau passiert ist, das `QApplication` die Ereigniswarteschlange der Anwendung verwaltet, das bedeutet, sie wertet Ereignisse aus dem darunter liegenden Window-System aus und sendet sie an ihre Kindprozesse, wie z.B. Maus-Bewegungen oder Tastaturereignisse. Dies ist auch der Grund, warum nur eine Instanz von `KApplication` verwendet werden darf und warum dies das Erste ist, was die `main()`-Funktion ausführt.

Die `KApplication`-Klasse erweitert die Qt-Klasse mit zusätzlichen Funktionen für eine Anwendung mit einem gleichartigem Aussehen, die sich in andere Desktop-Komponenten integriert und die daher in ihrem Verhalten von Steuerungsanwendungen (in KDE im Allgemeinen Bestandteil des KDE Kontrollzentrums) beeinflusst werden kann, wie z.B. Tastaturkürzelkonfiguration und GUI-Stil.

Wie in der Qt-Klasse, so bietet die `KApplication`-Klasse eine statische Funktion um auf das Anwendungsobjekt innerhalb der Anwendung zugreifen zu können, `KApplication::getKApplication()`. Diese Vorgehensweise löst das Problem, den Zeiger an das Anwendungsobject weitergeben zu müssen. Außerdem stellt die Include-Datei `kapp.h` ein Makro zur Verfügung, welches anstelle der statischen Funktion benutzt werden kann, `kapp`. Immer wenn Sie auf das Anwendungsobjekt zugreifen müssen, benutzen Sie bitte dieses Makro.

> In KDE2 kann man das Anwendungsobjekt mit mit `KApplication::kApplication()` erhalten.

Das `KApplication`-Object selbst bietet eine Anzahl von Instanzen, wie sie gewöhnlich in KDE-Anwendungen verwendet werden und bietet dem Programmierer hierauf Zugriff durch Funktionen. Sie werden intensiven Gebrauch hiervon machen, da hierdurch die Erstellung eigener Instanzen umgangen wird. Diese Objekte werden für folgende Zwecke verwendet:

KConfig

  , ein Konfigurations-Objekt, welches zum Lesen und Schreiben von Konfigurationsinformationen in einer Ressource-Datei verwendet wird. Benutzen Sie bitte die zugehörigen Methoden von `KConfigBase` um Werte zu lesen und zu schreiben. Das Konfigurationsobjekt erhalten Sie durch `kapp->getConfig()`

  > In KDE2 benutzen Sie bitte `KGlobal::config()` um das Konfigurationsobjekt zu erhalten

  , die Session Management Konfiguration durch `kapp->getSessionConfig()`

KIconLoader

  , ein Objekt welches Icons in `QPixmap`s unter Benutzung des KDE-Dateisystems lädt. Hierdurch wird verhindert, daß nach einer Bilddatei im Dateisystem gesucht werden muß, denn es muß nur der Dateiname angegeben werden. Benutzen Sie das Makro `Icon("icon.xpm")` um ein Icon auf einfache Art und Weise zu laden. Die Iconloader-Instanz kann mittels `kapp->getIconLoader()` erhalten werden

  > KDE 2 nutzt `KGlobal::iconLoader()` um auf die Iconloader-Instanz zuzugreifen

KLocale

  ein Objekt, welches die aktuellen Spracheinstellungen zurück gibt. Das sorgt dafür, daß die Anwendung in der Sprache auf dem Desktop dargestellt werden, die der Benutzer global eingestellt hat. Benutzen Sie das Makro `klocale` um auf das locale-Objekt zuzugreifen.Auf die klocale-Intanz kann durch `kapp->getLocale()` zugegriffen werden (wie es das Makro klocale bereits tut)

  > Auch dies wird in KDE2 durch eine statische Methode `KGlobal::locale()`ersetzt.

KCharsets

  das Zeichensatzobjekt, z.Zt. global durch den Benutzer eingestellt. Hierdurch werden Tastaturereignisse in den korrekten Zeichensatz übersetzt. Die Zeichensatzinstant kann mit `kapp->getCharsets()` ermittelt werden.

  > In KDE2 ersetzt durch `KGlobal::charsets()`.

Zusätzlich bietet Ihnen die KApplication-Klasse alle benötigten Methoden um auf Dateien gemäß dem KDE-Filesystemstandard zuzugreifen. Dies verhindert Probleme die durch festes Einprogrammieren von Pfaden entstehen können (siehe Das KDevelop Programmierhandbuch für weitere Informationen zum KDE-FSS). Die Klasse stellt außerdem benötigte Zugrifssmechanismen für Anwendungs-Icons und Mini-Icons, aktuelle KDE-Schriften und Unterstützung zum Sitzungsmanagement.

Um die Zwischenablage zu nutzen, bietet die `QApplication`-Klasse ein Zwischenablagenobjekt, `QApplication::clipboard()`, welches für den Austausch von Text und Bilddaten zwischen Anwendungen genutzt werden kann (siehe `QClipboard`).

Internationalisierung ist ein weiterer Schlüsselbegriff für KDE-Anwendungen. Diese wird mit dem `KLocale`-Objekt wie bereits erwähnt unterstützt und wird durch das Makro `i18n()` aus `kapp.h` schon verwendet.

Dies ist eine Abkürzung für den Aufruf des KApplication-Zeigers auf den KLocale-Zeiger und wird von gettext ausgelesen um alle durch das Makro eingeschlossenen Zeichenketten in eine Anwendungsspezifische Nachrichtendatei zu schreiben, welches dann übersetzt werden kann.

Schlußendlich erzeugt `KApplication` ein Hilfe-Menü, welches in eine Menüleiste eingefügt werden kann, einen vordefinierten (an- und ausschaltbaren) Hinweisdialog und den "Über"-Dialog Ihrer Anwendung.

Die folgenden Ratschläge sollten im Umgang mit der `KApplication`-Klasse beherzigt werden:

- erzeugen Sie das `KApplication`-Objekt am Anfang der `main()`-Funktion
- führen Sie die Anwendung mit `exec()` am Ende der `main()`-Funktion aus
- beenden Sie die Anwendung durch Aufruf der `quit()` Slot-Funktion.

Bei Verwendung von `KApplication` können Sie die folgenden Ereignis-Signale auswerten:

- kdisplayPaletteChanged()
- kdisplayStyleChanged()
- kdisplayFontChanged()
- appearanceChanged()
- saveYourself()
- shutDown()

Da die Widgets Ihrer Anwendung diese Signale empfangen, aktualisieren sie sich normalerweise selbst. Die wichtigsten Signale für Sie sind in den meissten Fällen `saveYourself()` und `shutDown()` (wobei `KTMainWindow` bereits `saveYourself()` abfängt und `KTMainWindow::saveData()` aufruft).

Sie werden mittels der entsprechenden, statischen Methoden von `kwm.h` in der Lage sein, mit dem KWM Fenstermanager zu kommunizieren.

### 3.2 Auswertung der Kommandozeilenargumente

Eine Anwendung soll normalerweise in der Lage sein, Kommandozeilenargumente auszuwerten. Diese werden durch den Benutzer angegeben, entweder beim Start von der Kommandozeile aus oder innerhalb einer kdelnk-Datei. Kommandozeilenargumente werden oft verwendet um die Anwendung mit einer bestimmten Datei zu starten. Dies erlaubt auch Datei-Managern Ihre Anwendung korrekt aufzurufen und die Mime-Typ-Mechanismen in KDE zu verwenden. Um Kommandozeilenargumente verwenden zu können, sollte die `main()`-Funktion mit der folgenden Deklaration konstruiert werden:

> `

>     int main(int argc(), const char* argv[])

> `

Hierbei enthält `argc()` die Anzahl der übergebenen Optionen und das Array `argv[]` die Optionen in Textform. Wie auch der Konstruktor von `QApplication`, wird auch derjenige von `KApplication` zuerst ausgeführt. Er wertet alle Optionen aus, die ihn betreffen (z.B. Geometrie- oder Display-Optionen) und entfernt diese aus dem Array, so daß sie nicht mehr ausgelesen werden können, wenn die `KApplication`-Instanz deklariert ist:

(aus der Qt 1.42 Online-Referenz zu `QApplication`)

- -nograb, weist Qt an weder Maus noch Tastatur auszuwerten. (Wenn Sie Ihr Programm in einem Debugger, ist diese Option automatisch aktiviert).
- -sync (nur unter X11), schaltet den synchronen Modus für Debug-Zwecke ein.
- -display Anzeige, setzt das zu verwendende X-Display (standard ist $DISPLAY).
- -geometry Geometrie, setzt die Abmessungen des Hauptfensters.
- -fn oder -font Schriftart, definiert die Anwendungsschriftart.
- -bg oder -background color, setzt die standard Hintergrundfarbe und die Anwendungspalette (Hell- und Dunkelschattierungen werden berechnet).
- -fg oder -foreground color, setzt die standard Vordergrundfarbe.
- -name name, setzt den Anwendungsnamen.
- -title title, setzt den Anwendungstitel (caption).
- -style= style, setzt den GUI-Stil der Anwendung. Mögliche Werte sind Motif und Windows. Standardmäßig wird die globale Einstellung von KDE gewählt.
- -visual TrueColor, zwingt die Anwendunng, TrueColor auf einem 8-bit Display zu verwenden.
- -ncols count, limitiert die Anzahl an Farben im Farbraum auf einem 8-Bit-Display, wenn die Anwendung die QApplication::ManyColor Spezifikation benutzt. Wenn count = 216 ist, wird ein 6x6x6-Farbraum benutzt (z.B. 6 Rot-Werte, 6 Grün-Werte und 6 Blau-Werte); bei 108 wird ein 3x3x3 und für andere Werte ein Farbraum, der proportional zu einem 2x3x1-Farbraum ist, benutzt.
- -cmap läßt die Anwendung eine eigene Farbtabelle auf einem 8-Bit-Display verwenden.

Anschließend wertet `KApplication` Optionen aus, deren Werte innerhalb einer `.kdelnk`-Datei gesetzt werden können. Üblicherweise enthalten diese Link-Dateien internationalisierte Beschreibungen und den Anwendungsnamen, wie auch andere Werte wie den Namen des Icons und des Mini-Icons. Die Kommandozeilenargumente um diese Werte zu benutzen lautet:

> `

>     foo %i %m -caption \"%c\"

> `

Hierdurch wird die Anwendung mit der Option -icon irgendwas.xpm für %i und -miniicon for %m gestartet. Der Anwendungstitel kann mit -caption %c gesetzt werden. Die Klasse `KApplication` bietet zudem entsprechende Methoden die Rückgabewerte zu den Kommandozeilen argumenten zurückgeben.

Wenn Sie die Kommandozeilenargumente selbst auswerten möchten, können Sie dies direkt nach der Deklaration des Anwendungsobjektes tun um die o.g. Werte in der `main()`-Funktion auszuschließen. In der Anwendung selbst (z.B. der Hauptfensterklasse), stellt `QApplication` die Methoden `argc()` und `argv()` um beliebige andere Optionen auszuwerten. Auf diese kann über die Argumentnummer zugegriffen werden, wobei das Argument `kapp->argv()[0]` der Anwendungsname ist; Auf alle folgenden Argumente kann man über `kapp->argv()[nummer]` zugreifen.

> KDE 2 enthält eine zusätzliche Klasse, `KCmdLineArgs`, um zusätzliche Kommandozeilenargumente zu verarbeiten, die bereits von KDevelop für KDE 2 Projekte verwendet wird.

#### Comment

Die `KApplication`-Klasse verwendet verschiedene Methoden um den Anwendungsstil, -schriften und -farben durch X11 Atome, welche alle offenen Anwendungen auffordern, ihre Einstellungen rekursiv über alle Widgets zu ändern. Dies wird automatisch durchgeführt, wenn der Benutzer die entsprechenden Werte mittels des KDE-Kontrollzentrums ändert, was eines dieser X11-Events hervorruft. Die Methode `x11eventFilter()` entsendet die entsprechenden Signale um diese Werte zu ändern. So weit mir bekannt ist, ist der einzige Wert, der in KDE 1.x nicht verändert wird, das Doppelklick-Intervall, welches in `QApplication` standardmäßig auf 400ms eingestellt ist. Veränderungen hieran ist nur durch Nutzung der Methode `QApplication::setDoubleClickInterval()`.

### 3.3 Andere Anwendungsklassen

Durch "Andere Anwendungsklassen" wollen wie alle Ersetzungen der `KApplication`-Klasse beschreiben. Die KDE-Bibliothek `kdeui` enthält zwei weitere Klassen, die von `KApplication` für spezifischere Anwendungen innerhalb von KDE-Anwendungen abgeleitet sind. Dies sind die Klassen `KControlApplication` und tt/KWMModuleApplication/.

#### KControlApplication

`KControlApplication` ist eine Klasse für spezielle Anwendungen, die als Setup-Module geplant sind. Da sie einen Tab-Dialog zur Verfügung stellt, können Kontrollmodule leicht erzeugt werden. Die Unterschiede zu `KApplication` sind:

- nutzt `-init` als Kommandozeilenargument um die Methode `init()` aufzurufen. Diese ist überschrieben worden um die Dialogeinstellungen zu initialisieren.
- Der Titel des Dialogs muß unabhängig von der Art, wie in `KApplication` verfahren wird, mittels `setTitle()` gesetzt werden.
- bietet einen kompletten Rahmen für Ihre Kontroll-Widgets, welche eingefügt werden müssen.

Um die virtuellen Methoden wie `init()` zu überschreiben, müssen sie eine anwendungsspezifische `KControlApplication`-Klasse von `KControlApplication` ableiten. Die Klasse wird allgemein für Kontroll- (Setup-) Anwendungen wie in KDE als auch in separaten Programmen verwendet.

#### KWMModuleApplication

KWMModuleApplication ist eine weitere Klasse, die von `KApplication` für bestimmte Zwecke abgeleitet ist: die Klasse bietet Methoden, die eine Interaktion mit dem Fenstermanager erlauben. Ein Beispiel für eine KWMModuleApplication ist der `kpager`, welcher Signale des Fenstermanagers zur Verwaltung der Fenster mittels statischen Methoden des KWM benutzt.

Um eine KWMModuleApplication zu erstellen, müssen Sie zunächst Ihre Anwendungsinstanz erzeugen und die Methode `connectToKWM()` aufrufen.

#### Docken von Fenstern

Ein weiteres Thema beim Design von KDE-Anwendungen ist die Nutzung von `kpanel` um ihre laufenden Anwendungen symbolisiert darzustellen. KDE-Benutzer sind wahrscheinlich vertraut mit der Anzeige der Anzeigeeigenschaften links von der Uhr im `kpanel`.

Der Weg hierzu ist recht einfach: Sie müssen ein Widget zur Verfügung stellen, das im Panel gedockt ist; hierzu muß ein Hauptfenster erzeuugt werden, indem der Konstruktor mit 0 als Elternfenster aufgerufen wird. Binden Sie die kwm.h Headerdatei ein und rufen Sie

> `

>     KWM::setDockWindow(mywidget->winID());

> `

auf.

Bedenken Sie, daß es für das Verstecken des Widgets nicht genügt, `destroy()` aufzurufen (siehe `QWidget` für `destroy()` und `create()`).

### 3.4 Das Hauptfenster

Wie bereits erwähnt, ist das zuerst zu erstellende Objekt einer KDE-Anwendung eine Instanz von `KApplication`. Es bietet sicherlich keine Widgets (sichtbare Benutzerschnittstellen), außer dem "Über"-Dialog wie in der `QApplication`-Klasse als PopUp-Menü, das jedoch nicht sichtbar ist. Daher benötigt jede Anwendung ein Top-Widget, um sich selbst sichtbar zu machen.

Betreffend die sichtbaren Teile, ist der Programmierer frei in der Wahl des Widgets das er Benutzen oder von dem er sein Hauptfenster ableiten möchte. Es kann ein simples `QLabel` genauso wie das komplexe `KTMainWindow` sein, welches alle benötigten Objekte einer gewöhnlichen Desktop-Anwendung enthält.

#### Allgemeine Regeln

Im Allgemeinen werden Sie fertige Komponenten benutzen wollen, die spezialisiert sind. KDE unterstützt dies mit der Klasse `KTMainWindow` als ein Pendant zur Qt-Klasse `QMainWindow`. Bevor wir die allgemeine Regel betrachten, zunächst ein Blick auf die Ausname: die Benutzung jedes anderen Widgets. Wenn sie `QApplication` als Basisklasse Ihrer Anwendung verwenden wollten, würden Sie die Anwendungsinstanz erstellen, danach das Hauptwidget. Jetzt ist es sicher, das Widget als Top-Widget mittels `setMainWidget()` zu registrieren da der Benutzer dann den "Schließen"-Button des Hauptfenster zum Verlassen verwenden kann. Er erwartet, daß die Anwendung beendet wird, wenn das letzte Fenster geschlossen wird. Um dies jedoch zu erreichen, müssen Sie den QApplication-Slot `quit()` aufrufen Sie könnten dies in einer abgeleiteten Klasse durch überschreiben der Methode `QWidget::closeEvent()` tun aber mit der Methode `setMainWidget()` wird dies bereits getan. In jedem Fall, in welchem `KApplication` genutzt wird, sieht es ähnlich aus, mit dem Unterschied, daß die entsprechende Methode von KDE `setTopWidget()` ist. Die einzige Ausnahme besteht bei Benutzung der Klasse `KTMainWindow`, welche dies automatisch in ihrem Konstruktor erledigt (wenn kein anderes Top-Widget vorhanden ist).

Ein weiterer Weg wäre, kein Fenster explizit als Top-Widget zu setzen, wenn Sie mehrere Top-Widgets verwenden. Da das Anwendungsobjekt noch immer mit `quit()` beendet wird, Sie können stattdessen `connect()` nutzen um es automatisch aufzurufen, wenn das letzte Anwendungsfenster geschlossen wird (`QApplications` `lastWindowClosed()`-Signal nutzend):

    QObject::connect(kapp, SIGNAL(lastWindowClosed()), kapp, SLOT(quit()));

#### Benutzung von KTMainWindow

Gewöhnlich besitzen Desktop-Anwendungen ein komplettes Benutzerinterface, welches üblichen Regeln für GUI-Programme folgt. KDE bietet eine Klasse, welche bereits alle benötigten Funktionen enthält, aus denen eine Anwendung Nutzen ziehen kann, `KTMainWindow`, welche Teil der `kdeui`-Bibliothek ist. Sie ist eng verbunden mit `KApplication` und daher sehr einfach zu benutzen. Die Klasse bietet:

- Unterstützung des Sitzungsmanagements
- ein Hauptwidget
- eine Menüleiste
- so viele Werkzeugleisten wie ihre Anwendung benötigt
- eine Statuszeile

Die Elemente des Widgets selbst werden bereits von `KTMainWindows` Geometrie-Implementation verwaltet, daher müssen Sie sich normalerweise nicht darum kümmern müssen, eine Anwendungsspezifische Instanz für Ihr Programm neu zu implementieren.

Weiter Zurück Inhaltsverzeichnis