Mise en forme du texte dans un GtkTextView

Ici nous créons un GtkTextView tout simplement avec la fonction gtk_text_view_new comme vous avez sans doute l'habitude de faire, nous récupérons ensuite son GtkTextBuffer et nous le stockons:

GtkWidget * p_text = gtk_text_view_new ();
GtkTextBuffer * p_buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (p_text_buffer));

Nous partirons donc d'un widget créé de cette manière ou du moins de son GtkTextBuffer.

Nous voici donc dans le cœur du sujet… Ici nous allons voir comment créer des tags de toutes sortes avec la fonction simplifiée du widget GtkTextBuffer à savoir : gtk_text_buffer_create_tag.

Cette fonction va créer pour nous le GtkTextTag correspondant à nos souhaits et l'insérer dans la liste des tags GtkTextTagTable de notre GtkTextBuffer sans autre action de notre part !

Il faut également savoir que des propriétés, il en existe de différents types, nous pouvons créer par exemple des tags attendant une valeur entière comme une constante ou parfois même une valeur booléenne ou des structures comme les GdkColor, etc. Il convient donc de vous référer à la liste passée en lien dans le chapitre 2 pour savoir quel type de valeur attend la propriété que vous désirez éditer dans un GtkTextTag !

Voyons donc comment nous allons créer différents tags à savoir :

• Texte italique ;
• Texte gras ;
• Texte souligné ;
• Texte barré ;
• Texte centré ;
• Changement de taille ;
• Changement de couleur.

Pourquoi voir plusieurs propriétés ? Tout simplement, car chacune de ces propriétés est vraiment différente et je vous montre également les plus connues et donc les plus utilisées dans des éditeurs de texte par exemple, cela vous permettra de voir un peu le fonctionnement et le raisonnement pour leur mise en place. Commençons par voir les arguments que prend la fonction gtk_text_buffer_create_tag dont voici son prototype :

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

Le premier argument n'est pas difficile, c'est le pointeur sur le GtkTextBuffer de votre GtkTextView comme celui que nous avons récupéré dans la création d'un GtkTextView dans la section précédente.

Le second argument permet de donner un nom au tag que nous créons, ceci peut être n'importe quel identifiant, mais il est préférable d'en choisir un assez évocateur, car c'est vous qui devrez le retenir ! Cet argument peut également être NULL ce qui donnera naissance à un tag anonyme. Inutile de vous dire que si vous ne gardez pas un pointeur sur un GtkTextTag anonyme, vous n'arriverez sans doute plus à y accéder. Il faut également prendre le soin de choisir un nom qui n'est pas déjà défini, aucun doublon ne peut exister.

Le troisième argument est ici le début d'une liste qui va par couple « propriété/valeur », cette liste doit se terminer par un NULL. Le nom de la propriété correspond donc au nom d'une propriété connue du widget GtkTextTag et la valeur est le style que vous désirez appliquer au texte par le biais de cette propriété.

La fonction retourne un pointeur sur le nouveau GtkTextTag créé et initialisé aux bonnes valeurs d'après vos paramètres. Le choix vous appartient de récupérer ce pointeur ou non, dans nos exemples, nous n'allons pas nous en soucier.

III-B-1. Texte italique▲

gtk_text_buffer_create_tag (
   p_buf, "italic", 
   "style", PANGO_STYLE_ITALIC,
   NULL
);

III-B-2. Texte gras▲

gtk_text_buffer_create_tag (
   p_buf, "bold",
   "weight", PANGO_WEIGHT_BOLD,
   NULL
);

III-B-3. Texte souligné▲

gtk_text_buffer_create_tag (
   p_buf, "underline",
   "underline", PANGO_UNDERLINE_SINGLE,
   NULL
);

III-B-4. Texte barré▲

gtk_text_buffer_create_tag (
   p_buf, "strikethrough",
   "strikethrough", TRUE,
   NULL
);

III-B-5. Justification du texte▲

gtk_text_buffer_create_tag (
   p_buf, "center",
   "justification", GTK_JUSTIFY_CENTER,
   NULL
);

III-B-6. Taille du texte▲

gtk_text_buffer_create_tag (
  p_buf, "size20",
  "size", 20 * PANGO_SCALE,
   NULL
);

III-B-7. Couleur du texte▲

gtk_text_buffer_create_tag (
   p_buf, "font-blue", 
   "foreground", "blue",
   NULL
);

GdkColor color;
 
/*
 * Initialisation du GdkColor avec par exemple un 
 * widget GtkColorSelection...
 */
...
 
gtk_text_buffer_create_tag (
   p_buf, "fontcolor",
   "foreground-gdk", & color,
   NULL
);

Vous pouvez télécharger le code source complet d'un programme mettant en application ce que nous venons de voir dans ce chapitre.

La création de ce widget que nous allons voir est plus longue (mais pas obligatoire cependant). Nous allons créer un GtkTextTagTable que nous mettrons dans notre GtkTextBuffer lors de son initialisation que nous mettrons dans notre GtkTextView !

Voyons tout cela :

/* Creation du GtkTextTagTable: */
p_tag_table = gtk_text_tag_table_new ();
 
/* Creation du GtkTextBuffer: */
p_buf = gtk_text_buffer_new (p_tag_table);
 
/* Creation du GtkTextView: */
p_text = gtk_text_view_new_with_buffer (p_buf);

Tout ceci n'est pas vraiment obligatoire, on peut très bien utiliser la méthode que nous avons vue au précédent chapitre, mais il vous faudra alors récupérer le GtkTextBuffer comme il l'a également été montré, mais il faut aussi en plus récupérer un pointeur sur le GtkTextTagTable créé automatiquement avec la fonction gtk_text_buffer_get_tag_table !

Entrons dans le vif du sujet. Ici je vais vous expliquer la seconde méthode pour créer des tags pour mettre en forme votre texte dans un GtkTextView. Il nous faut commencer par la création d'un GtkTextTag tout en lui donnant un nom, par exemple pour un tag qui permet la mise en italique du texte :

GtkTexTag * p_tag = gtk_text_tag_new ("italic");

C'est très simple effectivement ! C'est le même principe qu'auparavant, il faut donner un nom au tag, c'est ici que ça se fait. Il nous faut maintenant définir les propriétés à appliquer au texte, nous devons utiliser pour cela la fonction g_object_set. Le fonctionnement est à peu près pareil, dans le premier argument on transmet un pointeur générique sur notre GtkTextTag puis la liste des propriétés pour le texte :

g_object_set (
   (gpointer) p_tag,
   "style", PANGO_STYLE_ITALIC,
   NULL
);

Comme d'habitude, il faut terminer la liste par NULL ! La dernière étape qui reste tout aussi importante est d'ajouter le GtkTextTag dans notre GtkTextTagTable ce que nous faisons grâce à la fonction gtk_text_tag_table_add :

gtk_text_tag_table_add (p_tag_table, p_tag);

Notre tag est enfin prêt à être utilisé comme avant !

Vous pouvez télécharger le code source complet d'un programme mettant en application ce que nous venons de voir dans ce chapitre.

On ne récupère en fait pas le texte sélectionné, mais uniquement les repères de début et de fin de la sélection donc des GtkTextIter. Pour ce faire, nous utilisons la fonction gtk_text_buffer_get_selection_bounds. Cette fonction renvoie TRUE si du texte est sélectionné dans le GtkTextView, FALSE sinon. Si du texte est sélectionné, la fonction initialise alors les GtkTextIter dont l'adresse est passée en paramètre.

Voici un exemple d'utilisation :

gboolean ret = FALSE;
GtkTextIter start;
GtkTextIter end;
 
ret = gtk_text_buffer_get_selection_bounds (
   p_buf, & start, & end
);

Il y a deux façons d'appliquer des tags à du texte dans un GtkTextBuffer. La première consiste à utiliser la fonction gtk_text_buffer_apply_tag. On passe ici directement un pointeur sur le GtkTextTag à appliquer au texte, il faut donc posséder un pointeur sur les tags que vous utilisez.

Exemple :

GtkTextTag * p_tag = NULL;
 
/* Creation du tag... */
...
 
gtk_text_buffer_apply_tag (
   p_buf, p_tag,
   & start, & end
);

De même pour supprimer un tag sur un texte, on utilise la fonction gtk_text_buffer_remove_tag.

La seconde méthode pour appliquer des tags consiste à utiliser la fonction gtk_text_buffer_apply_tag_by_name. À peu de choses identiques à la fonction précédente, celle-ci permet d'appliquer un tag en précisant directement son nom, celui que vous avez choisi lors de sa création.

Exemple :

gtk_text_buffer_apply_tag_by_name (
   p_buf, "italic", & start, & end
);

La seconde méthode pour supprimer un tag sur un texte est d'utiliser la fonction gtk_text_buffer_remove_tag_by_name.

On a parlé jusqu'ici d'application de tag à du texte dans un GtkTextBuffer, mais il est également possible d'insérer directement du texte tout en y appliquant des tags, il est même possible d'appliquer plusieurs tags en même temps et dans un unique appel. Ceci se fait avec les fonctions gtk_text_buffer_insert_with_tags et gtk_text_buffer_insert_with_tags_by_name.

La première fonction permet d'ajouter les tags en passant un pointeur sur chacun des GtkTextTag à appliquer au texte et la seconde ne demande que le nom de ceux-ci. La liste doit être terminée par NULL.

Exemple :

gtk_text_buffer_insert_with_tags_by_name (
   p_buf, & iter,
   "Votre texte à insérer dans le GtkTextBuffer...", -1
   "italic", "bold", "underline", "center",
   NULL
);

Le GtkTextIter passé en second paramètre correspond à l'emplacement de départ de l'insertion du texte, il convient donc de l'initialiser correctement avant son utilisation. Ceci peut se faire de plusieurs manières soit avec les fonctions suivantes :

• gtk_text_buffer_get_iter_at_line_offset ;
• gtk_text_buffer_get_iter_at_offset ;
• gtk_text_buffer_get_iter_at_line ;
• gtk_text_buffer_get_iter_at_line_index ;
• gtk_text_buffer_get_iter_at_mark ;
• gtk_text_buffer_get_iter_at_child_anchor ;
• gtk_text_buffer_get_start_iter ;
• gtk_text_buffer_get_end_iter.