The K Desktop Environment

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:

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:

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 QPixmaps 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:

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

    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)

    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:

    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:

    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