Pour commencer notre introduction à Gtk-Perl, nous commencerons par l'un des programmes les plus simples possibles. Ce programme créera une petite fenêtre avec un bouton nommé ``Goodbye World ``. Cliquer sur le bouton ou fermer la fenêtre sortira du programme.
#!/usr/bin/perl -wuse Gtk; # charge le module Gtk-Perl
use strict; # une bonne idée pour tout script Perl non-trivial
init Gtk; # initialise Gtk-Perl
# variables convenables pour vrai et faux
my $false = 0;
my $true = 1;
# création d'un widget
my $window = new Gtk::Window( "toplevel" );
my $button = new Gtk::Button( "Goodbye World" );
# enregistrement des rappels
$window->signal_connect( "delete_event", \&CloseAppWindow );
$button->signal_connect( "clicked", \&CloseAppWindow );
# montre le bouton
$button->show();
# déclare les attributs de la fenêtre et les montre
$window->border_width( 15 );
$window->add( $button );
$window->show();
# boucle d'évènement Gtk
main Gtk;
# ne devrait jamais arriver là
exit( 0 );
### la fonction de rappel pour fermer la fenêtre
sub CloseAppWindow { Gtk->exit( 0 ); return $false; }
Sous Unix, vous devrez rendre ce programme exécutable en utilisant la commande :
chmod a+x goodbyeworld
Si vous avez des problèmes pour l'exécuter, vérifier que le chemin de Perl mentionné à la première ligne est correct et que Gtk-Perl est correctement installé. ( Essayez d'exécuter le programme de test fourni avec Gtk-Perl, si vous n'êtes pas sûr ).
Quand vous lancez le programme vous devriez voir quelque chose de semblable à :
Votre programme peut ne pas ressembler exactement à l'image ci-dessus. GTK est, parmi d'autres choses, ``thémable''. C'est-à-dire que l'utilisateur décide du style des widgets, des couleurs et icônes à utiliser, les polices, etc... L'exécution ci-dessus utilisait le thème par défaut. Quoi qu'il en soit, la barre de titre dépend du window manager choisi ou de l'OS.
Maintenant, voyons si nous ne pouvons pas cheminer à travers le programme et lui donner du sens.
use Gtk; doit être inclus dans tout programme Gtk-Perl. Cela permet
à Perl d'utiliser les variables, fonctions structures, etc...définies par GTK.
Cela peut-être facilement combiné avec d'autres directives use comme
use strict ; .
init Gtk; doit également être inclus dans tout programme Gtk-Perl.
Cela initialise le module Gtk et met en place quelques éléments comme l'aspect
par défaut, la couleur, initialise la librairie à utiliser et les déclencheurs
de signaux par défaut.
J'utilise les variables $true et $false pour montrer la différence
entre la valeur booléenne et la valeur numérique. Je ne suis pas obligé de le
faire, mais je fais ce choix par soucis de clarté pour le débutant. Sans cela,
vous devriez décider si ce ``1'' est juste là pour représenter la vérité ou
s'il a un sens différent. Que se passe-t-il si vous le changez en ``2'' ?
J'utilise $true et $false dans tous mes programmes pour ne
pas avoir à me poser ce genre de question.
new Gtk::Window(); crée une nouvelle fenêtre. Le window manager décide
comment la décorer ( avec des choses comme la barre de titre ) et où la placer.
Tous les widgets GUI sont placés à l'intérieur et vous pouvez avoir plusieurs
fenêtres par programme. L'argument indique à X le type de fenêtre dont il s'agit.
Les fenêtres ``Top-Level'' n'ont pas de fenêtre parent et ne peuvent être
contenues par aucune fenêtre. Vous pouvez également créer des fenêtres de dialogue
avec new Gtk::Dialog(); .
La fonction border_width() prendra un conteneur ( comme une fenêtre
) et placera de l'espace autour. Cela évitera à votre application d'être trop
``tassée''. Le nombre passé en argument est la largeur ( en pixel ) de la
bordure créée. Essayez différentes valeurs.
new Gtk::Button() crée un nouveau bouton. Ici, nous en avons créé un
avec un label texte. Que ce serait-il passé si nous n'avions pas spécifié de
texte à mettre sur le bouton ? Essayez et voyez par vous même. Remarquez la
taille du bouton et de la fenêtre quand vous le faîtes ? GTK redimensionnera
automatiquement les widgets sauf si vous lui dîtes de ne pas le faire ( cela
inclus la fenêtre ). Pour cette raison, il ne sert à rien de s'inquiéter du
style ou de la taille de la police que l'utilisateur peut avoir définie par
défaut. Donnez juste la disposition à GTK et laissez le faire le reste. Pour
plus d'informations sur les boutons voir la section sur les boutons.
signal_connect() relie un évènement ou un signal à un appel de routine.
Un exemple serait d'appuyer sur le bouton de la souris. En terme de profane,
quand un évènement ou un signal est généré, GTK regarde si cet évènement possède
une routine enregistrée pour ce widget, si c'est le cas, il exécute cette routine.
Si aucune routine n'est enregistrée, il ne se passe rien. Les routines enregistrées
sont appelées ``rappels''. Bien plus d'informations sont disponibles plus
loin ( incluant une description sur les différences qu'il y a entre elles ).
Dans notre exemple, le premier argument de signal_connect() est une
chaîne indiquant l'évènement que vous voulez enregistrer et le second argument
est une référence à la routine à appeler si l'évènement se produit. Certains
évènements peuvent nécessiter différents arguments.
La fonction add() ajoute un widget dans un conteneur ( ici, la fenêtre
). Si nous n'avions pas fait cela, nous n'aurions pas vu le bouton parce qu'il
n'aurait pas été dans la fenêtre.
Le fonction show() rend la fenêtre visible. N'exécutez pas show()
tant que toutes les propriétés du widget ne sont pas définies. Vous devriez
toujours montrer les widgets enfants avant les widgets parents ( ici, rendre
visible le bouton avant la fenêtre qui le contient ). La manière dont la fenêtre
apparaît tout d'un coup rend le programme plus professionnel.
main Gtk; déclenche le processus de contrôle des évènements GTK. Il
s'agit d'une ligne que vous verrez dans toutes les applications Gtk-Perl. Quand
le contrôle atteint ce point, GTK se mettra en sommeil, attendant les évènements
X ( comme les boutons ou les touches pressés ), les délais ou les notifications
de fichier E/S qui peuvent se produire. Imaginez cela comme une boucle infinie
dont on sort par l'appel Gtk->exit(); . La ligne suivante ne devrait
jamais être exécutée mais j'en mets une au cas ou.
La routine placée à la fin du code, est celle qui est appelée quand on clique
sur le bouton ou quand on ferme la fenêtre. La seule chose intéressante ici
est l'appel Gtk->exit(); qui sortira du programme en utilisant l'argument
comme code de sortie. L'état de retour est très important pour une routine exécutée
quand le delete_event est appelé. Une valeur fausse signifie ``en
avant et tue la fenêtre'' alors qu'une valeur vraie signifie ``ne tue pas
la fenêtre''. C'est utile pour demander `` êtes-vous sûr ?'' avant que la
fenêtre ne soit balayée.