Programmation GTK/Labels
Les labels sont très utilisés dans GTK et sont relativement simples. Ils n'émettent pas de signaux car ils n'ont pas de fenêtre X qui leur est associée. Si vous avez besoin de capturer des signaux ou de faire des coupures (« clippings »), utilisez un widget "EventBox".
Pour créer un label, on utilise :
 GtkWidget* gtk_label_new (char *str);
où l'unique paramètre est la chaîne de caractères que l'on veut que le label affiche.
Pour changer le texte d'un label après sa création, on utilise la fonction :
 void gtk_label_set (GtkLabel *label,
 char *str);
où le premier paramètre est le label que l'on veut modifier, que l'on convertit en utilisant la macro codice_1, et le second est la nouvelle chaîne.
L'espace nécessaire à la nouvelle chaîne sera automatiquement ajusté si nécessaire.
Pour récupérer la chaîne courante, on utilise la fonction :
 void gtk_label_get (GtkLabel *label,
 char **str);
où le premier paramètre est le label dont on veut récupérer la chaîne et le second sert à retourner cette chaîne.

Programmation GTK/Le widget bulle d'aide

Ce sont les petits textes qui surgissent lorsque vous laissez votre pointeur sur un bouton ou un autre widget pendant quelques secondes. Ils sont faciles à utiliser, on ne donnera donc pas d'exemple. Si vous voulez voir du code, consultez le programme codice_1 distribué avec GTK.
Certains widgets (comme les labels) ne fonctionnent pas avec les bulles d'aide.
Le premier appel que vous utiliserez sera pour créer une nouvelle bulle d'aide. Vous n'avez besoin que de le faire une fois dans une fonction donnée. Le "GtkTooltip" que cette fonction retourne peut être utilisé pour créer plusieurs bulles d'aide.
 GtkTooltips *gtk_tooltips_new (void);
Lorsque vous avez créé une nouvelle bulle d'aide et le widget sur lequel vous voulez l'utiliser, vous n'avez qu'à faire cet appel pour la configurer :
 void gtk_tooltips_set_tip (GtkTooltips *tooltips,
 GtkWidget *widget,
 gchar *tips_text);
Les paramètres sont la bulle d'aide déjà créée, suivi du widget pour lequel vous voulez voir apparaître cette bulle et le texte que vous voulez qu'elle contienne.
Voici un petit exemple :
 GtkTooltips *tooltips;
 GtkWidget *button;
 tooltips = gtk_tooltips_new ();
 button = gtk_button_new_with_label ("bouton 1");
 gtk_tooltips_set_tip (tooltips, button, "C'est le bouton 1",NULL);
D'autres fonctions peuvent être utilisées avec les bulles d'aide. Je ne ferais que les énumérer et les décrire brièvement.
 void gtk_tooltips_destroy (GtkTooltips *tooltips);
Destruction de bulles d'aide.
 void gtk_tooltips_enable (GtkTooltips *tooltips);
Activation d'un ensemble de bulles d'aide désactivées.
 void gtk_tooltips_disable (GtkTooltips *tooltips);
Désactivation d'un ensemble de bulles d'aide activées.
 void gtk_tooltips_set_delay (GtkTooltips *tooltips,
 gint delay);
Configure le nombre de millisecondes pendant lequel le pointeur doit se trouver sur le widget avant que la bulle d'aide n'apparaisse. Par défaut, ce délai est de 1000 millisecondes, soit 1 seconde.
 void gtk_tooltips_set_tips (GtkTooltips *tooltips,
 GtkWidget *widget,
 gchar *tips_text);
Change le texte d'une bulle d'aide déjà créée.
 void gtk_tooltips_set_colors (GtkTooltips *tooltips,
 GdkColor *background,
 GdkColor *foreground);
Configure les couleurs de fond et de premier plan des bulles d'aides. Je ne sais toujours pas comment spécifier les couleurs...
Et c'est tout concernant les fonctions associées aux bulles d'aide. C'est plus que vous ne vouliez sûrement en savoir :)

Programmation GTK/Barres de progression
Les barres de progression sont utilisées pour afficher la progression d'une opération. Elles sont très simple à utiliser comme vous pourrez le constater en étudiant le code ci-dessous. Commençons d'abord par l'appel permettant de créer une nouvelle barre.
 GtkWidget *gtk_progress_bar_new (void);
Maintenant que la barre est créée, nous pouvons l'utiliser.
 void gtk_progress_bar_update (GtkProgressBar *pbar, gfloat percentage);
Le premier paramètre est la barre de progression sur laquelle on veut agir, et le second est le pourcentage « effectué », signifiant le remplissage de la barres de 0 à 100 % (réel compris entre 0 et 1).
Les barres de progression sont généralement utilisées avec les délais d'expiration ou autres fonctions identiques (voir la section sur Expirations, fonctions d'E/S et d'attente) pour donner l'illusion du multi-tâches. Toutes emploient la fonction codice_1 de la même façon.
Voici un exemple de barre de progression mise à jour par des expirations. Ce code montre aussi comment réinitialiser une barre.
 #include <gtk/gtk.h>
 static int ptimer = 0;
 int pstat = TRUE;
 /* Cette fonction incrémente et met à jour la barre de progression,
 * elle la réinitialise si pstat vaut FALSE */
 gint progress (gpointer data)
 gfloat pvalue;
 /* récupération de la valeur courante de la barre */
 pvalue = GTK_PROGRESS_BAR (data)->percentage;
 if ((pvalue >= 1.0) || (pstat == FALSE)) {
 pvalue = 0.0;
 pstat = TRUE;
 pvalue += 0.01;
 gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
 return TRUE;
 /* Cette fonction signale une réinitialisation de la barre */
 void progress_r (void)
 pstat = FALSE; 
 void destroy (GtkWidget *widget, gpointer *data)
 gtk_main_quit ();
 int main (int argc, char *argv[])
 GtkWidget *window;
 GtkWidget *button;
 GtkWidget *label;
 GtkWidget *table;
 GtkWidget *pbar;
 gtk_init (&argc, &argv);
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 GTK_SIGNAL_FUNC (destroy), NULL);
 gtk_container_border_width (GTK_CONTAINER (window), 10);
 table = gtk_table_new(3,2,TRUE);
 gtk_container_add (GTK_CONTAINER (window), table);
 label = gtk_label_new ("Exemple de barre de progression");
 gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
 gtk_widget_show(label);
 /* Crée une barre, la place dans la table et l'affiche */
 pbar = gtk_progress_bar_new ();
 gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
 gtk_widget_show (pbar);
 /* Configure le délai d'expiration pour gérer automatiquement la
 * mise à jour de la barre */ 
 ptimer = gtk_timeout_add (100, progress, pbar);
 /* Ce bouton indique à la barre qu'elle doit se réinitialiser */
 button = gtk_button_new_with_label ("Reset");
 gtk_signal_connect (GTK_OBJECT (button), "clicked",
 GTK_SIGNAL_FUNC (progress_r), NULL);
 gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
 gtk_widget_show(button);
 button = gtk_button_new_with_label ("Annuler");
 gtk_signal_connect (GTK_OBJECT (button), "clicked",
 GTK_SIGNAL_FUNC (destroy), NULL);
 gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
 gtk_widget_show (button);
 gtk_widget_show(table);
 gtk_widget_show(window);
 gtk_main ();
 return 0;
Dans ce petit programme, il y a quatre parties concernant le fonctionnement général des barres de progression, nous les étudierons dans l'ordre de leurs appels.
 pbar = gtk_progress_bar_new ();
Cet appel crée une nouvelle barre, nommée codice_2.
 ptimer = gtk_timeout_add (100, progress, pbar);
Cet appel utilise des délais d'expiration pour permettre un intervalle de temps constant. ces délais ne sont pas nécessaires à l'utilisation des barres de progression.
 pvalue = GTK_PROGRESS_BAR (data)->percentage;
Ce code assigne à pvalue la valeur du pourcentage de la barre.
 gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
Finalement, ce code met à jour la barre avec la valeur de codice_3.
Et c'est tout ce qu'il y a à savoir sur les barres de progression. Amusez-vous bien.