Weiter Zurück Inhaltsverzeichnis

### 2. Klassen Kategorien

Die KDE/Qt C++ Klassen-Bibliotheken bieten einfache Lösungen um Anwendungen dramatisch zu erweitern, mit einem minimalen Aufwand auf Seiten des Programmieres. Dieses Kapitel ordnet die zur Verfügung gestellten Klassen bezüglich ihrer Benutzung in bestimmte Kategorien:

- Basisklassen
- Anwendungsarchitektur-Klassen
  - Anwendungsobjekte von KDE
  - Anwendungskonfiguration
  - Hauptfenster
- Benutzerinterface-Objekte
  - Ansichten
  - Dialoge
  - Kontrollelemente
  - Menüs
- Allgemeine Klassen
  - Dateien
  - Datenobjekte
  - Grafik
  - Prozesse

### 2.1 Basisklassen

Die meißten KDE/Qt-Klassen haben `QObject` als ihre Basisklasse in ihrer Vererbungshierarchie. `QObject` kann man als Basisklasse bezeichnen, da sie die Nutzung von Qt's signal/slot Mechanismen ermöglicht, welche die Interaktion von Objekten innerhalb der Anwendung erlauben und sollte als Basisklasse für jede selbsterstellte Klasse, die Signale aussenden oder sich über Slots an Signale binden können soll, genutzt werden.

### 2.2 Anwendungsarchitektur-Klassen

KDE-Anwendungen bestehen gewöhnlich aus einer Anzahl Objekte, die miteinander interagieren. Der Programmierer kann die zur Verfügung gestellten Klassen nutzen, um eine KDE-Anwendung zu erstellen, entweder durch Instanzierung oder durch Vererbung. Eine typische Anwendung enthält:

- Ein Anwendungsobject des Typs `KApplication`
- Eine Hauptfensterklasse, abgeleitet von `KTMainWindow`
- Eine Klasse, abgeleitet von `QWidget` um die Anwendungssicht zu erzeugen

### 2.3 Anwendungsobjekte von KDE

Das K Desktop Environment bietet Funktionen, die von einer Anwendung benutzt werden können, um sich in KDE zu integrieren. Diese Funktionalität ist in der Klasse `KApplication` implementiert und sollte daher als Basisklasse für jede KDE-Anwendung benutzt werden. Eine KDE-Anwendung beinhaltet nur ein Objekt der Klasse `KApplication`. Dieses wird in der `main()`-Funktion der Anwendung erstellt. Das Objekt des Typs `KApplication` ist dafür verantwortlich, das grundlegende Benutzerinterface, bezogen auf den Desktop, zur Verfügung zu stellen und die Kommandozeilenargumente auszuwerten. Da diese Instanz nicht sichtbar, jedoch das Hauptobjekt der Anwendung ist, müssen folgende Regeln beachtet werden:

- die Anwendung wird beendet mit `kapp->quit()`.
- das Objekt, das die grafische Schnittstelle repräsentiert, muß als Hauptwidget mit `setTopWidget()` gesetzt werden (für widgets, die nicht von `KTMainWindow` abgeleitet sind)

Das `KApplication`-Objekt bietet:

- Zugriff auf das KDE Filesystem
- ein Objekt zur Sitzungskonfiguration
- ein Konfigurationsobjekt
- Internationalisierung durch das Objekt locale
- Veränderung der sichtbaren Objekte durch Signale

> KDE 2 greift auf die entsprechenden Instanzen durch statische Methoden zu, die von `KGlobal` zur Verfügung gestellt werden.

Abhängigkeiten: -lkdecore -lqt

Includes: `#include <kapp.h>`

Die `kdeui`-Bibliothek bietet zusätzlich zwei Klassen für bestimmte Zwecke, die von `KApplication` abgeleitet sind:

#### KWMModuleApplication

Includes: `#include <kwmmapp.h>`

Abhängigkeiten: -lkdeui -lkdecore -lqt

Die Klasse KWMModuleApplication ist die Basisklasse für KDE-Windowmanager-Module. Sie informiert ein Modul über alle zur Zeit verwalteten Fenster und Änderungen an ihnen (durch Qt-Signale). Es gibt keine Methoden, um Fenster zu beeinflussen. Diese sind in der Klasse KWM (siehe kwm.h) definiert. Ein Beispiel für die Benutzung von KWMModuleApplication ist kcontrol.

#### KControlApplication

Includes: `#include <kcontrol.h>`

Abhängigkeiten: -lkdeui -lkdecore -lqt

KControlApplication ist die Basis für Setup-Anwendungen. Es bietet einen tab (Kartenreiter)-Dialog und Funktionen, wie sie in den meißten Setup-Programmen üblich sind. Die Konfigurationsdialoge von KDE sind Beispiele für KControlApplications.

#### KWM

Includes: `#include <kwm.h>`

Abhängigkeiten: -lkdeui -lkdecore -lqt

Die KWM-Klasse bietet eine Anzahl von statischen Methoden um mit dem Window- und Sessionmanager zu interagieren. Daher muß jedes Mitglied diese Klasse mit

KWM::<method()>

aufgerufen werden, abhängig vom Zweck der gewünschten Funktion.

#### Anwendungs-Konfiguration

Die Klasse `KConfig` stellt ein Konfigurations-Objekt zur Verfügung, das seine Einträge in Konfigurationsdateien schreiben kann. Abhängig von den Werten die Sie lesen und schreiben wollen, müssen Sie Methoden der Klasse `KConfigBase`. nutzen.

Das `KApplication`-Objekt stellt ein Applikations-Konfigurationsobjekt mit einer Ressourcedatei standardmäßig zur Verfügung, welches im KDE-Verzeichnis des Benutzers abgelegt wird. Zudem wird eine Datei angelegt, die Informationen zum Sitzungsmanagement zwischen einzelnen Sitzungen enthält.

Zur Internationalisierung nutzt das `KApplication`-Objekt die Klasse `KLocale` um Einträge in der lokalen Sprache entsprechend der gewählten Sprache zu übersetzen. Statt der `klocale->translate()`-Methode sollten KDE-Anwendungen das `i18n()`-Makro benutzen, welches die zu übersetzende Zeichenkette enthält, da die Meldungserstellung auf diesem Makro aufbaut.

#### Hauptfenster

Da die Instanz `KApplication` der Anwenung nicht sichtbar ist, stellt sie nur die grundsätzlichen Funktionen einer KDE-Anwendung zur Verfügung. Daher muß jede KDE-Anwendung ein Haupfenster bseitzen, um sich dem Benutzer grafisch zu präsentieren. Das Hauptfenster besteht im Normalfall aus einem Widget, welches im einfachsten Fall aus einem Button bis hin zum komplexesten Fall, dem `KTMainWindow`-Widget bestehen kann und alle notwendigen Funkionen für ein vollständiges Hauptfenster mit Geometrieverwaltung, Sitzungsverwaltung, Menüleiste, Werkzeugleisten und einer Statuszeile zur Verfügung stellt.

Im Allgemeinen muß jedes Hauptfenster mit der Methode `setTopWidget()` von `KApplication` als Haupt-Widget gesetzt werden. Eine Ausnahme bilden Hauptfenster die von `KTMainWindow` abgeleitet sind.

Das Hauptfenster ist üblicherweise für die Beendung der Anwendung verantwortlich, indem es eine Benutzerschnittstelle zur Verfügung stellt, die mit `KApplication::quit()` verbunden ist und einfach durch `kapp->quit()` genutzt werden kann.

Die meißten KDE-Anwendungen werden `KTMainWindow` nutzen, um die Anwendung grafisch darzustellen.

### 2.4 Benutzerschnittstellen-Objekte

Dieser Abschnitt befasst sich mit Benutzerschnittstellen-Objekten, wie sie von den KDE-Bibliotheken zur Verfügung gestellt werden. Diese können in Kategoriern, abhängig von ihrem Zweck, unterteilt werden. Eine Benutzerschnittstelle kann sein:

- ein Widget der Hauptansicht, welches die Daten, die durch die Anwendung erzeugt werden sollen dartellt und Methoden zu ihrer Manipulation bietet.
- Dialoge, um Benutzereingaben abzufordern (z.B. ein Dateidialog)
- Kontrollelemente, um Anwendungsspezifische Widgets zu erzeugen.
- Menüs, die Benutzerschnittstellen zur Übermittlung von Kommandos an die Anwendung enthalten

#### Ansichten

Ansichten stellen im Allgemeinen den Teil des Anwendungsfensters, der die Inhalte darstellt. Darum kann es sich um das Hauptwidget oder einen Teil des Hauptwidgets handeln, der zusätzlich einige Funktionen bietet,wie z.B. `KTMainWindow`.

Die KDE-Bibliotheken bieten eine Anzahl von vordefinierten Ansichten, von denen eigene abgeleitet werden können um die gewünschte Funktionalität zu erreichen:

- KTabListBox: bietet eine Listbox mit mehreren Spalten, bei der der Benutzer die Zeilen mittels Drag'n Drop bearbeiten kann.
- KEdit: Die Basisklasse von KEdit, wie es KDE beiliegt. Sie kann anstatt QMultiLineEdit benutzt werden.
- KNewPanner: verwaltet zwei Widgets ähnlich QSplitter

  > Entfernt in KDE 2. QSplitter sollte stattdessen genutzt werden

- KHTMLView: Ein Widget, welches HTML interpretiert (khtmlw)

Um `KTMainWindow` zu benutzen, erstellen Sie die Instanz Ihrer Sicht und rufen Sie `setView(QWidget*)` auf, um die Verwaltung durch die `KTMainWindow`-Instanz zu erreichen.

Individuelle Ansichten werden gewöhnlich durch Vererbung von `QWidget` oder anderen zur Verfügung gestellten Widgets, die der gewünschten Funktionalität am nächsten kommen, erstellt. Für Widgets, die die Fähigkeit zum Scrollen besitzen sollen, können Sie diese von `QScrollView` ableiten oder eine `QScrollView`-Instanz erstellen und Ihr Widget als verwalteten Bereich mittels `addChild()` setzen.

#### Dialoge

Dialoge sind ein Hauptbestandteil der Benutzerinteraktion, wann immer die Anwendung das Setzen von Parametern durch den Benutzer benötigt. Glücklicherweise stellt die KDE-Bibliothek eine Anzahl von fertigen Dialogen zur Verfügung, die zur Abfrage von Standardparametern wie Schriftarten und Farben dienen. Wo immer diese Informationen von Benutzer benötigt werden, sollten diese Standarddialoge verwendet werden.

Wenn diese fertigen Dialoge nicht den Anforderungen entsprechen, müssen Sie Ihren eigenen Dialog erstellen, den Sie per Vererbung aus `QWidget` oder `QDialog` entweder direkt durch Programmierung mit Geometrieangaben oder mittels des Dialogeditors von KDevelop generieren.

Die KDE-Bibliotheken bieten die folgenden Dialoge:

- KColorDialog: Auswahl einer Farbe
- KWizard: Basisdialog-Klasse zur Erstellung von Wizzards
- KEdGotoLine: Go-to-Line-Dialog für Editoren
- KEdReplace: Suche- und Ersetze-Dialog für Editoren
- KEdSrch: Suchdialog für Editoren
- KFontDialog: Dialog zur Schriftartauswahl
- KIconLoaderDialog: Icon-Auswahldialog
- KKeyDialog: Konfigurationsdialog für Tastaturkürzel
- KMsgBox: Nachrichtendialog mit bis zur vier Buttons
- KFileDialog: (kfile) Dateidialog zum Laden oder Speichern von Dateien
- KSpellDlg: (kspell) Dialog zur Rechtsschreibprüfung mit ISpell
- DatePickerDialog: (kab) Dialog zur Datumsauswahl

Zusätzlich bietet die Qt-Bibliothek:

- QFileDialog
- QMessageBox
- QPrintDialog
- QProgressDialog

> Qt 2.0 bringt einen QColorDialog für die Farbauswahl und einen QFontDialog für die Schriftartauswahl

### 2.5 Kontrollelemente

Kontrollelemente werden in sichtbaren Bereichen der Anwendung genutzt und können zur Erstellung eines Dialoges oder einer Ansicht kombiniert werden. Über die Kontrollelemente, die durch die Qt-Bibliothek geboten werden, bietet KDE:

- KButton: aktiver Maximieren/Minimieren-Button
- KButtonBox: verwaltet Buttons
- KColorButton: Button der einen Farbauswahldialog anzeigt, ruft `KColorDialog` auf
- KIconLoaderButton: Button der einen Icon-Auswahldialog anzeigt, ruft `KIconLoaderDialog` auf
- KDatePicker: Datumsauswahldialog
- KIntegerLine: Eingabezeile, die nur Integerzahlen annimt
- KLedLamp: LED Lampe
- KLined: Eingabezeile
- KNewPanner: Bereichsteiler, der zwei Widgets verwaltet

  > `QSplitter` stattdessen benutzen, da dies in KDE 2 entfernt wurde.

- KPopupMenu: PopUp-Menü mit Titel
- KRestrictedLine: Eingabezeile, die nur bestimme Eingaben akzeptiert
- KSelector: Wertauswahl
- KSeparator: Standard-Trenner
- KSlider: Schieberegler
- KTabCtl: Tabulator

### 2.6 Allgemeine Klassen

#### Dateien und Verzeichnisse

Qt bietet bereits eine Anzahl von Klassen um mit Dateien und Verzeichnissen zu arbeiten, diese sind:

- `QDir`
- `QFileInfo`
- `QFile`
- `QFileDialog`

Eine vergleichbare und erweiterte Technik wurde mit den KDE-Bibliotheken eingeführt und ist ähnlich zu verwenden, wie die entsprechenden Klassen von Qt, diese sind:

- `KDir`
- `KFileInfo`
- `KFileDialog`
- `KFilePreviewDialog`

Zum Laden und Speichern von Dateien benutzen Sie bitte `QFile`, welche mit Streams arbeitet. Wenn Sie netzwerktransparenten Dateizugriff benötigen, können Sie `KFile` nutzen.

#### Datenobjekte

Die Qt-Bibliothek unterstützt Datenobjekte mit Klassen, die die Verwaltung von Listen, Arrays, Streams, Strings u.Ä. erlaubt. Konsultieren Sie hierzu bitte die Qt-Dokumemtation für weitere Informationen.

#### Grafiken

Qt unterstützt eine Anzahl von Grafikformaten, welche für Zeichen- oder Bildbearbeitungsprogramme verwendet werden können. Zur Ausgabe wird <`QPainter` verwendet.

#### Prozesse

Da Anwendungen verschiedene Typen von Interprozesskommunikation mit anderen Anwendungen auf dem System nutzen können, wie die üblichen Unix-Möglichkeiten, können Entwickler die Klasse `KProcess` verwenden, um mit anderen Anwendungen zu kommunizieren. Da eine Anwendung unabhängig von derjenigen läuft, die sie gestartet hat, können Sie lediglich den derzeitigen Status der Anwendung durch Aufruf von `isRunning` bekommen. Dieser Aufruf kann zudem mit verschiedenen Startwerten geschehen. Schließlich kann der Prozess die Anwendung benachrichtigen, wenn sie beendet wurde oder sich selbst beendet hat. Siehe `KProcess` für Details.

Weiter Zurück Inhaltsverzeichnis