15.11 Mehrzeiliger Text 

Das Text-Widget-System von GTK+ ist so umfangreich, dass selbst dieser Abschnitt hier nicht einmal ein Anriss dessen ist, was es bietet. Dennoch soll hier wenigstens ein Überblick zu den Widgets gegeben werden, damit Sie mit mithilfe der Referenz wissen, wo Sie was finden bzw. wonach Sie Ausschau halten müssen.

Grundsätzlich unterscheidet man dabei zwischen dem sichtbaren Bereich und dem internen Bereich (wie dem Textpuffer). Um überhaupt einen Text darstellen zu können, benötigen Sie mindestens das Widget zur Textansicht (GtkTextView; Typenkennung: GTK_TYPE_TEXT_VIEW) und das Widget zum Textpuffer (GtkTextBuffer; Typenkennung: GTK_TYPE_TEXT_BUFFER).

Weitere Widgets, die in Verbindung mit dem Textpuffer (GtkTextBuffer) verwendet werden, sind:

GtkTextIter – Text-Iteratoren werden verwendet, wenn eine Position in einem Textpuffer dargestellt werden muss – genauer eine Stelle zwischen zwei Zeichen (Typenkennung: GTK_TYPE_TEXT_ITER).

GtkTextMark – Ebenso wie die Iteratoren werden Marken dazu verwendet, um eine bestimmte Position zwischen zwei Zeichen darzustellen. Im Gegensatz zu den Iteratoren ist es mit Marken möglich, eine Textposition dauerhaft festzuhalten. Das hat zur Folge, dass selbst bei einer Änderung des Puffers die Marke nicht ungültig wird. Eine Marke ist ein unsichtbarer Cursor im Text (Typenkennung: GTK_TYPE_TEXT_MARK).

GtkTextTag – Hiermit werden Informationen zur Formatierung oder zu anderen Eigenschaften des Textes eingestellt und in einem Tag gespeichert. Ein Tag legt einen Satz von Eigenschaften für einen Text fest und kann sich auch nur auf Teilstücke des Textes beziehen (Typenkennung: GTK_TYPE_TEXT_TAG).

GtkTextTagTable – Eine Sammlung von Tags, die alle zusammen verwendet werden können (Typenkennung: GTK_TYPE_TEXT_TAG_TABLE).

GtkClipboard – Es handelt sich hierbei zwar nicht um ein direktes Widget in Verbindung mit den Text-Widgets, doch sollte das Widget hier erwähnt werden (Typenkennung: GTK_TYPE_CLIPBOARD), da es hier auch einige Funktionen gibt, die eine Schnittstelle zwischen dem Textpuffer und der Zwischenablage bieten.

Zur Demonstration folgt hier ein minimalistisches Beispiel zum GtkTextView- und GtkTextBuffer-Widget.

/* gkt7.c */
/* Mehrzeiliger Text     */
/*        GtkTextView    */
/*        GtkTextBuffer  */
/*        GtkScrolledWindow */
#include <gtk/gtk.h>
/* Funktionsprototypen */
static GtkWindow *create_window (void);
static void create_tags (GtkTextBuffer * buffer);
static void on_button_clear_clicked (
                   GtkButton * button, gpointer user_data );
static void on_button_cut_clicked (
                   GtkButton * button, gpointer user_data );
static void on_button_copy_clicked (
                   GtkButton * button, gpointer user_data );
static void on_button_paste_clicked (
                   GtkButton * button, gpointer user_data);
static void on_button_bold_clicked (
                   GtkButton * button, gpointer user_data);
static void on_button_underline_clicked (
                   GtkButton * button, gpointer user_data);
static void on_button_strike_clicked (
                   GtkButton * button, gpointer user_data );
static void on_button_color_clicked (
                   GtkButton * button, gpointer user_data );
static GtkWindow *create_window (void) {
  GtkWindow *window;
  GdkPixbuf  *pic;
  GtkVBox *vbox_main;
  GtkToolbar *toolbar;
  GtkWidget *button_clear, *button_cut, *button_copy,
  *button_paste, *button_bold, *button_underline,
  *button_strike, *button_color;
  GtkScrolledWindow *scrolledwindow;
  GtkTextView *textview;
  GtkTextBuffer *buffer;
  /* Eine Grafik in einen Pixbuf laden */
  pic = gdk_pixbuf_new_from_file("icon/at-work.gif", NULL );
  /* Fenster mit folgenden Eigenschaften anlegen */
  window = g_object_new( GTK_TYPE_WINDOW,
                         "title", "Textansicht und Textpuffer",
                         "default-width",  300,
                         "default-height", 200,
                         "resizable", TRUE,
                         "window-position", GTK_WIN_POS_CENTER,
                         "border-width", 0,
                         "icon", pic,
                         NULL );
  /* eine vertikale Box erzeugen */
  vbox_main = g_object_new( GTK_TYPE_VBOX,
                            "spacing", 0,
                            NULL);
  /* Eine neue Toolbar erzeugen */
  toolbar = g_object_new (GTK_TYPE_TOOLBAR,  NULL);
  /* Buttons mit Stock-Icons für die Toolbar erzeugen */
  button_clear=gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
                                        "gtk-clear",
                                        "Text loeschen",
                                        NULL,NULL,NULL,-1);
  button_cut = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
                                        "gtk-cut",
                                        "Text ausschneiden",
                                        NULL, NULL, NULL, -1);
  button_copy=gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
                                        "gtk-copy",
                                        "Text kopieren",
                                        NULL, NULL, NULL, -1);
  button_paste=gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
                                        "gtk-paste",
                                        "Text einfuegen",
                                        NULL, NULL, NULL, -1);
  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
  button_bold=gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
                                        "gtk-bold",
                                        "Fette Schriftart",
                                        NULL, NULL, NULL, -1);
  button_underline=gtk_toolbar_insert_stock(
                                        GTK_TOOLBAR (toolbar),
                                        "gtk-underline",
                                        "Schrift unterstreichen",
                                        NULL, NULL, NULL, -1);
  button_strike=gtk_toolbar_insert_stock(GTK_TOOLBAR (toolbar),
                                        "gtk-strikethrough",
                                        "Schrift durchstreichen",
                                        NULL, NULL, NULL, -1);
  button_color=gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
                                        "gtk-select-color",
                                        "farbige Schrift (Blau)",
                                        NULL, NULL, NULL, -1);
  /* Rollbalken erzeugen */
  scrolledwindow = g_object_new( GTK_TYPE_SCROLLED_WINDOW,
                     "hscrollbar_policy", GTK_POLICY_AUTOMATIC,
                     "vscrollbar_policy", GTK_POLICY_AUTOMATIC,
                     "window_placement" , GTK_CORNER_TOP_LEFT,
                     NULL);
  /* Eine Textansicht erzeugen */
  textview = g_object_new( GTK_TYPE_TEXT_VIEW, NULL);
  /* Aktuellen Puffer für die Textansicht ermitteln */
  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
  /* Einige einfache Tags zur Formatierung anlegen */
  create_tags (buffer);
  /* Signalhandler einrichten */
  g_signal_connect ( (gpointer) window, "delete_event",
                     G_CALLBACK (gtk_main_quit), NULL);
  g_signal_connect ( (gpointer) button_clear, "clicked",
                     G_CALLBACK (on_button_clear_clicked),
                     (gpointer) textview);
  g_signal_connect ( (gpointer) button_cut, "clicked",
                     G_CALLBACK (on_button_cut_clicked),
                     (gpointer) textview);
  g_signal_connect ( (gpointer) button_copy, "clicked",
                     G_CALLBACK (on_button_copy_clicked),
                     (gpointer) textview);
  g_signal_connect ( (gpointer) button_paste, "clicked",
                     G_CALLBACK (on_button_paste_clicked),
                     (gpointer) textview);
  g_signal_connect ( (gpointer) button_bold, "clicked",
                     G_CALLBACK (on_button_bold_clicked),
                     (gpointer) textview);
  g_signal_connect ( (gpointer) button_underline, "clicked",
                     G_CALLBACK (on_button_underline_clicked),
                     (gpointer) textview);
  g_signal_connect ( (gpointer) button_strike, "clicked",
                     G_CALLBACK (on_button_strike_clicked),
                     (gpointer) textview);
  g_signal_connect ( (gpointer) button_color, "clicked",
                     G_CALLBACK (on_button_color_clicked),
                     (gpointer) textview);
  /* Alles packen */
  gtk_container_add ( GTK_CONTAINER(window),
                      GTK_WIDGET(vbox_main));
  gtk_box_pack_start ( GTK_BOX (vbox_main),
                       GTK_WIDGET(toolbar),
                       FALSE, FALSE,0);
  gtk_box_pack_start ( GTK_BOX (vbox_main),
                       GTK_WIDGET(scrolledwindow),
                       TRUE,TRUE, 0);
  gtk_container_add ( GTK_CONTAINER (scrolledwindow),
                      GTK_WIDGET(textview) );
  /* Erzeugtes Fenster zurückgegeben */
  return window;
}
/* "Markierten" Text im Puffer löschen */
static void
on_button_clear_clicked(GtkButton * button, gpointer user_data) {
  GtkTextBuffer *textbuffer = NULL;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Markierten Text löschen */
  gtk_text_buffer_delete_selection (textbuffer, TRUE, TRUE);
}
/* Text ausschneiden und in Zwischenablage legen */
static void
on_button_cut_clicked (GtkButton * button, gpointer user_data) {
  GtkTextBuffer *textbuffer = NULL;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Text im Puffer löschen und in Zwischenablage legen */
  gtk_text_buffer_cut_clipboard (textbuffer,
                             gtk_clipboard_get (GDK_NONE), TRUE);
}
/* Text vom Puffer kopieren und in Zwischenablage legen */
static void
on_button_copy_clicked (GtkButton * button, gpointer user_data) {
  GtkTextBuffer *textbuffer = NULL;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Text im Puffer in die Zwischenablage kopieren */
  gtk_text_buffer_copy_clipboard (textbuffer,
                                  gtk_clipboard_get (GDK_NONE));
}
/* Text aus der Zwischenablage in den Puffer legen */
static void
on_button_paste_clicked(GtkButton * button, gpointer user_data) {
  GtkTextBuffer *textbuffer = NULL;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Text aus der Zwischenablage  (falls vorhanden) */
  /*  in den Puffer kopieren                        */
  gtk_text_buffer_paste_clipboard (textbuffer,
                                   gtk_clipboard_get (GDK_NONE),
                                   NULL, TRUE);
}
/* Markierten Text im Puffer in Fett-Schrift darstellen */
static void
on_button_bold_clicked (GtkButton * button, gpointer user_data) {
  GtkTextBuffer *textbuffer = NULL;
  GtkTextIter start, end;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Markierte Auswahl im Puffer ermitteln */
  gtk_text_buffer_get_selection_bounds(textbuffer,&start, &end);
  /* Markierte Auswahl im Puffer mit neuer Formatierung */
  /* belegen                                            */
  gtk_text_buffer_apply_tag_by_name ( textbuffer, "bold",
                                      &start, &end);
}
/* Markierten Text im Puffer mit Unterstrich darstellen */
static void
on_button_underline_clicked ( GtkButton * button,
                              gpointer user_data ) {
  GtkTextBuffer *textbuffer = NULL;
  GtkTextIter start, end;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Markierte Auswahl im Puffer ermitteln */
  gtk_text_buffer_get_selection_bounds (textbuffer,&start,&end);
  /* Markierte Auswahl im Puffer mit neuer Formatierung */
  /*  belegen                                           */
  gtk_text_buffer_apply_tag_by_name ( textbuffer, "underline",
                                      &start, &end);
}
/* Markierten Text im Puffer durchstreichen */
static void
on_button_strike_clicked(GtkButton *button, gpointer user_data) {
  GtkTextBuffer *textbuffer = NULL;
  GtkTextIter start, end;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Markierte Auswahl im Puffer ermitteln */
  gtk_text_buffer_get_selection_bounds(textbuffer,&start,&end);
  /* Markierte Auswahl im Puffer mit neuer Formatierung */
  /* belegen                                            */
  gtk_text_buffer_apply_tag_by_name ( textbuffer, "strike",
                                      &start, &end);
}
/* Markierten Text im Puffer mit neuer Farbe */
/* (hier Blau) versehen                      */
static void
on_button_color_clicked(GtkButton * button, gpointer user_data) {
  GtkTextBuffer *textbuffer = NULL;
  GtkTextIter start, end;
  g_assert (GTK_IS_TEXT_VIEW (user_data));
  /* Aktuellen Puffer für die Textansicht ermitteln */
  textbuffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
  /* Markierte Auswahl im Puffer ermitteln */
  gtk_text_buffer_get_selection_bounds (textbuffer,&start,&end);
  /* Markierte Auswahl im Puffer mit neuer Formatierung */
  /* belegen                                            */
  gtk_text_buffer_apply_tag_by_name ( textbuffer, "color",
                                      &start, &end);
}
/* Einige Textformatierungen (Tags) erstellen */
static void create_tags (GtkTextBuffer * buffer) {
  g_assert (GTK_IS_TEXT_BUFFER (buffer));
  /* Fette Schrift */
  gtk_text_buffer_create_tag (buffer, "bold",
                              "weight", PANGO_WEIGHT_BOLD, NULL);
  /* Unterstrichene Schrift */
  gtk_text_buffer_create_tag (buffer, "underline",
                             "underline", PANGO_UNDERLINE_SINGLE,
                             NULL);
  /* Durchgestrichene Schrift */
  gtk_text_buffer_create_tag (buffer, "strike",
                              "strikethrough", TRUE,
                              NULL);
  /* Schrift in blauer Farbe */
  gtk_text_buffer_create_tag (buffer, "color",
                              "foreground", "blue",
                              NULL);
}
int main (int argc, char **argv) {
  GtkWindow *window;
  gtk_init (&argc, &argv);
  window = create_window ();
  gtk_widget_show_all (GTK_WIDGET(window));
  gtk_main ();
  return 0;
}

Das Programm bei der Ausführung:

$ gcc -Wall -o gtk7 gtk7.c `pkg-config gtk+-2.0 --cflags --libs`
$ ./gtk7

15.11.1 Text(editor) – GtkTextView, GtkTextBuffer 

Zur Ansicht des Textes auf dem Bildschirm (im Fenster) wird das Widget der Klasse GtkTextView verwendet (Typenkennung: GTK_TYPE_TEXT_VIEW). Im Beispiel wird gleich nach der Erzeugung des sichtbaren Text-Widgets eine Verbindung zum Puffer GtkTextBuffer mit der Funktion gtk_text_view_get_buffer() hergestellt.

GtkTextBuffer* gtk_text_view_get_buffer (GtkTextView *text_view);

Diese Funktion gibt einen Puffer (GtkTextBuffer) unter Angabe des sichtbaren Textfeldes (erstes und einziges Argument) zurück. Mithilfe dieses Puffers werden anschießend mit der Funktion create_tags() einige einfache Tags festgelegt.

Einen solchen Tag können Sie recht einfach mit der Funktion gtk_text_buffer_create_tag() erstellen.

GtkTextTag* gtk_text_buffer_create_tag (
                         GtkTextBuffer *buffer,
                         const gchar *tag_name,
                         const gchar *first_property_name, ...);

Als erstes Argument wird der Puffer erwartet, auf den sich die neue Formatierung beziehen soll. Als zweites Argument legen Sie den Tag-Namen fest, auf den Sie im Laufe der Anwendung zurückgreifen können. Es kann aber auch mit NULL ein anonymes Tag erstellt werden. Jetzt folgt eine mit NULL abgeschlossene Liste von Eigenschaften mit Namen-/Wertepaaren, wie Sie diese schon beim Erstellen vieler anderer Widgets verwendet haben. Hierzu einige wenige der über 60 (!) Eigenschaften, mit denen Sie den Text entsprechend formatieren können.

Ferner wurden im Listing weitere Funktionen der wirklich enorm vielen Routinen, die sich auf den Inhalt des Puffers (GtkTextBuffer) beziehen, verwendet. Wichtig ist bei all diesen Funktionen, dass eine Beziehung zum sichtbaren Teil des Textes mit der bereits bekannten Funktion gtk_text_view_get_buffer() hergestellt wurde. Hierzu eine Auflistung der Syntax der im Beispiel verwendeten Funktionen mit einer anschießenden kurzen Erläuterung.

gboolean gtk_text_buffer_delete_selection (
                                 GtkTextBuffer *buffer,
                                 gboolean interactive,
                                 gboolean default_editable );
void gtk_text_buffer_paste_clipboard ( 
                                 GtkTextBuffer *buffer,
                                 GtkClipboard *clipboard,
                                 GtkTextIter *override_location,
                                 gboolean default_editable);
void gtk_text_buffer_copy_clipboard (
                                 GtkTextBuffer *buffer,
                                 GtkClipboard *clipboard );
void gtk_text_buffer_cut_clipboard (
                                 GtkTextBuffer *buffer,
                                 GtkClipboard *clipboard,
                                 gboolean default_editable );
gboolean gtk_text_buffer_get_selection_bounds( 
                                 GtkTextBuffer *buffer,
                                 GtkTextIter *start,
                                 GtkTextIter *end );
void gtk_text_buffer_apply_tag_by_name( 
                                 GtkTextBuffer *buffer,
                                 const gchar *name,
                                 const GtkTextIter *start,
                                 const GtkTextIter *end );

Mit gtk_text_buffer_delete_selection() wird eine Auswahl aus dem Puffer zwischen den Marken "insert" und "selection-bound" gelöscht. Wird interactive auf TRUE gesetzt, wird die Veränderung auch beachtet, und das dritte Argument default_editable hat auch hier eine Bedeutung. Wird dieser Wert auf TRUE gesetzt, gibt diese Funktion erst wirklich TRUE zurück, wenn auch tatsächlich eine Löschung stattgefunden hat.

Die nächsten drei Funktionen gtk_text_buffer_paste_clipboard(), gtk_text_buffer_cut_clipboard() und gtk_text_buffer_copy_clipboard() dienen alle als Schnittstelle zwischen der Zwischenablage und dem Textpuffer. Alle drei Funktionen haben ein Argument der Klasse GtkClipboard (Typenkennung: GTK_TYPE_CLIPBOARD). Im Beispiel wurde mithilfe des Funktionsaufrufs gtk_clipboard_get(GDK_NONE) als Argument dafür gesorgt, dass keine eigene Zwischenablage verwendet wird, sondern die systemweite Standard-Zwischenablage. Ebenfalls erhalten alle Funktionen als erstes Argument den Textpuffer vom Typ GtkTextBuffer.

Ansonsten wird mit der Funktion gtk_text_buffer_paste_clipboard() ein Text aus der Zwischenablage in den Puffer kopiert. Mit dem Argument override_location der Klasse GtkTextIter wurde im Beispiel NULL verwendet, was bedeutet, dass der Text an der Position des Cursors eingefügt wird. Mit default_editable geben Sie an, ob der Text editierbar sein soll – was gewöhnlich mit TRUE besetzt ist.

Mit gtk_text_buffer_copy_clipboard() wird ein ausgewählter Text im Textpuffer in die Zwischenablage kopiert.

gtk_text_buffer_cut_clipboard() fügt einen Text aus der Zwischenablage wieder in den Puffer ein. Auch hier wird mit default_editable angegeben, ob der Text editierbar sein soll.

Mit gtk_text_buffer_get_selection_bounds() initialisieren Sie die Argumente start und end mit der Anfangs- und Endposition des markierten Textes im Textpuffer (erstes Argument). Den so ermittelten Wert verwenden Sie anschließend zum Formatieren des Textes mit der Funktion gtk_text_buffer_apply_tag_by_name(), um einen Textpuffer (erstes Argument) mit einem Tag-Namen zu versehen, den Sie im Beispiel mit der Funktion create_tag() erzeugt haben.

Wie schon erwähnt, stellt dieser Überblick nur einen kleinen Abriss der Funktionen dar, die Ihnen mit dem Text-Widget-System zur Verfügung stehen. Wichtig erscheint mir noch ein Überblick über die Eigenschaften des GtkTextView-Widgets. Wobei es sich bei den Eigenschaften keineswegs um die Textformatierungen handelt, sondern um reine Darstellungsoptionen des Widgets GtkTextView selbst!

15.11.2 Scrollendes Fenster – GtkScrolledWindow 

Im Beispiel wurde auch GtkScrolledWindow (Typenkennung: GTK_TYPE_SCROLLED_WINDOW) verwendet. Dabei handelt es sich um ein Behälter-Widget, das genau ein Widget aufnehmen kann. Dieses wird z. B. verwendet, wenn etwas auf dem Bildschirm (Hauptfenster) nicht auf einmal vertikal bzw. horizontal darstellbar ist. Ist das Widget in diesem Behälter (GtkScrolledWindow) größer als darstellbar, findet der Anwender hierzu einen automatischen Rollbalken an einer von der Eigenschaft "window-placement" angegebenen Position. Damit lässt sich das Kind-Widget vertikal und/oder horizontal rollen. Folgende Eigenschaften können Sie für GtkScrolledWindow verwenden.