Programmation GTK2 en Pascal/GtkWindow

Présentation

Le contrôle GtkWindow est l'élément de base d'une interface graphique, car c'est ce contrôle qui va vous permettre de créer la fenêtre principale ainsi que toutes les autres fenêtres de votre programme.

Hiérarchie

GObject
  └─GtkObject
      └─GtkWidget
          └─GtkContainer
              └─GtkBin
                  └─GtkWindow

Utilisation de base

Création de la fenêtre

Dans un premier temps, il faut déclarer un pointeur sur notre objet fenêtre. Bien que nous voulions créer un objet GtkWindow, il faut déclarer un objet GtkWidget.

var
  pWindow : PGtkWidget;

Par la suite, quel que soit l'objet à créer, il faudra toujours déclarer un pointeur sur un GtkWidget.

Une fois l'objet pWindow déclaré, il faut l'initialiser. Pour cela, une fonction est à notre disposition :

function gtk_window_new(_type : TGtkWindowType) : PGtkWidget;

Le paramètre _type définit le type de la fenêtre en cours de création, et peut prendre une des deux valeurs suivantes :

GTK_WINDOW_TOPLEVEL : pour créer une fenêtre complète avec une zone réservée dans la barre des tâches ;
GTK_WINDOW_POPUP : pour créer une fenêtre sans aucune décoration (barre de titre, bordure, ...).

La valeur de retour est le pointeur sur notre nouvel objet fenêtre. Cette fonction est donc à utiliser comme ceci :

pWindow := gtk_window_new(GTK_WINDOW_TOPLEVEL);

La création de la fenêtre est maintenant terminée.

Titre de la fenêtre

Pour définir le titre d'une fenêtre une fonction spécifique est à notre disposition. Cette dernière est très simple d'utilisation :

procedure gtk_window_set_title(window : PGtkWindow; title : Pgchar);

Le premier paramètre window correspond au contrôle que nous venons de créer. Mais comme pWindow est de type GtkWidget il faut utiliser la fonction de conversion GTK_WINDOW(). Le deuxième paramètre title est bien entendu le titre que l'on veut donner à la fenêtre (gchar correspond à char en Pascal).

Au contraire, pour connaître le titre d'une fenêtre, la fonction est :

function gtk_window_get_title(window : PGtkWindow) : Pgchar;

La variable qui recevra la valeur de retour de cette fonction devra être de type Pgchar et non pas String.

Taille de la fenêtre

La fonction pour définir la taille par défaut de la fenêtre est :

procedure gtk_window_set_default_size(window : PGtkWindow; width : gint; height : gint);

Le paramètre width est la largeur de la fenêtre tandis que le paramètre height est sa hauteur.

Et très logiquement, la fonction pour connaître la taille par défaut de la fenêtre est :

procedure gtk_window_get_default_size(window : PGtkWindow; width : Pgint; height : Pgint);

Position de la fenêtre

La première fonction étudiée permet de définir la position de la fenêtre avant son affichage. Son prototype est le suivant :

procedure gtk_window_set_position(window : PGtkWindow; position : TGtkWindowPosition);

Le deuxième paramètre position est la position que l'on veut donner à la fenêtre. Les valeurs acceptées sont :

GTK_WIN_POS_NONE : la fenêtre aura une position aléatoire lors de son affichage ;
GTK_WIN_POS_CENTER : la fenêtre sera centrée à l'écran ;
GTK_WIN_POS_MOUSE : le coin supérieur droit de la fenêtre correspondra à la position de la souris au moment de l'affichage ;
GTK_WIN_POS_CENTER_ALWAYS : la fenêtre sera centrée et ne pourra être déplacée ;
GTK_WIN_POS_CENTER_ON_PARENT : la fenêtre sera centrée par rapport à la fenêtre parente.

La deuxième fonction est utilisable à tout moment du programme et permet de donner la position exacte de la fenêtre :

procedure gtk_window_move(window : PGtkWindow; x : gint; y : gint);

Le premier paramètre est toujours la fenêtre dont on veut modifier la position. Les deux autres paramètres sont la nouvelle position de la fenêtre. Le paramètre x est la position suivant l'axe X (axe horizontal) et le paramètre y, la position suivant l'axe Y (axe vertical).

À l'inverse, pour connaître la position de la fenêtre, il faut utiliser cette fonction :

procedure gtk_window_get_position(window : PGtkWindow; root_x : Pgint; root_y : Pgint);

Affichage de la fenêtre

Le contrôle GtkWindow, comme tous les autres contrôles, n'a pas de fonctions particulières concernant son affichage. Pour cela il faut utiliser une fonction du contrôle de base GtkWidget qui est :

procedure gtk_widget_show(widget : PGtkWidget);

Cependant cette fonction ne s'occupera d'afficher que la fenêtre et pas les contrôles qui ont été ajoutés à l'intérieur de celle-ci. Pour simplifier les choses, Gtk+ nous offre cette fonction qui affichera tout d'un seul coup :

procedure gtk_widget_show_all(widget : PGtkWidget);

Il en est de même en ce qui concerne la destruction d'un contrôle, qui se fait avec cette fonction :

procedure gtk_widget_destroy(widget : PGtkWidget);

Premier programme exemple

Nous allons créer une fenêtre toute simple. Voilà le fichier gtk001.pas :

program gtk001;
uses glib2, gtk2;

procedure destroy(widget : PGtkwidget; data : pgpointer); cdecl;
begin
  // Arrêt de la boucle événementielle
  gtk_main_quit();
end;

var
  pWindow : PGtkWidget; 
begin
  gtk_init(@argc, @argv);
  pWindow := gtk_window_new(GTK_WINDOW_TOPLEVEL);
  // Connexion du signal "destroy"
  gtk_signal_connect(pGTKOBJECT(pWindow), 'destroy', GTK_SIGNAL_FUNC(@destroy), NULL);
  // Affichage de la fenêtre
  gtk_widget_show(pWindow);
  // Démarrage de la boucle événementielle
  gtk_main();
end.

Voila ce que donne l'exécution du programme gtk001 :

Deuxième programme exemple

Nous allons créer une fenêtre de taille 320x200, dont le titre sera « Fenêtre de base » et qui sera centrée à l'écran.

Pour que les caractères accentués ne posent pas de problèmes, il faut utiliser un éditeur qui sauvegarde au format utf-8, comme par exemple gedit sous Linux.

Voilà le fichier gtk002.pas :

program gtk002;
uses glib2, gtk2;

procedure destroy(widget : PGtkwidget; data : pgpointer); cdecl;
begin
  // Arrêt de la boucle événementielle
  gtk_main_quit();
end;

var
  pWindow : PGtkWidget; 
begin
  gtk_init(@argc, @argv);
  pWindow := gtk_window_new(GTK_WINDOW_TOPLEVEL);
  // Definition de la position 
  gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
  // Definition de la taille de la fenêtre 
  gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
  // Titre de la fenêtre 
  gtk_window_set_title(GTK_WINDOW(pWindow), 'Fenêtre de base');
  // Connexion du signal "destroy"
  gtk_signal_connect(pGTKOBJECT(pWindow), 'destroy', GTK_SIGNAL_FUNC(@destroy), NULL);
  // Affichage de la fenêtre
  gtk_widget_show(pWindow);
  // Démarrage de la boucle événementielle
  gtk_main();
end.

Voila ce que donne l'exécution du programme gtk002 :

La fenêtre est bien centrée sur le bureau dès le lancement.

Fenêtres : GtkWindow ~ GtkDialog ~ GtkMessageDialog