Um mit GTK zu Programmieren ist es unbedingt notwendig, dass Konzept davon zu verstehen. Aber keine Angst es ist einfacher als man denkt.

Ein GTK-Programm initialisiert sich erst mal selbst (gtk_init), arbeitet das ganze Programm iterativ bis zur Funktion gtk_main() ab. Und das war's dann erst mal. Nun wartet das Programm in der gtk_main Funktion auf eine Ereignis. Man kann nun sagen das Programm schläft oder ist in einer Endlosschleife. Tritt ein Ereignis ein, arbeitet GTK das Ereignis ab und springt wieder zu gtk_main Funktion zurück. Außer bei dem Ereignis handelt es sich um gtk_main_quit, welches unser GTK - Programm beendet. Hierzu der Programmablauf eines GTK - Programms grafisch:

Nun wissen sie schon mal wie ein GTK - Programm abläuft. Als nächstes müssen sie nur noch wissen, wie sie mit GTK ein Ereignis erfragen können und vor allem wie sie mit einer, zum Ereignis entsprechenden Funktion reagieren können.

Und dies ist noch einfach als man Glauben will. Dazu müssen sie nur für ein Widget einen Signalhandler mit einer entsprechende Callback-Funktion einrichten.

In der Praxis würde dies folgendermaßen ablaufen. Nehmen wir mal an, sie erzeugen als Widget einen Button (Knopf). Für diesen Knopf richten sie jetzt einen Signalhandler ein mit einer Callback-Funktion. Nun drückt der User den Button. Sofort wird ein entsprechendes Signal an die gtk_main - Funktion geschickt. Nun wird nachgesehen, welche Callback-Funktion wir für diese Widget eingerichtet haben. Nun wird diese Callback-Funktion ausgeführt. Und zum Schluß springt unser GTK Programm wieder in die gtk_main - Schleife (sofern nicht die Funktion gtk_main_quit aufgerufen wurde).

Es dürfen aber durchaus mehr als ein Ereignis pro Widget verwendet werden. In diesem Fall werden die einzelnen Ereignisse, in der Reihenfolge ihrer Initialisierung, aufgerufen.

Einige dieser Signal generiert GTK selbst. Andere wiederum werden im X-Window-System generiert. Wir werden diese Signal in den Programmen ansprechen.

Nun benötigen wir noch eine Funktion, mit der wir einen Signalhandler für ein Widget registrieren können. Hier die Funktion dazu:

gint gtk_signal_connect(GtkObject *object, gchar *name,
                        GtkSignalFunc func, gpointer func_data);  

Hier wird ein Zeiger für ein GtkObjekt (Widget) übergeben. Wobei für GtkObject wieder ein Casting gemacht werden muss. Für name geben wir den Namen des Ereignishandler an. Dies könnte zum Beispiel sein:

• delete_event - wird vom Windowmanager erzeugt und an unser Programm gesendet Liefert die Callback-Funktion FALSE zurück wird das Ereignis destroy_event ausgeführt. Mit TRUE wird diese Ereignis ignoriert.
• destroy_event - Widget wird gelöscht
• clicked - Auf Widget wurde geklickt mit Maus.

Davon gibt es noch ein Menge mehr Ereignisse, worauf wir aber, wie schon erwähnt, in den Programmen zu sprechen kommen.

Der Dritte Parameter der Funktion gtk_signal_connect ist ein Zeiger auf eine Callback-Funktion. Mit dem letzten Parameter können wir unserer Callback- Funktion noch Daten mitgeben, oder NULL für keine Daten.

Nun werden sie sich fragen, wie ein solche Callback-Funktion überhaupt auszusehen hat? Nehmen wir an wir haben unser Callback-Funtkion folgendermaßen registriert:

gtk_signal_connect(GTK_OBJECT(fenster), "destroy_event",
                   GTK_SIGNAL_FUNC(my_callback), NULL);  

Wir richten also hier für das Widget fenster einen Ereignishandler destroy_event für das löschen des Widets ein. Als Callback-Funktion wir my_callback ohne Daten aufgerufen. Nun wollen wir uns die Funktion my_callback ansehen:

void my_callback(GtkWidget *widget, gpointer data)
{
 g_print("Ende");
 gtk_main_quit();
}  

Das widget ist logischerweise ein Zeiger auf das Widget welches das Signal ausgelöst hat. Die Callback-Funktion beendet also unser GTK - Programm mit gtk_main_quit.

Ein zweite Möglichkeit eine Callback-Funktion für ein bestimmtes Signal einzurichten wäre mit der Funktion:

gint gtk_signal_connect_object(GtkObject *object, gchar *name,
                               GtkSignalFunc func, GtkObjekt *slot_object);  

Damit ist es zum Beispiel möglich für ein Widget, eine Callbackfunktion für ein anderes Widget aufzurufen. Simples Beispiel:

gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                          GTK_SIGNAL_FUNC(my_callback), GTK_OBJECT(fenster));  

Hiermit wir Beispielsweise wenn das Widget button angeklickt wurde die Callbackfunktion my_callback aufgerufen, welche sie aber auf das Widget fenster bezieht. Keine Sorge, davon werden sie noch genug in der Praxis sehen.

Nun haben sie das Konzept von GTK kennen gelernt. Jetzt wollen wir im nächsten Beispiel zur Tat schreiten und mit unserem "Hallo Welt" Programm beginnen.