In der Welt von Glade Programmieren unter Gnome

Von Alexander Scheb

Zur Entwicklung von Benutzeroberflächen (User Interfaces) werden unter LINUX verschiedene Toolkits bereitgestellt. Diese Toolkits kann der Entwickler zur Realisierung seiner Anwendungen nutzen. Um portable Oberflächen mit gleichen Look & Feel zu erstellen, gibt es das GTK+ (GIMP Toolkit). Jede GOME Anwendung nutzt als Basis das GTK+. Da das GTK+ der GPL (GNU Public Licence unterliegt, liegen die Quellen offen. Bei den Entwicklern ist das GTK+ sehr beliebt, da jeder diese modifiziert weitergegeben darf, solange die Quellen enthalten sind.

Einführung

Das GTK+ stellt drei aufeinander aufbauende Bibliotheken bereit. Dies ist das GIMP Tookit GTK+, dem GTK Drawing Kit GDK und der GLibrary GLib. Das GDK kapselt dabei alle XLib Aufrufe. GLib stellt eine Bibliothek mit häufig gebrauchten Funktionen, wie verkettete Listen, Speichermanagement und Fehlerbehandlung dar. Das GIMP Toolkit stellt eine Sammlung von Widgets für die Entwicklung von Oberflächen bereit. Dies sind unter anderem Widgets wie Fenster, Schaltflächen, Textboxen, Buttons, Combo, Eingabefelder,Listboxen, Register und verschiedene Standard-Dialoge. Der Entwickler von Oberflächen kommt so gut wie garnicht mit den anderen Bibliotheken in Berührung. Obwohl das GIMP Toolkit in der Sprache C entwickelt worden ist, stellt es eine objektorientierte Schnittstelle bereit. Also werden Konzepte wie Klassen, Instanzierung und Vererbung angewendet.

Die Konzepte von GTK+

Jedes Widget entspricht einem Objekt und ist als typisierte Datenstrukturen intern implementiert, welche vom GTK selbst verwaltet wird. Über das Objekt wird konkret definiert was ein Widget tun soll. Da es verschiedene Arten von Widgets gibt, sind diese in einer Vererbungshierarchie organisiert.

Die Struktur jedes Objekts (oder Klasse) enthält als erstes Element einen Zeiger auf das Elternelement. Diese Angabe muß immer am Beginn der Datenstruktur stehen. Dies gewährleistet das die Kindobjekte typkompatibel mit ihren Eltern und allen davon abgeleiteten Objekten bleiben. Die Hierarchiebildung gewährleistet eine hohe Polymorphie und der Entwickler kann so leichter seine Implementerung vornehmen. Ein Objekt agiert eben so, wie dieses es von den geerbten Klassen gelernt hat. So können verschiedene Objekte auf die selbe Methode anwendet werden, solange diese Objekte vom selben Klassentyp geerbt haben. Ohne Probleme läßt sich ein GtkButton auch als GTKWidget auf die Funktion gtk_widget_show() anwenden. Für ihre identischen Funktionalitäten stellen natürlich beide die gleichen Funktionen der Außenwelt bereit. Jeglicher Objekt-Zugriff(in C typisch) geschieht dabei über einen Zeiger.Wie die Hierarchie konkret aussieht kann in der Referenzdokumentation (http://developer.gnome.org/doc/api/gtk) nachgeschlagen werden. Ein Entwickler der solche Widgets erstellt, legt konkret fest, über welche Attribute und Aktionen für eine Widget Klasse bereitstehen.

Das GTK+ bedient sich dem Konzept der Ausrichtungsmanager aus der Sprache Java. Es gibt zwei Arten von Geometriemanager: Einen zur relativen Positionierung der Widgets ohne explizite Angabe der Koordination und eben einen mit direkter Positionsangabe. Da jegliche Widgets in Containern liegen müssen, ermöglicht die automatische Ausrichtung aller Widgets. Sobald sich die Ansicht ändert, wird automatisch angepasst.

Natürlich kann jedes Widget auch auf Ereignisse reagieren. Das Konzept der Ereignisverarbeitung mittels Signale hat man von Qt übernommen. Jedes Widget verfügt über eine Reihe von definierten Signalen. Sobald eine Benutzerinteraktion erfolgt, wird ein bestimmtes Signal gesendet. Wird beispielsweise eine Schalftläche (Button) gedrückt, wird das Signal 'pressed'“ rausgeschickt. Der Entwickler übernimmt dabei die Aufgabe, diese Signale mit einer konkreten Funktion zu verbinden. Dies geschieht über die Funktion gtk_signal_connect( GtkObject *object, gchar *name, GtkSignalFunc func, gpointer data ). Das erste Argument (*object) ist dabei das Widget, welches das Signal auslöst. Das zweite ist der Name des Signals (z.B. clicked). Das dritte Argument ist die Funktion, die aufgerufen werden soll, wenn das Widget das Signal liefert. Das vierte Argument, sind Daten die zusätzlich der Funktion übergeben werden können.

Die konkrete Ereignisbehandlungsroutin, welche das Ereignis dann behandelt, ist die

sogenannte Callback-Funktion. Solch eine Callback-Funktion sieht folgendermaßen aus: void callback_function (GtkWidget *widget, gpointer data). Das erste Argument wird automatisch übergeben und ist ein Zeiger auf das Widget, welches das Signal ausgelöst hat. Das zweite Argument ist ein Zeiger auf die Parameter die zusätzlich übergeben wurden. Das Hauptprogramm ruft eine bestimmte Callback-Funktion bei Eintritt eines Ereignisses auf. Bereits zum Zeitpunkt der Erzeugung des Widgets, teilt man dem GTK+ mit, welche Routine im Hauptprogramm aufgerufen wird, wenn ein bestimmtes Ereignis eintritt.

Um auf Ereignisse jedoch besonders flexibel zu reagieren, da innerhalb der Widgets unterschiedliche Ereignisse auftauchen können, sind auch selbsterstellte Funktionen erlaubt. Diese werden an spezielle Aktionen angebunden. Solche Aktionen lösen immer Signale aus, welche jedoch nichts mit den Linux Signalen gemein haben. Für jedes Signal worauf man reagieren möchte, läßt sich eine Behandlungsroutine definieren. Welche Signale überhaupt gerade zur Verfügung stehen, ist innerhalb der Widget Klasse selbst spezifiziert.

So wie das GTK+ seine Widgets in einer Klassenhierarchie aufbaut, so wird zur Laufzeit einer GTK-Anwendung eine interne Instanzenhierarchie aufgebaut. Solch ein Widget wird durch die Instanziierung einer konkreten Klasse erzeugt. Um solch eine Instanz anzulegen steht die standardmäßige Funktion gtk_widgetname_new() bereit. Jede Funktion verfügt über eine verschiedene Argumentenliste. So ist es ganz nützlich, sich zuerst den Funktionsprototyp anzuschauen, bevor man das Widget erzeugt. Die Funktion gibt nach der Erzeugung einen Zeiger auf das neue Widget zurück. Jeglicher Zugriff auf das Widget findet dann über diesen Zeiger statt.

Entwicklung vereinfachen

Mitterlweile gibt es auch RAD-Tools zur einfacheren Entwicklung unter Linux. Zur Entwicklung von GTK+ Anwendungen ist das Werkzeug »GLADE« geradezu prädestiniert. Dieses wurde selbst auf der Basis des GTK+ entwickelt und unterstützt die Sprachen C, C++, Ada95, Python und Perl. Der Entwickler ist damit in der Lage schnell Benutzeroberflächen umzusetzen. Denn GLADE generiert automatisch den korrespondierenden Quellkode. Diesen kann man natürlich noch beliebig anpassen. Der Aufbau des GUI BUILDERS ist übersichtlich und auf drei Fensterbereiche aufgeteilt. Das Hauptfenster wird primär für Dateioperationen verwendet. Zusätzlich findet darüber aber auch die Projektverwaltung statt. Innerhalb des Paletten-Fenster werden die verschiedenen Rubriken (Basic, Additional und Gnome) mit ihren verschiedenen Widget-Elementen angezeigt. Zum Schluß gibt es noch das Property-Fenster, welche die Eigenschaften des gerade aktivierten Widget-Element einblendet. Über das Fenster läßt sich ein Widget leicht entsprechend konfigurieren.

Ein gewöhnliches Fenster läßt sich per Mausklick im Paletten-Fenster auf das Fenster-Symbol in der Rubrik 'GTK+Basic' anlegen. Jedoch lassen sich Widgets nicht einfach so auf dieses Fenster plazieren. Es müssen zuerst die Bereiche des Fensters definiert werden. Dazu zieht man das Widget-Element 'VerticalBox' auf das Fenster. Dabei wird man gefragt, in wieviel Zeilen das Fenster aufgeteilt werden soll. Üblicherweise nimmt man eine Aufteilung in Menü, ToolBar, Textbereich und Statusleiste vor. Erst danach lassen sich weitere Widgets auf dem Fenster plazieren.

Glade installieren

Die neuste Version von Glade kann vom Internet-Server [2] bezogen werden. Leider finden sich dort nur Pakete für die Debian und NetBSD Distributionen, so daß die meisten User wohl die Sourcen verwenden werden. Daher beschreiben wir hier, wie man die Glade Sourcen kompiliert und einrichtet. Es ist übrigends kein gutes Vorgehen die vorkompilierte Pakete des Herstellers zu verwenden. So kann man meist keine Patches mehr einspielen oder das Programmverzeichnis mitangeben. Auch die verschiedenen Distributionen machen einem das Leben schwer. Dies liegt an den voneinander abweichende Installationspfade und unterschiedliche Informationen über Bibliotheksabhängigkeiten. Um solchen Problemen vorzubeugen, sollte man am besten direkt den Quellcode nehmen. So stehen einem mehr Möglichkeiten offen, ein auf die eigenen Bedürfnisse angepaßtes System einzurichten. Für die Installation und Konfiguration von Glade ist es erforderlich als SuperUser zu agieren. Also meldet man sich als root-Anwender beim System an. Sobald man das Archiv 'glade-0_5_9.tar' von der Homepage http://glade.pn.org heruntergeladen hat, empfiehlt es sich, die Datei in das Verzeichnis /usr/local/src zu kopieren und auf der Shell oder im Shell-Fenster von KDE mit der Anweisung

'tar xvf glade-0_5_9.tar' zu entpacken. Um den Quellcode nach den eigenen Vorstellungen zu kompilieren, gibt es eine Vielzahl von Parametern zu dem Konfigurationsskript ./configure. Zu dieser Gattung zählt der Parameter --prefix=/usr/local/glade, dessen Zweck darin besteht, das Programmverzeichnis von Glade festzulegen. Mittels »make« und »make install« schließt der SuperUser die Installation von Glade ab. Sollten während der Kompilierung Probleme auftreten und die GTK+ Bibliotheken nicht gefunden werden, kann es sein das die etc/d.so.conf entsprechend anpasst werden muß. Manchmal genügt es auch, vor jeder erneuten Kompilierung die Anweisungen rm config.cache und anschließend make clean auszuführen.

Ein Praxisbeispiel

Als Einführung erstellen wir ein kleines Programmbeispiel. Hieran soll der Aufbau eines GTK Programms ersichtlich werden. Das Programm zeigt lediglich ein Fenster an. Nun der Programmaufbau der Reihe nach. Als erstes müssen alle nötigen Bibliothek eingebunden werden, damit man auch eine GOME Unterstützung erhält. Danach legt man eine Zeigervariable für die Anwendung an. Diese zeigt später auf die eigentliche Anwendung.Die nächste Zeile gnome.init() initialisiert die Anwendung und das EventHandling und wertet verschiedene Kommandozeilenargumente aus. Die Initialisierung muß jede GNOME Anwendung vornehmen. Danach wird über gnome_app_new() das Hauptfenster für die Anwendung erzeugt. Hierbei erfolgen verschiedene Initialisierungsvorgänge und stellt entsprechend Speicherplatz bereit. Als Argument wird dabei der Programmname und der Fenstertitel übergeben. Das gerade erzeugte Objekt wird dann der Anwendung selbst übergeben. Mittels der Funktion gtk_widget_show() wird die Anwendung letztlich dann auch dargestellt. Zum Schluß wird über gtk_main() in die Hauptschleife des Programms gesprungen. Dessen Aufgabe ist es auf eintretende Ereignisse zu warten.

#Code: Listing#1

Grundlegendes Programmgerüst einer GNOME-Anwendung#

beispiel1.c

#include <gnome.h>

/* Die Hauptfunktion */

int main (int argc, gchar *argv[]) {

GtkWidget *meine_anwendung;

gnome_init ("GTK+Beispiel", "0.0.1", argc, argv);

meine_anwendung = gnome_app_new ("GTK+Beispiel", "GTK+Beispiel");

gtk_widget_show (meine_anwendung);

gtk_main ();

return (0);

}

Eine erweiterte Fassung

Damit das Ganze noch etwas transparenter wird, haben wir ein weiterführendes Beispiel entworfen. Dieses zeigt den Entwurf einer kompletten GNOME Anwendung. Da dies nicht immer sofort verständlich ist, erläutern wir die Details des Kodes der Reihe nach. Aber erstmal den Aufbau der Anwendung. Eine Benutzeroberfläche kommt heute natürlich nicht ohne ein Menü aus, um als bedienungsfreundlich zu gelten. Zusätzlich wäre eine ToolBar schön, um die am häufigsten benutzten Programmfunktionen schnellstmöglich zur Verfügung zu stellen. Praktisch ist, daß man die Details des Widgets nicht kennen muß, man konfigurierte diese nur noch. Solche Parameter nennt man Ressourcen. Welche lediglich nichts anderes als eine Datei ist, worüber das Widget konfiguriert wird. So wird das Verhalten und Aussehen des Widget vorab definiert. Der Entwickler muß noch die Ressource eines Widget und dessen Argumentenliste einstellen. Hier hilft die Dokumentation.

Ein standardmäßiges Menü läßt sich über eine Struktur mit dem Namen 'GnomeUIInfo' anlegen. Dazu ist zuerst das Hauptmenü anzulegen. Diese hat die Aufgabe die Untermenüs zu verwalten. Die Struktur für das Hauptmenü sieht dann so aus:

#code#

static GnomeUIInfo main_menu [] = {

GNOMEUIINFO_MENU_FILE_TREE(datei_menu),

GNOMEUIINFO_MENU_HELP_TREE(hilfe_menu),

GNOMEUIINFO_END };

Die Struktur deklariert dazu die Untermenü Einträge. Die Struktur main_menu stellt das Hauptmenü dar und verwaltet das Dateimenü und das Hilfemenü. Die Struktur für das eigentliche Dateimenü und dem Hilfemenü fällt genauso aus:

#code#

static GnomeUIInfo datei_menu [] = {

GNOMEUIINFO_ITEM_STOCK ("Beenden", "programm beenden",

end_program, GNOME_STOCK_MENU_EXIT),

GNOMEUIINFO_SEPARATOR,

GNOMEUIINFO_END

};

static GnomeUIInfo hilfe_menu [] = {

GNOMEUIINFO_ITEM_STOCK ("Programminformation", "Programminformation",

create_about_box, GNOME_STOCK_MENU_ABOUT),

GNOMEUIINFO_END};

Jedes Dateimenü sollte nach dem StyleGuider immer den MenüEintrag "Beenden" verfügen. Also haben wir einen entsprechend en Eintrag untergebracht. Wird Eintrag aufgerufen, wird das Programm über die Funktion end_program() beendet. Das Hilfemenü beinhaltet nur

den Eintrag 'Produktinformation'. Dieser Eintrag ruft die Funktion create_about_box() auf, welche den Dialogbox 'Produktinformation' dann anzeigt.

Auf die selbe Art und Weise läßt sich schnell die dazugehörige ToolBar anlegen. Für ein einheitliches Look & Feel liefert das GTK+ verschiedene Symbole gleich mit. Diese kann man auf die ToolBar anwenden. Die Struktur für eine ToolBar könnte dann so ausfallen:

#code#

static GnomeUIInfo menu_toolbar [] = {

GNOMEUIINFO_ITEM_STOCK ("Beenden", "programm beenden",

end_program, GNOME_STOCK_PIXMAP_EXIT),

GNOMEUIINFO_SEPARATOR,

GNOMEUIINFO_ITEM_STOCK (Pprogramminformation", "Programminformation",

create_about_box, GNOME_STOCK_PIXMAP_ABOUT),

GNOMEUIINFO_END

};

Hierbei ist wichtig, daß jede Definition mit GNOMEUIINFO./END abgeschlossen wird, um dessen Ende zu definieren. Ebenfalls bringt GTK eine Möglichkeit um Dialogboxen schnell zu erstellen. Ein beliebtes Beispiel ist hier der Dialog 'Produktinformation'. Dieser Dialog zeigt standarmäßig die Versionsnummer des Programms, die Namen und der Autoren und weitere Informationen an. Mit der standardmäßigen Funktion gnome_about_new() wird dieser Dialog erzeugt. Als Argument kann man hier die Autorennamen, Versionsnummer,

#code#

Nachdem die Widgets definiert sind, müssen diese noch erzeugt und angzeigt werden. Dies geschieht im Hauptprogramm (main). Das komplettte Menü wird über die Funktion gnome_app_create_menus() angezeigt. Die dazugehörige ToolBar wird über die Funktion gnome_appbar_new() sichtbar gemacht. Das eigentliche Hauptfenster der Anwendung wird über gnome_app_new() angezeigt. Welche Argumente dabei übergeben werden, sind im Listing#2 ersichtlich.

Nun kommen noch die Ereignisse die von der GNOME-Anwendung zu verarbeiten sind. Auch unser Fenster beinhaltet das Symbol »Fenster schließen«, da es ein Standarddialog ist. Den Dialog einfach vom Bildschirm zu entfernen reicht nicht. Jeder C-Kundige wird wissen, daß er den Speicher unter der Sprache C selbst für das Programm freigeben muß. Es ist also erforderlich auf das Ereignis zu reagieren, um den Speicher auch freigeben zu können. Hier kommt das GTK Toolkit wieder zum Einsatz. Jedes Widget kann mittels der Funktion gtk_signal_connect() mit einem bestimmten Signal und einer Ereignisbehandlungsroutine verbunden werden. Erst dann ist die Schleife gtk_main in der Lage auf verschiedene Ereignisse zu reagieren. Da es sich um ein Standardereignis handelt, stellt GTK+ das Signal »activate« und eine entsprechende Callback-Funktion »gtk_main_quit()« hierzu direkt bereit. So läßt sich das Programm korrekt beenden. Welche Signale es gibt, sind in der folgenden Tabelle#1 aufgelistet:

#Tabelle1:#

GTK Ereignisarten Beschreibung

clicked wird bei Schalftlächen verwendet

destroy wird bei Fenstern verwendet

value_changed wird bei jedem Typ von GtkObject verwendet

toggled wird bei jedem Typ von GtkObject verwendet

activate wird bei jedem Typ von GtkObject verwendet

button_press_event wird bei jeden Widget verwendet

select_row wird von anklickbaren Widget verwendet

select_child wird bei Wirdgets mit einer Baumstruktur verwendet

unselect_child wird bei Widgets mit einer Baumstruktur verwendet

select wird bei Widgets mit Einträgen verwendet

deselect wird bei Widgets mit Einträgen verwendet

expose_event sobald ein Widget das erstemal angelegt wird, tritt das Signal auf

configure_event sobald ein Widget das erstemal angelegt wird oder neu positioniert wird, tritt das Signal auf

#Code: Listing#2

Einer GNOME-Anwendung mit grundlegenden Funktionalitäten#

/* Dies ist eine Beispiel einer Gnome-Anwendung

* Illustration für die Linux Open Zeitschrift

#include <gnome.h>

/*Eine Reihe von CallbackFunktionen */

/* Beenden des Programmes über Menü */

static void end_program(GtkWidget *widget, gpointer data)

{ gtk_main_quit();}

/* Schließen des Fensters */

static int exit_window(GtkWidget *widget, gpointer data)

{ gtk_main_quit ();

return FALSE; }

/* Anzeigen des Dialogs */

static void create_about_box(GtkWidget *widget, gpointer data)

{ GtkWidget *dialog;

const gchar *authors[]={ Mueller, Meier, Schmitz, NULL };

const text *text = "Ein GTK+ Programmbeispiel";

gtk_widget_show (dialog);

return;

}

/* Das Hauptmenü */

static GnomeUIInfo main_menu [] = {

GNOMEUIINFO_MENU_FILE_TREE(datei_menu),

GNOMEUIINFO_MENU_HELP_TREE(hilfe_menu),

GNOMEUIINFO_END };

/* Das Dateimenü */

static GnomeUIInfo datei_menu [] = {

GNOMEUIINFO_ITEM_STOCK ("Beenden", "programm beenden",

end_program, GNOME_STOCK_MENU_EXIT),

GNOMEUIINFO_SEPARATOR,

GNOMEUIINFO_END

};

/* Das Hilfemenü */

static GnomeUIInfo hilfe_menu [] = {

GNOMEUIINFO_ITEM_STOCK ("Programminformation", "Programminformation",

create_about_box, GNOME_STOCK_MENU_ABOUT),

GNOMEUIINFO_END

};

/* Die ToolBar */

static GnomeUIInfo menu_toolbar [] = {

GNOMEUIINFO_ITEM_STOCK ("Beenden", "gnomovision beenden",

end_program, GNOME_STOCK_PIXMAP_EXIT),

GNOMEUIINFO_SEPARATOR,

GNOMEUIINFO_ITEM_STOCK ("Ueber", "Über gnomovision",

create_about_box, GNOME_STOCK_PIXMAP_ABOUT),

GNOMEUIINFO_END

};

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

{

/* Deklaraton der Widgets

GtkWidget *anwendung;

GtkWidget *w; /* pointer to some widget */

/* Initialisierung der Umgebung */

gnome_init("GTK+Beispiel", VERSION, argc, argv);

/* Anlegen der Anwendung */

anwendung = gnome_app_new("hello_world", "Hello World (Gnome Edition)");

/* Das Ereignis »FensterSchließen« mit CallbackFunktion verbinden */

gtk_signal_connect(GTK_OBJECT(anwendung), "exit_window",

GTK_SIGNAL_FUNC(exit_window), NULL);

/* Anlegen der Menüs

gnome_app_create_menus(GNOME_APP(anwendung), main_menu);

/* Anlegen der ToolBar */

gnome_app_create_toolbar(GNOME_APP(anwendung), menu_toolbar);

/* Setzen aller Inhalte im Fenster */

gnome_app_set_contents(GNOME_APP(anwendung), w);

/* Alle Widgets anzeigen auf dem Fenster */

/* und das Fenste selbst ! */

gtk_widget_show_all(anwendung);

/* Eintritt in die Haupprogramm-Schleife */

gtk_main();

return; }

Die Quelltext Ebene

Zum Schluß speichern wir unser Projekt unter Glade mit dem Menüpunkt „File/Save“ ab. Nun ist das Projekt gesichert. Selbstverständlich wollen wir auch die Quelltexte einsehen. Daher generieren wir über den Menüpunkt „File/Write Source Code“ den Quellkode. Wenn Sie nun in das Projektverzeichnis schauen, werden Sie eine Reihe von Dateien vorfinden. Diese wirken auf den ersten Blick sehr verwirrend. Daher die Dateien hier im Detail: Die AUTHOOS Datei dient dazu den Autorennamen des Programms zu hinterlegen. Dazu kommt die Change.Log Datei, welche Änderungen am Quelltext protokolliert. Die Datei NEWS dient zur Ablage von Informationen, was sich am Programm geändert hat. Die README Datei erhält natürlich die allgemeinen Informationen zum Programm. Die restlichen Dateien wie:

Makefile.am, Acconfig.h, Autogeh.sh,Configure.in und Stamp.in

werden von den Konsolenprogrammen autoconf und automake zur Konfigurierung verwendet. Damit der Übersetzungvorgang auch funktioniert, ist es notwendig, das automake und autoconf auch auf dem Rechner installiert sind. Sollte dies nicht sein, müssen diese nachinstalliert werden. Die automatische Systemskonfiguration kann über den Befehl ./autogen.sh angestoßen werden. Dieser erstellt das Konfigurationsscript ./configure dann und ruft es auf. Hierüber werden

die Pfade auf die entsprechenden Bibliotheken und des Compilers für die Konfiguration ihres Rechners gesetzt. Mit »make« kann dann der eigentliche Kompilierungsvorgang gestartet werden. Danach erfolgt mittels »make install« die eigentliche Installation. Wo die ausführbare Programm dann letztlich abgelegt wird, kann unter den Projektoptionen eingestellt werden. Hiermit haben wir den grundlegenden Weg zur Erstellung einer GNOME Anwendung beschrieben.

Überschrift: Schluß

Das GTK ist eine ausgereifte Bibliothek , was anhand der vielen GNOME Programme ersichtlich wird. Da GTK frei ist und dessen Quellen einsehbar sind, wird diese gerne von den Entwicklern genutzt und trägt zur großen Verbreitung bei. Die Entwicklung von GNOME sieht auf dem ersten Blick schwieriger aus als sie es letzten Endes ist. Hat man die Konzepte erst einmal verstanden und erste Beispiele erarbeitet, wird dessen Einfachheit deutlich. Mittels des RAD-Tools 'GLADE' findet man leicht den Einstieg, wenn man die Quelltext Ergebnisse sorgfältig mal anschaut. Zusätzlich hilft noch ein GTK+ Tuturial welche von der Webseite [³] runtergeladen werden kann. Dieses beinhaltet fast alle Aspekte der GTK+ Programmierung. Da die GTK+ Entwickler sich keines Dokumentationstools bedienen, wird man um das Selbststudium der Quellcode wohl nicht herumkommen.