Weiter Zurück Inhaltsverzeichnis
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:
QWidget
, von denen alle GUI-Komponenten abgeleitet sindMehr Informationen über KDE-Anwendungen können in den folgenden Sektionen nachgeschlagen werden:
Zu Informationen über Qt-Anwendungsdesign, schauen Sie bitte in die Qt-Onlinereferenz.
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:
, 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()
, 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
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.
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:
KApplication
-Objekt am Anfang der main()
-Funktionexec()
am Ende der main()
-Funktion ausquit()
Slot-Funktion.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.
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.
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()
.
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
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:
-init
als Kommandozeilenargument um die Methode init()
aufzurufen. Diese ist überschrieben worden um die
Dialogeinstellungen zu initialisieren.KApplication
verfahren wird, mittels setTitle()
gesetzt
werden.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 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.
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()
).
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.
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()));
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