---

---

Les tables

Dans la famille des containers, voilà sûrement le widget le plus intéressant. En effet il peut être parfois douloureux de placer correctement son interface avec l'utilisation de plusieurs GtkBox. Le widget GtkTable est conçu pour résoudre ce problème car il utilise une grille invisible pour attacher les widgets mais sans pour autant perdre la puissance de GTK+ avec le redimensionnement automatique.

I. Introduction

Au moment de la création de la GtkTable, nous allons spécifier le nombre de lignes et de colonnes, puis y placer les éléments avec 3 principales caractéristiques :

• la position de départ et de fin de l'élément par rapport aux lignes ;
• la position de départ et fin de l'élément par rapport aux colonnes ;
• la façon de réagir du widget (remplir la zone, agrandir, etc...).

Reprenons l'exemple que nous avons créé dans le chapitre précédent sur les GtkBox. Nous avons créé une fenêtre contenant quatre boutons :

Pour faire cela sans GtkTable, nous avons dû créer deux GtkBox, une première verticale, puis une deuxième horizontale dans laquelle nous avons placé les boutons 2 et 3, puis ajouter le quatrième bouton dans la première GtkBox (verticale), voila beaucoup de travail pour pas grand chose.

Avec le widget GtkTable, la première chose à faire sera de choisir le nombre de lignes et de colonnes sur cette grille. Dans notre cas, il s'agit d'une grille à trois lignes et deux colonnes :

Ensuite il suffit de placer nos boutons sur cette grille, en spécifiant en premier les points de départ et d'arrivée suivant les colonnes puis suivant les lignes :

• Bouton 1 : de 0 à 2 suivant les colonnes et de 0 à 1 suivant les lignes -> (0, 2, 0, 1) ;
• Bouton 2 : de 0 à 1 suivant les colonnes et de 1 à 2 suivant les lignes -> (0, 1, 1, 2) ;
• Bouton 3 : de 1 à 2 suivant les colonnes et de 1 à 2 suivant les lignes -> (1, 2, 1, 2) ;
• Bouton 4 : de 0 à 2 suivant les colonnes et de 2 à 3 suivant les lignes -> (0, 2, 2, 3).

Comme vous pouvez le constater, on ne donne pas la longueur et la largeur du widget, mais sa position finale sur la grille. Cela devient nettement plus facile et naturel de positionner les widgets sur une grille, car si ici nous ne gagnons que deux opérations par rapport à la méthode GtkBox, cette valeur s'élève très vite quand il s'agit de placer plus de 4 boutons. Après ces quelques explications, voyons comment programmer cela.

2. Utilisation du widget GtkTable.

2.1 Création.

La fonction de création est :

GtkWidget* gtk_table_new(guint rows, guint columns, gboolean homogeneous);

Les paramètres rows et columns permettent de définir respectivement le nombre de lignes et de colonnes de la grille. Le paramètre homogeneous quant à lui définit, comme pour une GtkBox, si tous les widgets contenus dans la GtkTable utilisent un espace équivalent.

2.2 Insertion de widget.

La première fonction étudiée est :

void gtk_table_attach( GtkTable *table, GtkWidget *child,
    guint left_attach, guint right_attach,
    guint top_attach, guint bottom_attach,
    GtkAttachOptions xoptions, GtkAttachOptions yoptions,
    guint xpadding, guint ypadding);

A première vue, cette fonction peut apparaître compliquée, mais elle est en réalité très simple. Le paramètre child représente le widget à attacher à la grille, les paramètres left_attach et right_attach, les positions à gauche et à droite du widget et les paramètres top_attach et bottom_attach, les positions supérieures et inférieures du widget.

Les paramètres xoptions et yoptions permettent de spécifier respectivement la façon dont le widget réagit horizontalement et verticalement au redimensionnement de la GtkTable. Ces paramètres peuvent prendre 3 valeurs (que l'on peut associer) :

• GTK_EXPAND : spécifie que cette section de la grille s'étirera pour remplir l'espace disponible ;
• GTK_SHRINK : détermine ce qui se produira s'il y a un espace insuffisant pour répondre à la requête de taille du widget enfant, alors le widget se voit attribué une allocation réduite, ce qui peut entraîner un effet de "bords coupés" ;
• GTK_FILL : spécifie que le widget enfant s'étirera pour remplir l'espace disponible, important que si GTK_EXPAND est défini.

Les deux derniers paramètres xpadding et ypadding définissent l'espace supplémentaire à ajouter aux bords du widget (à droite et à gauche pour le premier, au-dessus et en dessous pour le second).

Regardons maintenant les effets des paramètres xoptions et yoptions suivant différentes valeurs :

Valeurs de xoptions et yoptions	Résultat
xoptions = GTK_EXPAND yoptions = GTK_EXPAND
xoptions = GTK_EXPAND | GTK_FILL yoptions = GTK_EXPAND
xoptions = GTK_EXPAND yoptions = GTK_EXPAND | GTK_FILL
xoptions = GTK_EXPAND | GTK_FILL yoptions = GTK_EXPAND | GTK_FILL

La deuxième fonction est :

void gtk_table_attach_defaults(GtkTable *table, GtkWidget *child,
    guint left_attach, guint right_attach,
    guint top_attach, guint bottom_attach );

Ceci est la version simplifiée de la première fonction car elle définit automatiquement les paramètres xoptions et yoptions à GTK_EXPAND | GTK_FILL et les paramètres xpadding et ypadding à 0.

2.3 Modifier la table.

Il est possible de changer la taille de la grille après sa création à l'aide de cette fonction :

void gtk_table_resize(GtkTable *table, guint rows, guint columns);

Le paramètre table est la GtkTable à modifier, et les paramètres rows et columns les nouveaux nombres de lignes et de colonnes.

Ces deux fonctions permettent de changer l'espace d'une ligne ou d'une colonne spécifique :

gtk_table_set_row_spacing(GtkTable *table, guint row, guint spacing);
gtk_table_set_col_spacing(GtkTable *table, guint column, guint spacing);

La première définit l'espace autour d'une ligne tandis que la deuxième fait la même chose pour une colonne.

Celles-ci ont le même rôle que les deux précédentes fonctions, mais agissent sur l'ensemble de la GtkTable :

gtk_table_set_row_spacings(GtkTable *table, guint spacing);
gtk_table_set_col_spacings(GtkTable *table, guint spacing);

Et pour connaître ces espacements nous avons quatre fonctions différentes :

guint gtk_table_get_row_spacing(GtkTable *table, guint row);
guint gtk_table_get_col_spacing(GtkTable *table, guint column);
guint gtk_table_get_default_row_spacing(GtkTable *table);
guint gtk_table_get_default_col_spacing(GtkTable *table);

Les deux premières fonctions permettent de connaître l'espace entre ligne numéro row (ou la colonne numéro column) et sa suivante. Les deux autres fonctions quant à elles, renvoient la valeur par défaut des espacements, c'est à dire la valeur qui sera utilisé au prochain ajout d'un widget.

2.4 Exemple.

Nous allons utiliser le même exemple que dans le chapitre sur les GtkBox, pour bien montrer la différence au niveau du code.

2.5 Programme exemple.

#include <stdlib.h> #include <gtk/gtk.h> int main(int argc, char **argv) {     GtkWidget *pWindow;     GtkWidget *pTable;     GtkWidget *pButton[4];     gtk_init(&argc, &argv);     pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);     gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);     gtk_window_set_title(GTK_WINDOW(pWindow), "Les GtkTable");     g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);     /* Creation et insertion de la table 3 lignes 2 colonnes */     pTable=gtk_table_new(3,2,TRUE);     gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));     /* Creation des boutons */     pButton[0]= gtk_button_new_with_label("Bouton 1");     pButton[1]= gtk_button_new_with_label("Bouton 2");     pButton[2]= gtk_button_new_with_label("Bouton 3");     pButton[3]= gtk_button_new_with_label("Bouton 4");     /* Insertion des boutons */     gtk_table_attach(GTK_TABLE(pTable), pButton[0],         0, 2, 0, 1,         GTK_EXPAND | GTK_FILL, GTK_EXPAND,         0, 0);     gtk_table_attach_defaults(GTK_TABLE(pTable), pButton[1],         0, 1, 1, 2);     gtk_table_attach(GTK_TABLE(pTable), pButton[2],         1, 2, 1, 2,         GTK_EXPAND, GTK_EXPAND | GTK_FILL,         0, 0);     gtk_table_attach_defaults(GTK_TABLE(pTable), pButton[3],         0, 2, 2, 3);     gtk_widget_show_all(pWindow);     gtk_main();     return EXIT_SUCCESS; }

Résultat :

3. En savoir plus.

3.1 Fonctions documentées.

void gtk_table_set_homogeneous( GtkTable *table, gboolean homogeneous );

Permet de définir si la table est homogène ou pas. Entrée(s) : table : la GtkTable. homogeneous : TRUE si l'on veut que table soit homogène, FALSE sinon. Sortie : rien.

gboolean gtk_table_get_homogeneous(GtkTable *table);

Permet de savoir si la table est homogène. Entrée(s) : table : la GtkTable. Sortie : TRUE si table est homogène, FALSE sinon.

Date de mise à jour : 20 juillet 2003.

---

---