Programmation GTK2 en Pascal/GtkTable

Présentation

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

Hiérarchie

GObject
  └─GtkObject
      └─GtkWidget
          └─GtkContainer
              └─GtkTable

Utilisation de base

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 contrôle (remplir la zone, agrandir, etc.).

Création d'une GtkTable

La fonction de création est :

function gtk_table_new(rows : guint; columns : guint; homogeneous : gboolean) : PGtkWidget;

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 [[Programmation GTK2 en Pascal/GtkBox|GtkBox, si tous les contrôles contenus dans la GtkTable utilisent un espace équivalent.

Insertion d'éléments

La première fonction étudiée est :

procedure gtk_table_attach(table : PGtkTable; child : PGtkWidget; 
  left_attach : guint; right_attach : guint; 
  top_attach : guint; bottom_attach : guint; 
  xoptions : TGtkAttachOptions; yoptions : TGtkAttachOptions; 
  xpadding : guint; ypadding : guint);

À 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 contrôle à attacher à la grille, les paramètres left_attach et right_attach, les positions à gauche et à droite du contrôle et les paramètres top_attach et bottom_attach, les positions supérieures et inférieures du contrôle.

   0    1    2    3    4    5
 0 ┌────┬────┬────┬────┬────┐
   |    |    |    |    |    |
 1 ├────┼────┼────┴────┼────┤
   |    |    |         |    |    Coordonnées du contrôle (Contr.)
 2 ├────┼────┤  Contr. ├────┤    left_attach = 2, right_attach = 4
   |    |    |         |    |    top_attach = 1, bottom_attach = 3
 3 └────┴────┴─────────┴────┘

Les paramètres xoptions et yoptions permettent de spécifier respectivement la façon dont le contrôle 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 contrôle enfant, alors le contrôle se voit attribué une allocation réduite, ce qui peut entraîner un effet de « bords coupés » ;
GTK_FILL : spécifie que le contrôle enfant s'étirera pour remplir l'espace disponible, utilisé uniquement si GTK_EXPAND est défini.

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

La deuxième fonction est :

procedure gtk_table_attach_defaults(table : PGtkTable; widget : PGtkWidget; 
  left_attach : guint; right_attach : guint; 
  top_attach : guint; bottom_attach : guint);

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.

Modification de la table

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

procedure gtk_table_resize(table : PGtkTable; rows : guint; columns : guint);

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 :

procedure gtk_table_set_row_spacing(table : PGtkTable; row : guint; spacing : guint);
procedure gtk_table_set_col_spacing(table : PGtkTable; column : guint; spacing : guint);

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 :

procedure gtk_table_set_row_spacings(table : PGtkTable; spacing : guint);
procedure gtk_table_set_col_spacings(table : PGtkTable; spacing : guint);

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

function gtk_table_get_row_spacing(table : PGtkTable; row : guint) : guint;
function gtk_table_get_col_spacing(table : PGtkTable; column : guint) : guint;
function gtk_table_get_default_row_spacing(table : PGtkTable) : guint;
function gtk_table_get_default_col_spacing(table : PGtkTable) : guint;

Les deux premières fonctions permettent de connaître l'espace entre la 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 contrôle.

Programme 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.

Voilà le fichier gtk008.pas :

program gtk008;

uses glib2, gtk2;

var
  pFenetre : PGtkWidget;
  pTable   : PGtkWidget;
  pBouton  : array [1..4] of PGtkWidget;
begin
  gtk_init(@argc, @argv);
  pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
  gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk008 : GtkTable');
  gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', GTK_SIGNAL_FUNC(@gtk_main_quit), NULL);

  // Création de la GtkTable (3 lignes et 2 colonnes) et ajout dans la fenêtre
  pTable := gtk_table_new(3, 2, TRUE);
  gtk_container_add(GTK_CONTAINER(pFenetre), pTable);

  // Création des boutons
  pBouton[1] := gtk_button_new_with_label('Bouton 1');
  pBouton[2] := gtk_button_new_with_label('Bouton 2');
  pBouton[3] := gtk_button_new_with_label('Bouton 3');
  pBouton[4] := gtk_button_new_with_label('Bouton 4');

  // Ajout des boutons dans la GtkTable
  gtk_table_attach(GTK_TABLE(pTable), pBouton[1], 
    0, 2, 0, 1,
    GTK_EXPAND or GTK_FILL, GTK_EXPAND,
    0, 0);
  gtk_table_attach_defaults(GTK_TABLE(pTable), pBouton[2], 
    0, 1, 1, 2);
  gtk_table_attach(GTK_TABLE(pTable), pBouton[3], 
    1, 2, 1, 2,
    GTK_EXPAND, GTK_EXPAND or GTK_FILL,
    0, 0);
  gtk_table_attach_defaults(GTK_TABLE(pTable), pBouton[4], 
    0, 2, 2, 3);

  gtk_widget_show_all(pFenetre);
  gtk_main;
end.

Voilà ce que donne l'exécution du programme gtk008 :

Conteneurs : GtkContainer ~ GtkBox ~ GtkBin — GtkHBox ~ GtkVBox ~ GtkTable ~ GtkNotebook