Les zones de texte
Nous avons appris à saisir une ligne tapée par l'utilisateur
grâce à GtkEntry mais comment fait-on pour saisir plusieurs lignes
(comme le font les traitements de texte, etc.). Et bien nous utilisons non pas
un mais trois widgets !
GtkTextBuffer : Ce widget non-graphique sert à stocker les données.
C'est tout simplement un buffer !
GtkTextView : Ce widget sert à afficher le contenu d'un GtkTextBuffer.
Il s'occupe de tout ce qui est graphique : il gère les évènements
de l'utilisateur, les insertions de caractères, etc.
GtkTextIter : Ce widget non-graphique désigne une position dans GtkTextBuffer.
Il permet de manipuler GtkTextBuffer.
1. Créer une application saisissant un paragraphe.
1.1 Afficher un GtkTextView
On va maintenant initialiser un pointeur de type GtkWidget* qui pointera vers
la structure du GtkTextView :
GtkWidget* text_view=gtk_text_view_new();
Là, nous venons de créer un GtkTextView mais également
un GtkTextBuffer. Si nous voulons donner notre propre buffer, nous utiliserons
la fonction
GtkWidget* gtk_text_view_new_with_buffer(GtkTextBuffer* buffer) qui reçoit
en argument l'adresse de notre buffer.
Il faut maintenant insérer text_view dans la box.
gtk_box_pack_start(GTK_BOX(box),text_view,TRUE,TRUE,0);
C bon ! On peut commencer à compiler pour voir le résultat et
même commencer à saisir du texte dedans (mais ça ne sert
strictement à rien:-).
1.2 Accéder au contenu de GtkTextBuffer
Tout d'abord, on va créer un bouton qui dès qu'il sera cliqué
par l'utilisateur, on saisira le contenu du buffer :
button=gtk_button_new_with_label("Valider");
gtk_box_pack_start(GTK_BOX(box),button,false,false,0);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(saisie),text_view);
Pendant la connection du signal, on envoie text_view pour pouvoir travailler
dessus dans la fonction callback :
void saisie(GtkButton *button, gpointer user_data)
{
}
Ce qui suit est à insérer dans la fonction.
Comme on a pas donné "notre" GtkTextBuffer pendant la création
de text_view, GTK+ a donné un buffer par défaut. Pour récupérer
l'adresse de ce buffer, on utilise la fonction
GtkTextBuffer* gtk_text_view_get_buffer (GtkTextView* text_view)
On va bien sûr recevoir la valeur renvoyée par la fonction dans
un un pointeur de type GtkTextBuffer* et non pas GtkWidget* :
text_buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(user_data));
Enregistrer la macro de conversion au passage…
Maintenant, reste plus qu'à extraire les données contenues dans
text_buffer et les mettre dans un gchar* par exemple. On utilise la fonction
gchar* gtk_text_buffer_get_text (GtkTextBuffer *buffer, const
GtkTextIter *start, const GtkTextIter *end, gboolean include_hidden_chars)
Où là ! C'est quoi tous ces paramètres ! On va les traiter
un par un :
buffer : pas de commentaire
start : la position de début de la chaîne de caractère
end : la position de fin de la chaîne de caractère
include_hidden_chars : on verra plus tard :-) (mettre false)
valeur retournée : une chaîne de caractère de type C et
allouée dans le tas
Mais à quoi peut bien servir le deuxième et le troisième
paramètre ? Et bien imaginez que vous ne vouliez qu'une partie du buffer,
et bien ces deux paramètres indiquent la position de début et
de fin de la chaîne de caractère dans le buffer. On appelle cela
une sous-chaîne de caractère.
Mais comment ça s'initialise les GtkTextIter ?
On ne va pas déclarer des pointeurs comme on a l'habitude de le faire
mais des variables directo. Nous voulons recevoir tout le buffer. Les itérateurs
doivent être les itérateurs de début et de fin de text_buffer.
Pour ce faire, nous utiliserons les deux fonction
void gtk_text_buffer_get_start_iter (GtkTextBuffer *buffer,
GtkTextIter *iter)
void gtk_text_buffer_get_end_iter(GtkTextBuffer *buffer, GtkTextIter *iter)
On va donc initialiser nos deux itérateurs comme cela :
gtk_text_buffer_get_start_iter(text_buffer,&start);
gtk_text_buffer_get_end_iter(text_buffer,&end);
A noter que nous n'avons pas besoin de la macro de conversion GTK_TEXT_BUFFER()
pour text_buffer car c'est déjà un pointeur de type GtkTextBuffer*
et ne pas oublier le & avant start et end car ce ne sont pas des pointeurs.
Et la fonction reçoit leur adresse.
Maintenant, on va utiliser la fonction gtk_text_buffer_get_text :
buf=gtk_text_buffer_get_text(text_buffer,&start,&end,false);
Et voilà ! Nous avons le contenu de text_buffer copié dans buf.
On peut faire ce qu'on veut avec maintenant : le copier dans un fichier, l'afficher
dans un autre widget, etc.
Il ne faut surtout pas oublier d'utiliser la fonction g_free() qui est la version
GTK+ de la fonction free du C pour libérer la mémoire allouée
dans le tas par buf :
g_free(buf);
1.3 Programme exemple
#include <gtk\gtk.h>
gboolean fin(GtkWidget *widget, GdkEvent *event, gpointer user_data);
void saisie(GtkButton *button, GtkWidget *view);
int main(int argc, char* argv[])
{
GtkWidget* window;
GtkWidget* box;
GtkWidget* text_view;
GtkWidget* button;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 320, 200);
gtk_window_set_title(GTK_WINDOW(window), "XIII. Les zones de texte.");
g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),0);
box=gtk_vbox_new(FALSE,5);
gtk_container_add(GTK_CONTAINER(window),box);
text_view=gtk_text_view_new();
gtk_box_pack_start(GTK_BOX(box),text_view,TRUE,TRUE,0);
button=gtk_button_new_with_label("Afficher");
gtk_box_pack_start(GTK_BOX(box),button,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(saisie),text_view);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
gboolean fin(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
gtk_widget_destroy(widget);
gtk_main_quit();
return 0;
}
void saisie(GtkButton *button, GtkWidget *view)
{
GtkWidget *dialog;
GtkTextBuffer* text_buffer=0;
GtkTextIter start;
GtkTextIter end;
gchar* buf=0;
//On recupere le buffer
text_buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
//On recupere l'origine du buffer
gtk_text_buffer_get_start_iter(text_buffer,&start);
//On recupere la fin du buffer
gtk_text_buffer_get_end_iter(text_buffer,&end);
//On copie le contenu du buffer dans une variable
buf=gtk_text_buffer_get_text(text_buffer,&start, &end,TRUE);
//On affiche le texte dans une boite de dialogue.
dialog = gtk_message_dialog_new(NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"Votre texte :\n%s", buf);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
//On libere la memoire
g_free(buf);
} |
Résultat :
|
2. Affichage du contenu d'un fichier.
Maintenant, nous allons utiliser ce que nous avons vu dans les deux précédents
chapitres afin de créer une application ouvrant un fichier et affichant
son contenu.
2.1 Construction de l'application.
Nous avons déjà vu la quasi totalité des fonction que
nous allons utiliser pour ce programme, cela va donc aller assez vite. Nous
allons étudier uniquement la partie du code qui a pour fonction de lire
le fichier et d'afficher le texte.
Dans un premier temps, nous allons récupérer le buffer de notre
GtkTextView.
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
Ensuite on récupère le chemin du fichier et on l'ouvre en mode
texte :
chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION
(file_selection));
fichier = fopen(chemin,"rt");
Si le fichier ne c'est pas ouvert correctement, on affiche bien sur un message
d'erreur.
On vide ensuite le contenu du buffer avec cette fonction.
void gtk_text_buffer_delete (GtkTextBuffer *buffer, GtkTextIter
*start, GtkTextIter *end);
Il faut bien sur récupérer auparavent les valeurs start
et end comme pour le premier exemple.
gtk_text_buffer_delete(buffer, &start, &end);
Ensuite, le procédé consiste à lire les lignes du fichier
une par une et à les ajouter au buffer avec la fonction :
void gtk_text_buffer_insert (GtkTextBuffer *buffer, GtkTextIter
*iter, const gchar *text, gint len);
Le paramètre iter est la position du buffer à partir de laquelle
le texte text va être ajouté. Il faut donc avant chaque insertion
récupérer la position finale du buffer pour que le texte se place
correctement. Voici la boucle qui nous permet de créer notre buffer.
while(fgets(lecture, 1024, fichier))
{
gtk_text_buffer_get_end_iter(buffer,&end);
gtk_text_buffer_insert(buffer, &end, g_locale_to_utf8(lecture, -1, NULL,
NULL, NULL), -1);
}
Et voila le code source est complet.
2.2 Programme exemple.
#include <gtk/gtk.h>
#include <stdio.h>
static GtkWidget *text_view;
void saisie(GtkButton *button);
void ouvrir_fichier(GtkWidget *bouton, GtkWidget *file_selection);
int main(int argc, char* argv[])
{
GtkWidget* window;
GtkWidget* box;
GtkWidget* button;
GtkWidget *scrollbar;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 480, 480);
gtk_window_set_title(GTK_WINDOW(window), "XIII. Les zones de texte.");
g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),0);
box=gtk_vbox_new(FALSE,5);
gtk_container_add(GTK_CONTAINER(window),box);
scrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(box), scrollbar, TRUE, TRUE, 5);
text_view=gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(scrollbar),text_view);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbar), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
button=gtk_button_new_with_label(g_locale_to_utf8( "Sélectionnez
un fichier", -1, NULL, NULL, NULL));
gtk_box_pack_start(GTK_BOX(box),button,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(saisie),NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void saisie(GtkButton *button)
{
GtkWidget *selection;
selection = gtk_file_selection_new( g_locale_to_utf8( "Sélectionnez
un fichier", -1, NULL, NULL, NULL) );
gtk_widget_show(selection);
g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(selection)->ok_button),
"clicked", G_CALLBACK(ouvrir_fichier), selection );
g_signal_connect_swapped(G_OBJECT(GTK_FILE_SELECTION(selection)->cancel_button),
"clicked", G_CALLBACK(gtk_widget_destroy), selection);
}
void ouvrir_fichier(GtkWidget *bouton, GtkWidget *file_selection)
{
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
FILE *fichier;
const gchar *chemin;
gchar lecture[1024];
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION (file_selection));
fichier = fopen(chemin,"rt");
if(fichier == NULL)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new(GTK_WINDOW(file_selection), GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Impossible d'ouvrir le fichier
: \n%s", g_locale_to_utf8(chemin, -1, NULL, NULL, NULL));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
gtk_widget_destroy(file_selection);
return;
}
gtk_widget_destroy(file_selection);
gtk_text_buffer_get_start_iter(buffer,&start);
gtk_text_buffer_get_end_iter(buffer,&end);
gtk_text_buffer_delete(buffer, &start, &end);
while(fgets(lecture, 1024, fichier))
{
gtk_text_buffer_get_end_iter(buffer,&end);
gtk_text_buffer_insert(buffer, &end, g_locale_to_utf8(lecture, -1, NULL,
NULL, NULL), -1);
}
fclose(fichier);
}
|
Résultat :
|
3. En savoir plus :
Les fonctions de ces trois widgets sont très nombreuses, aussi la plupart
des fonctions documentées ici seront étudiés plus en détails
dans les prochains chapitres du cours. (Fonction documentées à venir).
3.1 Les signaux
GtkTextView
| copy-clipboard |
| Prototype fonction callback : void user_function (GtkTextView
*textview, gpointer user_data); |
| cut-clipboard |
| Prototype fonction callback : void user_function (GtkTextView
*textview, gpointer user_data); |
| delete-from-cursor |
| Prototype fonction callback : void user_function (GtkTextView
*textview, GtkDeleteType arg1, gint arg2, gpointer user_data); |
| insert-at-cursor |
| Prototype fonction callback : void user_function (GtkTextView
*textview, gchar *arg1, gpointer user_data); |
| move-cursor |
| Prototype fonction callback : void user_function (GtkTextView
*textview, GtkMovementStep arg1, gint arg2, gboolean arg3, gpointer user_data); |
| move-focus |
| Prototype fonction callback : void user_function (GtkTextView
*textview, GtkDirectionType arg1, gpointer user_data); |
| page-horizontally |
| Prototype fonction callback : void user_function (GtkTextView
*textview, gint arg1, gboolean arg2, gpointer user_data); |
| paste-clipboard |
| Prototype fonction callback : void user_function (GtkTextView
*textview, gpointer user_data); |
| populate-popup |
| Prototype fonction callback : void user_function (GtkTextView
*textview, GtkMenu *arg1, gpointer user_data); |
| set-anchor |
| Prototype fonction callback : void user_function (GtkTextView
*textview, gpointer user_data); |
| set-scroll-adjustments |
| Prototype fonction callback : void user_function (GtkTextView
*textview, GtkAdjustment *arg1, GtkAdjustment *arg2, gpointer user_data); |
| toggle-overwrite |
| Prototype fonction callback : void user_function (GtkTextView
*textview, gpointer user_data); |
GtkTextBuffer :
| apply-tag |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTextTag *arg1, GtkTypeTextIter arg2, GtkTypeTextIter arg3,
gpointer user_data); |
| begin-user-action |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, gpointer user_data); |
| changed |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, gpointer user_data); |
| delete-range |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTypeTextIter arg1, GtkTypeTextIter arg2, gpointer user_data); |
| end-user-action |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, gpointer user_data); |
| insert-child-anchor |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTypeTextIter arg1, GtkTextChildAnchor *arg2, gpointer user_data); |
| insert-pixbuf |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTypeTextIter arg1, GdkPixbuf *arg2, gpointer user_data); |
| insert-text |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTypeTextIter arg1, gchar *arg2, gint arg3, gpointer user_data); |
| mark-deleted |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTextMark *arg1, gpointer user_data); |
| mark-set |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTypeTextIter arg1, GtkTextMark *arg2, gpointer user_data); |
| modified-changed |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, gpointer user_data); |
| remove-tag |
| Prototype fonction callback : void user_function (GtkTextBuffer
*textbuffer, GtkTextTag *arg1, GtkTypeTextIter arg2, GtkTypeTextIter arg3,
gpointer user_data); |
3.2 Fonctions non documentées
GtkTextView :
GtkWidget* gtk_text_view_new_with_buffer (GtkTextBuffer *buffer);
void gtk_text_view_set_buffer (GtkTextView *text_view, GtkTextBuffer *buffer);
GtkTextBuffer* gtk_text_view_get_buffer (GtkTextView *text_view);
void gtk_text_view_scroll_to_mark (GtkTextView *text_view, GtkTextMark *mark,
gdouble within_margin, gboolean use_align, gdouble xalign, gdouble yalign);
gboolean gtk_text_view_scroll_to_iter (GtkTextView *text_view, GtkTextIter *iter,
gdouble within_margin, gboolean use_align, gdouble xalign, gdouble yalign);
void gtk_text_view_scroll_mark_onscreen (GtkTextView *text_view, GtkTextMark *mark);
gboolean gtk_text_view_move_mark_onscreen(GtkTextView *text_view, GtkTextMark
*mark);
gboolean gtk_text_view_place_cursor_onscreen(GtkTextView *text_view);
void gtk_text_view_get_visible_rect (GtkTextView *text_view, GdkRectangle *visible_rect);
void gtk_text_view_get_iter_location (GtkTextView *text_view, const GtkTextIter
*iter, GdkRectangle *location);
void gtk_text_view_get_line_at_y (GtkTextView *text_view, GtkTextIter *target_iter,
gint y, gint *line_top);
void gtk_text_view_get_line_yrange (GtkTextView *text_view, const GtkTextIter
*iter, gint *y, gint *height);
void gtk_text_view_get_iter_at_location(GtkTextView *text_view, GtkTextIter *iter,
gint x, gint y);
void gtk_text_view_buffer_to_window_coords(GtkTextView *text_view, GtkTextWindowType
win, gint buffer_x, gint buffer_y, gint *window_x, gint *window_y);
void gtk_text_view_window_to_buffer_coords(GtkTextView *text_view, GtkTextWindowType
win, gint window_x, gint window_y, gint *buffer_x, gint *buffer_y);
GdkWindow* gtk_text_view_get_window (GtkTextView *text_view, GtkTextWindowType
win);
GtkTextWindowType gtk_text_view_get_window_type(GtkTextView *text_view, GdkWindow
*window);
void gtk_text_view_set_border_window_size(GtkTextView *text_view, GtkTextWindowType
type, gint size);
gint gtk_text_view_get_border_window_size(GtkTextView *text_view, GtkTextWindowType
type);
gboolean gtk_text_view_forward_display_line(GtkTextView *text_view, GtkTextIter
*iter);
gboolean gtk_text_view_backward_display_line(GtkTextView *text_view, GtkTextIter
*iter);
gboolean gtk_text_view_forward_display_line_end(GtkTextView *text_view, GtkTextIter
*iter);
gboolean gtk_text_view_backward_display_line_start(GtkTextView *text_view, GtkTextIter
*iter);
gboolean gtk_text_view_starts_display_line(GtkTextView *text_view, const GtkTextIter
*iter);
gboolean gtk_text_view_move_visually (GtkTextView *text_view, GtkTextIter *iter,
gint count);
void gtk_text_view_add_child_at_anchor(GtkTextView *text_view, GtkWidget *child,
GtkTextChildAnchor *anchor);
GtkTextChildAnchor* gtk_text_child_anchor_new(void);
GList* gtk_text_child_anchor_get_widgets(GtkTextChildAnchor *anchor);
gboolean gtk_text_child_anchor_get_deleted(GtkTextChildAnchor *anchor);
void gtk_text_view_add_child_in_window(GtkTextView *text_view, GtkWidget *child,
GtkTextWindowType which_window, gint xpos, gint ypos);
void gtk_text_view_move_child (GtkTextView *text_view, GtkWidget *child, gint
xpos, gint ypos);
void gtk_text_view_set_wrap_mode (GtkTextView *text_view, GtkWrapMode wrap_mode);
GtkWrapMode gtk_text_view_get_wrap_mode (GtkTextView *text_view);
void gtk_text_view_set_editable (GtkTextView *text_view, gboolean setting);
gboolean gtk_text_view_get_editable (GtkTextView *text_view);
void gtk_text_view_set_cursor_visible(GtkTextView *text_view, gboolean setting);
gboolean gtk_text_view_get_cursor_visible(GtkTextView *text_view);
void gtk_text_view_set_pixels_above_lines(GtkTextView *text_view, gint pixels_above_lines);
gint gtk_text_view_get_pixels_above_lines(GtkTextView *text_view);
void gtk_text_view_set_pixels_below_lines(GtkTextView *text_view, gint pixels_below_lines);
gint gtk_text_view_get_pixels_below_lines(GtkTextView *text_view);
void gtk_text_view_set_pixels_inside_wrap(GtkTextView *text_view, gint pixels_inside_wrap);
gint gtk_text_view_get_pixels_inside_wrap(GtkTextView *text_view);
void gtk_text_view_set_justification (GtkTextView *text_view, GtkJustification
justification);
GtkJustification gtk_text_view_get_justification(GtkTextView *text_view);
void gtk_text_view_set_left_margin (GtkTextView *text_view, gint left_margin);
gint gtk_text_view_get_left_margin (GtkTextView *text_view);
void gtk_text_view_set_right_margin (GtkTextView *text_view, gint right_margin);
gint gtk_text_view_get_right_margin (GtkTextView *text_view);
void gtk_text_view_set_indent (GtkTextView *text_view, gint indent);
gint gtk_text_view_get_indent (GtkTextView *text_view);
void gtk_text_view_set_tabs (GtkTextView *text_view, PangoTabArray *tabs);
PangoTabArray* gtk_text_view_get_tabs (GtkTextView *text_view);
GtkTextAttributes* gtk_text_view_get_default_attributes(GtkTextView *text_view);
GtkTextBuffer :
GtkTextBuffer* gtk_text_buffer_new (GtkTextTagTable *table);
gint gtk_text_buffer_get_line_count (GtkTextBuffer *buffer);
gint gtk_text_buffer_get_char_count (GtkTextBuffer *buffer);
GtkTextTagTable* gtk_text_buffer_get_tag_table(GtkTextBuffer *buffer);
void gtk_text_buffer_insert_at_cursor(GtkTextBuffer *buffer, const gchar *text,
gint len);
gboolean gtk_text_buffer_insert_interactive(GtkTextBuffer *buffer, GtkTextIter
*iter, const gchar *text, gint len, gboolean default_editable);
gboolean gtk_text_buffer_insert_interactive_at_cursor(GtkTextBuffer *buffer, const
gchar *text, gint len, gboolean default_editable);
void gtk_text_buffer_insert_range (GtkTextBuffer *buffer, GtkTextIter *iter, const
GtkTextIter *start, const GtkTextIter *end);
gboolean gtk_text_buffer_insert_range_interactive(GtkTextBuffer *buffer, GtkTextIter
*iter, const GtkTextIter *start, const GtkTextIter *end, gboolean default_editable);
void gtk_text_buffer_insert_with_tags(GtkTextBuffer *buffer, GtkTextIter *iter,
const gchar *text, gint len, GtkTextTag *first_tag, ...);
void gtk_text_buffer_insert_with_tags_by_name(GtkTextBuffer *buffer, GtkTextIter
*iter, const gchar *text, gint len, const gchar *first_tag_name, ...);
gboolean gtk_text_buffer_delete_interactive(GtkTextBuffer *buffer, GtkTextIter
*start_iter, GtkTextIter *end_iter, gboolean default_editable);
void gtk_text_buffer_set_text (GtkTextBuffer *buffer, const gchar *text, gint
len);
gchar* gtk_text_buffer_get_slice (GtkTextBuffer *buffer, const GtkTextIter *start,
const GtkTextIter *end, gboolean include_hidden_chars);
void gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer, GtkTextIter *iter,
GdkPixbuf *pixbuf);
void gtk_text_buffer_insert_child_anchor(GtkTextBuffer *buffer, GtkTextIter *iter,
GtkTextChildAnchor *anchor);
GtkTextChildAnchor* gtk_text_buffer_create_child_anchor(GtkTextBuffer *buffer,
GtkTextIter *iter);
GtkTextMark* gtk_text_buffer_create_mark (GtkTextBuffer *buffer, const gchar *mark_name,
const GtkTextIter *where, gboolean left_gravity);
void gtk_text_buffer_move_mark (GtkTextBuffer *buffer, GtkTextMark *mark, const
GtkTextIter *where);
void gtk_text_buffer_move_mark_by_name(GtkTextBuffer *buffer, const gchar *name,
const GtkTextIter *where);
void gtk_text_buffer_delete_mark (GtkTextBuffer *buffer, GtkTextMark *mark);
void gtk_text_buffer_delete_mark_by_name(GtkTextBuffer *buffer, const gchar *name);
GtkTextMark* gtk_text_buffer_get_mark (GtkTextBuffer *buffer, const gchar *name);
GtkTextMark* gtk_text_buffer_get_insert (GtkTextBuffer *buffer);
GtkTextMark* gtk_text_buffer_get_selection_bound(GtkTextBuffer *buffer);
void gtk_text_buffer_place_cursor (GtkTextBuffer *buffer, const GtkTextIter *where);
void gtk_text_buffer_apply_tag (GtkTextBuffer *buffer, GtkTextTag *tag, const
GtkTextIter *start, const GtkTextIter *end);
void gtk_text_buffer_remove_tag (GtkTextBuffer *buffer, GtkTextTag *tag, const
GtkTextIter *start, const GtkTextIter *end);
void gtk_text_buffer_apply_tag_by_name(GtkTextBuffer *buffer, const gchar *name,
const GtkTextIter *start, const GtkTextIter *end);
void gtk_text_buffer_remove_tag_by_name(GtkTextBuffer *buffer, const gchar *name,
const GtkTextIter *start, const GtkTextIter *end);
void gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer, const GtkTextIter
*start, const GtkTextIter *end);
GtkTextTag* gtk_text_buffer_create_tag (GtkTextBuffer *buffer, const gchar *tag_name,
const gchar *first_property_name, ...);
void gtk_text_buffer_get_iter_at_line_offset(GtkTextBuffer *buffer, GtkTextIter
*iter, gint line_number, gint char_offset);
void gtk_text_buffer_get_iter_at_offset(GtkTextBuffer *buffer, GtkTextIter *iter,
gint char_offset);
void gtk_text_buffer_get_iter_at_line(GtkTextBuffer *buffer, GtkTextIter *iter,
gint line_number);
void gtk_text_buffer_get_iter_at_line_index(GtkTextBuffer *buffer, GtkTextIter
*iter, gint line_number, gint byte_index);
void gtk_text_buffer_get_iter_at_mark(GtkTextBuffer *buffer, GtkTextIter *iter,
GtkTextMark *mark);
void gtk_text_buffer_get_iter_at_child_anchor(GtkTextBuffer *buffer, GtkTextIter
*iter, GtkTextChildAnchor *anchor);
void gtk_text_buffer_get_bounds (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter
*end);
gboolean gtk_text_buffer_get_modified (GtkTextBuffer *buffer);
void gtk_text_buffer_set_modified (GtkTextBuffer *buffer, gboolean setting);
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_begin_user_action(GtkTextBuffer *buffer);
void gtk_text_buffer_end_user_action (GtkTextBuffer *buffer);
void gtk_text_buffer_add_selection_clipboard(GtkTextBuffer *buffer, GtkClipboard
*clipboard);
void gtk_text_buffer_remove_selection_clipboard(GtkTextBuffer *buffer, GtkClipboard
*clipboard);
GtkTextIter :
GtkTextBuffer* gtk_text_iter_get_buffer (const GtkTextIter *iter);
GtkTextIter* gtk_text_iter_copy (const GtkTextIter *iter);
void gtk_text_iter_free (GtkTextIter *iter);
gint gtk_text_iter_get_offset (const GtkTextIter *iter);
gint gtk_text_iter_get_line (const GtkTextIter *iter);
gint gtk_text_iter_get_line_offset (const GtkTextIter *iter);
gint gtk_text_iter_get_line_index (const GtkTextIter *iter);
gint gtk_text_iter_get_visible_line_index(const GtkTextIter *iter);
gint gtk_text_iter_get_visible_line_offset(const GtkTextIter *iter);
gunichar gtk_text_iter_get_char (const GtkTextIter *iter);
gchar* gtk_text_iter_get_slice (const GtkTextIter *start, const GtkTextIter *end);
gchar* gtk_text_iter_get_text (const GtkTextIter *start, const GtkTextIter *end);
gchar* gtk_text_iter_get_visible_slice (const GtkTextIter *start, const GtkTextIter
*end);
gchar* gtk_text_iter_get_visible_text (const GtkTextIter *start, const GtkTextIter
*end);
GdkPixbuf* gtk_text_iter_get_pixbuf (const GtkTextIter *iter);
GSList* gtk_text_iter_get_marks (const GtkTextIter *iter);
GSList* gtk_text_iter_get_toggled_tags (const GtkTextIter *iter, gboolean toggled_on);
GtkTextChildAnchor* gtk_text_iter_get_child_anchor(const GtkTextIter *iter);
gboolean gtk_text_iter_begins_tag (const GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_ends_tag (const GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_toggles_tag (const GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_has_tag (const GtkTextIter *iter, GtkTextTag *tag);
GSList* gtk_text_iter_get_tags (const GtkTextIter *iter);
gboolean gtk_text_iter_editable (const GtkTextIter *iter, gboolean default_setting);
gboolean gtk_text_iter_can_insert (const GtkTextIter *iter, gboolean default_editability);
gboolean gtk_text_iter_starts_word (const GtkTextIter *iter);
gboolean gtk_text_iter_ends_word (const GtkTextIter *iter);
gboolean gtk_text_iter_inside_word (const GtkTextIter *iter);
gboolean gtk_text_iter_starts_line (const GtkTextIter *iter);
gboolean gtk_text_iter_ends_line (const GtkTextIter *iter);
gboolean gtk_text_iter_starts_sentence (const GtkTextIter *iter);
gboolean gtk_text_iter_ends_sentence (const GtkTextIter *iter);
gboolean gtk_text_iter_inside_sentence (const GtkTextIter *iter);
gboolean gtk_text_iter_is_cursor_position(const GtkTextIter *iter);
gint gtk_text_iter_get_chars_in_line (const GtkTextIter *iter);
gint gtk_text_iter_get_bytes_in_line (const GtkTextIter *iter);
gboolean gtk_text_iter_get_attributes (const GtkTextIter *iter, GtkTextAttributes
*values);
PangoLanguage* gtk_text_iter_get_language (const GtkTextIter *iter);
gboolean gtk_text_iter_is_end (const GtkTextIter *iter);
gboolean gtk_text_iter_is_start (const GtkTextIter *iter);
gboolean gtk_text_iter_forward_char (GtkTextIter *iter);
gboolean gtk_text_iter_backward_char (GtkTextIter *iter);
gboolean gtk_text_iter_forward_chars (GtkTextIter *iter, gint count);
gboolean gtk_text_iter_backward_chars (GtkTextIter *iter, gint count);
gboolean gtk_text_iter_forward_line (GtkTextIter *iter);
gboolean gtk_text_iter_backward_line (GtkTextIter *iter);
gboolean gtk_text_iter_forward_lines (GtkTextIter *iter, gint count);
gboolean gtk_text_iter_backward_lines (GtkTextIter *iter, gint count);
gboolean gtk_text_iter_forward_word_ends (GtkTextIter *iter, gint count);
gboolean gtk_text_iter_backward_word_starts(GtkTextIter *iter, gint count);
gboolean gtk_text_iter_forward_word_end (GtkTextIter *iter);
gboolean gtk_text_iter_backward_word_start(GtkTextIter *iter);
gboolean gtk_text_iter_forward_cursor_position(GtkTextIter *iter);
gboolean gtk_text_iter_backward_cursor_position(GtkTextIter *iter);
gboolean gtk_text_iter_forward_cursor_positions(GtkTextIter *iter, gint count);
gboolean gtk_text_iter_backward_cursor_positions(GtkTextIter *iter, gint count);
gboolean gtk_text_iter_backward_sentence_start(GtkTextIter *iter);
gboolean gtk_text_iter_backward_sentence_starts(GtkTextIter *iter, gint count);
gboolean gtk_text_iter_forward_sentence_end(GtkTextIter *iter);
gboolean gtk_text_iter_forward_sentence_ends(GtkTextIter *iter, gint count);
void gtk_text_iter_set_offset (GtkTextIter *iter, gint char_offset);
void gtk_text_iter_set_line (GtkTextIter *iter, gint line_number);
void gtk_text_iter_set_line_offset (GtkTextIter *iter, gint char_on_line);
void gtk_text_iter_set_line_index (GtkTextIter *iter, gint byte_on_line);
void gtk_text_iter_set_visible_line_index(GtkTextIter *iter, gint byte_on_line);
void gtk_text_iter_set_visible_line_offset(GtkTextIter *iter, gint char_on_line);
void gtk_text_iter_forward_to_end (GtkTextIter *iter);
gboolean gtk_text_iter_forward_to_line_end(GtkTextIter *iter);
gboolean gtk_text_iter_forward_to_tag_toggle(GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_backward_to_tag_toggle(GtkTextIter *iter, GtkTextTag *tag);
gboolean (*GtkTextCharPredicate) (gunichar ch, gpointer user_data);
gboolean gtk_text_iter_forward_find_char (GtkTextIter *iter, GtkTextCharPredicate
pred, gpointer user_data, const GtkTextIter *limit);
gboolean gtk_text_iter_backward_find_char(GtkTextIter *iter, GtkTextCharPredicate
pred, gpointer user_data, const GtkTextIter *limit);
gboolean gtk_text_iter_forward_search (const GtkTextIter *iter, const gchar *str,
GtkTextSearchFlags flags, GtkTextIter *match_start, GtkTextIter *match_end, const
GtkTextIter *limit);
gboolean gtk_text_iter_backward_search (const GtkTextIter *iter, const gchar *str,
GtkTextSearchFlags flags, GtkTextIter *match_start, GtkTextIter *match_end, const
GtkTextIter *limit);
gboolean gtk_text_iter_equal (const GtkTextIter *lhs, const GtkTextIter *rhs);
gint gtk_text_iter_compare (const GtkTextIter *lhs, const GtkTextIter *rhs);
gboolean gtk_text_iter_in_range (const GtkTextIter *iter, const GtkTextIter *start,
const GtkTextIter *end);
void gtk_text_iter_order (GtkTextIter *first, GtkTextIter *second);
Date de mise à jour : 06 octobre 2002
