Programmation GTK+/Bloc-notes

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Programmation GTK+
Programmation GTK+
Sommaire
Modifier ce modèle ce sommaire


Le widget bloc-notes est un ensemble de « pages » qui se chevauchent. Chaque page contient des informations différentes. Récemment, ce widget est devenu plus commun dans la programmation des interfaces graphiques et c'est un bon moyen de montrer des blocs d'information similaires qui justifient une séparation de leur affichage.

Le premier appel de fonction que l'on doit connaître est, vous l'aviez deviné, celui qui crée un widget bloc-notes.

 GtkWidget* gtk_notebook_new (void);

Lorsque le bloc-notes a été créé, il y a 12 fonctions permettant de travailler sur les blocs-notes. Étudions-les séparément.

La première permet de positionner les indicateurs de pages. Ceux-ci (désignés par le mot « tab » (signet)), peuvent se trouver en haut, en bas, à gauche ou à droite des pages.

 void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos);

GtkPositionType peut prendre les valeurs suivantes qu'il n'est pas nécessaire d'expliquer :

  • GTK_POS_LEFT
  • GTK_POS_RIGHT
  • GTK_POS_TOP
  • GTK_POS_BOTTOM

GTK_POS_TOP est la valeur par défaut.

La fonction suivante permet d'ajouter des pages à un bloc-notes. Il y a trois façons d'ajouter des pages. Regardons les deux premières qui sont très semblables.

 void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, 
                                GtkWidget *tab_label);

 void gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, 
                                 GtkWidget *tab_label);

Ces fonctions ajoutent des pages au bloc-notes notebook en les insérant à la fin (append) ou au début (prepend). child est le widget qui est placé dans la page du bloc-notes, et tab_label est le label de la page qui est ajoutée.

La troisième fonction ajoutant une page à un bloc-notes conserve toutes les propriétés des deux précédentes, mais elle nous permet en plus de spécifier la position où l'on désire insérer cette page.

 void gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, 
                                GtkWidget *tab_label, gint position);

Les paramètres sont les mêmes que _append_ et _prepend_ sauf qu'il y en a un de plus : position. Celui-ci sert à spécifier l'endroit où cette page sera insérée.

Maintenant que nous savons insérer une page, voyons comment en supprimer une.

 void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num);

Cette fonction ôte la page spécifiée par page_num du widget notebook.

Pour connaître la page courante d'un bloc-notes, on dispose de la fonction :

 gint gtk_notebook_current_page (GtkNotebook *notebook);

Les deux fonctions suivantes permettent de passer à la page suivante ou précédente d'un bloc-notes. Il suffit de faire l'appel de la fonction adéquate avec le widget sur lequel on veut opérer. Remarque : lorsqu'on est sur la dernière page du bloc-notes et que l'on appelle gtk_notebook_next_page, on revient à la première page. De même, si l'on est sur la première page et que l'on appelle gtk_notebook_prev_page, on se retrouve sur sa dernière page.

 void gtk_notebook_next_page (GtkNoteBook *notebook);
 void gtk_notebook_prev_page (GtkNoteBook *notebook);

La fonction qui suit permet de choisir la page « active ». Si vous voulez ouvrir le bloc-notes à la page 5, par exemple, vous utiliserez cette fonction. Sans elle, le bloc-notes s'ouvre sur sa première page par défaut.

 void gtk_notebook_set_page (GtkNotebook *notebook, gint page_num);

Les deux fonctions suivantes ajoutent ou ôtent les indicateurs de page et le contour du bloc-notes, respectivement.

 void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs);
 void gtk_notebook_set_show_border (GtkNotebook *notebook, gint show_border);

show_tabs et show_border peuvent valoir TRUE ou FALSE (1 ou 0).

Voyons maintenant un exemple, il est tiré du code de testgtk.c de la distribution GTK et montre l'utilisation des 13 fonctions. Ce petit programme crée une fenêtre contenant un bloc-notes et six boutons. Le bloc-notes contient 11 pages, ajoutées par trois moyens différents : à la fin, au milieu et au début. Les boutons permettent de faire tourner les indicateurs de page, ajouter/ôter les indicateurs et le contour, ôter une page, passer à la page suivante et précédente, et sortir du programme.

 #include <gtk/gtk.h>
 
 /* Rotation des indicateurs de page */
 
 void rotate_book (GtkButton *button, GtkNotebook *notebook)
 {
    gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
 }
 
 /* Ajout/Suppression des indicateurs de pages et des contours */
 
 void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
 {
    gint tval = FALSE;
    gint bval = FALSE;
    if (notebook->show_tabs == 0)
            tval = TRUE; 
    if (notebook->show_border == 0)
            bval = TRUE;
    
    gtk_notebook_set_show_tabs (notebook, tval);
    gtk_notebook_set_show_border (notebook, bval);
 }
 
 /* Suppression d'une page */
 
 void remove_book (GtkButton *button, GtkNotebook *notebook)
 {
    gint page;
    
    page = gtk_notebook_current_page(notebook);
    gtk_notebook_remove_page (notebook, page);
 
    /* Il faut rafraîchir  le widget --
     * ce qui force le widget à se redessiner. */
 
      gtk_widget_draw(GTK_WIDGET(notebook), NULL);
 }
 
 void delete (GtkWidget *widget, GdkEvent *event, gpointer *data)
 {
    gtk_main_quit ();
 }

 int main (int argc, char *argv[])
 {
    GtkWidget *window;
    GtkWidget *button;
    GtkWidget *table;
    GtkWidget *notebook;
    GtkWidget *frame;
    GtkWidget *label;
    GtkWidget *checkbutton;
    int i;
    char bufferf[32];
    char bufferl[32];
     
    gtk_init (&argc, &argv);
    
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                        GTK_SIGNAL_FUNC (delete), NULL);
    
    gtk_container_border_width (GTK_CONTAINER (window), 10);
    
    table = gtk_table_new(2,6,TRUE);
    gtk_container_add (GTK_CONTAINER (window), table);
    
    /* Création d'un bloc-notes, placement des indicateurs de page. */
 
    notebook = gtk_notebook_new ();
    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
    gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
    gtk_widget_show(notebook);
    
    /* Ajoute un groupe de pages à la fin du bloc-notes. */
 
    for (i=0; i < 5; i++) {
        sprintf(bufferf, "Append Frame %d", i+1);
        sprintf(bufferl, "Page %d", i+1);
        
        frame = gtk_frame_new (bufferf);
        gtk_container_border_width (GTK_CONTAINER (frame), 10);
        gtk_widget_set_usize (frame, 100, 75);
        gtk_widget_show (frame);
        
        label = gtk_label_new (bufferf);
        gtk_container_add (GTK_CONTAINER (frame), label);
        gtk_widget_show (label);
        
        label = gtk_label_new (bufferl);
        gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
    }
    
    
    /* Ajoute une page à un endroit précis. */
 
    checkbutton = gtk_check_button_new_with_label ("Cochez moi !");
    gtk_widget_set_usize(checkbutton, 100, 75);
    gtk_widget_show (checkbutton);
    
    label = gtk_label_new ("Emplacement de la nouvelle page");
    gtk_container_add (GTK_CONTAINER (checkbutton), label);
    gtk_widget_show (label);
    label = gtk_label_new ("Ajout de page");
    gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
    
    /* Ajout de pages au début du bloc-notes */
 
    for (i=0; i < 5; i++) {
        sprintf(bufferf, "Prepend Frame %d", i+1);
        sprintf(bufferl, "Page %d", i+1);
        
        frame = gtk_frame_new (bufferf);
        gtk_container_border_width (GTK_CONTAINER (frame), 10);
        gtk_widget_set_usize (frame, 100, 75);
        gtk_widget_show (frame);
        
        label = gtk_label_new (bufferf);
        gtk_container_add (GTK_CONTAINER (frame), label);
        gtk_widget_show (label);
        
        label = gtk_label_new (bufferl);
        gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
    }
    
    /* Configuration de la page de départ (page 4) */
 
    gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);
     
    
    /* Création des boutons */
 
    button = gtk_button_new_with_label ("Fermer");
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               GTK_SIGNAL_FUNC (delete), NULL);
    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label ("Page suivante");
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               (GtkSignalFunc) gtk_notebook_next_page,
                               GTK_OBJECT (notebook));
    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label ("Page précédente");
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               (GtkSignalFunc) gtk_notebook_prev_page,
                               GTK_OBJECT (notebook));
    gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label ("Position des indicateurs");
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
    gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label ("Indicateurs/Contours oui/non");
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               (GtkSignalFunc) tabsborder_book,
                               GTK_OBJECT (notebook));
    gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
    gtk_widget_show(button);
    
    button = gtk_button_new_with_label ("Oter page");
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               (GtkSignalFunc) remove_book,
                               GTK_OBJECT(notebook));
    gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
    gtk_widget_show(button);
    
    gtk_widget_show(table);
    gtk_widget_show(window);
    
    gtk_main ();
    
    return 0;
 }

En espérant que ceci vous aide à créer des blocs-notes pour vos applications GTK.