Programmation GTK+/Placement avec les tables

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


Étudions une autre méthode de placement : les tables. Elles peuvent s'avérer très utiles dans certaines situations.

En utilisant des tables, on crée une grille dans laquelle on peut placer les widgets. Ceux-ci peuvent occuper tous les endroits que l'on désire.

La première chose à faire est, bien sûr, d'étudier la fonction gtk_table_new :

 GtkWidget* gtk_table_new (gint rows,
                           gint columns,
                           gint homogeneous);

Le premier paramètre est le nombre de lignes de la table et le deuxième, le nombre de colonnes.

Le paramètre homogeneous s'occupe de la façon dont les cases de la table seront dimensionnées. Si homogeneous vaut TRUE, les cases prennent la taille du plus grand widget de la table. S'il vaut FALSE, la taille des cases dépend du widget le plus haut de la ligne et du plus large de cette colonne.

Le nombre de lignes et colonnes va de 0 à n, où n est le nombre spécifié dans l'appel à gtk_table_new. Ainsi, avec rows = 2 et columns = 2, la table ressemblera à ceci :

 0          1          2
0+----------+----------+
 |          |          |
1+----------+----------+
 |          |          |
2+----------+----------+

On notera que le système de coordonnées part du coin en haut à gauche. Pour placer un widget dans une case, ou utilise la fonction suivante :

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

Où le premier paramètre (table) est la table que l'on a créée et le second (child) est le widget que l'on veut placer dans la table.

Les paramètres left_attach et right_attach spécifient l'emplacement du widget et le nombre de cases à utiliser. Par exemple, si on veut placer un bouton dans le coin inférieur droit de la table décrite plus haut et que l'on désire ne remplir QUE cette case, left_attach vaudra 1, right_attach vaudra 2; top_attach vaudra 1 et bottom_attach vaudra 2.

Si on veut un widget occupant toute la ligne supérieure de notre table, on utilisera les valeurs 0, 2, 0, 1.

Les paramètres xoptions et yoptions servent à préciser les options de placement et peuvent être combinées par un OU logique pour permettre des options multiples.

Ces options sont :

  • GTK_FILL - Si la case de la table est plus large que le widget, et que GTK_FILL est spécifié, le widget s'élargira pour occuper toute la place disponible.
  • GTK_SHRINK - Si la table a moins de place qu'il ne lui en faut (généralement, à cause d'un redimensionnement de la fenêtre par l'utilisateur), les widgets sont alors simplement poussés vers le bas de la fenêtre et disparaissent. Si GTK_SHRINK est spécifié, les widgets se réduiront en même temps que la table.
  • GTK_EXPAND - Cette option provoque l'extension de la table pour qu'elle utilise tout l'espace restant dans la fenêtre.

Les paramêtres de padding jouent le même rôle que pour les boîtes : ils créent une zone libre, spécifiée en pixels, autour du widget.

gtk_table_attach() a BEAUCOUP d'options. Voici donc une fonction-raccourci :

 void gtk_table_attach_defaults (GtkTable   *table,
                                 GtkWidget  *widget,
                                 gint        left_attach,
                                 gint        right_attach,
                                 gint        top_attach,
                                 gint        bottom_attach);

xoptions et yoptions valent par défaut GTK_FILL | GTK_EXPAND, et xpadding et ypadding valent 0. Les autres paramètres sont les mêmes que ceux de la fonction précédente.

Il existe aussi les fonctions gtk_table_set_row_spacing() et gtk_table_set_col_spacing(). Elles permettent de placer des espaces après une ligne ou une colonne.

 void gtk_table_set_row_spacing (GtkTable      *table,
                                 gint           row,
                                 gint           spacing);

et

 void gtk_table_set_col_spacing  (GtkTable      *table,
                                  gint           column,
                                  gint           spacing);

Pour les colonnes, l'espace est ajouté à droite de la colonne et pour les lignes, il est ajouté en dessous.

On peut aussi configurer un espacement pour toutes les lignes et/ou colonnes avec :

 void gtk_table_set_row_spacings (GtkTable *table,
                                  gint      spacing);

Et,

 void gtk_table_set_col_spacings (GtkTable  *table,
                                  gint       spacing);

Avec ces appels, la dernière ligne et la dernière colonne n'ont pas d'espace supplémentaire.