GTK-Workshop VI: Scrollbars und Textboxes

Daten von der Textbox holen

Wenn wir schon Einstellungen ändern können, wollen wir natürlich im Laufe des Programmes auch irgendwo herausfinden, welche Einstellungen gerade gemacht sind. Sicherlich wäre es doch schön zu wissen, an welcher Stelle der Cursor gerade steht, damit er in die entgegengesetzte Richtung verfrachtet werden kann (um wieder beim obigen Beispiel zu sein). Um herauszufinden, an welcher Stelle der Cursor steht, benutzt man folgende Funktion:

guint gtk_text_get_point (GtkText *text);

In dieser Funktion ist text wieder das GtkText-Widget (die Textbox). Diese Funktion gibt dann einen guint (das gleiche wie unsigned int) zurück, welcher die Position des Cursors darstellt.

Um herauszufinden, wie lang der Text ist, der in der Textbox steht, nimmt man die folgende Funktion:

guint gtk_text_get_length (GtkText *text);

text ist wieder die Textbox. Die Funktion gibt einen guint zurück, welcher die Anzahl der Zeichen im Text in der Textbox enthält.

Da ein GtkText-Widget auch ein GtkEditable ist, können wir auch dessen Funktionen benutzen :-). Mit der folgenden Funktion lässt sich eine bestimmte Zeichenfolge auslesen:

gchar* gtk_editable_get_chars (GtkEditable *editable,
 gint start_pos,
 gint end_pos);

Hier ist editable die TextBox. Achten Sie bitte darauf, daß Sie hier keinen GtkText übergeben dürfen, sondern unbedingt Ihre Text-Box nach GtkEditable casten. Das geht, wenn Sie GTK_EDITABLE(ihre_textbox) übergeben. start_pos ist die Anfangsposition, an der die auszulesende Zeichenfolge beginnt. end_pos ist die Endposition der Zeichenfolge. Die Funktion liefert uns dann einen String zurück.

Text verändern

Wo wären wir denn, wenn es nicht möglich wäre, den Text auch zu verändern? (Bei der Win-API vielleicht ;-) ) Aber wir programmieren ja mit GTK, und dort stehen uns viele Möglichkeiten offen, den Text auch noch zu verändern. Es gibt jedoch eine mehr oder weniger wichtige Sache, die wir vor dem Ändern des Textes beachten sollten: Das GtkText-Widget ist eines der wenigen Widgets, die sich selbstständig aktualisieren, und zwar außerhalb von gtk_main. Wenn wir jetzt den Text verändern würden, könnte der Betrachter unseres Programms genau sehen, was wir verändert und wie wir es verändert haben. Nehmen wir an, ein Text steht in der Textbox, wir in unserem Programm löschen den Text raus, schreiben einen anderen rein, löschen diesen wieder, und fügen wieder den ersten Text ein. (Das macht zwar wenig Sinn, ist aber kein schlechtes Beispiel, um das zu demonstrieren.) Der User würde das genau mitbekommen. Jetzt wollen wir aber, daß er denkt, nichts wäre passiert. Der einfachste Weg wäre, dem GtkText-Widget zu sagen, daß es sich nicht mehr aktualisieren soll. Wir frieren es also ein (aha!). Die Funktion dafür (und wie sollte sie auch anders heißen) ist:

void gtk_text_freeze (GtkText *text);

Auch hier ist text die Textbox. Nach dem Aufruf dieser Funktion werden keine Änderungen am Widget sichtbar. Auch wenn Sie jetzt Text eingeben würden, würden Sie nichts sehen, bis Sie nicht die Auftau-Funktion angewendet haben. Und die Funktion zum Auftauen ist:

void gtk_text_thaw (GtkText *text);

Jetzt können wir darüber reden, den Text zu verändern... Das Einfachste und das, woran man dabei als erstes denkt, ist das Einfügen von Text. Dafür wird folgende, etwas komplexere Funktion benutzt:

void gtk_text_insert (GtkText *text,
 GdkFont *font,
 GdkColor *fore,
 GdkColor *back,
 const char *chars,
 gint length);

text ist hier keineswegs der Text, der eingefügt werden soll, sondern die TextBox, in die der Text rein soll. Bitte nicht verwechseln, sonst könnten Sie wertvolle Zeit mit der Fehlersuche verschwenden (kenne ich zur Genüge). font, fore und back sind die Schriftart, die Hintergrundfarbe und die Vordergrundfarbe. Über diese drei Elemente der Gdk-Library werde ich Sie aber erst ganz am Ende dieses Workshops aufklären, und somit schreiben Sie für diese drei Parameter einfach NULL (Sie können sich aber auch woanders schlau machen). Der chars-Parameter ist letztendlich der Text, der hinzugefügt werden soll. length ist die Anzahl der Buchstaben von chars, die tatsächlich hinzugefügt wird. Wenn Sie für chars den Text GTK-Workshop von Pro-Linux nehmen und für length die 12, so wird nur der Text GTK-Workshop in die Textbox eingetragen. Wenn Sie für length den Wert -1 benutzen, wird der gesamte String eingefügt.

Diese Funktion ist zum Markieren von Text da:

void gtk_editable_select_region (GtkEditable *editable,
 gint start,
 gint end);

editable ist eine nach GtkEditable gecastete TextBox. start ist die Position, an der die Markierung beginnen soll, beendet wird die Markierung an der Position end.

Aber wir können noch mehr als nur Text hinzufügen. Wir können auch Text relativ zum Cursor löschen. Dazu stehen folgende Funktionen zur Verfügung:

gint gtk_text_backward_delete (GtkText *text,
 guint nchars);

Das, wie es hier steht, kommt etwa diesem hier in der menschlichen Sprache gleich (ich weiß nicht wie ich es sonst erklären soll): »Drück im text nchars-mal die Taste [Backspace]!«

Dann gibt es hier noch die zweite Funktion:

gint gtk_text_forward_delete (GtkText *text,
 guint nchars);

Und die kann man in »Drück im text nchars-mal die Taste [Delete]!« übersetzen...

Was im Folgenden kommt, kommt wieder von den GtkEditable-Widgets. Vergessen Sie also nicht, anstatt ihre_textbox immer GTK_EDITABLE(ihre_textbox) zu schreiben. Mit Hilfe dieser Funktionen können wir auch Text von einer bestimmten Position bis zu einer bestimmten Position löschen. Und die Funktion dafür heißt:

void gtk_editable_delete_text (GtkEditable *editable,
 gint start_pos,
 gint end_pos);

editable ist unsere gecastete TextBox. start_pos ist die Position, ab der Text gelöscht werden soll. end_pos ist die Position bis zu der der Text gelöscht werden soll. Zum Löschen des gesamten Textes in der TextBox hilft folglich folgendes Konstrukt:

gtk_editable_delete_text (GTK_EDITABLE( textbox),
 0, gtk_text_get_length(
 GTK_TEXT( textbox )));

Und jetzt kommen wir zu etwas Interessantem...