Sehr Umfangreiche Webseite zum Programmieren in C Perl CGI, Skripting, Linux, Systemprogrammierung C C++ C/C++ ANSI C Linux Windows GUI gtk gtk+ Gimp Toolkit Text Widgets Entry GUI gtk gtk+ Gimp Toolkit Text Widgets Text und Entry Widgets

Entry Widget           zurück Ein Kapitel tiefer zum Inhaltsverzeichnis

GtkEntry ist eine einfache einzeilige Texteingabebox. Erzeugen können Sie diese mit folgenden Funktionen ...

GtkWidget *gtk_entry_new(void);

...oder...

GtkWidget *gtk_entry_new_with_max_length(guint16 max);

Die erste Version dürfte klar sein. Bei der zweiten Version können Sie als Parameter angeben, wie viele Zeichen maximal in der Textbox mitangegeben werde dürfen.

Wollen Sie den Inhalt der Eingabebox schon mit einem Text belegen, dann verwenden Sie diese Funktion ...

void gtk_entry_set_text(GtkEntry *entry, const gchar *text);

Auslesen können Sie den Text aus der Textbox mit der Funktion ...

gchar *gtk_entry_get_text(GtkEntry *entry);

Nun wollen wir uns doch mal ein Programmbeispiel dazu ansehen ...

#include <gtk/gtk.h>

/*Programmende*/
void ende_cb(GtkObject *object)
{
 gtk_main_quit();
}

/*Ende vom 2.Fenster welches die Eingabe ausgibt*/
void ende_cb2(GtkWidget *widget, gpointer *data)
{
 gtk_widget_destroy(GTK_WINDOW(widget));
}

/*Inhalt von Entry leeren*/
void delete_text_cb(GtkWidget *widget, gpointer *data)
{
 gtk_entry_set_text(GTK_ENTRY(widget),"");
}

/*Inahlt von Entry auslesen und in einem neuem Fenster ausgeben*/
void read_text_cb(GtkWidget *widget, gpointer *data)
{
 GtkWidget *fenster2;
 GtkWidget *label;

 gchar *text=gtk_entry_get_text(GTK_ENTRY(widget));
 g_print("%s\n",text);

  /*Ein neues Fenster erstellen*/
 fenster2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 label = gtk_label_new(text);

 gtk_signal_connect(GTK_OBJECT(fenster2), "destroy",
                    GTK_SIGNAL_FUNC(ende_cb2), NULL);

 gtk_container_add(GTK_CONTAINER(fenster2),label);

 /*Zeigs uns.....*/
 gtk_widget_show_all(fenster2);

}


int main(int argc, char **argv)
{
 GtkWidget *fenster;
 GtkWidget *box;
 GtkWidget *button_quit, *button, *button2;
 GtkWidget *entry;

 /*Gtk initialisieren*/
 gtk_init(&argc, &argv);
 /*Ein neues Fenster erstellen*/
 fenster = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 /*Buttons erstellen*/

 button_quit  = gtk_button_new_with_label("Ende");
 button       = gtk_button_new_with_label("Text löschen");
 button2      = gtk_button_new_with_label("Text einlesen");

 entry        = gtk_entry_new_with_max_length(50);
 gtk_entry_set_text(GTK_ENTRY(entry),"Hier bitte Eingabe machen");

 /*Neue Box erstellen*/
 box = gtk_vbox_new(FALSE,0);


 /*Signale registrieren*/
 gtk_signal_connect_object(GTK_OBJECT(button_quit), "clicked",
                           GTK_SIGNAL_FUNC(ende_cb), GTK_OBJECT(fenster));
 gtk_signal_connect(GTK_OBJECT(fenster), "destroy",
                    GTK_SIGNAL_FUNC(ende_cb), NULL);
 gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                           GTK_SIGNAL_FUNC(delete_text_cb), GTK_OBJECT(entry));
 gtk_signal_connect_object(GTK_OBJECT(button2), "clicked",
                           GTK_SIGNAL_FUNC(read_text_cb), GTK_OBJECT(entry));


 /*Fensterposition*/
 gtk_window_set_position(GTK_WINDOW(fenster),GTK_WIN_POS_CENTER);

 gtk_container_set_border_width(GTK_CONTAINER(fenster),25);

 gtk_box_pack_start(GTK_BOX(box), entry, FALSE, FALSE, 10);
 gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
 gtk_box_pack_start(GTK_BOX(box), button2, FALSE, FALSE, 0);
 gtk_box_pack_start(GTK_BOX(box), button_quit, FALSE, FALSE, 0);


 gtk_container_add(GTK_CONTAINER(fenster),box);

 /*Zeigs uns.....*/
 gtk_widget_show_all(fenster);

 gtk_main();

 return 0;
}

Und so könnte es aussehen ...

Ich denke das Programm ist nicht schwer zu verstehen. Nun will ich hier noch weitere nützlich Funktionen erwähnen. Wollen Sie einen Text an einem bereits vorhandenen Text in der Eingabebox vorne einfügen oder hinten anfügen, so können Sie dies mit den folgenden Funktionen machen ...

void gtk_entry_append_text(GtkEntry *entry, const gchar *text); /*hinten anhängen*/
void gtk_entry_prepend_text(GtkEntry *entry, const gchar *text);/*vorne einfügen*/

Wollen Sie den Cursor an einer bestimmten Position positionieren ...

void gtk_entry_set_position(GtkEntry *entry, gint position);

Oder wollen Sie einen bestimmten Bereich markieren ...

void gtk_entry_select_region(GtkEntry *entry, gint start, gint end);

Hiermit markieren Sie den Text in der Eingabebox von der Position start bis zur Position end.

Wenn der Text nicht mehr verändert werden soll, können Sie dies mit dieser Funktion erreichen ...

void gtk_entry_set_editable(GtkEntry *entry, gboolen editable);

Geben sie als zweiten Paramter FALSE an, ist die Box gesperrt. Mit TRUE beheben sie dies wieder.

Text Widget           zurück Ein Kapitel tiefer zum Inhaltsverzeichnis

Nun wollen wir uns die Wigets ansehen, mit den wir einen eigenen Texteditor erstellen könnten. GtkText stellt uns diese Widgets zur Verfügung. Und außerdem wollen wir uns ansehen, wie wir den Text weiter editieren können (GtkEditable).

Zuerst wollen wir also eine Text Widget erzeugen. Dies können Sie mit der folgenden Funktion machen ...

GtkWidget *gtk_text_new(GtkAdjustment *hadj, GtkAdjustment *vadj);

Als Parameter übergeben Sie das Adjustment für die horizontale und vertikale Scrollbar. Wollen Sie das Adjustment nachträglich eintragen oder verändern dann macht man dies mit der Funktion ...

void gtk_text_set_adjustments(GtkText *text,GtkAdjustment *hadj, GtkAdjustment *vadj);

Es muss noch angemerkt werden, das das Text Widget keine horizontale Scrollbar unterstützt. Dies müssen Sie selbst erzeugen mit der Funktion gtk_vscrollbar_new().

Als nächstes müssen Sie angeben, ob das Textfeld bearbeitet (editiert) werden darf oder nicht. Dies legen wir mit dieser Funktion an ...

void gtk_text_set_editable(GtkText *text, gboolen editable);

Setzen Sie den Parameter editable auf TRUE, kann ein Text damit verarbeitet werden. Mit FALSE haben Sie keinen Zugriff mehr auf das Textfeld.

Wollen wir uns doch schon mal ein kleines Beispiel dazu ansehen ...

#include <gtk/gtk.h>

/*Programmende*/
void ende_cb(GtkObject *object)
{
 gtk_main_quit();
}



int main(int argc, char **argv)
{
 GtkWidget *fenster;
 GtkWidget *box;
 GtkWidget *text;
 GtkWidget *button_quit, *button, *button2;

 /*Gtk initialisieren*/
 gtk_init(&argc, &argv);
 /*Ein neues Fenster erstellen*/
 fenster = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 /*Buttons erstellen*/

 button_quit  = gtk_button_new_with_label("Ende");


 text = gtk_text_new(NULL, NULL);
 gtk_text_set_editable(GTK_TEXT(text),TRUE);
 /*Neue Box erstellen*/
 box = gtk_vbox_new(FALSE,0);


 /*Signale registrieren*/
 gtk_signal_connect_object(GTK_OBJECT(button_quit), "clicked",
                           GTK_SIGNAL_FUNC(ende_cb), GTK_OBJECT(fenster));
 gtk_signal_connect(GTK_OBJECT(fenster), "destroy",
                    GTK_SIGNAL_FUNC(ende_cb), NULL);


 /*Fensterposition*/
 gtk_window_set_position(GTK_WINDOW(fenster),GTK_WIN_POS_CENTER);

 gtk_container_set_border_width(GTK_CONTAINER(fenster),15);

 gtk_box_pack_start(GTK_BOX(box), text, FALSE, FALSE, 0);
 gtk_box_pack_start(GTK_BOX(box), button_quit, FALSE, FALSE, 10);


 gtk_container_add(GTK_CONTAINER(fenster),box);

 /*Zeigs uns.....*/
 gtk_widget_show_all(fenster);

 gtk_main();

 return 0;
}

Und so könnte es aussehen ...

An diesem Beispiel können Sie schon erkennen, dass die Wörter am Zeilenende gebrochen werden. Vermeiden können Sie dies mit der Funktion ...

void gtk_set_word_wrap(GtkText *text, gboolen wrap);

Wenn Sie für den Parameter wrap TRUE eingeben, werden die Worte nicht mehr einfach abgezwackt, sondern fangen in der neuen Zeile an. Mit FALSE erreichen Sie wieder die Default-Einstellung. Für unser Programm würde dies so aussehen ...

gtk_text_set_word_wrap(GTK_TEXT(text), TRUE);

Wollen Sie das die Zeile nicht am Ende gebrochen wird , können Sie diese Funktion verwenden ...

void gtk_text_set_line_wrap(GtkText *text, gboolen wrap);

Wenn Sie FALSE eingeben werden die Zeilen nicht gebrochen. Dann müssen Sie aber eine horizontale Scrollbar eingerichtet haben, da sich sonst der Text außer Ihrer Sichtbarkeit fortsetzt. Mit TRUE stellen Sie alles wieder zum Default-Zustand.

Wollen Sie die Position des Textes abfragen, bzw. setzen dann machen Sie dies mit den Funktionen ...

void gtk_text_set_point(GtkText *text, guint index); /*setzen*/
guint gtk_text_get_point(GtkText *text);             /*abfragen*/

Die Länge des Textes können sie mit der Funktion ...

quint gtk_text_get_length(GtkText *text);

... ermitteln. Wollen Sie schon einen vorgegeben Text eingeben, dann mit folgender Funktion ...

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

Somit fügen Sie ins Text Widget length Zeichen mit dem Inhalt von chars und dem Vordergrund von fore und dem Hintergrund von back mit der Schriftart font ein.

Diese Funktion verwenden wir zum Beispiel zum Einlesen von Dateien in den Texteditor. Hierzu ein Programmbeispiel. Ich gehe vorerst nicht auf die Gdk-Elemente ein und setze dafür NULL ein.

Sie können das Programm in der Kommandozeile öffnen um eine andere Datei einzulesen mit ...

programmname datei_zum_lesen

Besser wäre es natürlich, dies mit einer Entry-Box oder ähnlichem zu machen. Hier geht es aber nur zur Demonstration der Funktion gtk_text_insert(). Hierzu der Quellcode ...

#include <gtk/gtk.h>
#include <stdio.h>

/*Programmende*/
void ende_cb(GtkObject *object)
{
 gtk_main_quit();
}

/*Gibt aktuelle Textlänge auf Konsole aus*/
void text_length_cb(GtkWidget* widget, gpointer data)
{
 guint length = gtk_text_get_length(GTK_TEXT(widget));
 g_print("Aktuelle Textlänge : %d\n",length);
}



int main(int argc, char **argv)
{
 GtkWidget *fenster;
 GtkWidget *box, *box2;
 GtkWidget *text;
 GtkWidget *button_quit, *button, *button2;
 FILE *f;
 char file[255];
 int is_file, nchar;

 if(argc == 2)
  {
   f = fopen(argv[1], "r");
   if(NULL == f)
    is_file = 0;
   else
    is_file = 1;
  }

 /*Gtk initialisieren*/
 gtk_init(&argc, &argv);
 /*Ein neues Fenster erstellen*/
 fenster = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 /*Buttons erstellen*/
 gtk_window_set_default_size(GTK_WINDOW(fenster), 320, 300);

 button_quit  = gtk_button_new_with_label("Ende");
 button = gtk_button_new_with_label("Textlänge");

 text = gtk_text_new(NULL, NULL);
 gtk_text_set_editable(GTK_TEXT(text),TRUE);
 gtk_text_set_word_wrap(GTK_TEXT(text), TRUE);

 /*Neue Box erstellen*/
 box = gtk_vbox_new(FALSE,0);
 box2= gtk_hbox_new(FALSE,0);


 /*Signale registrieren*/
 gtk_signal_connect_object(GTK_OBJECT(button_quit), "clicked",
                           GTK_SIGNAL_FUNC(ende_cb), GTK_OBJECT(fenster));
 gtk_signal_connect(GTK_OBJECT(fenster), "destroy",
                    GTK_SIGNAL_FUNC(ende_cb), NULL);
 gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
                    GTK_SIGNAL_FUNC(text_length_cb), GTK_OBJECT(text));


 /*Fensterposition*/
 gtk_window_set_position(GTK_WINDOW(fenster),GTK_WIN_POS_CENTER);

 if(is_file)
   {
     while (1)
      {
        nchar = fread(file, 1, 255, f);
        gtk_text_insert (GTK_TEXT (text), NULL, NULL,
                         NULL, file, nchar);

        if (nchar < 255)
          break;
      }
   }

 gtk_container_set_border_width(GTK_CONTAINER(fenster),15);

 gtk_box_pack_start(GTK_BOX(box), text, TRUE, TRUE, 10);
 gtk_box_pack_start(GTK_BOX(box2), button_quit, TRUE, FALSE, 0);
 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, FALSE, 0);
 gtk_box_pack_start(GTK_BOX(box), box2, FALSE, FALSE, 0);


 gtk_container_add(GTK_CONTAINER(fenster),box);

 /*Zeigs uns.....*/
 gtk_widget_show_all(fenster);

 gtk_main();

 return 0;
}

Und so könnte es aussehen ...

Weiter nützliche Funktionen wären ...

qint gtk_text_foreward_delete(GtkText *text, gint nchars);
gint gtk_text_backward_delete(GtkText *text, gint nchars);

Damit werden von der aktuellen Position nchar Zeichen im Text vorwärts bzw. rückwärts gelöscht.

Wollen Sie den Text für die weiter Bearbeitung Sperren ...

void gtk_text_freeze(GtkText *text);

Aufheben können Sie diese Sperre wieder mit der Funktion ...

void gtk_text_thaw(GtkText *text);

Weiter mit Menüs mit GtkItemFactory